Functional Programming (2) History

About Functional Languages and LISP

A functional language is a type of programming language that is structured around defining and calling functions, which are designed to take input values, process them, and return output values. Instead of using variables, functional languages use functions to process data. The function itself is also treated as a kind of value, so a function can be passed as an argument or returned as a return value.

Typical functional languages include Haskell, Lisp, ML, and OCaml. These languages have features such as static typing and type inference that can increase code maintainability and safety. Advantages of functional languages include the following

• Because side effects can be suppressed, programs are easier to understand and debug.
• Because they are suitable for parallel processing, they can efficiently utilize multi-core CPUs.
• Code reusability and maintainability are higher.

On the other hand, one of the challenges of functional languages is that they are more expensive to learn than object-oriented languages.

The oldest of these functional languages is LISP, which is composed mainly of lists, with functions defined and invoked in list form. LISP has a very simple syntax and is characterized by its ability to handle functions and data in the same way. It also has features not often found in other languages, such as dynamic typing and macro functions. These features make LISP very flexible and extensible, and it is often used in fields such as natural language processing and AI.

On the other hand, LISP has a rather unique syntax among functional languages, which can be expensive to learn and difficult to understand for newcomers. However, LISP offers a very high degree of freedom in writing programs, allowing programmers to freely extend the language, making it a very powerful tool when flexibility and expressiveness are required.

Functional Programming (2) History

Continuing from the previous article, I will discuss functional languages. In this article, we will discuss the history of functional programming, starting with the reference book “Hajimete no LISP Functional Programming: From Lambda Calculus to Refactoring”.

The history of functional languages (LISPs) is shown below.

はじめのLISP関数型プログミング ラムダ計算からリファクタリングまでより

In the previous summary, I mentioned that functional languages are simple and effective for programming productivity, but another aspect of their effectiveness is their relationship with computer engineering. The history of functional languages is very old, and the first functional language, IPL (Information Processing Language), was already introduced in 1956, two years after the first programming language, FORTRAN, was introduced in 1954. This is reasonable, considering that computers are machines that perform calculations in the first place, and that the simplest element of a calculation is a function. The procedural statements made by common high-level programming languages are connected to computation only through some kind of transformation.

The Information Processing Language (IPL), an early functional programming language created in 1956, was based on the “lambda calculus” and recursive functions (inductive functions) proposed by Church and Kurini in the 1930s. Following them, LISP was born from research by John McCarthy in 1958. LISP has since been reincarnated as a number of languages, and is still in use today.

In 1973, ML (Meta-Language), the origin of another functional language, was born. This language was originally a meta-language for describing the path of automatic theorem proving as a function in mathematical logic discussions. It has a “type inference” function for logical proofs, and is characterized as a “statically typed language” in contrast to LISP, which is a “dynamically typed language“.

In the 1980s, research on artificial intelligence (AI) became popular, and LISP, which is flexible and dynamic as a language, attracted attention, and LISP machines such as Symbolics and ELIS were developed as AI machines. At the same time, Common LISP was established as an ANSI standard in order to unify the many dialects of LISP.

In the 1990s, various AI programs (expert systems, etc.) created in LISP began to be created in the procedural languages C and C++, and LISP gradually fell out of use. At the same time, Haskell, a pure functional program, was born in 1990.

In 2002, Microsoft released F#, a functional language, and in 2003, Scala, which combines object-oriented features with functional programming, was introduced. Other existing languages such as Java and Javascript also started to include functional features. In addition, Clojure was introduced in 2007, and the 2000s was a time when functional languages were being reevaluated.

For more information on LISP, see “Reading notes on Practical Common Lisp” for more information on Schema, see “Schema, a derivative of The Little Schemer LISP: A textbook of functional programming languages” and for more information on Clojure, see “Clojure and functional programming“.