Software Language Design & Engineering

Software Language
Design & Engineering

Eelco Visser
http://eelcovisser.org

Zürich, May 12, 2011

Software Engineering

Problem
Machine
Domain

bridging the gap between problem domain and solution domain

High-Level Languages

Problem
HLL Machine
Domain

HLLs reduce gap

Domain-Speciﬁc Languages

Problem
DSL HLL Machine
Domain

domain-speciﬁc languages support more specialization

Domain-Speciﬁc Languages

Even Higher-
Level
Languages

Problem
DSL HLL Machine
Domain

domain-speciﬁc languages support more specialization

Software Language Design & Engineering

enable software engineers to
effectively design, implement,
and apply domain-speciﬁc
software languages

Research: Software Language Design

Systematically design domain-
speciﬁc software
languages with optimal
tradeoff between expressivity,
completeness, portability, coverage, and
maintainability

Expressivity vs Coverage

expressivity: fewer irrelevant details => conciseness
coverage: which portion of domain can we express

Software Language Design Case Studies

Mobl: client-side stateful web applications

WebDSL: server-side restful web applications

http://www.mobl-lang.org

Zef Hemel

Divergence in Mobile Platforms

Objective-C Java J2ME/C++

HTML/Javascript Java .NET

Native Applications not Portable

Convergence in Mobile Platform

Webkit browser Webkit browser

Webkit browser Webkit browser

The Universal Userinterface Engine

Rich Applications

Audio
WebDatabases
Full-screen support
Location information
(GPS)
Ofﬂine support
Canvas
Accelerator support
Multi-touch

Native Applications

Address book
Camera
Compass
File IO
Notiﬁcations

Software Engineering with JavaScript

annotated HTML imperative Javascript

MVC, No Integration, No Abstraction, Accidental Complexity

typed declarative

integrated concise

tipcalculator.mobl

application tipcalculator

import mobl::ui::generic

screen root() {
var amount = 20
var percentage = 10
header("Tip calculator")
group {
item { numField(amount, label="amount") }
item { numField(percentage, label="percentage") }
item { "$" label(Math.round(amount * (1 + percentage/100))) }
}
nl()
}

Data Model

entity Task {
name : String (searchable)
done : Bool
due : DateTime
category : Category (inverse: tasks)
tags : Collection<Tag> (inverse: tasks)
}
entity Category {
name : String
tasks : Collection<Task> (inverse: category)
}
entity Tag {
name : String
tasks : Collection<Task> (inverse: tags)
}

HTML5 Data Persistence

Logic
entity Task {
name : String (searchable)
done : Bool
due : DateTime
category : Category (inverse: tasks)
tags : Collection<Tag> (inverse: tasks)
function postpone(days : Num) {
this.due = DateTime.create(
this.due.getFullYear(),
this.due.getMonth(),
this.due.getDate() + days);
}
function import(user : String, pw : String) {
var tasksJSON = httpRequest("/export?user="+ user + "&pw=" + pw);
foreach(t in tasksJSON) {
add(Task.fromSelectJSON(t));
}
}
}

statically typed: catch errors early

Reactive User Interfaces

screen root() {
var phrase = ""
header("Tasks") {
button("Add", onclick={ addTask(); })
}
searchBox(phrase)
group {
list(t in Task.search(phrase) limit 20){
item {
checkBox(t.done, label=t.name)
}
}
}
}

Navigation

screen root() {
var phrase = ""
header("Tasks") {
}
searchBox(phrase)
group {
list(t in Task.search(phrase) limit 20){
item {
}
}
}
}

Navigation

screen root() { {
addTask()
var phrase = ""
t = Task()
header("Add") {
header("Tasks") {
button("Done", onclick={
} add(t);
searchBox(phrase)
screen return;
group {
})
} list(t in Task.search(phrase) limit 20){
textField(t.name)
item {
datePicker(t.due)
} }
}
}
}

Continuations

