Notes.ooutline

Topic

Lightweight Languages 2003
- 2003/11/08
  - http://ll3.ai.mit.edu/
- Notes by Jay McCarthy <jay@kenyamountain.com>
  - This is a Best effort.
  - Email if you have problems or comments.
ACME: Toward a LL Testing Framework for Large Distributed Systems
- Dana Moore and Bill Wright
- Presentation
  - Challenges of Testing Distributed Systems
    - Large Scale Distributed Testing
      - Goals
        
        Code quality
        
        Code instrumentation
        
        Test automation
        
        Assessment automation
      - How do implement a testing framework to do this?
        
        Especially if the system was not built with testability in mind
        
        No data capture points or logging built in
      - Implementation goals
        
        Serving developer needs + safeguard programme integrity
        
        Minimally instrusive instrumentation
        
        Assuring repeatability of software mixes
    - Components of Design
      - CVS Integration Dashboard
        
        Figure out how to fix something if it breaks
      - Polaris
        
        Easy to use testing system interface
        
        Push button system to view testing status of tests
        
        Creating tests
        
        Use-cases are made of test cases
  - The ACME Approach
    - ACME Service Structure (Parallel Agent system)
      - Botlets
        
        Command botlets
        
        Jabber Botlet
        
        "Botlet" is just used to differentiate from software agents
      - Databus
      - Botlet Manager
      - Operating System
    - DataBus Plugin Slot Structure
      - Plug in services and commands
      - Inspiration from IRC chat bots
        
        You want to be able to "talk" to the system underneath
    - ACME Framework Components
      - Multi backpane communications
  - XMPP as a Protocol for Distributed Systems
    - XMPP
      - AKA the Jabber Protocol
      - IETF Standard
      - XML format for messaging
        
        Simple and compact
      - Server based
        
        Not peer to peer
        
        Servers relay messages
      - Open IM protocol
    - Jabber Communications Web
      - Clients talk to servers who talk to other servers
      - Firewalls are not a problem like in P2P systems
    - XMPP Services
      - Messaging
      - Presence
      - Roster
      - Groupchat
      - User database
      - Server-to-server message relay
    - XMPP Packets
      - Example of simple to read messages
    - How XMPP is Used
      - Message convey commands
        
        Issue from an IM client to probe the system
      - Or you can do it through code!
        
        Jabber has interfaces for every language/os/platform/etc
  - Summary
    - Testing large distributed systems is a problem well-suited to lightweight languages
    - The ACME framework of plugin components shows one appraoch
    - JAbber is a powerful, efficient, platform-independent protocol for distributed systems
- Q & A
  - Jabber does not have reliable messaging. Any comments?
    - This is an incorrect comment for some definition of "reliable"
    - jabberd - the free edition - is what is used
    - The protocol is defined as reliable
  - SK: What is the lightweight connection?
    - Doing this in Java wouldn't've have worked
    - Doing it the right way is leveraging lightweight power
  - MF: It's great you made this as a lightweight application - but what is the migration path?
    - SK: Where's the type checker?
    - SK: Scripts to applications!
    - Take the flamewar offline
  - This is not a trivial script. This IS an application.
  - What language is the application you're testing written in?
    - Java
    - How do you really debug a Java program not in Java?
