Lambda the Ultimate

Via Patrick (who was once a LtU contributor), two interesting blog posts:

• A discussion of the uses of Lua in Lightroom and about the use of dynamic language to develop desktop software in general (blog post by a LtU member). Apparently, some 63% of the code written by the Adobe Lightroom team is in Lua.
• A brief history of IBM's Visual Age, originally written in Smalltalk (the product, not the blog post), and Digitalk (remember Digitalk?!).

Peteris Krumins has been posting his notes on MIT’s Introduction to Algorithms. The notes are valuable for anyone interested in working their way through the CLRS text and MIT Open Courseware videos.

I just finished watching the last lecture of MIT’s "Introduction to Algorithms" course. Having a great passion for all aspects of computing, I decided to share everything I learned...

Although not directly tied to programming languages, every PL has to eventually be able to express algorithms. Aside from Knuth, CLRS is probably the closest approximation to a comprehensive approach to algortihms. The text itself is language agnostic - the authors use their own brand of pseudo-code to describe the algorithms. This has the advantage of allowing the reader to focus on the algorithms at a higher level, rather than get bogged down in the specifics of any PL. The downside, at least in my estimation, is that the authors don't make it particularly easy to implement the algorithms in any specific PL. The pseudo code conflates common data structures (such as arrays) with properties/attributes that can be tagged with those structures. And some of the algorithms refer to variables that are outside of the scope of the function. Also, like Knuth, most of the algorithms are steeped in state, making it hard to implement them with functional programming approaches.

That said, the video lectures and the accompanying notes above are good resources for any that want to self-study CLRS. Here are the notes thus far:

• Lectures 1 and 2: Analysis of Algorithms
• Lecture 3: Divide and Conquer
• Lectures 4 and 5: Sorting
• Lecture 6: Order Statistics
• Lectures 7 and 8: Hashing
• Lectures 9 and 10: Search Trees
• Lecture 11: Augmenting Data Structures
• Lecture 12: Skip Lists
• Lectures 13 and 14: Amortized Analysis and Self-Organizing Lists
• Lecture 15: Dynamic Programming
• Lecture 16: Greedy Algorithms
• Lectures 17, 18 and 19: Shortest Path Algorithms
• Lectures 20 and 21: Parallel Algorithms
• Lectures 22 and 23: Cache Oblivious Algorithms