the left fold

the left fold: 2009-12-28

Mon, 28 Dec 2009 10:47:00 -0600

Welcome to the tenth issue of The Left Fold, a weekly programming news and article digest.

Programming Languages & Implementations

EASTL - Electronic Arts Standard Template Library: why and how EA's proprietary C++ STL differs from the standard.
Grammars and Actions in Perl 6: how to create a DSL in Perl 6.
Freeing Factor from gcc's embrace-and-extend C language extensions: what global register variables and the regparm calling convention are, why Factor used them, and why it no longer does.
C's Biggest Mistake: argues that it's conflating arrays with pointers and offers small syntax changes as a fix.
The Year In Haskell: collection of news items; see the "Compilers and Infrastructure" section.
JVM extensions: collection of interesting ideas that OpenJDK has been extended with in a proprietary codebase.
CLOS initialization protocol: features that reduce code duplication in Common Lisp.
Python 3: a dearth of modules, a need for CPAN: critique of Python's package infrastructure in comparison with Perl's. (reddit)

Experience Reports

One year of Redis: reflections on running an open-source project for the long term.
Cross-Toolkit Software: reflections on reducing code reuse when using different graphics toolkits.

Game Mechanics

The AI Systems of Left 4 Dead: slideshow covering climbing, emotions, pacing, and zombies.
Movement Mechanics in “The Legend of Zelda”: how a small movement detail makes the game more playable. (reddit)

Web Standards

Why the HTML5 ‘Video’ Element Is Effectively Unusable, Even in Browsers Which Support It: buffering.
How to Improve Websocket: critique of the recently-released protocol for two-way communication from the browser.

Miscellaneous

What Should We Teach New Software Developers? Why?: Stroustrup argues for licensing of developers.
Just Let BASIC Die: argues that Python is an acceptable replacement for BASIC as a first language for young people.
Some thoughts on Copyright Assignment: discussion of the practice, plus a set of licensing suggestions with rationales.

the left fold: 2009-12-21

Mon, 21 Dec 2009 08:10:30 -0600

Welcome to the ninth issue of The Left Fold, a weekly programming news and article digest.

Development

API Design Matters: critiques existing APIs and provides guidelines. (LtU)
Flickr Doesn't Branch: how they do continuous integration and develop new features without branching. (reddit)

Programming Languages and Implementations

Pitfalls of Object-Oriented Programming: highlights the memory impact of OO techniques in the context of graphics rendering. Summary starts on page 108.
Clojure 1.1 Transients and Chunked Sequences: details on the new optimizations. (reddit)
Making GHC's I/O Manager More Scalable: a quick look into how GHC supports lightweight threads that don't block when performing I/O.
Unladen Swallow project no longer optimistic about removing the GIL: the project aiming to improve CPython's performance has recently updated its plan with a pessimistic outlook on removing the lock that prevents threads from executing simultaneously in the same process.
Python, Surprise Me!: a series of inconsistencies.
Why BASIC is Still Relevant: little explanation of the machinery necessary.
LLVM Project Blog: newly-launched. The introduction to load elimination articles are interesting.

Theory

Efficient Software-Based Fault Isolation: summary and discussion of the paper introducing fault isolation within a single address space.
Reweighting a Graph for Faster Shortest Paths: an introduction to A* search.

Miscellaneous

The C Programming Language: 4.10 Recursion: a fun tale.
Funding Clojure: discussion of the different funding models for free / open source software. (reddit)

The Left Fold

I expect the next two weeks to be lean on interesting news and articles due to the holidays. If there's not enough for an issue either week, there won't be one.

the left fold: 2009-12-14

Mon, 14 Dec 2009 07:40:20 -0600

Welcome to the eighth issue of The Left Fold, a weekly programming news and article digest.

Algorithms and Data Structures

Regular Expression Matching: the Virtual Machine Approach: explores several different ways to implement regular expressions using a virtual machine, with code.
Winning the 2K Bot Prize with a Long-Term Memory Database using SQLite: discusses several parts of an AI first-person-shooter player.
Representing Chess Positions: options and the trade-offs.

