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 style. 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 have decided to highlight only the most important milestones, so no lengthy paragraphs and descriptions this time. We are 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 power. For example, ML, Hope and Miranda. (From Miranda, the future language will take its semantics.)
The independent development of each of these languages and the development of functional programming as a whole became ineffective because none of these languages had the critical mass of users and language-design effort. 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. To create a language, taking into account all the problems that existed at that time in other disparate functional languages, as well as in order to popularize functional programming, a committee was organized there. From this point 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 first Haskell Report from the committee involved in its development was published 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 is responsible. This was a serious first step — a language appeared around which a community of researchers and developers began to form.
Two years later, in 1992, the first Haskell tutorial was published. It was “Gentle introduction to Haskell” written by Hudak and Fasel. Also, it is the year of creation for GHC, the most commonly-used native code compiler for Haskell language.
GHC is developing and has more than 400 contributors by now. Since 2009, third-party contributions to GHC have been funded by the Industrial Haskell Group. In this video, you can see the development of GHC from 1996 to 2019.
You can find a lot there — online communities, Haskell events and conferences, books, courses, tutorials and manual pages. Also, you can download all the necessary stuff to start, like Haskell toolchain, which is represented in 3 versions — from minimal to platform.
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 was 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.
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).
But 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.
That’s the story of Haskell from its foundations to nowadays. The language continues to develop and all of these processes are nothing without the people who contribute, fix and do significant improvements to make it work in a proper way.
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!
Originally published at https://serokell.io.