Interactive Web Programming using WASH/CGI
- Matthias Neubauer
- Presentation
  - The Changing Web
    - Web servers used to be static.
    - Most pages now are dynamic
      - Dependent on profiles, languages, etc
      - User interaction: chatting, blogging, online stores, etc
  - Common Pitfalls
    - Easy to start with a simple CGI csript
    - but it's hard to do it right
      - HTTP underneath is stateless
      - script-centric appraoch
      - data communication in key value pairs
      - values passed as strings
      - hard to structure XHTML forms
      - no guarantee for valid XHTML
      - management of persistent data
      - security
      - et cetera ad infinitum
  - WASH/CGI
    - Embedded into Haskell
      - use of abstract data types
      - type-safe interfaces
      - compositionality
    - Family of lightweight languages
      - Document Sublanguage
        
        constructor functions for XHTML document nodes
        
        Constructor functions transform sequences of XHTML nodes
        
        Sequences of nodes are actions
        
        The wash2hs preprocessor
        
        Example
        
        Validity
        
        Can find well-formedness
        
        Conforming with DTD
        
        Quasi-validity by using Haskell's type class system
      - Session Sublanguage
        
        A session is...
        
        Alternating sequence of Web forms and form submissions
        
        Possible implementations of session state
        
        URL rewriting
        
        cookies
        
        hidden input fields
        
        Browser navigation
        
        back button
        
        window cloning
        
        bookmarking/saving
        
        Transparent notion of session state
        
        Entire application in one program
        
        Complete session state in hiddenfields
        
        no state information stored on server
        
        browser navigation fully supported
        
        Operations
        
        ask
        
        tell
        
        Send output to a client
        
        io
        
        Integrate file io operations
        
        run
        
        Execute the session
        
        Example
      - Widget Sublanguage
        
        Interaction!
        
        Input elements for HTML input widgets
        
        Create HTML elements with combined user input
        
        Continuation buttons
        
        Web programming using WASH is like GUI programming
        
        Typed input fields return handles
        
        Submit buttons with callbacks
        
        Input validation for free!
        
        Example
      - Persistence Sublanguage
        
        For (persistent) state beyond built-in notion of session stae
        
        Fully type-safe, even across program boundaries
        
        Server side state
        
        globally accessible to all programs
        
        like simple database with versioning
        
        Interface
        
        init
        
        get
        
        set
        
        add
        
        current
        
        Get the current version of a given object handle.
        
        To make sure you're not working on old data
        
        Client-side state
        
        visible to scripts started from client
        
        Implementation like standard cookies
  - Related Work
  - Conclusions and Future Workx
    - Conclusions
      - Rich use of ADTs and type language of Haskell
      - WASH/CGI showed its usefulness
    - Future Work
      - Caching of interactive web programs
      - Better integration of shared resources
    - Available online
  - The Long Calculator Example
- Questions and Answers
  - Matthias F: In your world, you have embedded a little language into Haskell - you get to inherit all these strange types that you don't need know about them. What can you do about error messages in a WASH/CGI program that have nothing to do with WASH/CGI?
    - The Haskell community is working on this.
  - Shriram: You've taken away CPS. DS makes it hard to manage and coordinate development. Why is CPS not used? You've confused the distinction between cookies and hidden fields! This is not transparent to the user and programmes.
    - 2003/11/09 Update: Shriram writes to correct me, "Actually, I was arguing that you've *forced* the programmer to write the program in CPS. CPS is an ugly, complex syntactical pattern that WASH/CGI forces the programmer to maintain by hand. The continuation solution spares the programmer of ever having to convert the program from the natural form of the code. Indeed, this "inversion" is exactly the same one that Greg Cooper's talk was about!"
    - The distinction must be made by judicious use of cookies or hidden fields.
    - SK: Maybe this is unclear? Continuations are everything
  - How do you protect from tampering?
    - Encryption
Break
XS: Lisp on Lego MindStorms
- Taiichi Yuasa
  - From Kyoto University
