Language as the Ultimate Weapon

Language as the ultimate weapon

Author Jem Berkes explains different perspectives of George Orwell's novel 1984. He mostly states that Orwell is worried on the power of speech and tries to make the reader conscious and how they can be manipulated without even noticing. 

In Orwell's distopia, which is set in a supposely near future he from Orwell, he states the and emphatizes the great power of rhetoric and how it is used to politically manipulate people. This novel is not far from truth. It is widely known that worlds greatest orators use rhetoric to emphatize and convince people on following their same ideals.

In the article, Berkes mentions that language shape peoples' minds and beliefs to the point where reality can be easily manipulated. I think all of this is easily related to politics and world order. Language is used to conceal truth and the interests of just a few.

After reading this, I can agree on languages power in both right and wrong ways, Nevertheless, languages can be seen in programming as a tool to solve different problems and with different perspectives or paradigms. There is not one that is ing and better than any other in all ways, that's what makes programming fun and infinite. There is never one single way to do something and finding unique, faster and reliable ways to solve problems is what makes new programming languages being developed.

The Roots of Lisp

The roots of Lisp

Paul Graham shows no this paper once again why Lisp is such a power language. Paul shows a series of highlights where he tries to tell us some of Lisp's main pros against other "common and mortal" languages. An interesting point to keep in mind is the amount of credit Paul gives to McCarthy, who as we have discussed before, was the theoretical creator of Lisp. Paul Graham shows a great level of worshipness and acknowledgment as he even says McCarthy is as important toprogramming as Euclid is in geometry. 

According to Paul Graham, best programming languages are C and Lisp. Now that I have some knowledge on Lisp and been coding on one of its derivative languages, Clojure; I know that is not false at all. Personally I think Lisp and every language derived from this one is the ammount of abstraction built into the compiler so that multiple datatypes can be evaluated in the same way without having to worry about conversions, datatypes, memory, etc. However, I think and can certainly give credit to the architecture of all functional languages instead of just Lisp. 

Instead, Graham gives all credit to Lisp handling all expressions as lists, where the operators mainly occupy the first element in a list. However, we can actually see this operators from a different perspective, a bit more like functions. This emphatizes another Lisp great feature, which is that is functional.

In conclusion, Lisp main feature is its design and achitecture. How functions are evaluated allows programmers to comprehend more, how the code is working. This also translated into the ability to create macros.

The promises of functional programming

The promises of functional programming

Computer technology has dvanced since its beginnungs, however programming techniques have pretty much remained the same. IO burst, followd by a CPU burst and then another IO burst. But there is another technique developed in 1950s as a programming techniques and it is called functional programming.

Functional programming is not very know or used because it's commonly used for research and not for real-life programs. Recently it has gained more popularity because it has advantages for concurrent and parallel programs and it provides a simple way to test programs.
Functional programming is used by computing functions by mapping input values to output values. The only task should be to return the same output when given the same input without side effects. One important part of functional programming is that as functions don' need to write in memory, variables are not needed. This may sound as a problem but the computation of a value is much easier. 

Functional programming uses abstraction very prominent so we use what we call a higher-order function that uses another function as a parameter and returns another functions as a result. This makes it very usefur to implement repeated patterns inside an algorithm.

Concurrency and parallelism are gaining importance since single threaded performance is not improving nor moving forward as it should. Also computer hardware is becoming more powerful to a point where it becomes almost impossible to improve more. These concepts are sometimes very hard to work on using traditional programming. Therefore enters functional programming.

Rich Hickey on Clojure

Rich Hickey on Clojure

For this week's blog, we heard Rich Hickey's opinion on Clojure. He starts talking about Lisp and its importance in understanding programs as a data structure. Also, he talks about is huge potential as the ability to also compile programs as data structures is really useful. However, Hickey also gives some huge arguments of why he thinks Lisp is not so popular and is its own power. It may sound odd at first, but it does make sense. Since Lisp is a really powerful language, everybody has its own dialect or way to develop in that same language. Also, not everybody knows all its capabilities or uses them at its 100% so some functions/abilities become unused, unsupported and unfollowed.

