A version of a talk on Enso that I gave at Microsoft Research and CWI in 2012. http://www.enso-lang.org/

1. Ensō
William Cook, Alex Loh
UT Austin
Tijs van der Storm
CWI
UT Austin

2. Prevent Bad
Enable Good
UT Austin
2

3. Bug Finding
Race Detection
Type Checking
etc.
Prevent Bad
Enable Good
UT Austin
3

4. Bug Finding
Race Detection
Type Checking
etc.
Prevent Bad
Enable Good
New languages?
UT Austin
New features?
For what?

5. Bug Finding
Race Detection
Type Checking
etc.
Prevent Bad
Advantages:
Measurable
Domain-free Enable Good
New languages?
UT Austin
New features?
For what?

6. Kolmogorov Complexity
UT Austin
6

7. Shortest program
that
generates information
UT Austin
7

8. Best
Shortest program
that
generates information
behavior
UT Austin
8

9. Best
Shortest program
that
generates information
behavior
Qualitative Kolmogorov
UT Austin
Program Complexity 9

10. I don't know how
UT Austin
10

11. but it’s a good goal
UT Austin
11

12. A Problem
1. Many (many!) repeated
instances of similar code
2. Unique details and names
prevent generalization
UT Austin
12

13. Requirements
(what)
Strategies
(how)
Application Behavior
UT Austin
(Code) 13

14. Small change to
Requirements
Very different
Strategies
Application
Application
Very different
UT Austin
(Code)
(Code) Behavior
Code 14

15. Small change to
Requirements
Very different
Strategies
Chaos!
Application
Application
Very different
UT Austin
(Code)
(Code) Behavior
Code 15

16. Requirements
(what) Reify!?
Strategies
(how)
Application Behavior
UT Austin
(Code) 16

17. Requirements Technical
Requirements
Models
Strategies
UT Austin
Behavior 17

18. Data Technical
Requirements Requirements
Data
Model
Data
Manager
UT Austin
Objects 18

19. Using Managed Data (Ruby)
• Description of data to be managed
Point = { x: Integer, y: Integer }
• Dynamic creation based on metadata
p = BasicRecord.new Point
p.x= 3
p.y= -10
print p.x + p.y
p.z = 3 # error!
• Factory BasicRecord: Descrption<T> T
UT Austin
19

20. Implementing Managed Data
• Override the "dot operator" (p.x)
• Reflective handling of unknown methods
• Ruby method_missing
• Smalltalk: doesNotUnderstand
• Also IDispatch, Python, Objective-C, Lua, CLOS
• Martin Fowler calls it "Dynamic Reception"
• Programmatic method creation
• E.g. Ruby define_method
UT Austin
• Partial evaluation
20

21. Other Data Managers
• Mutability: control whether changes allowed
• Observable: posts notifications
• Constrained: checks multi-field invariants
• Derived: computed fields (reactive)
• Secure: checks authorization rules
• Graph: inverse fields (bidirectional)
• Persistence: store to database/external format
• General strategy for all accesses/updates
UT Austin
• Combine them for modular strategies
21

22. Grammars
• Mapping between text and object graph
• A point is written as (x, y)
Individual Grammar
(3, 4) P ::= [Point] "("x:int "," y:int")"
class fields
• Notes:
• Direct reading, no abstract syntax tree (AST)
UT Austin
• Bidirectional: can parse and pretty-print
• GLL parsing, interpreted! 22

23. Door StateMachine StateMachine Grammar
start Opened M::= [Machine] "start" start:</states[it]>states:S*
S ::= [State] "state" name:symout:T*
state Opened T ::= [Trans] "on" event:sym "go" to:</states[it]>
on close go Closed
state Closed StateMachine
A StateMachine Interpreter Schema
class Machine
on open go Opened
on lock go Locked def run_state_machine(m) start : State
current = m.start states! State*
state Locked while gets
puts "#{current.name}" class State
on unlock go machine: Machine
input = $_.strip
Closed current.out.eachdo |trans| name # str
if trans.event == input out ! Trans*
current = trans.to in : Trans*
State end
break
class Trans
Machine end event : str
UT Austin
end from : State / out
end to : State / in
Example 23

