CoffeeScript: Its 2009 Release and Compile-to-JavaScript Design

Jeremy Ashkenas initiated CoffeeScript in response to the code complexity web developers encountered in everyday work. JavaScript could already handle functions, objects and prototype relationships, but parentheses, semicolons and repeated structures often obscured a program’s intent. CoffeeScript concentrated on the form in which authors wrote and read code.

In a 2011 book foreword, Ashkenas explained that he wanted developers to use JavaScript’s useful mechanisms more directly while maintaining a clear correspondence between the two languages. CoffeeScript source was therefore compiled into JavaScript before execution in a browser or another JavaScript environment. This choice gave the new language access to existing execution engines and libraries.

References: [1]

The project’s release history dates version 0.1.0 to December 24, 2009. Its compiler was initially written in Ruby. Version 0.5.0, released on February 21, 2010, replaced it with a self-hosting compiler written in CoffeeScript. The compiler began using the language it processed, making the language’s development a continuing application of its own features.

Early syntax changed rapidly. January 2010 releases introduced meaningful indentation and subsequently changed the function symbol to the familiar arrow form. The notes specifically thanked Liam O’Connor-Davis for assistance with indentation and expression handling, showing how contributors’ feedback helped refine the rules. Version 1.0.0 was released on December 24, 2010.

References: [2]

Burnham’s language textbook demonstrates the conversion by calculating cubes. A function can be defined as “cube = (num) -> Math.pow num, 3”, followed by a list of numbers and “cubedList = (cube num for num in list)” to calculate each result. The arrow introduces a function body, while the parenthesized comprehension brings iteration and collection of results together.

The corresponding JavaScript requires a function definition, a return statement, a result array, a loop index and an operation that adds each calculation to the array. CoffeeScript delegates expansion of these familiar structures to its compiler. The expression becomes shorter; the generated program still performs the cubing, iteration and storage.

This approach also makes mixing with existing code convenient. Strings, numbers and function calls remain exchangeable with JavaScript programs. Developers can rewrite selected files gradually without first moving the entire application to a new runtime system.

References: [3]

In his 2012 textbook, Mark Bates recalled using version 0.9.4 for a client project in October 2010. Bugs, missing features and the fact that the project needed only a few scripts led him to abandon it temporarily. He changed his view after trying it again in an application with more JavaScript work. His experience illustrates how the value of concise syntax depends on project scale and tool maturity.

The textbook also observes that CoffeeScript adds a language the team must understand. Programmers still need to know how the generated code behaves, and to learn variable scope, comparison operations and library calls. Using concise syntax goes together with understanding the corresponding JavaScript behavior.

References: [4]

Ruby on Rails 3.1 incorporated CoffeeScript into its asset pipeline in 2011. The official guide explains that generating a controller with the relevant default components can also create files ending in “.js.coffee”. Sprockets organizes the assets, and a CoffeeScript processor converts them into JavaScript. The browser receives the transformed scripts.

This integration made language choice part of project files and deployment steps. Individual files could be processed during development, while production assets could be precompiled and delivered as static files by a server. CoffeeScript entered the ordinary web application workflow, with compilation no longer depending entirely on a manually maintained process.

References: [5]

CoffeeScript 2, released in 2017, retained concise source syntax while generating modern JavaScript structures. Bound arrow functions and classes could produce JavaScript arrow functions and class syntax directly, with support added for asynchronous functions and JSX. To accommodate older execution environments, the output might undergo another transformation through Babel.

From generating existing scripts with new syntax to adapting its output as JavaScript evolved, CoffeeScript used compilation to connect authors with runtime platforms. Its early history contains three clear stages: the first release in 2009, the self-hosting implementation in 2010 and version 1.0 at the end of that year.

References: [6] [2]