Haskell. History of a Community-Powered Language
Before we go back to the first steps in the history of Haskell, let’s refresh what we already know about functional programming (FP). Functional programming is a way of designing software code by composing pure functions, avoiding shared state, mutable data, and side-effects. It is a declarative type of programming: its main focus is on “what to solve” in contrast to an imperative style where the main focus is “how to solve”.
You can find a lot of different tutorials, articles and blog posts about Haskell and functional programming, but we suggest you to start from this book written by Graham Hutton. Also, we have a Haskell course prepared together with ITMO scientists and suitable for newcomers. But if you are experienced Haskeller with a wizard beard, don’t waste your time on such basic things – better check out our Haskell-related blog posts.
Here, we focus on the history of Haskell, the main programming language at Serokell. We will highlight only the most important milestones, so no lengthy paragraphs and descriptions this time. Are you ready to travel to the roots?
The Radical 80’s
In the 80s, functional languages might have been radical and elegant, but they were also laughably impractical.
By the late 80s, FP community faced a problem caused by the emergence of a number of functional programming languages that were quite similar in their semantics and expressive power. For example, ML, Hope, and Miranda. (From Miranda, the future language will take its semantics.)
Since none of these languages had a critical mass of users and design effort, their development was quite ineffective. Neither had a stable foundation for real applications development.
The first milestone in the History of Haskell is dedicated to the FPCA ‘87 conference, which was held in Portland, Oregon. A committee was organized there, with the goal to create a language that would take into account all the problems of other disparate functional languages.
As you might have guessed, here begins the story of a statically typed, purely functional programming language, named after an American mathematician and logician Haskell Brooks Curry.
The Productive 90’s
The committee published its first Haskell Report on April 1, 1990.
The report described the motivation for creating the language, the nature of the language and the process of its creation, for which the committee was responsible. This was a momentous first step – a community of researchers and developers began to form around the language.
Two years later, in 1992, the first Haskell tutorial was published. It was “Gentle introduction to Haskell”, written by Hudak and Fasel. Also, 1992 is the year of creation for GHC, the most commonly used Haskell compiler.
(GHC is being actively developed and has more than four hundred contributors by now. In this video, you can see the development of GHC from 1996 to 2019.)
In 1994, John Peterson registered the haskell.org domain name and set up a server and website at Yale. You can find a lot of stuff there – online communities, Haskell events and conferences, videos, documentation, and all the necessities for Haskell development.
In 1996, the Haskell version 1.3 Report was published, edited by Hammond and Peterson.
Haskell 1.3 featured some very significant changes:
- A Library Report was added, reflecting the fact that programs can hardly be portable unless they can rely on standard libraries.
- Monadic I/O made its first appearance, including the “do” syntax, and the I/O semantics in the Appendix were dropped.
- Type classes were generalised to higher kinds – so-called “constructor classes”.
- Algebraic data types were extended in several ways: newtypes, strictness annotations, and named fields.
In the late 90’s, Haskell continued to develop, many small flaws in the language design and ambiguities in the report were discovered.
But now, let’s return to our times.
21st Century for the Haskell programming language
In 2005, at Haskell Workshop, John Launchbury called for a definition of “Industrial Haskell” to succeed Haskell 98. So many extensions had appeared since the latter was defined that few real programs adhered to the standard. A new committee was formed to design the new language, appropriately named Haskell′ (Haskell Prime).
After several years exploring the design space, it was decided that a single monolithic revision of the language was too large a task, and the best way to make progress was to evolve the language in small incremental steps, each revision integrating only a small number of well-understood extensions and changes.
Haskell 2010 was the first revision created in this way. The most significant language changes in Haskell 2010 relative to Haskell 98:
- A Foreign Function Interface (FFI).
- Hierarchical module names, e.g. Data.Bool.
- Pattern guards.
- Removal of the (n + k) pattern syntax.
It is the most important point in the modern history of Haskell development and it is also the current standard for most Haskell developers.
Today, the main Haskell compiler – GHC – adheres to the Haskell 2010 standard, and improves it with multiple language extensions, opt-in features that modify the standard. Some of the more important directions for improvements are linear types and dependent types. There have been efforts to create a new language standard, Haskell 2020, but those have largely stalled for now.
Meanwhile, the Haskell programming language continues to develop and all of these processes are nothing without the people who contribute, fix, and do significant improvements to it.
Haskell for us is not only a great tool, but a wonderful example of a programming language built around the community. Thanks to all who have worked hard on this functional language before us and continue to work on it today!