Back 2 basics with proto
Download
1 / 39

Back 2 Basics with Proto - PowerPoint PPT Presentation


  • 211 Views
  • 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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
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

MIT AI Lab


Proto l.jpg
Proto

  • Goals

  • Examples

  • Relation

  • Definition

  • State

  • Future


Proto hello world l.jpg
Proto Hello World

(format out “hello world”)


Proto goals l.jpg

Simple

Productive

Powerful

Extensible

Dynamic

Efficient

Real-time

Teaching and research vehicle

Electronic music is domain to keep it honest

Proto Goals


Simplicity l.jpg
Simplicity

  • 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

Prototype-based

Procedural macros

Rationalized collection protocol / hierarchy

Always open

Predicate types

Infix syntax

Class-based

Rewrite-rule only …

Conflated collection protocol / hierarchy

Sealing

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
Learnability

  • 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
Understandability

  • 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
Writability

  • 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
Modifiability

  • 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

  • WSYWIG

    • 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
Runnability

  • 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
Status

  • 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

Series

Macros

Language Implementation

Dynamic compilation

Analysis/optimizations

Visualization

Real-time

Research Directions


ad