OOPLSA 2003 Trip report Monday

Monday was the day that I had awaited for because I was going to attend the VM workshop

2nd International Workshop on language Agnostic Runtimes and Component Based Architectures. Hosted Yahya H. Mirza David Simmons (who couldn't attend) Mario Wolczko Shawn Woods

Yahya talked first on:

Need for a Virtual Machine for Interactive CG Movies on Future Game Consoles.

More on this later, perhaps a link to slides for his site.

Croquet Andreas

Interesting things we've found that affect a VM

Shared 3d space, highly connected. Croquet is a collaboration environment cross platform, open source built for (but not limited to) 3d world and synchronized by TeaTime

Tested across the Atlantic ocean, yes a distributed collaborative testing process.

To run Croquet you need a decent graphics accelerator, works on any Squeak platform that has that support.

Computers are communication devices, but email, http are very narrow communication channels. Want lots and lots of context.

Presentation used slides within a Croquet environment so you have a richer experience. {Your author notes that if it wasn't Croquet or Squeak the presenter was using it was Apple's KeyNote}

Some examples, A mirror but you can grab objects in the mirror and move them around. During the demo John S was confused by cloud movement in the mirror because it did not match what was happening in the background in terms of left/right orientation. it turns out clouds are moving in a circle around the platform so as he pointed out the mirrored movement looked wrong, but the math was correct.

Portals, the way independent spaces are linked. Some example of moving thru portals Off to the Flag example, a real time modeling problem, fabric blowing in the wind. He attached and detached flag from pole to show how the flag reacted.

Question: About setting wind speed and direction? Andreas: No, don't have an interface to change that, but we could. Ok, let's inspect the space and go down to the TFlag instance and see if we can change things. Yes we alter one of the instance variables and something happens, but we couldn't really understand what, the model is too complex.

David: Question about boxing unboxing primitives?

Andreas: That wasn't an issue. The issue is really vector types. Really need a vector algebra. The heavy computational work is in vectors. The machines have hardware to support this either in CPU or GPU. We don't need the simulation in the main memory, need it in the GPU. Looking at domain sublanguage to handle graphics programming. Looking at what was done in APL. Need to manipulate containers of ints or floats. What to solve algrabrically and reduce computation, then realize the actual calculations.

Doug Lea: Example is high performance network I/O.

Andreas: Up the escalator to where I started even though I didn't go down, yes you can cheat in a 3d world. Off to the mars simulator, start the robot. Let's talk about issues with collaboration in the shared space.

TeaTime From David's thesis, objects evolve over time and get certain messages over time. Employ two phase commit. If commit fails we rollback. You'll need ask David about this, not me.

Models of programming Call Return But in Croquet Very small usage of call return. Usually the messaging model. Not in high usage, E uses it a bit. What other systems use it?

{Discussion about what is time}

There is a universal TeaTime in the distributed environment. This guarantee ordering so you can say who was first, so you can have a loser and rollback two phase commit.

Andreas Question about robust system.

George: Guarantees on levels, which reduce the exceptions you get for feedback.

Event base programming can be easier and less likely to screw up. Model real work situation. Yet pure approach will cause failure. People are pushed into designs for high performance.

{Discussion I didn't capture}

Example of browser, you can't recall a page request, you need to live with it. Event based can allow you to react you don't need to recall the logic.

Andreas: Problem: Running IP model on all machines. Heavy model. So for example the chess model which could produce different results based on machine performance characteristics. Does the model run on my machine or his machine.

Synchronize issues

In this portal there is an example of a particle system which produces a tree structure. Grossly inefficient because the 2-phase abort causes a huge issue. Question: what about a transaction based GC. No idea how to implement. Want much much more control.

{Discussion about database logic. Discussion about time based GC and self modify generational GC}

Underwater based environment, based on vivarium project. Make it simple to allow people to make a fish and give it behavior. Ok, so use a painting tool to make 3d objects. Grab a shark shortcut, change the color, then save and it's calculated as a 3d object. A tab kinda like an Etoy, provides control so we can change attributes, and send message and script it. Little pauses in the simulation are results of the matrix calculations, need that hardware support.

Created another costume, created a script to alter costumes between the two costumes which make the shark appear to open/close mouth. Now let's set this up to perform behavior to shap shut jaws when we get near another object, like a fish.

Security? So this code gets replicated all over the place. Who knows about the E! language www.elangs.org?

Most interesting language in the last five years. Distributed security model Some folks are building it on top of Squeak Want to roll into Croquet.

Lots' of security issues are user interface issues. For example shutting down window services are buried in lots of places.

George:. Issues like having to prove who you are and then we grant full access. Dialog is granting too much authority versus granting a scope to restrict what is done. So like granting access to open file can mean he can open ALL files, which is not what was wanted.

So with a capable object security model you restrict authority to the file object. Now the user interface problem is the hard-one. How to denote that access to the application, need a proper user interface notation.

George: Object based security systems miss something, like there are three players so for database update this person, this field, this time, this application. Those aren't mapped correctly in existing models. {You author notes this reminds me of something Dr. Ralph Johnston is doing in accounting where he always has three players in a transaction}

Tie? Security to the VM Where is security done?

Component Packaging Distributed Code Security Extensible VMs VM support for component evaluations

Doug: Making extensible VM changes safe.

George VM changes cascade badly. Lie cheat and steal

Today's world is markedly different and one could re-think the tradeoffs. Overcontraint and very brittle code generation versus services.

Runtime changes versus dead time changes

Smalltalk VM extend features in the language, not in the VM. Now we want VM to run every language, that has been the rare case.

VM still live in the old world, living with hardware issues. Now want to deal with security.

{Lots of discussion I missed, about security, but no good clear directions}

Doug Lea: Java VM doesn't need to do the sync logic in the VM, Do it higher up.

{Lots of discussion} Basically pushing up to the language resulted in 68+ code changes and lots of testing and finding these places was very hard. But this greatly simplified the VM and has made things much better and more robust.

Ian piumarta a Virtual VM (VVM) a primitive interface a GC interface a virtual processor to deal with byte codes a application loader to load the VM

Biggest issue is modularity and explosion of combinations. So the VM does not exist until the application arrives. So we push the entire VM down into the execution machinery.

You feed it parse trees. Object memory stores parse trees and meta-data. Produces stack based program. 4MB of compiled code per second on average Pentium box.

Extending this we can modularize the entire tool change.

So for example we can read in what a Java VM looks like. So we instantiate the JVM. 3000 lines of code for VVM

Next presentation:

Hillel Kugler Smart play-out of behavioral requirements

Requirements Scenario-based Stories about the system. Inter-object behavior via Messaging Sequence Charts (MSCs) But we need richer requirements man/must; can/always; fragmental and overlapping scenarios; anti-scenarios (these should NEVER occur).

Live sequence charts (LSC's) a natural extension of classical MSCs, with modalities...etc

etc.

smart play-out Compute a super step that is figure out a good series of responses to the system compute a way to satisfy a full existential chart, that is figure out a good sequence. etc.

Virtual Machines for LSC Allow rapid prototyping Powerful analysis in early stage Generate production code On different platforms Various operating systems Distributed Settings Demo varied from phone systems to modeling the C. elegans N Kam, M Stern, J Hubbard and others) 300 LSCs as the start to focus on egg laying system.

Flight control system (voting and monitoring) for unmanned air vehicle.

MDP model driven programming, a real example that works.

Questions about how it's implemented. Also then discussion about how to build a VM to work with this.

What stuff in the VM needs to be pushed up for the tools Discussion do we need a VM. Callbacks? API? special data structures? I mention GC feedback, resource feedback?

George: Is this all the VM needs to provide?

Allen: Discussion about what a VM is and what it's objective. Stuff down in the VM enforces a rule, if you push it out that allows the user/language to change the rules. David points out that common tool abstraction enforces common business rules against multiple language organization. George points out that custom attributes are in the CLI to allow tools to pass information about, this makes it easier to pass messages around. The VM makes a place to pass that information around.

Ian points out this is in Obj-C on OS-X on the Mac originally from NextStep and compiled. Allen Yes if you have a single compiler to worry about, but the VM brings about platform independence.Note from Ian for all of us to review Obj-C which solves these problems. They do have the luxury of having one compiler.

Doug Lea If the data has meta-data in the code, does the VM trust it? Mmm say non-null this attribute tag means never null. Mmm compiler needs to be paranoid. Even if it's signed and said safe... Trust model should not be from the client. Meta-data is hints not to be trusted. {Lots of discussion about the fact we make the programmer supply this data but then we don't use or trust it}

Discussion about standardization across all vendors.

Abuse of meta data annotations because they are afraid to extend language, because that can be hard to change a language. David T, the bet is if you hint then you can guess a better solution.

Discussion about annotation creation, how it's created, by who, when etc.

Tools can enforce annotations, but not in the VM, that is where we stand. Mmm like if you have database transaction annotation, then you should supply annotation, otherwise not. {Lots of discussion}

Building from the bottom up, versus top down? If we build from bottom up a slight change can result in a very different thing. From top down we get a system that always looks the same with little change because the tools want to see the same thing this week and the next. Bottom up gives a different program every time.

Ian, well no.

Discussion about is this true or no. Well no, one can drown in the quicksand. Discussion then about hardware support and handlers to interpret the data differently at execution time, say to take advantage of a vector processor.

Doug VM is a small part of the chain. The meta data comes from elsewhere, the VM is a minor player.

George: Scheduling threads happens in OS or above, not in the CLI?

Nick. Making VM as small as possible, write in Java, versus C.

Dinner thoughts? Nope, lots of talking I think I when to bed at midnight

Onward to OOPSLA 2003 Trip report Tuesday