{"id":462,"date":"2014-03-12T01:04:23","date_gmt":"2014-03-12T06:04:23","guid":{"rendered":"http:\/\/sunapi386.ca\/wordpress\/?p=462"},"modified":"2015-10-28T16:06:58","modified_gmt":"2015-10-28T21:06:58","slug":"programming-languages","status":"publish","type":"post","link":"https:\/\/sunapi386.ca\/wordpress\/programming-languages\/","title":{"rendered":"Programming Languages"},"content":{"rendered":"

Low level programs contain a lot of ad hoc, buggy, and slow implementation of higher level languages. Paul Graham described an excellent idea in “Hackers and Painters”<\/p>\n

If you solve a hard problem, the question is not whether you will use a powerful enough language, but whether you will (a) use a powerful enough language, (b) write a defacto interpreter for one, or (c) yourself become a human compiler for one.”
\n[…]
\nFor example in the OO world you hear a good deal about “patterns.” I wonder if these patterns are not sometimes of case (c), the human compiler, at work.”<\/p><\/blockquote>\n

In short, as developers we like concise, unbloated languages that is sufficient for what we need.<\/p>\n

In-list functions<\/h2>\n

I was reading Peter Norvig’s spell correct<\/a> and discovered python had in-list comprehensions. It’s a nice feature which allows you to easily construct a list.<\/p>\n


\n>>> [ x**2 for x in range(1,11) if x % 2 == 0 ]
\n[0, 4, 16, 36, 64]
\n<\/code><\/p>\n

It looks very readable. Now, ruby being my favourite language over python, I wanted to see if ruby had a similar feature. The best I can come up with is this:<\/p>\n


\n2.0.0-p247 :017 > (1..10).to_a.map{|x| x**2 if x%2 == 0 }.compact
\n=> [4, 16, 36, 64, 100]
\n<\/code><\/p>\n

This isn’t as easy to comprehend. For instance, why is it necessary to have .compact<\/code>?
\nWhy do we need to call .to_a<\/code>? Python wins in this case. I’m now a lesser fan of ruby and more of python.
\nLastly, I checked this out in haskell – which many consider to be a dense language. It’s also a language I’m looking to do some coding in.<\/p>\n


\nPrelude> [ x^2 | x [4,16,36,64,100]
\n<\/code><\/p>\n

Not bad. I’d argue that this is as easy as pythons – provided that you understand haskell syntax. Syntax wise, I suspect python is more wordy than haskell.<\/p>\n

Ruby lambda vs. procs<\/h2>\n

In ruby, lambda and procs are pretty much the same, but not quite. Syntactically, they are similar.<\/p>\n


\nlambda_larger_than_4 = lambda { |num| num if num > 4 }
\nproc_larger_than_4 = Proc.new { |num| num if num > 4 }
\n(-1..8).to_a.collect &lambda_larger_than_4
\n=> [nil, nil, nil, nil, nil, nil, 5, 6, 7, 8]
\n(-1..8).to_a.collect &proc_larger_than_4
\n=> [nil, nil, nil, nil, nil, nil, 5, 6, 7, 8]
\n<\/code><\/p>\n

However, there are two main differences.<\/p>\n