Back 2 basics with proto
1 / 39

Back 2 Basics with Proto - PowerPoint PPT Presentation

  • Updated On :

Back 2 Basics with Proto. Jonathan Bachrach MIT AI Lab. Proto. Goals Examples Relation Definition State Future. Proto Hello World. (format out “hello world”). Simple Productive Powerful Extensible Dynamic Efficient Real-time. Teaching and research vehicle

Related searches for Back 2 Basics with Proto

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Back 2 Basics with Proto' - DoraAna

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Back 2 basics with proto l.jpg

Back 2 Basics with Proto

Jonathan Bachrach


Proto l.jpg

  • Goals

  • Examples

  • Relation

  • Definition

  • State

  • Future

Proto hello world l.jpg
Proto Hello World

(format out “hello world”)

Proto goals l.jpg








Teaching and research vehicle

Electronic music is domain to keep it honest

Proto Goals

Simplicity l.jpg

  • 10K lines 10 page manual

  • Hard limit – pressure makes pearls

Best of all worlds l.jpg
Best of All Worlds

  • Want scripting and delivery language rolled into one

  • Tools work better

  • No artificial boundaries and cliffs

  • Never been done effectively

  • Electronic music forces realism

Proto ancestors l.jpg
Proto Ancestors

  • Language Design is Difficult

    • Leverage proven ideas

    • Make progress in selective directions

  • Ancestors

    • Scheme

    • Cecil

    • Dylan

Proto scheme l.jpg

Concise naming

Procedural macros

Objects all the way

Long-winded naming

Rewrite rule only

Only records

Proto <=> Scheme

Proto cecil l.jpg

Prefix syntax

Scheme inspired special forms

Infix syntax

Smalltalk inspired special forms

Proto <=> Cecil

Proto dylan l.jpg

Prefix syntax


Procedural macros

Rationalized collection protocol / hierarchy

Always open

Predicate types

Infix syntax


Rewrite-rule only …

Conflated collection protocol / hierarchy


Fixed set of types

Proto <=> Dylan

Object orientation l.jpg
Object Orientation

  • Assume you know OO basics

  • Motivations:

    • Abstraction

    • Reuse

    • Extensibility

Prototype based oo l.jpg
Prototype-based OO

  • Simplified object model

  • No classes

  • Cloning basic operation for instance and prototype creation

  • Prototypes are special objects that serve as classes

  • Inheritance follows cloned-from relation

Proto oo mm l.jpg
Proto: OO & MM

(dv <point> (isa <any>))

(slot <point> (point-x <int>) 0)

(slot <point> (point-y <int>) 0)

(dv p1 (isa <point>))