Programming Languages

Sun's "Project Lambda" to add first-class functions, function types, and lambda expressions to Java kicked off this past week:
The much-delayed ECMAScript 5 (JavaScript) specification was released:
- Summary of changes
- Why strict mode is interesting
- Reflection on standard process, why some items weren't added, and the future (video with transcript)
Ruby Draft Specification: to be submitted to ISO for standardization. This is an endeavor separate from RubySpec. See also discussion on ruby-core@.

Experience Reports and Advocacy

Scaling to efficiently process large datasets: a high-level overview from Facebook and another from Google.
Tuning Concurrent Clojure: finds it's not the algorithms, it's the JVM options and type hints.
Optimizing Common Lisp: demonstrates how to annotate Common Lisp code for performance and how the SBCL compiler helps.
How I Learned to Stop Worrying and Love Erlang's Process Dictionary: using a mutable datastructure in a purely functional context.
Google Web Toolkit 2.0: So good it's ridiculous: why one developer is excited about the new capabilities of the web application framework.

Miscellaneous

GPU Virtualization: overview of the options and which approach VMWare has taken.
Hot patching inlined functions: part two on runtime-patching the Ruby VM for memory profiling.

the left fold: 2009-12-07

Sun, 06 Dec 2009 23:05:28 -0600

Welcome to the seventh issue of The Left Fold, a weekly programming article digest. Submissions for future issues are solicited.

Craft

Peter Seibel on Coders at Work: video of the author discussing trends observed while interviewing for the book. Topics include how to read code, the importance of altering black box code in an era dominated by libraries, and the surprising secret to becoming an expert debugger (hint: 24:30). Worth the hour running time.

Advocacy

Why I chose Common Lisp over Python, Ruby, and Clojure: language and libraries aren't changing too fast. (reddit)
Eleven Theses on Clojure: takeaway from a few days with the language. (reddit)
How a type system helps you write better code: enforced documentation and ease of refactoring.
Why Perl Lost It: reflection on why Perl no longer enjoys the prominence it used to. (reddit)
Why the 'J' in JRuby?: reflection on using the JVM as a target for Ruby.

Programming Languages

On understanding data abstraction, revisited: the difference between abstract data types and objects, and why it's important.
Why Object-Oriented Languages Need Tail Calls: to preserve object-oriented abstractions. (LtU)
Python's Moratorium: discussion by one of the authors of the proposal to freeze changes to Python's syntax and semantics.
JVM: tailcalls meet invokedynamic: discussion of the issues around implementing tail calls, especially with the new invokedynamic.

Miscellaneous

git: why you shouldn't fast-forward: it loses important information. (reddit)
Web form design guidelines: an eyetracking study: detailed look into the small details that make signup forms usable.

the left fold: 2009-11-29

Sun, 29 Nov 2009 22:12:00 -0600

Welcome to the sixth issue of The Left Fold, a weekly programming article digest. Submissions for future issues are solicited.

This week's issue is short, probably due to the Thanksgiving holiday in the US.

Programming Languages

New language features in Java 7: a summary with examples.
Announcing Haskell 2010: a new revision of the language has been announced, codifying several existing language extensions. This is the first in an anticipated yearly set of revisions to the language. (shortlist of changes)
Optional laziness doesn't quite cut it: argues that strict languages with optional laziness lack modularity compared to lazy languages.
Reviewing Project Lombok: an attempt at reducing Java boilerplate.

Experience Reports

Gluing Things Together - Scheme in the Real-time CG Content Production: see in particular section 6, which discusses pros/cons from experience of using Scheme in place of C.
Writing a URL Shortener in Scala: likes the language, unhappy with build and deployment tools. (reddit)
Recursion and concurrency with Go: introduction via a parallel search algorithm for Connect-4. Likes the concurrency constructs but finds the implementation lacking.
Rewrite your Ruby VM at runtime to hot patch useful features: implementing memory profiling with trampolines.
The 8 hour journey to a single character: debugging story with a moral. (news.yc)