Hickey also talks on how the creation of Clojure was a need to fix one of Lisp's biggest problems which was the communication with other languages. Thanks to this need and give Lisp this ability is why Clojure was created. Let's also remark that the alleged power of Lisp doesn't mean that is a language that can withstood a whole system and thus an integration with other languages is required. Clojure keeps all the functionality and power of Lisp without being restricted to only its library. This is why also Clojure brings the ability to compile and use a whole repository of Java libraries.

In conclusion, I think the article is redundant and states what many other articles about Lisp does and praises it as so. I did learn a couple of different things, but I do think is the same Lisp-fanboy praises.

Revenge of the Nerds

Revenge of the Nerds

The author starts by comparing two statements, that all programming languages are pretty much equivalent and the opposite, some programming languages are better than others in solving some specific problems. Sometimes is simpler and more comfortable to think that programming languages are equivalent, however, it is a lie.

Lisp was never really designed to be a programming language, instead, as an effort to define an alternative to Turing Machine. Some time later, Steve Russell looked at the definition of eval  and realized the translation to machine language was actually a Lisp interpreter.

Lisp was made different by nine new ideas that were to 2002 still unique to Lisp. The most interesting and most important are the following. Functions are a data type and they can have a literal representation, can be stored in variables and passed as arguments. Lisp was the first one to support recursion. Symbol type variables that are pointers to strings in a hash table to test fast equality.

The are three main problems that can arise from using less common languages. Programs may not work well with programs written in other languages, Amount of libraries at our disposal. Amount of programmers familiar with the language. The importance of this problems varies on the amount of control there is over the whole system. If you have little to no control, then it is advised to stick to the common languages, else, you could create your own language if you want.

If you use a less powerful languages it is pretty much certain you will end up with a larger program. It is not specific how much shorter Lisp program would be, but against C there has been numbers that is 7-10x smaller. With all these information I just keep on thinking that functional languages should be the first approach of a person to computer programming.

Dick Gabriel on Lisp

Dick Gabriel on Lisp

The podcast starts with an introduction of Dick Gabriel and the projects he has worked on. It talks a lot of how a functional language works and how is very easy to use data and functions very easily. He begins explaining how a functional programming works and how you can distinguish the functions from the actual data. To do so, you just quote ‘ before the parenthesis.

Dick Gabriel has also spoken a little bit about macros and its importance. What I basically understood from this part is that Macros are programs that create more programs. This part has left me a bit curious cause I have also heard from older classmates that this is the topic they consider the hardest. Until this point, I have never done this in any language. The closest I have been is writing ejs scripts that generate HTML. I also don't know in what type of situations this is needed which makes me even more curious.

Dick also talks about Lisp's interpreter. One of its main features is that is metacircular, which means that is a language able to evaluate itself. I am also not sure I heard this correctly but the eval function was actually developed in just one night instead of months as they have thought. Lisp is also important for its influence and inspiration to other languages such as Ruby. Lisp is also a language that is favored for Artificial Intelligence.

The podcast ends making a big statement that Lisp as a functional language may appear really hard to be implemented. However, it lies a huge development potential. If you wait till the end of the podcast, you may also hear a song called God wrote in Lisp which if you listen to carefully can definitely  give you a good laugh.

Beating the averages

Beating the Averages

Beating the Averages is an article –written by Paul Graham– which explains how the the first web app was created.

The writer explains that one of the essential part was the language that they would use. Thew were extremely proficient using Lisp. Even though everyone was using C or some other low-level language, they decided to stick with Lisp cause they knew the language all the way around and this would help releasing new features really fast. When you use the language you’re most comfortable with or when you are writing new code, it takes a lot of time to lookup some information like “How to do ___ in language ____”. This type of searches become more and more often the more you are unfamiliar with the language. When you need speed, this is not the best way to go.

When you are beginning a startup, what language to use is one of the hardest things to do. You  know that using some languages or technologies will make the development easier to make for certain functions. However, any language can be used, and it may be required to do some extra research. That extra research time is the one you need to minimize.

The writer has a theory about the language we are more comfortable with, he calls it The Blub paradox. He calls Blub the language a person is more familiar with. So when you’re programming and doing some stuff in other language, programmer will often turn back to see Blub and notice that it lacks features. One last advice from author was to learn Lisp as a language, not because you’re actually gonna use it. You may not even use it but it makes your reasoning and coding skills improve.

All this advices are really nice to have. Most of the time, when you think of starting your own project, you’re not sure on what language to choose or start on and you should just stick to the one you’re more comfortable with.