Rich Hickey on Clojure

The first thing that is noticeable, at least for me, we are talking now about Clojure not about Lisp (Even when they’re similar) that may be not that impactful, but we’re learning Clojure not its parent, so makes me a little more comfortable.

The first differentiation that the interviewee find between Lisp and the discussed language is the data structures that can be used as fundamentals, in this case we can use not vectors and maps, not only lists. Topic that might not seem that important, but it is useful for some purposes.

Also, the concept that they talk about the nature of the language is interesting, when the aboard the topic of why Lisp didn’t become popular or mainstream Rich gives us a new perspective about the defects that he can find for Lisp, such as its isolation (because of the lack of libraries) and that it was designed for making hard and intense problems easier to solve. The macros appear again here when their talking about the differentiator of Lisp.

This great explanation about the “non-Object Oriented Programming” of Clojure, that you can find the functionality of the OOP not explicitly, but the idea could be found on Clojure. The way they explore a simple comparison between Java and Clojure, not only limited to the time and development capacity, but the way that an object can be mutable and in Object Oriented Programming the difference between Identity and State are currently hard to understand, and how Clojure manage this with the Data Structures.

One of the most interesting points for me is that the support for the values and the way that functional programming with the data structures and the concurrency against the use of the libraries with something like Java. In this way is one of the most curious points for studying Clojure.

Finally, this interview had my special attention because of the way that Rich Hickey expose Clojure with solid and well explain arguments that has also this technical strength, and even when is not my first language option, it could make me think of it as an option for my professional development.

Revenge of the nerds

For this article I've found plenty of interesting things, starting with the concept of the “pointy-haired boss”, the one that doesn’t know of technology, but has some specifications based on the popularity of a language or the standardization of the software industry. I liked this concept principally because of the necessity of comprehension from the technologists to the authorities, but not submitting about the thinks that we know for sure, like the importance of the development’s language for a project.

I’ve found some value on the premise that the most modern programming languages slowly are becoming more and more like Lisp, and even when it was, at first, a shocking statement, I’ve realized that it is true. Python, for example, it tending to the simplicity at the expressions and is starting to look like a functional based language (considering that Python wasn’t thought for that), that doesn’t happen to be an accident, is just a better way of making more complex problems, easier.

Talking about the part of the averages vs the uncommon and more powerful languages, he mention’s again about the macros and the impact of using Lisp on a practical way, not only because it’s easier to develop for problems with a high complexity, but also for the velocity in a business matter. The comparison was simply brutal, a develop made in a year with C compared to the same advance in Lisp only using 3 or 4 weeks, a bet that everyone will take.

For last, I think that the lesson went beyond this time, is not only to use Lisp or to try it for startups or in certain situations, The lesson that I felt reading this article was to sometimes is really worth to take risks and to do things by the unconventional way, not to do this always, but at the times that could be reliable, don’t stay at the “industry best practices” and go further, the reward may be greater than you think.

DIck Gabriel on Lisp

For this podcast there are several interesting things, but one that takes my attention is that here is the third time that I find the mention of the macros as one of the strengths of Lisp, but in this case I think it was explained by Dick Gabriel like a major advantage focused on the technical utility, more than the others, than mentioned some technical advantages, but were so more reiterative with the competition advantage or the general advantages.

Also, one of the things that I enjoyed were the direct comparisons with other languages, I felt his preference just by the way he expressed himself; that could be just presented again with the several advantages he finds about the functional ways of Lisp, its methods, the way Lisp can express everything as a function against the object oriented languages, and the significance of the popularity of Scheme in the history of the relegation of Lisp.

Some things he mentioned that were impactful for me is specific enterprises that were using Lisp at that time, and the way that Common Lisp is still viable, and you can find that can be way more powerful than others. He lived that transition from Lisp being the most used language to be almost disappeared. He gives us his perspective about the past, present and future of this great language, and one thing that makes me wonder the importance when we learn Lisp at my Programming Languages class is that he doesn’t place it on the most used languages, but with his experience and the advantages he shows for using it; just make me have even more interest about some practical applications.

For the end, I liked so much the approach that we made to Lisp with this podcast, I feel it way more personal than the articles, and It was way more impactful for me and for my perspective of Lisp.