Lisp: Good News, Bad News, How to Win Big (Review)
Upon reading the first few words of this essay, originally published in 1991, I had to stop for a second and Google what Lisp was. According to Wikipedia, Lisp is the second-oldest high-level programming language in widespread use today. Only Fortran is older, by one year. I was shook to learn that almost 30 years later, this essay would still have any relevance, but as I kept reading, I realized it did: many of today’s modern and powerful programing languages are a result of the lessons learned from Lisp’s successes and failures.
First and foremost, let’s discuss about the successes of Lisp, which have been the base on which modern high-level programming languages have been built upon: standardization, good performance, good environments, good integrations, object-oriented programming and good delivery. Many of today’s most-prominent languages have all or most of these characteristics, such as Python, which is known for its simple syntax yet powerful performance and for being a modern and portable object-oriented language.
However, not only did computer scientists learned from Lisp’s successes, but also from its flaws. One of these flaws was the misinterpretation of design patterns such as the SCCC (Simplicity, Correctness, Consistency, Completeness), which are all good things if used correctly, but if misinterpreted, can lead to a worse-is-better approach. Such approach can be translated into bad practices, in which developers think that simplicity is the most important consideration in a design, and therefore it is slightly better to be simple than correct, when incorrectness should simply not be allowed, and consistency and completeness are often sacrificed in the name of simplicity. Alongside, in the worse-is-better world, integration is linking your source code files together, freely inter-calling functions, and using the same basic data representations, which brought serious trouble later on. Additionally, Lisp failed to catch up with its competing environments, which included improved symbolic debuggers and data inspectors.
Even after all these years of development, programming languages can improve, just as Lisp could have, by continuing to promote the progress of standardization, making sure they update regularly to retain the high ground in environments, promoting correctness in implementations and achieving a total integration.