News aggregator

Strathclyde PhD Position

General haskell list - Fri, 04/17/2015 - 9:28am
Applications are welcome from ANYWHERE for a Microsoft Research sponsored PhD position in the Mathematically Structured Programming group at the University of Strathclyde. Project: Real World Data with Dependent Types: Integrity and Interoperation Strathclyde supervisor: Dr Conor McBride Microsoft supervisor: Dr Don Syme Starting: October 2015 Tuition fees: fully funded or substantially subsidised, depending on residency status Stipend: £14,057K Contact: Conor, by 8 May 2015 -------------------------------------------------------------------- Project Summary Data integrity, manipulation and analysis are key concerns in modern software, for developers and users alike. We are often obliged to work with a corpus of files – spreadsheets, databases, scripts – which represent and act on aspects of data in some domain. This project seeks to improve the integrity and effi
Categories: Incoming News

Deadline extended: WPTE 2015 Second International Workshop on Rewriting Techniques for Program Transformations and Evaluation

General haskell list - Fri, 04/17/2015 - 9:19am
FINAL CALL FOR PAPERS Second International Workshop on Rewriting Techniques for Program Transformations and Evaluation WPTE 2015 affiliated with RDP 2015 2 July, 2015, Warsaw, Poland http://www.trs.cm.is.nagoya-u.ac.jp/event/wpte2015/ !! Submission deadline is extended until April 24th !! Aims and Scope ============== The aim of WPTE is to bring together the researchers working on program transformations, evaluation, and operationally-based programming language semantics, using rewriting methods, in order to share the techniques and recent developments and to exchange ideas to encourage further activation of research in this area. The previous WPTE was held in Vienna 2014. Topics of interest in the scope of this workshop include: * Correctness of program transformations, optimizations and translations. * Program transformations for proving te
Categories: Incoming News

Recognizing projects schemes

haskell-cafe - Fri, 04/17/2015 - 4:50am
I recently came across the following blog-post: http://blog.cleancoder.com/uncle-bob/2015/04/15/DoesOrganizationMatter.html It speaks a bit of simplicity, efficiency and stuff that isn't important. What is important at least to me was the concept of project scheme, summarized on the following phrase: ``And so this gets to the crux of the question that you were really asking. You were asking whether the time required to learn the organization scheme of the system is worth the bother. Learning that organization scheme is hard. Becoming proficient at reading and changing the code within that scheme take time, effort, and practice. And that can feel like a waste when you compare it to how simple life was when you only had 100 lines of code.'' And that is something I totally struggle at approaching new projects. The only reason I could understand XMonad for example is because they gave a general overview (thanks) of it on the Developing module. I feel I got a problem of methodology. What approaches are you
Categories: Offsite Discussion

Lawful Foldable

Haskell on Reddit - Fri, 04/17/2015 - 2:35am

It is relatively common to criticize Foldable for not having laws, unlike its cousin, Traversable. The reason it doesn't have laws is because not all Foldables are Functors, the obvious example being Set. However, couldn't this be solved by throwing a Coyoneda on the type?

class BetterFoldable f where traverseish :: (Applicative g) => (a -> g b) -> (Coyoneda f a -> g (Coyoneda f b))

Edit: to be clear, by using a Traversable-like interface, you can have laws that require every position to be traversed/folded exactly once, which is what we would expect, but can't require due to Foldable not being powerful enough.

submitted by tailcalled
[link] [42 comments]
Categories: Incoming News

Strathclyde PhD Position

Haskell on Reddit - Fri, 04/17/2015 - 2:30am
Categories: Incoming News

Scala at position 25 of the Tiobe index,Haskell dropped below 50

haskell-cafe - Thu, 04/16/2015 - 10:41pm
L.S., From the Tiobe index page[0] of this month: Another interesting move this month concerns Scala. The functional programming language jumps to position 25 after having been between position 30 and 50 for many years. Scala seems to be ready to enter the top 20 for the first time in history. Haskell dropped from the top 50 last month and hasn't come back. I suppose, if Haskell compiled to JVM, Haskell would have a much wider audience. Regards, Henk-Jan van Tuyl [0] http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
Categories: Offsite Discussion

Yesod Web Framework: Announcing stackage-update

Planet Haskell - Thu, 04/16/2015 - 10:00pm