- Presentation
  - Hardware organization of Mindstorms
    - PC
    - IR Tower
    - RCX 1.0, 1.5, or 2.0 attached with Lego devices and bricks
      - Very small machine
  - Features of XS (Extra Small)
    - Interactive development environment
      - repl
      - interactive definition and redefinition
      - error messages w/ backtrace
      - tracing
    - autonomous evaluator in RCX
      - dynamic object allocation & GC
      - tail-recursive
      - robust against bugs
      - terminal interrupts
    - Sufficient functionality to control robots
      - Scheme-like w/ no first class continuations
        
        So it's called a Lisp, rather than a Scheme
      - interface to Lego devices
      - event / time waiting and async event watchers
  - System Overview of XS
    - Interaction between two components
      - Linux or Windows PC
        
        reader
        
        preprocessor
        
        printer
        
        LNP
      - RCX
        
        evaluator
        
        brickOS (legOS)
  - Data Types
    - Booleans
    - integers: 14 bit signed
    - empty list
    - conses
    - functions
      - built-in functions
      - lambda closures
    - symbols
      - built-in symbols
      - user-defined symbols
  - Pseduo-data types and read constants
    - string => list of character
    - character => ASCII code
    - reader constants => integer
  - Common functions
    - top-level
      - (bye) ; sayonara
    - basic
    - control
      - (catch ...)
      - (throw ...)
    - condition
    - binding
    - type predicates
    - comparison
    - arithmetic
    - random numbers
    - list processing
    - I/O from/to front-end PC
    - garbage collection
      - (gc) ; returns # of free cells
    - Note: Some functions may be left out for space
  - Lego Specific Functions
    - top-level
      - (last-value)
    - control
      - (sleep int) ; in 1/10 seconds
      - (wait-until cond)
      - (with-watcher ((cond . handler)*) . body )
    - system clock
      - (time) ; overflows in 13 minutes
      - (reset-time)
    - IR communication status
      - (linked?)
    - light sensors
    - rotation sensors
    - temperature sensors
    - touch sensors
    - motors
    - sounds
    - Prgrm button
    - LCD display
    - battery level
  - The Evaluator
    - Written in C
    - compiled by GNU
    - sizes
      - brickOS: 9 KB
      - binary: 11 KB
      - IO buffers: 256 bytes
      - C stack: 1 KB
      - Variable: 0.5 KB
      - Heap: 5 KB (1280 cells)
    - Object representation
    - Heap management
      - every cell occupies two words
      - no need for compaction
      - free cells are linked together to from a free list
      - mark & sweep, stop the world garbage collector
  - Current Status of XS Project
    - Linux version for RCX 1.0 & 1.5
    - Linux version for RCX 2.0
    - Windows version for RCX 1.0, 1.5, & 2.0 completed by Franz Inc.
    - draft reference manual ready
    - will soon start Web distribution as open source at http://www.xslisp.com/
  - Show Time
    - Seeing is believing!
    - Timing is very important when you're giving commands
      - The robot may be moving around
- Questions and Answers
  - How are guaranteeing tail calls in the system?
    - New method, not trampolining
    - When it finds a tail call then it just jumps to itself
  - Is brickOS that comes with Lego Mindstorms?
    - It is open source
  - Is there is anything specific to the Lego system or can you use any H8 system?
    - Maybe? Hard to say
  - Is it possible to get two bricks to communicate with each other?
    - This is on the list
  - How do you do (load ...) ?
    - Files are sent on the IR
  - How limiting do you find the 1280 cell limit?
    - Very difficult
    - Debugging is very difficult
      - Count the number of beeps
  - What's the data transfer rate over IR?
    - Very slow
Poster session
Lunch
Bluespec, Language Support for Next-Generation Hardware Design
- Rishiyur S. Nikhil
- Presentation
  - ASIC Design "flow"
    - Stages
      - Modelling (in high level)
      - RTL coding (Verilog/VHDL)
      - Synthesis to gate-level netlist
      - Physical Design
      - Tapeout, Manufacture
    - Verification and Respin are very costly
      - And getting worse.
    - Synopsys CEO: "61% of ASICs respin"
  - Evolution of HDLs
    - Pre 1990 - Schematic Capture
      - Write your schematic on paper and capture them.
    - 1990 - Verilog / VHDL
      - C and ADA with regards to government
      - Not much have chanced
    - 2002 - Bluespec
      - Started earlier
    - 2004 - System Verilog
      - "Best of" and do more
      - Hopefully become IEEE
  - Previous attempts to improve methodology
    - Cooperating FSMs
      - "Not cons-ing up hardware on the fly"
    - Dynamic software process models
      - Behavioral HDLs
      - SystemC
      - From a high level description, press a button and get good hardware
        
        This a pipedream, just use this at the first level
    - Problem: Semantic gap -> poor HW Synth
      - Very very hard problem
      - Nowhere close to prime time
      - Some may say it'll never happen
    - Bluespec tries to be higher but not blue sky
  - Where does Bluespec fit?
    - Bluespec SystemVerilog
      - Political decision on name
    - Bluespec Compiler (Synthesis)
    - Verilog RTL (or Verilog/SystemVerilog)
    - Synthesis
    - ..etc..
  - Example of 2-stage pipelined CPU
    - Overview of Process
      - Everything built out of modules
      - Describe behaviour with rules
      - Describe implementation of CPUifc interface
    - Component module: FIFO
      - glue between stages
      - Bluespec automatically sets up arguments to circuit
        
        And implicit conditions
        
        ie, "not full", "not empty"
      - Verilog doesn't say anything about behaviour, timing
        
        Just wires to wires
      - Bluespec is Better Than That
    - Behaviour rule for Bz
      - Pattern matching
      - Rules are atomic
        
        Ensures pc update and discard of mispredicted instrs in bu are done consistently
      - Implicit checks play a role
    - Adding stalling
      - Add more conditions
      - rules aren't until conds are satisfied
  - Bluespec
    - Overview
      - Object oriented
      - Private state
      - Rules
      - Interfaces
      - Polymorphism
      - Higher order functions
    - Bluespec offers...
      - Familiar HW modle
      - Rules
      - Modular Composition
      - Advanced Programming Features
        
        powerful programmability to compose complex systems from component parts. But since this is just for static elaboration, and not for hardware behavior, they place no limits on "syntheizability"
        
        This all about structure, not about rules and behaviour
        
        This difference is key to the difference between Bluespec and other Behavioural HDL
      - High quality synthesis
        
        None of the other things matter without this
  - Validation
    - Arbiter for a 16-port 10 Gb/s IP Packet router
      - 12 months vs 8 months of development
      - Higher gate count
      - Moved lines of code from 65.K to 4.5K
      - A third of the bugs
      - Explored 3 variations
  - Acknowledgments
