What is isomorƒ?
isomorƒ is an experimental coding paradigm. It’s a platform for writing, sharing, and deploying software from your web browser. It’s a new approach to reducing the complexity of the software development workflow — creating a workflow that is more structured, more automated, more assistive.
isomorƒ implements a syntax-directed editing paradigm in place of the usual code-as-text paradigm. This means that there are no syntax errors in the traditional sense, no possibility of mismatched parenthesis or dangling commas. New code is presented as a template that needs to be filled in rather than as a blank file that needs to be written.
Different modes exist for different styles of interaction. Hot key options enable rapid keyboard interaction, button/menu options enable mouse interaction, and touch/drag options enable tablet interaction.
The presentation of the code is projectional in that it is customized to the user and indirect from the storage. The keywords (e.g.,
let) and syntax elements (e.g.,
->) are completely configurable and not an inherent part of the program. In this way, “syntax” in isomorƒ is more akin to font in a word processor.
Projectional editing enables customization that goes beyond the simple substitution of keywords or symbols. The editor providers a syntactic sugar layer for the arbitrary transformation of code into a final view state. This can provide for not only simple aliasing (e.g.,
||) but also the introduction of complex control structures (e.g., monadic
bind operations become
for comprehensions) and even datatype specific DSLs (e.g., a
JSON data structure edited in the familiar
isomorƒ implements automatic background-style saving akin to other cloud content creation services (i.e., Google Drive).
Commits correspond to only meaningful changes (not just aesthetic changes) and commit messages are generated automatically (e.g., “Renamed
y”, “Added arg
x to function
f”). Commit histories and diffs are presented visually and with function-level granularity.
The language of isomorƒ is an abstract, functional AST. It is intentionally low-power — designed to facilitate cleaner normalization (to power meta-analysis), easier re-use, and lower barriers to entry. What are traditionally viewed as more powerful language features are shifted to be syntactic sugar. The defining properties of the language are the following:
- Functional. All logic is encoded in functions as a single expression (as opposed to a series of statements). Functions are higher order, and close over any values in their broader scope.
- Pure. Functions are expressions in the pure mathematical sense: a mapping of input to output. Data is represented as immutable values. Function applications are referentially transparent. There is no direct notion of pointers or memory, and there is no global state.
- Statically Typed. Code is assessed to ensure only values of the specified type are provided at any application point. This is to say, a function application is constrained by the types provided in its definition. The type system is complete to the extent that there is no concept of
null, no dubious casting or coercion, and generally no means to misdirect the inferable type of a given value.
- Eagerly Evaluated. The logical runtime platform in which isomorƒ code is executed assumes an eager evaluation strategy. Arguments to a function application are evaluated before the expression body of the function itself, regardless of whether the resultant values are referenced at all. Delayed evaluations can be achieved naturally via argument-less functions (i.e.,
() → Foo).
The platform relies heavily on types for both runtime and assistance purposes. Types are algebraic data types composed of groups of constructor definitions. Before attempting compilation, type compatibility is assessed. Resolved types are available as annotations for all code to assist with informal reasoning and debugging. To facilitate speed in prototyping, types in function signatures need not be defined up front and can be filled in by the platform once inferable.
Execution and Testing
Code is executed from within the web browser — without the need for explicit build steps or command line interaction. Clear human-readable diagnostics are provided if any errors exist that prevent execution. Successful executions are catalogued and can be converted directly into unit tests. As code is changed, unit tests are rerun automatically and notification of regression is provided.
Collaboration and Reuse
All code is public by default and sharing is encouraged. Users can search the codebase using types, function signatures, and function behaviors. All functionality is available for immediate import and use. The platform handles dependency management and naming conflicts automatically.
All functions can be deployed as microservices. They can be hosted natively by the platform or pushed to common providers (e.g., Amazon Lambda). Multiple encoding options are available for both the request and the response (e.g., JSON, XML, Protocol Buffers)