A real dive into LISP


The podcast Dick Gabriel on Lisp mentions a lot of the workarounds from this programming language, one of the most interesting aspect of the programming language is that it is very similar to the theoretical Turing Machine. The importance of Lisp is the promise that it makes to help in the research of artificial intelligence due to its functional approach to programming. This approach is what makes it really similar to the Turing Machine, because said machine is a mathematical representation of programming and functional programming is also a mathematical representation.

 Comparing Common Lisp with Clojure which is a Lisp dialect that we are learning, you soon realize that Lisp has not taken yet the world of programming because it is not a very obvious language, a lot of the mnemonics have to do with the assembly implementation of the language itself and not with the action that it makes in a higher level. I think this is one of the reasons why functional programming has not taken the world yet, also, it changes a lot between the different languages even when they are derivate versions of Lisp which makes really difficult to change between them even when the approach is the same. Finally, I think that the fact that functional programming has not yet figured out how to fulfill its promise of parallelization it is not yet worth the pain of learning the approach.

 Combining both, the reading about the promises of functional programming and the podcast you soon realize that the biggest problem of functional languages is that they are used mostly by people who know the potential they have and this people spread the word to get more people into functional programming, but it is not as Python which is a language that is very attractive to learn. In other words, functional programming is a tradition passed through generation, it is missing the attractiveness of other languages and is missing a redefined branding because it is more than 50 years old.

Dick, G. (2008) Episode 84: Dick Gabriel on Lisp.
Hinsen, K. (2009) The Promises of Functional Programming.

Comentarios

Publicar un comentario

Entradas más populares de este blog

Two is more than double of one

This week's reading talks about pair programming, a software development practice in which two developers work at the same time in the same project in the same thing in order to keep track of the work in case one misses. But it also improves times, productivity and software quality. The reading's goal is to facilitate the transition to pair programming by explaining how you already know how to do it. The text begins explaining how pair programming in the XP methodology for development is really successful and how programmers attribute the success of their productivity and the methodology to the technique. And although many programmers tend to work alone and resit to the change, most of them  succeed in the transition to pair programming and begin loving it. The first rule of pair programming is Share everything, even mistakes. The second one is play fair, meaning that you shall not take the control of the development and let the other person also be the one who codes. The thi
Leer más

What makes Lisp Lisp?

I found this last text repetitive and boring, I think I had understood where Lisp came from and almost everything there was to know about its story in the previous readings and podcasts. The only part of the reading I found interesting was the eval definition function where they showed you how to write the Lisp interpreter in Lisp. The thing with programming using a functional language is that is a complete flip of paradigm, when the data is also the code and you need to differentiate it using quotes. One of the difference I found in this reading regarding Lisp and Clojure is that in Lisp the empty list represents false and the atom t represents true where as in Clojure we have true to represent true and false or nil to represent false. Also, I noted the differences between the primitive functions in Clojure and in Lisp, where in Lisp they are called weird and in Clojure they have the name of what they do. This last I noted since the podcast about Lisp that explained why the functio
Leer más

Is really functional programming better?

Since the beginning of software development, we have used the same programing techniques, the author mentions that this is because it “closely resembles how a computer works at the hardware level: the processor fetches data from memory, performs elementary opera- tions on it, and writes the result back to a memory cell” (Hinsen, 2009). The only different technique that has been developed is functional programming, which was developed as a mathematical theory first and then into a programming language called LISP. So, we have two different approaches: functional programming and imperative programming.   Functional programming consists on composing functions for computations, just as previously mentioned, this paradigm was first a mathematical theory and thus a function is “a mapping from input values to output values” (Hinsen, 2009) not to be confused with subroutines. A big difference between functions from functional programming and from imperative programming is that functional fu
Leer más