- Questions and Answers
  - Do tools like this facilitate asynchronous circuits?
    - Important question especially with regards to power consumption.
    - The rules are not a clock stop.
    - Bluespec interprets them into clocks
    - Promise is there, but it has not be done.
  - Performance
  - Question about type inference and proving correctness
    - Difficult to see that something that does SOMETHING is wrong
The Virtual Machine of Lua
- Roberto Ierusalimschy
- Presentation
  - Description of Lua
    - Yet another scripting language
    - Conventional syntax
    - Associative arrays as single data structure
      - first class values
      - any value allowed as index
      - very efficient
      - syntactic sugar
    - Several not-so conventional features
      - first class functions
      - lexical scoping
      - proper tail call
      - coroutines
      - "dynamic overloading"
  - Why use Lua?
    - Light
      - Fits in around 60k or 140K
    - Portable
      - Written in "clean C"
      - Runs on many platforms
    - Efficient
    - Easy to embed
      - A library, not a proper language
      - Designed to be embedded from start
  - Some applications
    - Games
      - LucasArts, BioWare, Microsoft, Relic Entertainment, etc
    - Other uses
      - tomsrtbt
      - Crazy Ivon Robot (RoboCup champ 2000/2001)
      - chip layouts
      - APT-RPM
      - Space Shuttle Hazardous Gas Detection System (ASRC Aerospace)
    - Poll on gamedev.net about scripting language
      - Lua third popular (none and own beat it)
  - Virtual Machine of Lua 5.0
    - Most virtual machines use a stack model
      - Lua 4.0 was as well
    - Another model other than stack
      - Stack machine instructions are far low level
      - Interpreters generally have high overhead per instruction
      - Register machines allow more powerful instructions
      - overhead to decode more complex instruction is compensated by fewer instructions
      - "registers" for each function are allocated on the execution stack at activation time
        
        And large number of register simplify code generation
    - Instruction Formats
      - Standard three argument format
      - Also, a second style that do not need three arguments or with arguments that do not fit in 9 bits
    - Implementation of Tables
      - Each table may have two parts: a "hash" part and an "array" part
      - Hard to decide where to put new elements
        
        Only make the hard decision when you have to resize one part of the table
    - Performance
    - Final Remarks
      - Compiler for register based machine is more complex
        
        Needs primitive optimizations
      - Interpreter for register-based machine is more complex
        
        Needs to decode instructions
      - Requirements
        
        no more than 256 local variables and temporaries
      - Main gains
        
        avoid moves of local variables and constants
        
        fewer instructions per task
        
        potential gain with CSE optimizations
