A few project goals:
- Support substantial hosted language alterations with minimal code changes.
- Functional style implementation.
- Modular code structure of composable functions.
- Minimal direct reliance on host language features.
- Support powerful debugging.
Example Supported Projects
- Sheut - Functional style debugging library built using Atum.
git clone https://github.com/mattbierner/atum atum cd atum git submodule update --init
Direct dependencies included in the project as submodules:
- amulet - Helper library for working with immutable objects
- Nu - Functional streams
- parse.js - Base combinatory parsing library
- seshat - Parser memoization utility.
- parse-ecma - Combinatory ECMAScript parser
- ecma-ast - ECMAScript AST nodes
Indirect dependencies, used for testing or UI or some other supporting part of the project. They are included as source files.
- Require.js - Default AMD implementation used by Atum
- Require.js Text - Loading text files
- jQuery - Webpages
- jQuery UI - Console interface presentation
- jQuery Layout - Console pane layout
- CodeMirror - Console interface text editor
- Knockout - Console interface data layer
- Qunit - Unit testing
Atum uses require.js text to load hosted language files implementing hosted language builtins. Directly running from the file system works on Safari but generates cross origin errors in Chrome and Firefox.
To get around this, either access run atum off a webserver or disable this security restriction for development in the browser. A server using node connect is included as server.js at the top level.
cd atum node server.js // navigate to: http://localhost:8080/console.js
Atum is being actively developed and is not feature complete. Take a look at the issue tracker to see some features that are being worked on or are not yet implemented.
Any contribution to atum is welcome. Some ideas to get started helping Atum:
- Develop tools that take advantage of Atum's unique features.
Support for Deep Language Alteration
Composed computations and minimal reliance on the host language allow altering core language features and introducing new language features easily. For example, try statements can be made transactional, with statements can be repurposed, or objects can be passed by value with only few changes. Combined with parse-ecma, new syntax can be introduced and implemented.
State and Snapshots
The interpreted program's state is stored in a single immutable state object. Copies of the state object can be easily created, allowing snapshots of program state to be collected.
Atum's functional implementation and state snapshots enable novel debugging of interpreted programs. This allows unique interaction with the code not possible in traditional programming language implementations.
For example, with snapshots, a theoretical debugger could step through code not only forwards, but also backwards and examine the events leading to the current state. Further, the debugger can inject new states, creating branches in the program's timeline that can be explored individually. The distinction between writing, running, and debugging code disappears; programs becomes dynamic documents programmers query, inspect, and change in real time.
More commonplace debugging tools also gain new power. Complex queries, conditional breakpoints, event logging, and stepping are easily supported and can be enhanced to take advantage of Atum's unique features.