History of programming languages: how Haskell became the standard of functional programming

The theoretical foundations of imperative programming were laid back in the 1930s by Alan Turing and John von Neumann. The theory underlying the functional approach was formed in the 1920s and 1930s. Among the developers of the mathematical foundations of functional programming are Moses Schönfinkel (Germany and Russia) and Haskell Curry (England), and Alonzo Church (USA). Schönfinkel and Curry laid the foundations of combinatorial logic, and Church is the creator of lambda calculus.

Functional programming is based on ideas from combinatorial logic and lambda calculus.
')
But the theory remained the theory until, in the early 50s of the last century, John McCarthy developed Lisp (1958), which became the first almost functional programming language. For many years, Lisp had no competitors. Later, functional programming languages ​​APL (1964), ISWIM (1966) and FP (1977) appeared, which were not widely used.

Over time, Lisp has ceased to meet some of the requirements of software developers, especially with the growth in the size and complexity of the program code. In connection with this circumstance typification began to play an increasing role. In the late 1970s - early 1980s, typing models were intensively developed that were suitable for functional languages.

Most of these models included support for such powerful mechanisms as data abstraction and polymorphism. Many typed functional languages ​​have appeared: ML, Scheme, Hope, Miranda, Clean and many others. In addition, the number of dialects has steadily increased.

ML (1973) - first Hindley – Milner type language;
Scheme (1975) is one of the two most popular Lisp language dialects;
SASL, KRC, Miranda (1972–1985) - one of the first lazy languages;
Hope (1980) is one of the first languages ​​with algebraic data types.

Haskell Curry

As a result, it turned out that almost every functional programming group used its own language. This prevented the further spread of these languages ​​and gave rise to numerous problems.

The history of Haskell begins in 1987. One after another, new functional programming languages ​​appeared. After the release of Miranda (Research Software Ltd, 1985), interest in lazy computation grew: by 1987, more than a dozen nonstrict purely functional programming languages ​​had appeared.

Miranda was the most widely used, but it was proprietary software. At the conference on functional programming languages ​​and computer architecture (FPCA, 1987) in Portland (Oregon), participants agreed that a committee should be created to define an open standard for such languages. The purpose of the committee was to unite the existing functional languages ​​into one common, which would provide a basis for future research in the development of functional programming languages.

This is how Haskell appeared. It was named after one of the founders of the combinatorial logic Haskell Curry.

By the end of the 1980s, many functional languages ​​had been created. Some of them had a significant impact on Haskell:



The new language was supposed to be a free language suitable for research activities and solving practical problems. Free languages ​​are based on a standard that is formulated by a design committee. Then anyone can do the implementation of the standard, write a language compiler. The first version of the Haskell standard was published on April 1, 1990.

Haskell 1.0 - 1.4

The first version of Haskell (Haskell 1.0) was released in 1990. The committee’s attempts resulted in a series of language implementations (1.0, 1.1, 1.2, 1.3, 1.4).

Haskell 98

At the end of 1997, versions of Haskell 98 needed to be specified into one stable, minimal and portable version of the language and the accompanying standard library for study, as the basis for future development. The committee positively accepted the creation of extensions and variations of haskell 98 by adding and implementing experimental features.

In February 1999, the Haskell 98 standard was first published as The Haskell 98 Report. In January 2003, the revised version was published as “Haskell 98 Language and Libraries: The Revised Report”. The language continued to evolve rapidly, the implementation of the Glasgow Haskell Compiler (GHC) compiler represents the actual standard of the language.

Haskell 2010

The modern standard of Haskell - Haskell 2010 - was announced on November 24, 2009; GHC supports it from version 7.0.1.

Compared with Haskell '98, it contained the following changes:

• Do and If Then Else
• Hierarchical modules
• Empty variable declarations
• Sustainability solution
• Interface of third-party functions
• Linear comment syntax
• Guard patterns
• Lightweight dependency analysis
• Language guidelines (pragma)
• Lack of n + k patterns



Additional changes were published on January 7, 2011:

• Lack of data type context
• Bulleted Variable Lists