- Questions & Answers
  - Was it a surprise that Lua was used for games?
    - Yes
  - Byte code size comparison or benchmark
    - Did not compare byte code size
    - One of the problem with these methods
    - Very big problems can happen with byte code size in Lua
      - Not optimized
  - Opcode numbers are not powers of 2, they are 6 bits... why? Performance hit from masking or shifting?
    - Not measured, but it was thought about
  - Measurements about how arrays are actually used?
    - No explicit research or experimentation
  - Any idea why it is attractive for game programmers?
    - Portability and Embedding
    - Efficiency a little bit... mostly from word of mouth though
    - Easy to learn
      - Most people who use it are not programmers, mainly game designers
Embedding an interpreted language using higher-order functions and types
- Norman Ramsey
- Presentation
  - Embedded Interpreters
    - Configure and control complex programs: scripting
    - Early: REXX (VM/CMS + XEDIT)
    - Popular: Tcl/Tk (script nasty X libraries)
    - Clean: Lua (two talks today)
    - Examples: script retargetable, optimizing compiler
  - Example: Simple interpretation of C-- in Lua
    - Loop through list of files, translating each one
    - Nothing embedded here.
  - Example: call embedded functions from Lua
    - Calling embedded is completely orthogonal to regular calls
  - Example: Build a back end in Lua
    - Back-end stages are sequenced in optimizer
    - Specified as table
    - Advantage: disable any stage
  - Use: Driver, configuration, stack layout in Lua
  - Today's talk: End scripting envy
    - Make Embedding work in a functional language
      - Existing implementations require C or C++
    - Salient aspects
      - type safety required (with static checking)
      - First class, higher order functions
    - Big impact on glue code
      - Manage mismatch between host function (C or ML) and embedded language (Lua)
        
        Host functions has fixed number of parameters of known types
        
        Embedded function has variable number of parameters of varying type
      - Real work is dominated by glue code
  - Where you can get glue code
    - Write glue code by hand
      - Overhead
    - Generate glue code using toLua
      - You must "clean" your header files by hand
      - Tool is about 4k
    - Generate glue code using SWIG
      - Supports 9 scripting languages (not Lua)
      - But tool is 30K lines of code
        
        C compiler we're scripting is only 9K!
  - Shorter, simpler glue code using Lua-ML
    - Specify interfaces
    - Mapping between host & embedded values
      - Dialect: Objective Caml
        
        Polymorphic, compile-time type checker
      - Mapping between values
        
        Embed/project cannot be a single Caml function!
        
        Family of functions
        
        type.{embed, project}
        
        Embed never fails
        
        project can fail
      - How big is the family?
        
        Typical strategy (Lua, Tcl, ...)
        
        Embedding & projection for built-ins only
        
        For each C function, a glue function to project arguments, embed results
        
        Better Strategy (Lua-ML)
        
        Infinite family
        
        Indexed by type
        
        Create new types and glue with: list, **->, **->>
      - Problem: Reconciling type systems
    - Reconciling different type systems
      - Base types are not the same.
      - In Lua everything is a table
    - Other reconciliations
      - Strings inter convert with numbers
      - True/false = non-nil/nil
      - Functions
        
        Caml functions conentionally curried
        
        Lua functions not Curried
        
        No details in 30 minute talk
  - Lua-ML in review
    - How big is it?
      - About 3.8K lines of code
      - Only 400 in embedding and projects
      - 2.5K in Lua 2.5 (written in C)
    - Beyond static typing
      - Variable number of arguments
      - Type-based dispatch
    - Things to remember
      - Higher-order functions to create glue functions at run time
        
        Hide conversion code
      - Embedding and projection indexed by type
      - Encapsulate programming conventions consistently
      - Modest: 400 of 3.8K lines are embedding and projection
      - At http://www.cminusminus.org (downloads)
