Dynamic Languages Symposium
Gilad Bracha - no more versions
Gilad painted a future where there are no version numbers for software components or applications. Where "Software Updates"
didn't stop the user and make them agree to EULA, reboot, etc.
The code still runs locally and is always available, but against remote components. Syncing and updates when the network is available just happen, so your always up to date
"Run locally think globally"
Some requirements:
* Self modifying code ( hot swapping )
Mirror based reflection - good for security
synchronization - program is quiescent , good time to update, user expects change, program as data - sync the program
throw away transient data, and sync persistent data
program and data are the service
a new take on orthogonal synchronization
Thus components within an application are much more software services, or subscriptions.
Mirror based reflective programming is one solution to the security problem of untrusted mobile code.
Modules - no imports, Modules are independent
external dependancy are pluggable parameters
runtime build code - per module sandbox
no static state! no class variables
lots of initialization is bad ( too much work up front )(turkish font in case you need them )
Classes modules Namespaces should be values
literal immutable values are easier to sync.
No versions
no releases, currently easy for apps, currently hard for libraries
No versions, but certainly different update streams to subscribe to:
developers subscribe to - dev stream
prod - prod
bits rot, deal with it. Let updates break dev, stabilize towards test. If you don't fix it, or have them fix it, it will eventually break prod.
can this work?
One mind bending idea is a "senders of" globally - who's calling you calling, and how much, and what is their email address? Across the entire physical world.
He mentions Fortress Modules system and the programming language E for security.
Object based Encapsulation -> Security -> Hotswapping
Some of my questions during the talk:
What about the dead components? Can you stop updates for certain components? What about their dependencies? Can you freeze dry them? etc...
Do library writers have to be more inherently intelligent? Hasn't this always been the (fallacious?)state of the world? Or can library designers design from the bottom up and change the namespace to evolve?
thin local adapter -> module cache -> subscription to a module
subscription over linking or importing...
For existing systems that don't currently have a dynamic language... Push soft layers up and keep hard layers thin
( Player -> scripting | network | scripting updates <- service provider )
Gilda's talk was great for jarring a few assumptions.
Paper Session I
Language Constructs for text-oriented programming
Context Root context layers - root - then another context, alters behavior
Dynamically scoped threads
Related to Feature Oriented Programming
Class extensions based on multiple inheritance and mixins.
Partial class declaration that makes sense in the current context. This is shown to be a better solution than vanilla MVC for GUI style programming.
Flexible object encapsulation for Ambient-oriented programming
prototyped based languages
encapsulation ( extreme encapsulation )
If I can unmarshall an object, I shouldn't be able to see their internal state
Mirror based reflection limits meta-level access
Higher Order Messaging (in Objective-C
Curried Function - Take a function that takes n param and turn it into a 1 argument func that returns a function which takes n -1 arguments. When you hit the bottom, evaluate your way back up to uncurry the message
For Smalltalk: #doesNotUnderstand ( Generic Implementation for HOM )
Worker HOM -> curries call stub
uses - exception handling, futures
Solve problems with message oriented viewpoint
ObjST???
OO + HO = power + ease
HOM instead of Function ( closures )
HANDS system - lang mechanisms that are natural
Notice when you are dissatisfied - keep digging! Language design up front probably didn't do it.
not anonymous functions
curried syntax
Java - Proxy for HOM -- impossible due to Type constraints says another guy
Pattern busting - not solved by programming language
Dynamic language let's you do things that aren't kosher, but also things that weren't thought of.
1991 Generic Functions paper white , blah blah the paper on this topic
lambda expressions instead of HOM? Yes of course, but Objective-C doesn't have this feature.
All around this was a great day of talks.