I just released a simple tool to Hackage called stackage-update. Instead of repeating myself, below is a copy-paste of the README.md from the Github repository.

This package provides an executable, stackage-update, which provides the same functionality as cabal update (it updates your local package index). However, instead of downloading the entire package index as a compressed tarball over insecure HTTP, it uses git to incrementally update your package list, and downloads over secure HTTPS.

It has minimal Haskell library dependencies (all dependencies are shipped with GHC itself) and only requires that the git executable be available on the PATH. It builds on top of the all-cabal-files repository.

Advantages

Versus standard cabal update, using stackage-update gives the following advantages:

  • Only downloads the deltas from the last time you updated your index, threby requiring significantly less bandwidth
  • Downloads over a secure HTTPS connection instead of an insecure HTTP connection
    • Note that the all-cabal-files repo is also updated from Hackage over a secure HTTPS connection
Usage

Install from Hackage as usual with:

cabal update cabal install stackage-update

From then on, simply run stackage-update instead of cabal update.

Why stackage?

You may be wondering why this tool is called stackage-update, when in fact the functionality is useful outside of the Stackage project itself. The reason is that the naming allows it to play nicely with the other Stackage command line tooling. Concretely, that means that if you have stackage-cli installed, stackage-update works as a plugin. However, you can certainly use stackage-update on its own without any other tooling or dependencies on the Stackage project.

Future enhancements
  • If desired, add support for GPG signature checking when cloning/pulling from the all-caba-files repo
Categories: Offsite Blogs

Functional Jobs: Mid/Senior Software Development Engineer at Lookingglass Cyber Solutions (Full-time)

Planet Haskell - Thu, 04/16/2015 - 3:46pm

Lookingglass is the world leader in cyber threat intelligence management. We collect and process all source intelligence, connecting organizations to valuable information through its cyber threat intelligence monitoring and management platform.

Our solutions allow customers to continuously monitor threats far and near, such as the presence of botnets, hosts associated with cybercriminal networks, unexpected route changes and the loss of network resiliency.

We are seeking qualified Software Development Engineers to join our team!

Required Skills & Experience:

  • US Citizen or Green Card Holder
  • Location: MD/VA based
  • Bachelor’s or Masters degree in: computer science, engineering, information systems or mathematics
  • 3-5 yrs experienced with full development life-cycle with shipping products
  • 2+ yrs experienced with Functional and OO languages – have worked in functional paradigms with immutable data models
  • 3+ yrs building distributed system products including messaging, NoSQL, RPC / RMI mechanisms – Including building Service Orientated Architectures
  • Proficiency with data structure and algorithm analysis
  • Experienced working in a TDD Environment

Nice to Have:

  • Product development experience in network security, content security or cyber threat intelligence
  • Experience with concurrency models
  • Experience with key-value distributed databases
  • Experience deploying production software in Haskell, OCAML, Clojure, or Lisp
  • Comfortable writing one or more of the following Javascript, GoLang, Ruby

At Lookingglass, we believe our employees are our greatest assets. We offer competitive salaries, a full benefits package, with available medical, dental, vision, and disability insurance, a 401k retirement package, and stock options. We offer generous PTO, a well supplied kitchen, and regular team activities. Most importantly, we offer the opportunity to build a world-class product with a team of talented engineers.

Get information on how to apply for this position.

Categories: Offsite Blogs

Functional Jobs: Senior/Principal Software Development Engineer at Lookingglass Cyber Solutions (Full-time)

Planet Haskell - Thu, 04/16/2015 - 3:46pm

Are you an experienced software engineer in security, networking, cloud and big data? Are you interested in cyber security or improving the security of the Internet? Do you push yourself to be creative and innovative and expect the same of others?

At Lookingglass, we are driven and passionate about what we do. We believe that teams deliver great products not individuals. We inspire each other and our customers every day with technology that improves the security of the Internet and of our customer’s. Behind our success is a team that thrives on collaboration and creativity, delivering meaningful impact to our customers.

We are currently seeking qualified Senior/Principal Software Development Engineers to join our team!

