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.

It’s an attempt to build a visual cloud IDE around the ideas of functional programming and serverless architecture.

Structured Editing

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.

new function template

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.

structured coding

The presentation of the code is projectional in that it is customized to the user and indirect from the storage. The keywords (e.g., def, for, end, 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.

syntax flexibility

Syntactic Sugar

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., List[Char] becomes String, or becomes ||) but also the introduction of complex control structures (e.g., monadic map/bind operations become for comprehensions) and even datatype specific DSLs (e.g., a JSON data structure edited in the familiar JSON syntax).

Version Control

isomorƒ implements automatic background-style saving akin to other cloud content creation services (i.e., Google Drive).

automatic saving

Commits correspond to only meaningful changes (not just aesthetic changes) and commit messages are generated automatically (e.g., “Renamed x to 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 becomes () → 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.

running a function and adding a unit test

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.

using behavior to search for code


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)


We are excited for what we think isomorƒ can do for software development — increasing efficiency and reducing barriers to entry. Take a look at our current sandbox to see what we’ve got so far. Let us know what you think or if you’d like to be a beta tester.