Haskell continues to evolve today. But stable versions rely on the standards of 1998 and 2010, respectively. But besides them, Haskell includes many extensions, new ideas are constantly being introduced. Several countries of the world work on the language - these are England, the Netherlands, America and Australia. The interest in Haskell is caused by the popularity of multiprocessor technologies. The Haskell model is well suited for parallel computing.

From the creator of Haskell

Curry is a general purpose embedded programming language implemented on top of Haskell. The Curry language seamlessly combines functional programming capabilities (nested expressions, higher-order functions, lazy calculations), logical programming (logical variables, partial data structures, embedded search) and programming methods for parallel systems (parallel computation of expressions synchronized with logical variables ).

Moreover, the Curry language provides additional mechanisms compared to pure programming languages ​​(compared to functional languages, searching and computing from incomplete data, compared to logical languages, a more efficient calculation mechanism due to determinism and calling for functions as necessary).

Popularity

On the site Github now occupies the 23rd line of popularity among programming languages.

In the TIOBE index it is on the 38th place:



In the RedMonk rating, Haskell is quite high - at the 16th position. In this case, the ranking is based on an estimate of the combination of popularity on GitHub, plus the active discussions on Stack Overflow.

Projects

Haskell has implemented many complex projects:

• Compilers and other development tools.

• Distributed version control system Darcs .

• xmonad window manager.

• HAppS Web Application Server .

• Perl 6 Pugs Interpreter / Compiler.

• House operating system.

• Lava hardware description language.

• Natural language processing system LOLITA.

• Systems of proof by Equinox / Paradox and Agda theorems.

Facebook

Spam filtering is one of the most important tasks that Facebook engineers are doing. The largest social network handles messages from over 1.5 billion people, so you can estimate the scale of the problem. In 2015, the company introduced new anti-spam filters, for the development of which it used the Haskell programming language.



Despite his youth, experimental status and relatively low popularity, Facebook chose Haskell to create an important module. One of the engineers, Louis Brandy (Louis Brandy), who is in the group of developers of the new anti-spam filter, spent two years on this project together with his colleagues. In an interview with Wired, he explained what they were guided by.

Louis Brandy, carefully choosing the words, called Haskell ideal for implementing the spam filter on Facebook, because it handles parallel tasks perfectly and allows developers to easily and conveniently set these tasks on the fly. Facebook is such a big project, and spammers change tactics so quickly that they need a tool to develop and constantly modify spam filters, which will take effect immediately.

If you look at the development of the modern Internet, then this path should be followed by many Internet projects for which scalability and real-time response are important. According to the developers of Facebook, the Haskell language has every chance of widespread popularity. The only thing that hinders is the fact that Haskell is quite different from other languages ​​- and this makes it difficult to migrate to it massively.

Nevertheless, the industry is moving in the right direction, as shown by the example of new programming languages ​​oriented towards parallel processes, for example, Go from Google and Rust from Mozilla. They may not be as effective as Haskell, but it’s easier to learn. In any case, Haskell can be thankful for the fact that he pushed the development of other programming languages ​​and contributed to the launch of new promising projects.

Evgeny Kozlov, in his blog, told about impressions from working with Haskell:

disadvantages

First of all - the high threshold of entry into the language. Yes, Haskell is beautiful, clean and laconic, but this is achieved not for free, but by long rebuilding the brain and learning complex abstractions such as monads, monad transformers, lenses and machines.

The second is the complexity of writing productive code. Since all code in Haskell is lazy, you can easily achieve such a situation when gigabytes of delayed computations are stored in memory, but they are not calculated because they are not yet requested.

Positive sides

First of all, of course, the purity of the language. Purity in both senses: purity of functions and the complete absence of the OOP paradigm. It's great that you can look at the function signature and see if it can produce side effects or not. The lack of OOP means that there is no way to do terrible things like untested casts from the base class to the subclass.

If code is written, it is difficult to interpret it in two ways. For example, you cannot confuse the use of a function with a reference to a function, as in Scala, since functions in Haskell are first class objects. Or, for example, you cannot confuse a function with a type or class, since all functions must begin with a small letter, and types / classes must begin with a large letter.

The language feature, without which talking about Haskell would be meaningless, is polymorphism. It is hardly an exaggeration if I say that Haskell is a language with the maximum amount of code reused. Any kind of repetitive functionality is brought into abstraction.