Required Skills & Experience:

  • US Citizen or Green Card Holder
  • Location: MD/VA or CA based
  • Bachelor’s or Masters degree in:computer science, engineering, information systems or mathematics
  • Strong technical leader with proven experience leading project technologies and mentoring junior development team members
  • 7-10 yrsexperienced with full development life-cycle with shipping products
  • 4-8yrs experienced with Functional and OO languages – have worked in functional paradigms with immutable data models
  • 5+ yrs building distributed system products including messaging, NoSQL, RPC / RMI mechanisms, and Service Orientated Architectures
  • Proficiency with data structure, algorithm analysis, and concurrency programming
  • Experienced working in a TDD Environment
  • Comfortable with aggressive refactoring
  • Architectural and design skills to map a solution across hardware, software, and business layers in a distributed architecture

Nice to Have:

  • Product development experience in network security, content security or cyber threat intelligence
  • Experience with CSP concurrency models
  • Experience with key-value distributed databases
  • Experience deploying production software in Haskell, OCAML, Clojure, or Lisp
  • Polyglot programmer with production experience in imperative, declarative, OO, functional, strongly/weakly typed, static/dynamic, interpreted/compiled languages

Lookingglass believes our employees are our greatest assets. We offer competitive salaries, a full benefits package, with available medical, dental, vision, and disability insurance, a 401k retirement package, and stock options. We offer generous PTO, a well supplied kitchen, and regular team activities. Most importantly, we offer the opportunity to build a world-class product with a team of talented engineers.

Get information on how to apply for this position.

Categories: Offsite Blogs

Visual control/data flow withing a Haskell expression

Haskell on Reddit - Thu, 04/16/2015 - 11:16am

So there was a recent LightTable discussion that made me think about what a pure statically type language could offer in terms of "next-gen editors". Apart from explicit state and FRP libraries enabling live programming and time travelling debuggers a la Elm I was thinking about features like visualizing control and data flow right there in the editor. Compared to imperative languages, where data and control traditionally flow "top-to-bottom", following the data flow in functional languages is a bit harder, since call graph dependencies can jump all over the place, i.e:

f x = [...] y [...] where b = h w [...] y = g w x z [...] z = j b [...] w = h x

So I was thinking, what speaks against something like this:

[1] [2]

Hovering over different identifiers would show the links between the dependencies. Functions defined somewhere else could be shown in hovering windows next to the currently inspected code paragraph and so on. All of this of course nicely integrated into some future graphics-supporting version of vim/emacs :)

SourceGraph only shows dependencies between functions, without delving into the actual definitions.

I guess I'm not the first one to think of this, are there any projects trying to do something similar?

submitted by _pka
[link] [4 comments]
Categories: Incoming News

Ongoing IHG work to improve Hackage security

haskell-cafe - Thu, 04/16/2015 - 10:33am
All, The IHG members identified Hackage security as an important issue some time ago and myself and my colleague Austin have been working on a design and implementation. The details are in this blog post: http://www.well-typed.com/blog/2015/04/improving-hackage-security We should have made more noise earlier about the fact that we're working on this. We saw that it was important to finally write this up now because other similar ideas are under active discussion and we don't want to cause too much unnecessary duplication. The summary is this: We're implementing a system to significantly improve Hackage security. It's based on a sensible design (The Update Framework) by proper crypto experts. The basic system is fully automatic and covers all packages on Hackage. A proposed extension would give further security improvements for individual packages at the cost of a modest effort from package authors. http://theupdateframework.com/ It will also allow the secure use of untrusted public Hackage mirrors, w
Categories: Offsite Discussion

Functions for type level lists?

Haskell on Reddit - Thu, 04/16/2015 - 9:45am

In some of my work on trying to implement relational algebra in haskell, I often find myself writing functions (more accurately closed type families) that work on type level lists. Basic stuff, like subtraction, intersection, lookup, etc. Is there a package where someone has already done all of these? I'm already aware of Data.Promotion.Prelude.List from the singletons package, but the way the it determines type-level equality makes me uncomfortable (https://github.com/goldfirere/singletons/issues/106). So, if anyone has seen any packages that are basically Data.List but on the type level, I would appreciate hearing about them (plus, it just seems like someone would have done this already).

submitted by andrewthad
[link] [13 comments]
Categories: Incoming News

Philip Wadler: Blame and Coercion:Together Again for the First Time

Planet Haskell - Thu, 04/16/2015 - 9:33am