- Questions and Answers
  - M: Can you handle mutable data? Being shared between Lua and ML
    - If one of the types is mutable then it's shared normally
    - Control flow is mutable and changes
    - M: How do you do the projection of the thing inside?
    - Not magically getting the value out.
    - Not allowed to change the type of the mutable value.
    - You're able to embed/project the operations on the value, but the abstraction stays the same
  - No claims having new ideas!
  - Sounds like NG FFI for ML?
    - Similar, that creates a type in ML representing the C type.
  - Why both trying to embed in Ocaml anyways?
    - It's already slow enough
  - Converting large Lua arrays into lists? If someone change it, are we screwed?
    - We have to do this, but it doesn't take much time so we don't worry about it.
    - As far as mutation goes you must be careful
  - Maybe this is smaller than SWIG just because it supports 1 language rather than 9?
Break
Functional Reactive Programming in Scheme
- Gregory Cooper
- Presentation
  - A simple program
    - A button to increment a counter
    - How do you write this?
      - There's the ideal way and then the way you must do it
    - Why do you have to write it the gross way?
      - You can't model the interaction
    - For interaction and reaction you need a different model of computation
      - We need a model where all the flow happens when you need it
    - In the callback model
      - It does the work of what the return values should have done
      - Because you're not using return values then you need some extra values
      - The language is not letting us return the way we want to
      - The structure of the program gets inverted and we're forced to use state
      - The result of this is an unnatural style of program and way of thinking of the system
        
        Mutation, tighter coupling, etc
  - Function Reactive Programming (FRP)
    - Extend a language with mechanisms for dealing with time
    - Treat time-varying entities as values
    - Historical
      - Fran
      - Haskell School of Expression
      - Genuinelyt Functional User Interfaces
      - Functional Reactive Programming
      - Scheme port in Lula
        
        This one is different from Father Time
  - Example of FrTime
    - (current-seconds) vs seconds
      - (current-seconds)
        
        The value is old as soon as you get it.
        
        When should we ask?
      - seconds
        
        Changes with time
  - Implement the simple GUI
    - Hey, this is almost the way we want to program
    - Create a source of a stream of clicks
    - Turn that into a stream of 'add1' operations
    - Accumulate and and hold this stream to have a value that is continuous of time
  - Benefits from this programming style
    - Intuitive programs
    - Define abstractions more easily
  - Graphical demos and demos of UI elements
  - You turn signals into values
    - With no polling or sampling
    - All event driven
    - No callbacks anywhere
    - Executable model
    - Very declarative
    - No mutation
  - Properties of Signal-Based Approach
    - Natural program structure
    - No explicit mutation
    - Treat events and signals as values, define invariants over them
      - Looser coupling
  - Implementation
    - Constructs dataflow graph
    - Drives recomputation with async message passing
    - Does not perform polling or sampling
    - Supports distributed signals
    - New language level in DrScheme
    - Available on PLT CVS Server
- Questions and Answers
  - How does it work?
    - Gave high level overview
    - Built dataflow graph and distribute dependencies within a thread
    - Structured around a message queue
  - Shows growing list demo
    - (define foo (build-list (modulo seconds 10) add1))
    - (foldl * 1 foo)
      - Factorial!
  - This is done with macros. It looks like it's in execution engine.
    - More than just macros.
    - The PLT module/macro system lets you re-implement the evaluation model.
    - Different language!
    - DrScheme supports language levels, this is cool
  - Nanoseconds is next release!
  - When you write animation, why don't you have to "undraw" your shapes?
    - How do you take a pure model and define the model with something impure?
    - Drawing is inherently impure.
    - I had to write this specifically.
  - What happens to exceptions?
    - The evaluation ignores exceptions
    - Because we have a completely different model of evaluation, so it's undefined what an exception really is.
    - The program is always there and things start flowing
    - An exception is defined as flow stopping.
  - What happens when you interface with something impure? Printing?
    - Undefined
  - How much of the world do you re-evaluate when something changes?
    - When a value is changed it propagates up
