Wednesday, January 26, 2011

Review: Language Grubbing

Yet another interesting reading from Steve Yegge: Language Grubbing.

He reviewed several programming languages (C, C++, Java, Perl, Python, Ruby, Smalltalk, Lisp family, ML family, Haskell, Erlang). He mentioned pros and cons for each of them, criticized some of them (Perl, Common Lisp). Also told that Lua, Tcl, Prolog, Pascal wouldn't be in his learning "backlog".

I looked at a lot of other languages: JavaScript, Lua, Tcl, Prolog, Eiffel, Pascal, and a bunch of others. None of them really stood out as being "special" like the others I've talked about.

For instance, you can do Prolog-like logic/constraint programming in Lisp or OCaml pretty easily, and they're both broader/better languages than Prolog. Pascal gives you nothing that C doesn't already do better. ... Lua is a cleaned-up Tcl, but neither one of them is as interesting (to me, anyway) as Python for doing embedded languages, unless you really need to strip it down to practically nothing, in which case Lua is useful.

IMHO, reasonable comments.
He mentioned about language groups:
  • Java, C# and C++ (I would add Objective-C and Smalltalk)
  • Haskell, SML, OCaml (I would add F#, Scala)
  • Common Lisp, Emacs Lisp, Scheme (I would add Clojure)
  • Perl, Python, Ruby (I would add PHP)
  • Erlang (I would add Prolog, Oz)
  • Lua, Tcl, JavaScript (I would add Io, Ioke, R, REBOL)
  • C, Pascal

I wrote about this but I'll repeat again. I time wasting if you learn several languages from the same group. E.g. Python and Ruby, or Java and C#.
So, just a pick the "major" language from each group and learn it. E.g.: Java, Haskell, Clojure, Ruby, JavaScript and C.

C language is like Latin for the plain developer. JavaScript is must be know by anyone involved in web-related development.

For myself I formed the next language priority list:
  1. Java
  2. JavaScript
  3. Ruby or Python (I haven't decided yet)
  4. Clojure, Scheme or Common Lisp (I haven't decided yet)
  5. C

Tuesday, January 25, 2011

Review: Beating the Averages

This Paul's Graham essay (Beating the Averages) is very popular among Lisp community. Someone told that it was the new Lisp push, the new Lisp wave. I read this essay and companion technical article "Lisp in Web-Based Applications" in one short. It's really inspired reading.

Paul Graham described the "hidden" power of Lisp. Unfortunately, the Common Lisp community is fragmented so much. Too many different implementations. It hurts Lisp as a sub-culture. I hope this situation will be resolved by Clojure vibrant community

Definitely, if you want to open your Lisp mind you should read this essay. Nothing special from technical point of view, but really cool as Lisp catalyst. Read it, feel the power, feel the spirit.

The general idea (IMHO): startup is the right place to try something new and revolutionary to "kill" your competitors.

Saturday, January 22, 2011

Lisp, Ruby, Acceptable and not Acceptable

There is one really (in)famous essay Why Ruby is an acceptable LISP by Eric Kidd. The most interesting of all this stuff are comments and other responsive blog posts (e.g. Lisp is Not an Acceptable Lisp by Steve Yegge)
I can say this is something like "vs" essay which is very popular nowadays.

Here is the list of some quotes and key ideas:

  • Lisp macros are far more powerful than the trivial use cases you’ve listed. I could give a lot of examples here, but just ask yourself: why is most of the programming community so fond with “Design Patterns”, while the Lisp community generally isn’t? Well, that’s because patterns are nothing but high-level specifications for code being rewritten again and again and again. The Lisp approach is to create some macros and auxiliary functions that actually implement the pattern, thus extending the language capabilities and avoiding continuous reinvention of the wheel.
  • This article sounds like it was written for folks who really want to use Lisp, but have chosen Ruby because all the cool kids are using it and want to reasonably justify an emotional decision.
  • If you want to learn a language that can change with the times and incorporate whatever latest fad the programming cool kids have to offer, Lisp is the choice. Lisp is the red pill.
  • A final example: look at the 2 open source Computer Algebra Systems written in Common Lisp available as Open Source: 1) Axiom – originally from IBM Thomas Watson Research Center; 2) Maxima – originally Department of Energy (US). This is software written in the 70s. You can’t write software that lasts so long with a language that is a moving target. This is the kind of survival and complex domain which shows the power of Lisp.
  • The real reason that brought me to Lisp (and never will get me away from it) is simply this:
    You can build it out of 7 (s-e-v-e-n) primitive operators!
    And, as a consequence, no other language can be expressed in itself as short as Lisp. (As you probably know, quite any language can be expressed in itself.)
    So let me repeat: really no other language can be expressed in itself that short, and (as a natural consequence) can be built out of less primitive operators.
  • Ruby has a syntax, and Ruby needs a full parser to get from that syntax to an AST. Because Lisp code is naturally an AST, things are very different
And small summary of the Steve's blog post Lisp is Not an Acceptable Lisp:
There is no acceptable Lisp. This is a problem. It's not a little teeny one, either. The Lisp communities (yeah, there are a bunch) are going to have to realize that if Lisp is ever going to be massively successful, it needs an overhaul. Or maybe a revolution. Contrary to what some might tell you, it doesn't need a committee, and it doesn't need a bunch of money. Linux proved exactly the opposite. Lisp needs a benevolent dictator. Lisp needs to ditch the name "Lisp", since it scares people. And Lisp needs to learn from the lessons of the 45 years of languages that have followed it.
Based on this comments and I'm attaching this funny picture:
The programmer's superiority complex... in hierarchy format.

Friday, January 14, 2011

Review: You Should Write Blogs?

I've just finished reading the Steve Yegge's post "You Should Write Blogs".
As for me it's very impressive and honest writing about blogging I've ever read. I like this style of writing.
The general idea is to explain why You should write blogs.
So don't worry about whether people will read it. Just write it!
No matter where you are in your education, some people will be interested in hearing your struggles. This is an important thing to keep in mind when you're blogging. Each person in your audience is on a different clock, and all of them are ahead of you in some ways and behind you in others. The point of blogging is that we all agree to share where we're at, and not poke fun at people who seem to be behind us, because they may know other things that we won't truly understand for years, if ever.
He described some reasons why people don't like to write blogs and commented it:
  1. I'm too busy.
  2. I'm afraid to put my true thoughts on public record.
  3. Nobody will read my blog.
  4. Blogging is narcissistic.
I must say that Steve inspired me to write more. Just for fun.

Wednesday, January 12, 2011

Should I learn Lisp?

I had been asking this question myself every time I had found something (blog post, article, book title, etc.) interesting related to Lisp. But those “ugly” brackets put me away again and again :-). So, what was happen and why I changed my vision?