Blame and Coercion:Together Again for the First Time
Jeremy Siek, Peter Thiemann, Philip Wadler.
PLDI, June 2015.

C#, Dart, Pyret, Racket, TypeScript, VB: many recent languages integrate dynamic and static types via gradual typing. We systematically develop three calculi for gradual typing and the relations between them, building on and strengthening previous work. The calculi are: λB, based on the blame calculus of Wadler and Findler (2009); λC, inspired by the coercion calculus of Henglein (1994); λS inspired by the space-efficient calculus of Herman, Tomb, and Flanagan (2006) and the threesome calculus of Siek and Wadler (2010). While λB is little changed from previous work, λC and λS are new. Together, λB, λC, and λS provide a coherent foundation for design, implementation, and optimisation of gradual types.

We define translations from λB to λC and from λC to λS. Much previous work lacked proofs of correctness or had weak correctness criteria; here we demonstrate the strongest correctness criterion one could hope for, that each of the translations is fully abstract. Each of the calculi reinforces the design of the others: λC has a particularly simple definition, and the subtle definition of blame safety for λB is justified by the simple definition of blame safety for λC. Our calculus λS is implementation-ready: the first space-efficient calculus that is both straightforward to implement and easy to understand. We give two applications: first, using full abstraction from λC to λS to validate the challenging part of full abstraction between λB and λC; and, second, using full abstraction from λB to λS to easily establish the Fundamental Property of Casts, which required a custom bisimulation and six lemmas in earlier work.
Categories: Offsite Blogs

Philip Wadler: A complement to blame

Planet Haskell - Thu, 04/16/2015 - 9:32am


A complement to blame
Philip Wadler.
SNAPL, May 2015.

Contracts, gradual typing, and hybrid typing all permit less-precisely typed and more-precisely typed code to interact. Blame calculus encompasses these, and guarantees blame safety: blame for type errors always lays with less-precisely typed code. This paper serves as a complement to the literature on blame calculus: it elaborates on motivation, comments on the reception of the work, critiques some work for not properly attending to blame, and looks forward to applications. No knowledge of contracts, gradual typing, hybrid typing, or blame calculus is assumed.
Categories: Offsite Blogs

Developing 3D Tic-Tac-Toe on Arduino in Haskell

Haskell on Reddit - Thu, 04/16/2015 - 7:39am

Hi Haskell folks in reddit, and thank @CarstenKönig for introducing here :)

I am building a three-dimensional tic-tac-toe game. I have already built the game itself that runs in command prompt (https://github.com/ryo0ka/tictactoe3d), and now I am ready to build a system that runs the game on a cube of bi-color LED lamps and an input button.

As the input through the button and the output through the cube will happen simultaneously, this is going to be my first concurrent/reactive programming in functional languages. I am clueless at all. I have read and understood the basics of those programming concepts, but can't quite apply them to my problem.

  • What kind of strategy and library is suit to this problem? (I don't know if this is a legitimate question..) I'm so lost that I need advice even about where to start from/with.

  • (In the stragety/library above,) How can an even listener (or anything that reacts to certain events in the system) "update" data, how can such mutable data (which I expect are called rather like mutable reference because data themselves should be immutable) be used like, and how do you explain that it keeps the referential transparency (please ignore this question if nonsense)?

  • (In the stragety/library above,) How does it deal with such a kind of input that the user can unintentionally input many times? For example, it's hard for us to "tap" a button at just one point of time. I want my program to recognize such sequential inputs as a single input.

About lamps, button and any components, I am on the hArduino library (http://hackage.haskell.org/package/hArduino) which basically does all the FFI thing and provides free access to Arduino boards. So I have the method to operate them and am ready to dive in the FRP implementation phase.

Also I've already soldiered up the cube and everything (http://i.imgur.com/XJ4P1ZQ.png)

Thank you so much for reading my weird English, and I would appreciate a lot if you could give me any pieces of guide or information, and stick with this topic for my further questions. Thank you again!

This question is originally from my post on Stack Overflow (http://stackoverflow.com/questions/29674926/developing-a-simple-reactive-program-with-haskell). Thank you @CarstenKönig again for guiding me here :)

submitted by ryo0ka
[link] [6 comments]
Categories: Incoming News