24. Sample Expression Expression Grammar
E ::= [Add] left:E "+" right:M | M
M ::= [Mul] left:M "*" right:P | P
3*(5+6) P ::= [Num] val:int | "(" E ")"
An Expression Interpreter Expression Schema
module Eval class Exp
operation :eval
class Num
def eval_Num(val) val : int
val
end class Add
left : Exp
def eval_Add(left, right) right : Exp
Expression left.eval + right.eval
end class Mul
Example def eval_Mul(left, right)
left : Exp
right : Exp
UT Austin
left.eval * right.eval
end
end 24

25. Grammar Grammar
start G
G ::= [Grammar] "start" start:</rules[it]>rules:R*
R ::= [Rule] name:sym "::=" arg:A
A ::= [Alt] alts:C+ @"|"
C ::= [Create] "[" name:sym "]" arg:S | S
S ::= [Sequence] elements:F*
F ::= [Field] name:sym ":" arg:P | P
P ::= [Lit] value:str
| [Value] kind:("int" | "str" | "real" | "sym")
| [Ref] "<" path:Path ">" non-terminal name
| [Call] rule:</rules[it]> reference to rule
| [Code] "{" code:Expr "}"
| [Regular] arg:P "*" Sep? { optional && many }
UT Austin
| [Regular] arg:P "?" { optional }
| "(" A ")"
Sep ::= "@" sep:P 25

26. Quad-model
UT Austin
Nontrivial
bootstrapping 26

27. Diagrams
• Model
• Shapes and connectors
• Interpreter
• Diagram render/edit application
• Basic constraint solver
UT Austin
27

28. Schema Diagram
UT Austin
28

29. Stencils
• Model: mapping object graph  diagram
• Interpreter
• Inherits functionality of Diagram editor
• Maps object graph to diagram
–Update projection if objects change
• Maps diagram changes back to object graph
• Binding for data and collections
–Strategy uses schema information
–Relationships get drop-downs, etc
UT Austin
–Collections get add/remove menus
29

30. Schema Diagram Editor
UT Austin
30

31. Schema Stencil
diagram(schema)
graph [font.size=12,fill.color=(255,255,255)] {
for "Class" class : schema.classes
label class
box [line.width=3, fill.color=(255,228,181)] {
vertical {
text [font.size=16,font.weight=700] class.name
for "Field" field : class.defined_fields
if (field.typeis Primitive)
horizontal {
text field.name // editable field name
text ": "
UT Austin
text field.type.name // drop-down for type
}}}}
31

32. Schema Stencil: Connectors
…
// create the subclass links
for class : schema.classes
for "Parent" super : class.supers
connector [line.width=3, line.color=(255,0,0)]
(class --> super)
…
[also for relationships]
UT Austin
32

33. Ensō Summary
• Executable Specification Languages
• Data, grammar, GUI, Web, Security, Queries, etc.
• External DSLs (not embeded)
• Interpreters (not compilers/model transform)
• Multiple interpreters for each languages
• Composition of Languages/Interpreters
• Reuse, extension, derivation (inheritance)
• Self-implemented (Ruby for base/interpreters)
• Partial evaluation for speed
UT Austin
33

34. Spectrum of programming
How What
(implementation) (Specification)
UT Austin
34

35. How What
(implementation) (Specification)
Verification
UT Austin
35

36. Synthesis
How What
(implementation) (Specification)
Verification
UT Austin
36

37. Synthesis
How Domain-Specific What
(implementation) Specifications (Specification)
Verification
Lite
Verification
UT Austin
Verification Lite
= Type checking 37

38. Enso is "Synthesis Lite": Fully
automated from domain-
specific specification language
Synthesis
Synthesis (guided)
Lite
How Domain-Specific What
(implementation) Specifications (Specification)
Verification
Lite
Verification
UT Austin
38

39. Don't Design
Your Programs
UT Austin
39

40. Program
Your Designs
Ensō
enso-lang.org
UT Austin
40