I think I’ve got three triggers to change my mind: a) friends of mine works with Gensym/G2 platform and they are really inspired by Lisp power; b) I saw several Rich Hickey’s talks about Clojure and the last one c) Paul Graham essays.

Then, I started googling to find other opinions about Lisp (when I say “Lisp” I mean Common Lisp, Scheme, Clojure and other Lisp dialects).

Monday, January 10, 2011

Review: How To Become A Hacker?

It's worth reading. I think that it's like hacker "mantra" ;-) I don't want to retell all that stuff. Just want to sum up.

1. Programming language learning.
We should learn different programming languages from paradigm point of view: "classical" OOP languages (C++, C#, Java), procedural languages (C), functional languages (Lisp family languages: Common Lisp, Scheme, Clojure), dynamic and scripting languages (Perl, Python, Ruby) and web-related (JavaScript).
"Besides being the most important ... languages, they represent very different approaches to programming, and each will educate you in valuable ways."
It means that you should  learn languages from different paradigms to get some conceptual  knowledge.
E.g. You shouldn't learn Java and  C#, or Python and Ruby. I think it's just waste of your time.
"To be a real hacker, you need to get to the point where you can learn a new language in days by relating what's in the manual to what you already know.This means you should learn several very different languages."
2. Learn Unix/Linux.
I think the best way to learn is to start playing with Ubuntu.

3. Learn English and native language. 
You should be able the speak and write fluently in both.

4. Persistent learning
It's the key point to success in any profession.

"To follow the path:
look to the master,
follow the master,
walk with the master,
see through the master,
become the master."