Boundaries
- Dan Sugalski
- Presentation
  - "Obligatory Non-technical hand waving presentation"
  - What am I talking about?
    - boundaries: something that indicates or fixes a limit or extent
    - picture of cup & women's faces
      - Having a boundary doesn't tell you anything useful.
      - What side are we on?
    - Water & Sky
      - Wave and Mt. Fuji
    - It's not always clear what's being bounded
    - Old lady or young women?
  - Boundaries are everywhere
    - Functions
    - Source Modules
    - CPU modes
    - Programs
    - Languages
    - People
  - Boundaries provide
    - Categorization
    - Isolation
    - Inflection Points
    - Constraint
    - Safety
    - Domain separation
  - Most important thing Boundaries provide: Perspective
    - Sometimes this obscures what you're looking at
    - Gives you distance
    - A chance to think about things external
  - Boundaries Provide
    - Restriction
    - Inefficiency
    - Annoyance
    - Vicious classification
  - Tendency to look poorly at what's on the other side of the boundary.
    - If you were any good you'd be on "our side"
  - Boundaries
    - Used properly, they provide structure and framework
    - Used improperly, the strangle the life out of a project
    - Which is which is always up for argument as well
  - Boundaries: A power so great it can only be used for good or evil!
  - Reality Check
    - The problem's just too big to fit in your brain all at once.
      - You need a boundary to think about it.
    - Unless it's a very small program
    - Or a scary size brain!
    - "Slice the problem or your brain?"
      - So you won't lose it all at once!
  - The landscape isn't mobile
    - "Problem points" are linked
    - They can be moved (some)
    - They exist whether you want to consider them or not!
      - Reality doesn't care about how you divide them.
  - Division of Labour
    - Who does what
    - Who DOESN'T do what
    - Who provides what to whom
    - Who has to understand what
  - API segregation
    - What you have to know to use a library
    - What data belongs to whom
    - How to cross the boundary
    - For code, defines part of the boundary
  - A boundary is there whether you think about it or not.
    - Look at embedding of languages.
    - Lua vs Perl 5
  - Paradigms - "The P word!"
    - Different languages act differently
    - Drawing boundaries keeps things separate
    - Beats having to think in Forth, C, Scheme, Prolog, APL, and Smalltalk simultaneously.
      - "You'd go insane... er."
  - Poor definition can be harmful
    - Sloppy APIs
    - Limits on forward changes
    - Confusion amongst users
    - Confusion amongst developers
    - Force extra work
  - Use them to your advantage
    - Partition problem spaces to fit your brain
      - Or other people's brains
      - "You're smarter than me, and that's okay"
    - Install inflection points
    - Provide guarantees
    - Hide cheating
      - Look at bytecode and JIT
  - Just remember
    - Always, always, place them on purpose
      - If you don't put them in then someone will and they'll be there
    - Ignore the landscape at your peril
      - Every point has baggage and neighbors
- Questions and Answers
  - "Think carefully about my interfaces?" In real life you don't know ahead of time! If you try to anticipate then you will never get started. What really happens is that you introduce boundaries where none were there before. I don't like being told to avoid this because it's unavoidable.
    - Life just suck huh?
    - There will always be times when you don't know.
    - While thinking about your API doesn't say you won't get it right, but if you DON'T think about it then it will suck even worse
  - "I want to advocate sloppiness! Throw away everything you don't care about and do something cool"
    - You're probably just drawing your boundaries too small
    - Just define your very large area
  - "You have to consider the movement and destruction of boundaries"
  - "Allow versions of boundaries? Versioning of interfaces?"
  - "Most of the tough problems are not where to draw a boundary but instead how to make a choice between competing boundaries"
    - Look on each side, what do you get and what don't you get?
    - Choose the one you like the best
    - This is an art
  - "I was hoping this would have solutions to the 'Life sucks!' scenario. One is versioning, one is rationale capture."
    - Document why you are making the choices you make.
  - "Aspect Oriented Programming is all about boundaries. It's an attempt."
    - Meh?
      - *Crowd claps*
  - It's not necessarily "This is the threading package I'm going to provide, just I'm going to provide threads."
    - "What will my system address?"
  - "A lot of the cleverness of this conference and computer science is ignoring and transcending boundaries."
    - "Switch to a better boundary"
    - Sometimes you may need to get rid of everything and go play.
  - "You're working on a project with very clear boundaries: It's a VM for every language. What are the boundaries of Parrot?"
    - Parrot is designed to implement dynamic languages fast.
      - Perl, Python, Ruby, and other dynamic languages
      - Not C.
    - The choices we made to make what's on our side work are not necessarily good for other languages like C.