screen root() {
button("Ask", onclick={
alert("Hello " + prompt("First name") + " "
+ prompt("Last name"));
})
}
screen prompt(question : String) : String {
var answer = ""
header(question) {
button("Done", onclick={
screen return answer;
})
}
textField(answer)
}

User Interface Idiom: Tab

control tab1() {
header("Tab 1")
label("This is tab 1")
}
control tab2() {
header("Tab 2")
label("This is tab 2")
}
screen root() {
tabSet([("One", tab1), ("Two", tab2)],
defaultTab="One")
}

Tab Set: Higher-Order Control

control tabSet(tabs : [(String,Control)], activeTab : String) {
list((tabName, tabControl) in tabs) {
block(onclick={ activeTab = tabName; },
style=activeTab==tabName ?
activeTabButton : inactiveTabButton) {
label(tabName)
}
}
list((tabName, tabControl) in tabs) {
block(activeTab==tabName ? visibleTab : invisibleTab) {
tabControl()
}
}
}

increase coverage: developers can create abstractions

User Interface Idiom: Master Detail

control taskItem(t : Task) {
}
control taskDetail(t : Task) {
textField(t.name)
datePicker(t.due)
}
screen root() {
header("Tasks")
masterDetail(Task.all() order by due desc,
taskItem, taskDetail)
}

Master Detail: Higher-Order Control

control masterDetail(items : Collection<?>, masterItem : Control1<?>,
detail : Control1<?>) {
group {
list(it in items) {
item(onclick={ detailScreen(it,detail); }) {
masterItem(it)
}
}
}
}
screen detailScreen(it : ?, detail : Control1<?>) {
header("Detail") { backButton() }
detail(it)
}

Ken

http://itsneh.com/ken/

Mobl IDE

static cross-concern consistency checking

Research: Software Language Engineering

Automatically derive efﬁcient,
scalable, incremental compiler +
usable IDE from high-level,
declarativelanguage
deﬁnition

The Spoofax Language Workbench

creating full featured IDEs for domain-speciﬁc languages


an IDE for developing languages and their IDEs


Integrated Language Deﬁnition Testing

Syntax Deﬁnition

module MoBL-Data

imports
Common
MoBL

exports
context-free syntax
MetaAnno* "entity" QId ":" Type "{" Property* "}" -> Definition {cons("Entity")}
MetaAnno* "entity" QId "{" Property* "}" -> Definition {cons("EntityNoSuper")}
MetaAnno* ID ":" Type "(" {Anno ","}* ")" -> Property {cons("Property")}
MetaAnno* ID ":" Type -> Property {cons("PropertyNoAnnos")}
ID -> Anno {cons("SimpleAnno")}
"inverse" ":" ID -> Anno {cons("InverseAnno")}

context-free syntax
"@sync" UriPath -> MetaAnno {cons("SyncEntityAnno")}

Type Checking

rules

constraint-error :
t@SimpleType(_) -> (t, $[Type is not defined: [<pp-mobl-type> t]])
where not(<lookup-type> t)

constraint-error :
t@FieldAccess(e, x) -> (t, $[Property [x] not defined])
where <type-of> e
where not(type-of)

Code Generation

rules

property-to-js(|ent) :
Property(_, x, t@SimpleType(_), anno*) -> $['[x]': '[sqlType]']
where not(<is-entity-type> t)
with sqlType := <sql-type> t
; if [_] := <filter(?SimpleAnno("searchable"))> anno* then
rules ( SearchableProperties :+= (ent, x) )
end

Software Language Design & Engineering

http://eelcovisser.org
Language Design as Engineering Discipline
http://spoofax.org
(More) Declarative Language Deﬁnition
http://mobl-lang.org
Static Analysis of Language Deﬁnitions
http://webdsl.org
Language Workbench in the Cloud

http://researchr.org

http://researchr.org/search/publication/mobl+spoofax+webdsl

Software Language Design & Engineering

More Related Content

What's hot (18)

Similar to Software Language Design & Engineering (20)

More from Eelco Visser (20)

Recently uploaded (20)

Software Language Design & Engineering