(dm + ((p1 <point>) (p2 <point>) => <point>)

(isa <point>

(set point-x (+ (point-x p1) (point-x p2)))

(set point-y (+ (point-y p1) (point-y p2))))

Language design user goals the ilities l.jpg
Language Design:User Goals -- The “ilities”

  • Learnability

  • Understandability

  • Writability

  • Modifiability

  • Runnability

  • Interoperability

Learnability l.jpg

  • Simple

  • Small

  • Regular

  • Gentle learning curve

  • Perlis: “Symmetry is a complexity reducing concept…; seek it everywhere.”

Proto learnability l.jpg
Proto: Learnability

  • Simple and Small:

    • 16 special forms: if, seq, set, fun, let, loc, lab, fin, dv, dm, dg, isa, slot, ds, ct, quote

    • 7 macros: try, rep, mif, and, or, select, case

  • Gentle Learning Curve:

    • Graceful transition from functional to object-oriented programming

    • Perlis: “Purely applicative languages are poorly applicable.”

Proto special forms l.jpg
Proto: Special Forms

IF (IF ,test ,then ,else)

SEQ (SEQ ,@forms)

SET (SET ,name ,form) | (SET (,name ,@args) ,form)

LET (LET ((,var ,init) …) ,@body)

FUN (FUN ,sig ,@body)

LOC (LOC ((,name ,sig ,@body) …) .@body)

LAB (LAB ,name ,@body)

FIN (FIN ,protected-form ,@cleanup-forms)

DV (DV ,var ,form)

DM (DM ,name ,sig ,@body)

DG (DG ,name ,sig)

ISA (ISA (,@parents) ,@slot-inits)

SLOT (SLOT ,owner ,var ,init)

sig (,@vars) | (,@vars => ,var)

var ,name | (,name ,type)

slot-init (SET ,name ,value)

Understandability l.jpg

  • Natural notation

  • Simple to predict behavior

  • Modular

  • Models application domain

  • Concise

Proto understandability l.jpg
Proto: Understandability

  • Describable by a small interpreter

    • Size of interpreter is a measure of complexity of language

  • Regular syntax

    • Debatable whether prefix is natural, but it’s simple, regular and easy to implement

Writability l.jpg

  • Expressive features and abstraction mechanisms

  • Concise notation

  • Domain-specific features and support

  • No error-prone features

  • Internal correctness checks (e.g., typechecking) to avoid errors

Proto error proneness l.jpg
Proto: Error Proneness

  • No out of language errors

    • At worst all errors will be be caught in language at runtime

    • At best potential errors such as “no applicable methods” will be caught statically earlier and in batch

  • Unbiased dispatching and inheritance

    • Example: Method selection not based on lexicographical order as in CLOS

Design principle two planned serendipity l.jpg
Design Principle Two:Planned Serendipity

  • Serendipity:

    • M-W: the faculty or phenomenon of finding valuable or agreeable things not sought for

  • Orthogonality

    • Collection of few independent powerful features combinable without restriction

  • Consistency

Proto serendipity l.jpg
Proto: Serendipity

  • Objects all the way down

  • Slots accessed only through calls to generic’s

  • Simple orthogonal special forms

  • Expression oriented

  • Example:

    • Exception handling can be built out of a few special forms: lab, fin, loc, …

Modifiability l.jpg

  • Minimal redundancy

  • Hooks for extensibility included automatically

  • Users equal partner in language design

  • No features that make it hard to change code later

Proto extensible syntax l.jpg
Proto: Extensible Syntax

  • Syntactic Abstraction

  • Procedural macros


    • Pattern matching

    • Code generation

  • Example:

    (ds (unless ,test ,@body)

    `(if (not ,test) (seq ,@body)))

Proto multimethods l.jpg
Proto: Multimethods

  • Can add methods outside original class definition:

    • (dm jb-print ((x <node>)) …)

    • (dm jb-print ((x <str>)) …)

Proto generic accessors l.jpg
Proto: Generic Accessors

  • All slot access goes through generic function calls

  • Can easily redefine these generic’s without affecting client code

Runnability l.jpg

  • Features for programmers to control efficiency

  • Analyzable by compilers and other tools

Proto optional types l.jpg
Proto: Optional Types

  • All bindings and parameters can take optional types

  • Rapid prototype without types

  • Add types for documentation and efficiency

  • Example:

    (dm format (s msg (args …)) …)

    (dm format ((s <stream>)(msg <str>) (args …)) …)

Proto pay as you go l.jpg
Proto: Pay as You Go

  • Don’t charge for features not used

  • Pay more for features used in more complicated ways

  • Examples:

    • Dispatch

      • Just function call if method unambiguous from argument types

      • Otherwise require dynamic method lookup

    • Proto’s bind-exit called “lab”

      • Local exits are set + goto

      • Non local exits must create a frame and stack alloc an exit closure

The rub l.jpg
The Rub

  • Support for evolutionary programming creates a serious challenge for implementers

  • Straightforward implementations would exact a tremendous performance penalty

Implementation strategy l.jpg
Implementation Strategy

  • Simple dynamic compilation

  • Maintains both

    • optimization and

    • interactivity

Initial loose compilation l.jpg
Initial Loose Compilation

  • Very quick compilation

  • Generate minimal dependencies

    • only names and macros

Dynamic whole program compilation l.jpg
Dynamic Whole Program Compilation

  • Assume complete information

  • Perform aggressive type flow analysis

    • Chooses, clones and inlines methods

  • Compilation can be triggered manually, through dependencies, or through feedback

Dependency tracking l.jpg
Dependency Tracking

  • Assumptions are tracked

  • Changed assumptions trigger recompilation

  • Based on Fun-O-Dylan approach

    • Dependencies logged on bindings

    • Record dependent and compilation stage

Simple code generator l.jpg
Simple Code Generator

  • Focus is on high-level optimizations

  • Potentially gen-code direct from AST with approximated peep-hole optimizations

Save image l.jpg
Save Image

  • Save executable copy of image to disk

    • Maintains optimizations and dependencies

    • Uses dump/undump approach of emacs

  • Avoid hassles of

    • File formats

    • Databases

    • etc

Status l.jpg

  • Fully bootstrapped

  • Module system on line by week’s end

  • Native code-gen in progress

  • Dependency tracking by summer’s end

  • Flow-typist by summer’s end

Research directions l.jpg

Language Design

Dynamic parameterized types

Dynamic Interfaces



Language Implementation

Dynamic compilation




Research Directions