News aggregator

What's wrong in my Data.Generic.Zipper code?

haskell-cafe - Sun, 07/10/2016 - 10:55am
Hello all, I do not understand why this simple piece of code returns Nothing instead of [1,2,3]. Can anybody help? {-# LANGUAGE BangPatterns,NoMonomorphismRestriction, DeriveDataTypeable #-} import Data.Typeable import Data.Data import Data.Generics.Zipper ex_list1 :: [Int] ex_list1 = [1,2,3] t1 = toZipper ex_list1
Categories: Offsite Discussion

The GHC Team: Rethinking GHC's approach to managing proposals

Planet Haskell - Sat, 07/09/2016 - 2:41pm

Recently there has been a ​fair bit of ​discussion around the mechanisms by which proposed changes to GHC are evaluated. While we have something of a formal proposal ​protocol, it is not clearly documented, inconsistently applied, and may be failing to serve a significant fraction of GHC's potential contributor pool.

Over the last few weeks, I have been doing a fair amount of reading, thinking, and discussing to try to piece together a proposal scheme which better serves our community.

The ​resulting proposal is strongly inspired by the ​RFC process in place in the Rust community, the leaders of which have thought quite hard about fostering community growth and participation. While no process is perfect, I feel like the Rust process is a good starting point for discussion, offering enough structure to guide new contributors through the process while requiring only a modest investment of developer time.

To get a sense for how well this will work in our community, I propose that we attempt to self-host the proposed process. To this end I have setup a ghc-proposals ​repository and opened a pull request for discussion of the ​process proposal. Let's see how this goes.


~ Ben

Categories: Offsite Blogs

Proposal and discussion: Deprecate Data.Set.mapMonotonic and Data.Map.mapKeysMonotonic; add correctly named functions

libraries list - Fri, 07/08/2016 - 6:49pm
We currently have a function mapMonotonic in Data.Set and one called mapKeysMonotonic in Data.Map. These names are confusing for two reasons: 1. In some mathematical contexts, a function is considered monotonic if it's *either* increasing or decreasing. 2. Even where monotonic specifically means *increasing*, it generally does *not* specifically mean *strictly increasing*. The functions in question work when, and only when, the given function is strictly increasing on the elements/keys in the set/map. I'd like to DEPRECATE these functions, and add new ones: Data.Set: mapStrictlyIncreasing and mapStrictlyDecreasing Data.Map: mapKeysStrictlyIncreasing and mapKeysStrictlyDecreasing Data.Map presents another possibility, however. We could make the replacements more general, giving them types Ord k => (k -> v -> (k', v')) -> Map k v -> Map k' v' and allowing the user to map over both keys and values in one pass. David Feuer _______________________________________________ Libraries mailing list Libraries< at >
Categories: Offsite Discussion

Position as lab docent Software Engineering at the University of Amsterdam

General haskell list - Fri, 07/08/2016 - 2:41pm
Dear all, I would like to draw your attention to the following job opening at the University of Amsterdam: <> This is a full-time teaching position in our MSc Software Engineering programme that is rated among the best ICT Master programmes in the Netherlands: We partially take a rather formal approach to software engineering and use Haskell in at least one of our courses. So the position might indeed be of interest to subscribers of this mailing list. After some local hickups the definitive and firm deadline for application is Monday July 11 any time Amsterdam time. If you have any questions, do not hesitate to contact me. Best regards, Clemens Grelck
Categories: Incoming News

Natural keys in Haskell data structures

haskell-cafe - Fri, 07/08/2016 - 2:35pm
Dear cafe, What is the idiomatic way to "split" records into their natural keys and content in a data structure? For example, given a user: data User = { username :: ByteString, hash :: ByteString, address :: Text, ... } Using map, a first choice would be Map ByteString User, but this leads to duplication of the username. And it is possible to make mistakes, such as insert "John" (User "Jane" ... What does cafe think? Is there any pattern for this? This is probably just a small nit in the overall architecture, but I'm curious to know the clean way to do it. Regards, Hon _______________________________________________ Haskell-Cafe mailing list To (un)subscribe, modify options or view archives go to: Only members subscribed via the mailman list are allowed to post.
Categories: Offsite Discussion

Chair in Information/Computer Security (Sheffield,UK)

haskell-cafe - Fri, 07/08/2016 - 2:04pm
(Apologies for duplicates) Dear all, The Computer Science Department of The University Of Sheffield has an open position for a Chair in Computer and Information Security. The new chair will lead a new research group in the Department of Computer Science and establish an agenda for security and privacy research across the wider university. Applications are welcome in all areas of computer and/or information security, including * Human factors and secure systems * Security aspects of distributed and autonomous systems Internet of things, cloud computing * Applications of secure systems Manufacturing, health, transport, robotics * Security analysis Intrusion monitoring, threat detection, links with machine learning and language processing * Secure software engineering (Both empirical and theoretical approaches) * Applied cryptography Applications in IT systems, homomorphic encryption For more information about the position and the Department, please visit
Categories: Offsite Discussion

Roman Cheplyaka: Debugging a CUPS Forbidden error

Planet Haskell - Fri, 07/08/2016 - 2:00pm

When I try to install a printer on a fresh Fedora 24 system through the CUPS web interface (http://localhost:631/admin/), I get

Add Printer Error Unable to add printer: Forbidden

Here’s the relevant part of the config file, /etc/cups/cupsd.conf:

<Limit CUPS-Add-Modify-Printer CUPS-Delete-Printer CUPS-Add-Modify-Class CUPS-Delete-Class CUPS-Set-Default CUPS-Get-Devices> AuthType Default Require user @SYSTEM Order deny,allow </Limit>

Now look at man cupsd.conf for the explanation:

Require user {user-name|@group-name} ... Specifies that an authenticated user must match one of the named users or be a member of one of the named groups. The group name "@SYSTEM" corresponds to the list of groups defined by the System‐ Group directive in the cups-files.conf(5) file. The group name "@OWNER" corresponds to the owner of the resource, for example the person that submitted a print job.

Let’s look at /etc/cups/cups-files.conf and find out what those groups are:

SystemGroup sys root

Alright, so the solution is:

sudo usermod -a -G sys feuerbach

(where feuerbach is my username).

Frankly, I think it’s a bug that an admin user cannot add a printer by default, but luckily it’s not hard to fix.

Categories: Offsite Blogs

3rd Call for Papers: OCL and Textual Modeling Tools and Textual Model Transformations (OCL 2016) - Less Than 10 Days Left To Submit Your Paper!

General haskell list - Fri, 07/08/2016 - 1:26pm
(Apologies for duplicates) Less than 10 days until the deadline! CALL FOR PAPERS 16th International Workshop on OCL and Textual Modeling Co-located with ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016) October 2, 2016, Saint-Malo, France Modeling started out with UML and its precursors as a graphical notation. Such visual representations enable direct intuitive capturing of reality, but some of their features are difficult to formalize and lack the level of precision required to create complete and unambiguous specifications. Limitations of the graphical notations encouraged the development of text-based modeling languages that either integrate with or replace graphical notations for modeling. Typical examples of such languages are OCL, textual MOF, Epsilon, and Alloy. Textual modeling languages have their roots in formal language paradigms like logic, programming an
Categories: Incoming News

3rd Call for Papers: OCL and Textual Modeling Tools and Textual Model Transformations (OCL 2016) - Less Than 10 Days Left To Submit Your Paper!

haskell-cafe - Fri, 07/08/2016 - 1:26pm
(Apologies for duplicates) Less than 10 days until the deadline! CALL FOR PAPERS 16th International Workshop on OCL and Textual Modeling Co-located with ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016) October 2, 2016, Saint-Malo, France Modeling started out with UML and its precursors as a graphical notation. Such visual representations enable direct intuitive capturing of reality, but some of their features are difficult to formalize and lack the level of precision required to create complete and unambiguous specifications. Limitations of the graphical notations encouraged the development of text-based modeling languages that either integrate with or replace graphical notations for modeling. Typical examples of such languages are OCL, textual MOF, Epsilon, and Alloy. Textual modeling languages have their roots in formal language paradigms like logic, programming an
Categories: Offsite Discussion

Strange error with cabal install on windows:

haskell-cafe - Fri, 07/08/2016 - 9:06am
I've got an error that I don't know how to fix with cabal install. Has anyone experienced such a thing? It installs fine on ubuntu but fails to install on windows 7. It's my own package called `sharc-timbre`: ~~~ Building sharc-timbre-0.1... Preprocessing library sharc-timbre-0.1... C:\Program Files\Haskell Platform\8.0.1\bin\ghc.exe: createProcess: does not exist (No such file or directory) cabal: Leaving directory 'C:\Users\антон\AppData\Local\Temp\cabal-tmp-4484\sharc-timbre-0.1' ~~~ Thanks, Anton _______________________________________________ Haskell-Cafe mailing list To (un)subscribe, modify options or view archives go to: Only members subscribed via the mailman list are allowed to post.
Categories: Offsite Discussion

Brent Yorgey: Eastman maximal comma-free codes in Haskell

Planet Haskell - Thu, 07/07/2016 - 8:32pm

This past January I watched a video of Don Knuth’s most recent annual Christmas lecture. Typically his Christmas lectures have been about trees, but breaking with tradition, he gave this lecture about comma-free codes, and presented an implementation of an interesting algorithm due to Willard Eastman. Of course his implementation was written in CWEB, and during the course of the lecture he noted that his algorithm was iterative, and he didn’t know of a nice way to write it recursively (or something like that). Naturally, that sounded like a challenge, so I implemented it in Haskell, and I think it came out quite nicely. (It still uses “iteration” in the sense of the iterate function, but of course that uses recursion, so…?) Unfortunately, that was in January, it is now July, and I don’t really remember how it works. So I decided I had better write about it now, before I forget even more about how it works.

A comma-free code is a set of strings such that if you concatenate any two strings in , the result does not contain any elements of as internal substrings. The term “comma-free” refers to the fact that sequences of strings from can be unambiguously concatenated, without the need for separators like commas. Even if you start reading somewhere in the middle of a message, you can unambiguously figure out how to partition the message into codewords. For example, {bear, like} is a comma-free code, but {bear, like, earl} is not, since bearlike contains earl as a substring. A comma-free code also obviously cannot contain any periodic strings (that is, strings which consist of repeated copies of some shorter string), like abcabc, since concatenating such a string with itself produces a string containing the same string as an internal prefix.

Given a fixed alphabet and codeword length, one is naturally led to ask how large a comma-free code can possibly be. Eastman solved this problem for odd codeword lengths, by showing how to construct a maximal commafree code. To understand Eastman’s solution, consider the set of all aperiodic strings of length over an alphabet (we have already seen that periodic strings cannot be part of a comma-free code). Consider two strings equivalent if they are rotations of each other. For example, bear, earb, arbe, and rbea are all equivalent. This is an equivalence relation on strings, and so it defines a partition of into classes of equivalent strings. Note that we can never have two equivalent strings as part of the same comma-free code, since if we concatenate a string with itself, the result contains all other equivalent strings as substrings. For example, bearbear contains earb, arbe, and rbea. So at most a comma-free code could contain one string from each equivalence class.

In fact, Eastman shows that for odd there are comma-free codes that contain exactly one string from each equivalence class! What’s more, his proof is constructive: he shows how to pick a particular, canonical representative from each equivalence class such that the collection of all such canonical representatives is a comma-free code. This is what the program below does: given an odd-length string, it outputs the canonical rotation of that string which is part of a maximal comma-free code.

So, without further ado, let’s see the implementation! Again, I really don’t remember much about the details of how (much less why) this works. For that, I recommend watching Knuth’s lecture or reading the explanations in his code (you’ll probably want to compile it into LaTeX first).

First, some imports and such. Look, ma, no LANGUAGE extensions!

> module Commafree where > > import Control.Arrow (first) > import Control.Monad (when) > import Data.List (findIndex, intercalate) > import Data.List.Split > import Data.Maybe (catMaybes) > import Data.Monoid ((<>)) > > import System.Environment > import System.Exit > import Text.Printf > import Text.Read (readMaybe)

Here’s the main Eastman algorithm, which actually works for any list of things with a total order (unlike Knuth’s, which only works for lists of nonnegative integers, although that is obviously just a cosmetic difference, since any finite set with a total order is isomorphic to a set of nonnegative integers). We turn each item into a singleton “block”, then iterate the eastmanRound function, which partitions the blocks into subsequences of blocks, which we coalesce into blocks again. So each iteration makes the partition coarser, i.e. the blocks get bigger. We keep iterating until there is only one block left, which contains the rotation that we seek.

> eastman :: Ord a => [a] -> [a] > eastman > = blockContent . head . head > . dropWhile ((>1) . length) > . iterate (map mconcat . eastmanRound) > . map mkBlock

Some code for dealing with blocks. A block is just a list that keeps track of its length for efficiency. The important point about blocks is that they are ordered first by length, then lexicographically (see the Ord instance below). The Monoid instance is straightforward.

> data Block a = Block { blockLen :: !Int, blockContent :: [a] } > deriving (Show, Eq) > > instance Ord a => Ord (Block a) where > compare (Block m as) (Block n bs) > = compare m n <> compare as bs > > instance Monoid (Block a) where > mempty = Block 0 [] > mappend (Block m as) (Block n bs) = Block (m+n) (as ++ bs) > > mkBlock :: a -> Block a > mkBlock a = Block 1 [a]

One round of the algorithm works as follows: we duplicate the list, partition it after each “dip” (chop splitDip, to be explained below), possibly drop some of the leading parts and coalesce other parts based on size parity (pickOdds), and then keep only a total amount of stuff equal to the length of the original list (takeTotal). This last part with takeTotal ensures that we will end up with something which is a rotation of the original input (though partitioned). In an implementation with random-access arrays, one would just wrap the indices around using mod; in this context it’s easier to first duplicate the input list so we can deal with all rotations at once, determine which rotation we want by dropping some stuff from the beginning, then drop any excess stuff at the end.

> eastmanRound :: Ord a => [a] -> [[a]] > eastmanRound as > = takeTotal (length as) > . pickOdds > . chop splitDip > $ (as ++ as)

It’s interesting to note that in eastmanRound the type a is actually going to be instantiated with Block b for some type b. In the first round, all the blocks are singletons, so this is no different than just taking a list of b. But in subsequent rounds the distinction is nontrivial.

A “dip” is a decreasing substring followed by a single increase, for example, 976325. (Though again, remember that we are actually dealing with sequences of blocks, not integers, so a dip is essentially a sequence of blocks of decreasing length followed by a longer one, with the requisite caveat about blocks of the same length.) splitDip looks for the first place in the list that looks like and breaks the list right after it. This is used with the chop function to split the list into a sequence of dips.

> splitDip :: Ord a => [a] -> ([a],[a]) > splitDip (a:b:cs) > | a < b = ([a,b], cs) > | otherwise = first (a:) (splitDip (b:cs)) > splitDip as = (as,[])

pickOdds does something like the following: it looks for maximal sequences of dips where the first dip has odd length and the rest have even length, and merges such sequences into one long partition. It also drops everything prior to the first odd dip. Something like that at least; my memory on this is a bit fuzzy.

> pickOdds :: [[a]] -> [[a]] > pickOdds > = map concat > . dropWhile (even . length . head) > . drop 1 > . splitAtOdds > > splitAtOdds :: [[a]] -> [[[a]]] > splitAtOdds = chop $ > \(x:xs) -> let (ys,zs) = break (odd.length) xs > in (x:ys, zs)

Finally, takeTotal just takes lists until their total length matches the given total.

> takeTotal :: Int -> [[a]] -> [[a]] > takeTotal _ [] = [] > takeTotal n _ | n <= 0 = [] > takeTotal n (xs:xss) = xs : takeTotal (n - length xs) xss

And that’s it! I also put together a main which more or less emulates what Knuth’s C program does. My program and Knuth’s give the same output on every example I have tried (except that Knuth’s prints out some intermediate information about each iteration step; mine just prints the final answer).

> main :: IO () > main = do > progName <- getProgName > args <- getArgs > let n = length args > when (n < 3) $ do > printf "Usage: %s x1 x2 ... xn\n" progName > exitWith (ExitFailure 1) > when (even n) $ do > printf "The number of items, n, should be odd, not `%d'!\n" n > exitWith (ExitFailure 2) > let ns :: [Maybe Int] > ns = map readMaybe args > case findIndex (maybe True (<0) . snd) (zip [1..] ns) of > Just i -> do > printf "Argument %d should be a nonnegative integer, not `%s'!\n" > i (args !! (i-1)) > exitWith (ExitFailure 3) > Nothing -> > putStrLn . > (' ' :) . intercalate " " . map show . > eastman . catMaybes $ ns
Categories: Offsite Blogs

Call for participation: PPDP 2016

General haskell list - Thu, 07/07/2016 - 3:15pm
============================================================ CALL FOR PARTICIPATION: PPDP 2016 18th International Symposium on Principles and Practice of Declarative Programming Edinburgh, UK, September 5-7, 2016 co-located with LOPSTR 2016 26th International Symposium on Logic-Based Program Synthesis and Transformation Edinburgh, UK, September 6-8, 2016 and SAS 2016 23rd Static Analysis Symposium Edinburgh, UK, September 8-10, 2016 ============================================================ Registration is now open: **Early registration until August 15** INVITED TALKS * Elvira Albert: Testing of Concurrent and Imperative Software using CLP * Greg Morrisett (jointly with LOPSTR'16): TBD * Francesco Logozzo (jointly with LOPSTR'16): TBD ACCEPTED PAPERS - Davide Fuscà, Stefano Germano, Jessica Zangari, Marco Anastasio
Categories: Incoming News


General haskell list - Thu, 07/07/2016 - 2:42pm
** We apologize if you receive multiple copies of this message ** ================================================================== The 14th ACM International Symposium on Mobility Management and Wireless Access (MobiWac 2016) November 13 - 17, 2016 - Malta ================================================================== The MOBIWAC series of event is intended to provide an international forum for the discussion and presentation of original ideas, recent results and achievements by researchers, students, and systems developers on issues and challenges related to mobility management and wireless access protocols. To keep up with the technological developments, we also open up new areas such as mobile cloud computing starting from this year. Authors are encouraged to submit both theoretical and practical results of significance on all aspects of wire
Categories: Incoming News

[ANN] processing-for-haskell. New graphics andanimation package

haskell-cafe - Wed, 07/06/2016 - 11:22am
I'd like to announce a graphics libary processing-for-haskell (available on Hackage). It tries to implement Processing language with Haskell. Processing is an imperative DSL for graphics and animation. It's very easy and fun to use. Intended to be used by non-programmers it has very small but powerful core of functions. It's a shallow EDSL. The Processing is implemented with OpenGL and GLUT. That gives us an opportunity to use all Haskell IO-functions inside the animation loop. Enjoy! github: hackage: _______________________________________________ Haskell-Cafe mailing list To (un)subscribe, modify options or view archives go to: Only members subscribed via the mailman list are allowed to post.
Categories: Offsite Discussion

Space-leak incurred by constraints

glasgow-user - Wed, 07/06/2016 - 9:08am
Hi, The following reduced test-case: > {-# LANGUAGE DataKinds, TypeOperators, TypeFamilies, ConstraintKinds, > FlexibleContexts, BangPatterns #-} > module ConstraintLeak where > > import GHC.TypeLits > import Data.Proxy > > type Constraint1 n > = ( Constraint2 n > , Constraint2 (2^n) > ) > type Constraint2 n > = ( KnownNat n > , ((n-1)+1) ~ n -- Comment this line to run in constant space > ) > > test :: Constraint1 x => Proxy x -> String > test !s | s == s = test s > > main :: IO () > main = putStr (test (Proxy :: Proxy 3)) contains a space-leak when compiled without optimisations (i.e. -O0 or in GHCi). It's true that the code doesn't actually do anything (when compiled with -O you get "Exception <<loop>>"), but I'm using it to exemplify some code that runs for some time, and then prints something. As you can see, 'test' is strict in its arguments, but it seems lazy in its constraints. When I look at the heap profile (-hy), I see it ra
Categories: Offsite Discussion

Haskell Data Structure design

haskell-cafe - Wed, 07/06/2016 - 2:26am
Hello All, I am just getting myself to code in Haskell and would like to design advice. Below, I have a made up example: data ClassRoom = ClassRoom { classRoomNo:: Integer, extra_fees::Float, students: Map StudentId Student} data Student = Student {name::String, feesOwed::Float} data StudentId = Integer get_fees_owed classroom student_id = extra_fees + feesOwed $ (students classroom) M.! studentid Here the `get_fees_owed` needs information from the container 'classroom'. Here is my question/problem: I believe I should model most of my code as expressions, rather than storing pre-computed values such as `fees_owed`. But, defining expressions involve passing the container objects all over. For example, deep down in a function that deals with just one `student`, I might need the fees owed information. Without, having a reference to the container, I cannot call get_fees_owed. Also, I think it hinders composing of functions that just deal with one student at a time, but end up with some dependen
Categories: Offsite Discussion

Yesod Web Framework: Implementing HTTP/2 server push

Planet Haskell - Wed, 07/06/2016 - 1:10am
What is HTTP/2 server push?

Server push is a hot topic of HTTP/2. Effective usage of server push can improve user experience. For instance, let's consider a scenario: downloading "index.html" which requires "style.css".

If a browser uses HTTP/1.1, it gets the "index.html" first, parses it, then obtains "style.css". So, two round-trip-times (RTTs) are necessary before the browser starts rendering.

On the other hand, if a browser uses HTTP/2 and the corresponding server supports server push, only one RTT is necessary. That is, when the browser send a GET request for "index.html", the server pushes "style.css" before it transfers "index.html". When the browser parses "index.html", it finds "style.css" in its local cache. Thus, it can start rendering at this timing.

APIs for server push

So, how can we implement HTTP/2 server push in Warp? Clearly, it is necessary for an application to tell Warp what files should be pushed. One way is to extend the Response type to store information on server push. But this breaks compatibility. We need to modify all existing applications.

To keep all existing types as is, I decided to use vault in the Request type. Vault is a heterogeneous infinite map which can store any type. Warp creates a new IORef and store its getter and setter to the vault:

getHTTP2Data :: Request -> IO (Maybe HTTP2Data) setHTTP2Data :: Request -> Maybe HTTP2Data -> IO ()

HTTP2Data is the data type to store a list of files to be pushed. An application can set files to be pushed by setHTTP2Data. Warp retrieves them by getHTTP2Data and pushes them before sending the corresponding Response.

Note that the vault is a part of Web Application Interface (WAI) but these two functions are not. They are APIs provided only by Warp.

Middleware for server push

The next question is how an application knows which files to be pushed for a given URL. One way is manifest files.

Another way is learning based on Referer:. This idea came from Jetty. Typically, there is the Referer: whose value is, say,", in a GET request to "style.css". So, analyzing requests for a while, we can learn that "style.css" should be pushed when "index.html" is requested.

@davean suggested that I implement this mechanism as a middleware. So, I created a middleware for HTTP/2 server push based on Referer:. Its default behavior for a given Request and Response is as follows:

  • If files to be pushed are found for a given path in a learning dictionary, set them by setHTTP2Data.
  • Otherwise, register the file of Response to the learning dictionary only when the following conditions are met:
  1. The Request stores a valid Referer:
  2. The Response is a file type
  3. The path of Referer: is "/" or ends with ".html"/".html"
  4. The path ends with ".js" and ".css"

The learning dictionary is cleared every 30 seconds.

Warp v3.2.7 with the push APIs and wai-http2-extra v0.0.0 with the middleware are already on Hackage. If you implement a server push middleware based on manifest files, please send a pull request on github.


Here are screen shots of Firefox accessing the new Warp. The first figure is the first access and the middleware has not learned anything. So, no pushes are used.

The second figure is the second access. You can see .js and .css files are pushed since bullets are not green.

Next Step

The next step would be an implementation of Cache Digests for HTTP/2. In this scheme, a browser can tell a list of cached file to a server. So, the server can avoid unnecessary pushes.


Efforts to bring HTTP/2 server push feature to Warp was originally made by Andrew Pritchard. Without his experience and suggestions, this work would be impossible. I thank him deeply.

Categories: Offsite Blogs

Haskell in Leipzig 2016: Another Call for Papers(deadline extended)

haskell-cafe - Tue, 07/05/2016 - 6:39pm
                             Haskell in Leipzig                             September 14-15, 2016                             HTKW Leipzig, Germany                 We have received good and interesting proposals, but our schedule still has room for more. So whether you wanted to submit, but just did not make the first deadline, or whether you only now decide to come to Leipzig, this is your chance: Please submit your short abstract until Friday, July 15th. Do you need ideas? Here some possible directions:  * Very fancy type tricks using all  of GHC’s extensions.  * Very fancy type tricks using none of GHC’s extensions.  * Getting Haskell to run really really fast.  * Using Haskell to make real money, in real life.  * Showing how this one odd Haskell library make doing something    appear rally simple.  * Stuff that is really horrible with Haskell (and how to do
Categories: Offsite Discussion

The team: New

Planet Haskell - Tue, 07/05/2016 - 6:00pm

By the team: Chris Done, Chris Allen, Julie Moronuki, Michael Snoyman, Sibi Prabakaran, Gabriel Gonzalez

We are happy to announce the launch of a new Haskell community nexus site: This website is aimed at providing modern best practices information for the Haskell programming language, and in particular with providing the best possible new user experience. The aim is to lower the barrier to getting started with Haskell, and ultimately increase adoption of Haskell in the greater programming community.

The launch of this website is paired with the launch of a number of additional community resources to aid its growth:

These community resources are open to all to discuss the contents of the website, and more broadly how to make Haskell as welcoming a language, community, and ecosystem as can be managed. We encourage all Haskellers to join, and to take part in lively discussions of how to improve the state of the art within Haskell.

As this community is just forming, now is the perfect time to get involved. Post questions and comments on Reddit, Tweet to us, send pull requests for the website, and open issues. This community will become what you put into it, so help shape it from the beginning!

Why a new site?

Since it is a common question in such statements, let us ask it directly here: why create a new website instead of working to incrementally update In the opinion of the team behind, the tooling story and general ecosystem infrastructure for the Haskell community has accumulated enough baggage that a clean break is the best use of everybody's time. We intend to streamline the on-boarding process for new developers, move away from infrastructure that is showing its age, and embrace newer approaches to facilitate open collaboration. Similar decisions have already been made in creating the Stack build tool and Stackage.

Categories: Offsite Blogs

Joachim Breitner: HaL deadline extended

Planet Haskell - Tue, 07/05/2016 - 11:40am

There is this long-running workshop series Haskell in Leipzig, which is a meeting of all kinds of Haskell-interested folks (beginners, experts, developers, scientists), and for year’s instance, HaL 2016, I have the honour of being the program committee chair.

The original deadline passed last week, and after looking through the submissions it became clear that although the quality was good, the quantitiy was still lacking. I therefore extended the submission deadline by two weeks, until July 15th.

So if you have something worth talking about, please do submit a proposal1 and come to Leipzig!.

Why should you submit here? Because it gives you a platform to talk about your ideas to an audience that usually does not consist just of your fellow speakers, as it is often with purely academic workshops, but “real” listeners of various kinds. And it is a fun event.

And why should you come to Leipzig? Because of all the interesting talks and tutorials! Of course I cannot say a lot here yet, besides that our invited speaker Alejandro Russo from Chalmers and Gothenburg University will present his work on information-flow control in Haskell (i.e., SecLib, LIO, MAC, HLIO).

  1. And if you want to save me from sleepless nights, submit the first version a few days before the deadline…

Categories: Offsite Blogs