Aug 29th 2001.	Camp Smalltalk Essen ESUG 2001

ESUG Day 1. Smalltalk in Europe Summer School.

Hey another early day. First it is Camp, now it is School.

The conference starts a bit late and being the first day I'm here early just waiting for the doors to open. Today some random notes, since the ESUG committee is in fact taking more detailed notes and slides will be available for all the presentations at some point via the ESUG site, and somewhere somehow I've got to work on my own presentation

During the first part of the conference some housekeeping occured. We got introduced to the sponsors: Prof Unland and the university of Essen, Daedalos, Roots software, Cincom and Heeg. ESUG and Cincom have some special CD for us.

First thing this morning we got a beta copy of VisualWorks NC 5.i4 (actually I was later told they weren't sure what we got and some Cincom people ran off to understand exactly what marketing had shipped us), then a CD built for ESUG that contained various Smalltalks and images or basically anything ESUG could find on the Web the last month or so.

Yes if you attend Smalltalk conferences then sometimes you get interesting CDs. Wait till you all see the t-shirts. Note the ESUG CD is free, please make copies and spread it around ,If you like ESUG say it, and come again next year. Also we are looking for PhD students wanting to work in Smalltalk in Bern (I think…)

Prof Unland welcomed us all and gave a background of Smalltalk at Essen, and was pleased to see the variety of people here from varied backgrounds and varied experiences.

Changes to the program
Dave Simmons had experienced a broken Raid Array which prevents his attending.
CosmoCows have a deadline to work to.
XML couldn't afford to come.
New Talks
Modular Squeak by Joseph Pelrine
VW 5.4I Cocoa on Mac OS-X


So for most of the day I attended presentations, because of the number of talks, and the number of people here there were two tracks, so I've missed half. Also because I want to talk to others and learn some things I've not fully detailed entire presentations. (Note to presenters if I've misunderstood something, please let me know and I'll correct it)

Peter's talk on SUnits.

Key point SUnits are good, hey you can spend 50 percent or more of your time in SUnits. The test cases should guide not only the code design but the tool choices. Therefore the SUnits test tools should really be a coding tool. Our example is to build a small application to measure distances. We have a tool to create the SUnit test class, this is a repetitive action, so why not automate it. So lets create a test script, then we save it and are prompted for information like the name, the envy applications needed etc. It makes the creation of test scripts easy. We run it, it works, well it shouldn't have, demo voodoo strikes, we found a method created earlier during setup, so we delete it. Now the test fails, because at this time we actually haven't written any code to support the test case.

At this time the example was "1 m" we got a doesnotunderstand because Number>>m does not exist. So we ask the test tool to create the method, this asks us which class to create the method in, and which category, again menu choices. The method is restarted and we find that the #m method only contains 'self halt' So the test breaks. So we added 'Meter new number. ^self'.

Again an error we don’t have a Meter class, we are prompted to create it, then the Meter class doesn't know about #number. Again we are prompted now we are actually creating a Setter pattern, so we have a hot key to create a template. On the next test iteration we get a message there is no instance variable, but are prompted to create one. Now the test case actually runs. Ok great, but now we need to check to see what we actually did. The Tool allows us to look at the history of our activity.

So that this point '1 m' creates a Meter instance with an instance var containing 1. So lets make another test script. '1 m ! 1m' were ! is a shortcut to represent =. The test fails because it inherits = from Object which invokes == (identity equality). Now we ask to create a replacement = in the Meter class, this copies = from Object. Now we write a broken = that always returns true, the test of course works. Now lets check '1 m ~! 2 m' (1 meter is not equal to 2 meter). So we run it and it fails. Ok we look at equal and we notice it's wrong so we fixit '^ self number = aValue number

This breaks because the accessor number does not exist. We add it and all the test run. We then do '1 m + 2 m' ! 3m. (1 m plus 2 meters equals 3 meters), this fails and to fix we need to create the plus method. Now lets do '1 m printString ! '1 m' this fails, but we know we need to redefine printOn: versus printString to make it print '1 m' by having a incorrect method to return '1 m'. Ok the test works then we add '3 m printString ! '3 m'' this fails and we realize printOn is incorrect so we fix it. The issue here is having a series of tests to consider a statistically significant set of results or incorrect results to ensure the code actually works as expected and you are not seeing only a limited number of specialized cases working correctly.

A question: "Since test 4 and 5 are similar, do we have two cases, or one case for printing and have multiple assertions."

Answer: That depends. This could be test printing, or test printing meter 1, test printing meter 2.

Ok, now lets test 1 km ! 1000 m (1 kilometer = 1000 meters ) yes it does.

We of course need to create the km method and make it 1000 * number now the test cases works. We go on to create the printString now we have a problem, '1000 m' not equal to '1 km' After some thinking we realize we need a Kilometer class. The process is similar to what we did for Meter, we need to create the setter, the accessor, and the printOn yet still problems, so we realize we want an Abstract class Distance and we drag classes around to reset Kilometer and Meter's superclass to Distance. We also move common code to Distance. There was various discussion about how to refactory and demos of how the tool would indicate duplicate code. Lots more refactoring. There also was discussion about if this was viable since you were running any tests when this code was being refactored.

At the end we resulted in a running application, mostly built driven by the SUnits testing tool and tools that assist in automating code generation.

Coffee….

Development of a 2d-3d Authoring Tool for Children.
Jana Hintze, Otto-von-Guericke university, Magdeburg

Wompland

She worked with Alan Kay last summer at SqC, (April to Sept 2000). Note the presentation was given in Squeak using Morphic. This presentation looks good as a prototype of presentations that you would give to your local school or computer user group on 2/3d authoring in Squeak. Stephane later in the day showed a very complex image that shows off many many things Squeak can do. Hint from your scribe: building slide presentations in Squeak should not be a difficult task.

"Computers as a learning medium for children, Authoring tools for children, active Essays, simulations, and learning by programming"

Some examples of Morphic.

Looks like a PowerPoint slide, but then it's not.

E-toys
Behavior for Morphic
Authoring tool for children as well as for Teachers.
E-toys->Morphic->Squeak

At this point she brought up a tile on a Morphic sketch and alter the x and y coordinates which made the Morphic move. Then we create an empty tile and drag commands to create a script. Like Sketch turn: 5 and Sketch forward: 5, which makes the car sketch move in a circle.

3D in squeak - Wonderland

Alice, the bunny demo.

Bunny move: forward
Etc.

But this is tedious.

Objective is to integrate 3d with e-toys.

So either a unified internal structure for 2 and 3 worlds.
Or Interaction between 2d and 3d.
Or 2d and 3d objects live in the same world.

Why for Unified 2d and 3d objects
Usability for user and developer and easy transition

To decide this she looked at what 2d and 3d objects have in common. Then what is different. Differences are hierarchies in 3d, occlusions, and lights and cameras for 3d.

So divide an object into
Actor -> the object (properties and skills)
The costume -> the look
The script book -> the behavior.

Gee Think about MVC and how it works, do you see the parallel viewpoint here


So an Actor has
Absolute size, commands, properties, and child or parts Objects
Costume has local bounds, renderOn and contains point.
Scriptbook has the commands.


In the World
Hierarchy represents the scene, Top object is the World. Tasks are the global coordinates, drawing, events, timing, and namespaces

The world and its event mechanism
dispatch event
all registered actors react with a Command or Animation
put reactions into Scheduler

TransitionMorph does drawing, events, and clock pulse.
A command is an instantaneous action at a certain point in time
Animation is a command plus duration and performed during a certain amount of time.


aCommand duration: 4

(car moveForward: 5 ) duration: 5

Under the covers we calculate the number of frames needed to do the animation, then split the animation into single commands, then the commands are scheduled.

We can also do composite Animations by either doing parallel animation, or sequential animations.

An example:
first load an Alice object. (from the web of course)
viewer _ WomplandView on: giraffe
viewer openInWorld

This give a tile showing the commands you can sent to the giraffe object.
Now create an empty tile and add commands say.
For 4 seconds do together
Giraffe moveForward: 0.1
Giraffe turnleft: 0.95

Ok, now create another camera, and open an Womplan viewer on the camera. Note as we moved the camera around, the camera was visible as a movie camera in the other camera's visual view.

Now the trick is to place the camera behind the giraffe and follow it as part of the script

Question: "if we could insert the camera as part of the giraffe"

Well we can't do that yet, but we have lots of more things we want to do. So for future work we want to have easy tools to do 3d Modeling, Arithmetic, UI concepts for direct manipulation of 3d, the 2d and 3d integration, and then Networking concepts.

Which means you could have children create 3d games.
End
The source code for WomplandView will be made available soon.

Craig Latte
Squeak on a handheld computer
Why
Squeak anywhere, Squeak impromtu, Squeak with pain.

Squeak Morphic is slow, Ipaq has no HW floating point or optimization because of compiler bugs. It has 256Mhz CPU, 12bit color, 64MB ram. VGA but it's a hack.
Craig had a VGA card that allowed him to display VGA on an external screen, the other slot had a 2gb hard disk. So it feels like a 200Mhz Intel box with 64mb of memory. Note that 400Mhz machines are coming. Beware it's fragile, dropping it would break it. A palm pilot is much more durable. But remember you couldn't buy all these pieces 7 months ago. Craig also had a folding keyboard about the size of palm which folded out into a regular small keyboard you could use for data entry versus pen strokes

Yes you can run linux on it but it is more constrictive, no driver for VGA card or hard disk. So one must live with that Windows OS Win CE v3. x

Note I can swap hard disk card from Ipaq to PC, this makes moving multi mb images easier. Serial or USB connection is very very slow. Also I can do source code debugging on desktop machine, which is quite handy.

Currently working with sound, we can actually do about 20 FM sound processes before the hardware bogs down. There could be better support in Squeak for dealing with a handheld. The hardware can zoom in on screen quadrants, but squeak has assumptions about the mouse. So pen gestures aren't mouse gestures and you can get into Morphic interfaces where only a mouse can continue due to how it works.
Some discussion about hardware durability.

Question: On which handheld can you run Squeak. Well you need at least 2mb. The image can be about 500K, but you leave out a lot.

Question: How long to do.
A year, but lots of time waiting for parts. Say 2 weekends for the port. But most of the time was because of bugs. So perhaps a day but this port is based on work done to port Squeak to win32 and work by others. So it was not that difficult.

Data input
Use a portable keyboard, or a visual keyboard. Or actually we can use the win CE hand recognition. But more work is needed to ensure Squeak can work with stylus devices.



Sketch modeling a thing called "Pooh"
A sample implementation in Squeak.
By Alexander Lazarevic.

The outcome of my internship at Squeak Central.

Modeling->Teddy->Hull->Drawing->Outlook

Creating computer generated images. This was an interesting slide with walking arrows, again a good example of what Morphic can do that you can't do in PowerPoint. The slide attempted to show that Modeling created the Model, which then was rendered, which then resulted in the Image to display.

The objective of the modeling is to produce an image that is photorealistic. But if you don't want that say you want something that looked hand shaded, then you have an extra step and do post processing. For example a hand, which then is post processed to look line engraving. But in order to have something completely different you must have different rending engines which take the Model and build quite a different image. This of course can be done in parallel with the other renderers.

Taking a step back before we can actually start the Modeling you must do the Design work. So for example if you want to model a hand, then you need to have different views of a hand to work from. Now would it not be possible to integrate this into the design phase, such has having a "exact" modeler and a 'sketch' modeler.

Why Sketchmodeling
Exact model might not be required
Just a single sketch might not give a good impression of the spatial information
Exact modeling might be too complicated during the design phase.


Teddy a sketching interface for 3d freeform design Takeo Igarashi, Satoshi Matsuoka, and Hidehiko Tanaka

Hull.

Creating a 3d object from a 2d cross esction.
Staring drawing the outline and create a closed polygon. He then showed an input tool that collected mouse coordinates to build a closed polygon. Then in the next step he performed a calculation to reduce the point set to produce a someone cruder outline based on adjacent point spacing and angle. In the end we have a polygon mesh and you want to reduce the number of triangles you are rending. Next step is to do a constrained Delaunay Triangulation. Then we perform the classification of triangles into Terminal, Sleeve and Junction. This was displayed using color . Now find the spine, by looking at the center points of the junctions triangles, and the mid points of the internal edges and the corner vertex of terminal triangles.

So we can elevate the spine which gives this object 3 dimensions.

Lets view an Alice world. Ok sketch an outline, Ooops the shared laptop had mismatch between image version and the VM version and the problem of black Alice worlds leaped to the foreground for the poor demonstrator to deal with, this time it was fatal. He could of course rotate and examine the object but we couldn't see it.

So onwards into the darkness

Korrespondierende Koordinaten
Figuring out where to put the texture.

Further things, Alice99, Teddy2 also there is Jun by AOKI Atsushi

Further extensions
Complete functionality of teddy
Hot spots on the object to assemble objects together
Using the spine for animation or model transformations.

Possible uses
Tool to help children to handicapped people train their spatial perception
Interface for a 3d object database
Tool to assist during the early design phase for complex models

Questions?
"Hey the objects look like potatoes. "
Yes complex objects are possible, but this takes a lot of time to render
"Really"
Yes, well they do have roundness, but they can be long..
"Well you can have problems with some type of objects"
There was discussion that you could cut pieces off the potato and bond them to another potato like object.

Note this is in the image so go explore.

Fractal Design and Development
By Alferd Wullschleger
Swiss National Bank (SNB>

1979-1999 at Fides Informatik, on VAX, VME, special hardware, then Smalltalk in 1992.

Mid 1999 then OASE at SNB.

Why Fractal
Maintenance on a system that went into production in 1999. The coast line on a map looks similar on every scale. Relative complexity remains "constant". If complexity increases then you are in trouble.

Question how do you measure complexity
We measure it by the difficulty of understanding the problem, so if you don’t understand a problem, or the software then you have a problem. This is a Bank not research. This is a difficult concept to explain. "fractal" is just a word.

A ClassHierarchy with a large inheritance tree is very dangerous as a base for a project. Look at Marin Fowlers book on Refactory, page xv. A messy class hierarchy was refactored into the C3 project. The start of XP

We use building blocks, small conceptual pieces which can be combined into many objects of the system. Need Object encapsulation, and delegation, polymorphism, and Inheritance only from the bottom up. As you build things complexity does increase but any small piece is understandable.

Objects
Encapsulation and Delegation
Well known as buzzwords, but not always reasonably implemented
Distribution of responsibility, linking by polymorphic messages
Hungary man<>

Implied polymorphism
C++ and Java usually use the geometrical objects example.
This is NOT what we are looking for

Polymorphism is a glue between objects each object implements its part of a message.


Lending of a book in a library has many helpers. So for incrementing a Library date, this is processed by the Library, the BookAdministration, the LentBooksLIst, the BookState, the LentBookState, and the OverDueBookState. Each of these have different meanings, but the same code or objectives. It looks complex but it is simple

polymorphism
separation of duties by introducing small abstractions through objects
reduction of complexity of polymorphic bracketing of objects
The message to a base object is the only thing a user needs to know to understand the service offered.

Objects are building blocks.
Needed a fine granular access model for objects stored in an OO database, should be easy to configure, should be very flexible. Originally we used Gemstone segments, but this was inflexible. Got to the point we could not change any model definition. So we changed this to our creation an RsSet.

An RsSet

4 methods. GetRsSet, rsParent, rsAllowed, reportRsDislayUser

Then we have read, modify, delete, and insert permissions. With rsModify: to change the security permissions.

Each rsSet has a parent rsSet, each rsSet defines inheritable restrictions used by child rsSets. So a rsSet definition at the root protects the whole tree by default.

<actually this looks like the simplification of the Unix file permission directory tree, the key is the use of client written software to solve the security problem that the database attempted to provide support for in an inflexible manner>

Each restriction has two parts.
Self defines restrictions for the object
Sub defines restrictions which are inherited by children

Example
InsertSelf controls creation of children
InsertSub is inherited by children restrictions and defines the default insert restriction for the children.

So RsSet as building blocks for security.
Can be used to protect any object,
Very simple interface
Restriction tree is defined by the developer

We have found that the tree is easy to explain to users, over coffee. The developers have a harder time understanding. But the objective is to avoid having to create lots of documentation on how to use this feature. Keep it simple.

<Scribes note. I'd think you could have users and groups, but this leads to user confusion and more training required to get them to understand it, so keep it simple>

So we have
SkMenge, a time dependent set of objects implemented as a composite pattern, using TimeIntervalEnsemble.

A TimeIntervalEnsemble, is a collection of non-overlaping time intervals the basis of work at the bank.

RsSet uses SkMenge instances for the description of the users who are allowed access according to a time restriction. This allows us to introduce restrictions based on time period, to grant future restrictions, time intervals when access is allowed, or temporary access for an hour.

Other examples of usage are for versioning of objects for migration, logging and audition, commit Ensembles, OVID trees and much more.

Code reuse at large
Hey it's a gift.
We had a high level of code reuse because of high abstraction.
So for example after looking at the Windows 3.x help system we found it was static, this is a problem, so we just used OVID trees. In 1997 we had a customer who wanted the data into forms, ah lots of thought about build a new system, but we realized we could use the relational framework we had in place which then allowed us to produce an outline which could be populated by the data. This was just a minor change to an existing system that was five years old. If you had to do this from scratch using just the data, that would be very time consuming.


Summary
Use Building blocks avoid large class hierarchies
Encapsulations and polymorphism are the base for building blocks
Building blocks are code reuse in the small scale
Large Scale code reuse is a gift.

One of the key points I think the author was raising he used his own security framework instead of the complex gemstone image segments.


Typed Smalltalk in Squeak.

Missed some

Slots are connected reflecting the runtime data flow
ty pes flow across connections

So given an TiAssignment node, a TiVariable, and a TiLiteral node from the parse tree we know that this section of the tree has a float argument.

So a type flow network is built for every analyzed method
The network is built by connecting the method parse tree
Method analysis begins with the monomorphic seeding of initial slots.

Once we put the type into a slot, that type flows upward the method tree.

So we have a new menu item in the inspector to infer type. So for example looking at 1. 0 we see that it is type float. If we inspect a bounding box we see a rectangle with two bounding points that contain two instance variables of type SmallInteger.

A diagram showing the relationship with TiAnalyzedMethod, TiMethodNode, Ti parseNode, TiSlot, TiType, TiAssignmentNode, tiLiteralNode, TiReturnNode and TiMessageNode. Of these objects the TiMessageNode is the most difficult to resolve.

So we have a simulator, with TiSystem, TiClass, TiType, TiObjectType, TiInterpreter, TiCompiler, TiAnalyzedMethod and TiIndexType using this simulator we can attempt to analyst the method and understand the returned type.

In a sense, compiled methods map to analyzed methods, bytecodes map to type flow networks, compile time maps to connection time, and run time maps to flow time. Mirroring the Smalltalk runtime system help in building the type simulator.

Question: "what about methods that return more than one type?".

In this case we return a collection of the possible types that could be returned.

The other problem is that it's impossible to meaningfully connect the slots of a message send expression. We must simulate late binding to attempt to figure out what type is returned.

Question:
"is this feasible?"
Well we think so.


So for perform aString returnArg: aNumber
We end up with a cartesian product of the possible combinations and analyze each one and see if it is feasible and what type would it return

Local Variable States
An assignment generates a new state in the assigned variable.
Each variable state is represented with a unique slot (and subindex)


Side Effects on Types
Messages could have side effects on objects
A side effect is a change to the internal structure of an Object
A side effect is reflected with a new type

For example a point could have types float and float, but a method could change x to String, then the type would be String float

Side effects on Variables
When a variable is an argument it could suffer side effects
A variable that suffers side effects changes its type
A new state is added when a variable plays the role of a message argument.

Instance Variable States
An assignment to an instance variable changes the receiver
Instance variable slots should be synchronized with receiver slots.
So for the example above we have the point being Float, Float, then the next usage is String, Float

primitives

primitive responses are simulated with primitive analysis
Each primitive is implemented inside a TiPrimitive method.
Each primitive analysis is a different challenge
So we only type 43 out of at least 200.


Block Types
Each block has a different type
The type of block is special
The type of a block has a reference to the block definitions
Block evaluations is requested in a different method where it was defined.
This is similar to the work on message send.

Reference to outer scope
We can correctly analyze blocks that refer to their own arguments
But outerscope references cause us problems
This is a major source of our inaccuracy.
Solution is to convert those references into block pseudo-arguments.

There are problems and this is a tool to start type interference, not a tool to give a complete answer. Please build on it.

Lots of questions about what this system can tell you and other work people have done.


Stephane:

"Presenting Squeak".

Note This code will go up on a wiki real soon.


First lots of flash, then creating a class, method and using the inspector and debugger. This is the type of thing you can do to show what Squeak can do. First lets see:
1000 factorial / 999 factorial
hey we get1000, but as them first to see if anyone knows. {printing 100! Is also cool}

Ok explain why large numbers should be in the VM. Why do you want the VM implementers to do it, versus you having to do it in some custom C or Java code.

Easy to work with 2nd year Java programmers then they know how difficult this is.

Also explain about the write compile, run debug process and how long it takes in a compiled language.

Ok here is an example image of Squeak which shows all the platforms that Squeak is running on. This is a collection of screen shots from various widely different machines. This was build doing an add morphic then adding a link to a project. Then you get the Morphic that gives a visual picture of the project.

Hey also use the new look. Remember the issue of the out of the box experience. Ok also remember 2.9 was alpha, 3. 0 is rough, waiting for 3.1. 2.8 seems to give the best experience, also beware of the 3.1 Open GL issue and change. Also beware of the screen depth. For the Macintosh beware of processor cycling and running on batteries. Turn this feature off via the macintosh control panel, or by the Squeak battery preference under performance. {Note I did ask some window users what problems they have with Squeak and was told once you get past the normal blue screens of death because of DLL issues and the like, then Squeak on windows is very stable}

Also be aware of Bob's Super Swiki. This is a collection of publish projects. These can damage your image. So always work with a copy of your image when you load things from the Swiki until you are sure of the impact on your precious image.

Lets look at the image we have that shows all the things you can do.

Explain BitBlt is very fast. Smalltalk to C.

Now some code to show the starwars effect on a section of the screen to show how powerful and fast things can be.

Then show how Morphic objects can hold text and have text flow along curves. It is important for people to understand the new paradigm. Most of this was done by show the standard 3.x out of the box image examples.

Showed bouncing atoms and the start of infection command.

Ok ya, the email program isn't fancy, but you get all the code. So we looked at the POP class. Yes there is a lot of network stuff. Yes we can parse HTML. Yes we can use the Explorer to inspect objects. Hey you have all the code, you don't need to wait for the next release to fix something.

Now Flash. We have a slide showing the flash animation, but we also try it. For this complicated task it's dangerous to try on the fly because it might not work due to system changes or the like. If so well you can always explain you'll fix it but see it did work in the past. Usually you can grab a flash character and copy to the workspace then resize and rotate.

Then off to sound. At which point things hung up and Stephane had to reboot.

There should also be a mention of the two Smalltalk books, and the other books on the Web about Squeak. So there is published material available.

Also the Mpeg player, Math Morphic, tiffLib primtives.

Also mention the VM is written in a subset of Smalltalk then translated to C. Also JIT versions exist.

Also mentioned the Squeak mailing list, although it has lots of traffic per day. Also the point out were the Swiki are.

There is a rich set of tools to explore sound. For example a project to record sound. This has a picture of the tool, then text to select to get the real player, which might have changed. Also a spectrum analyzer. In each one of these example projects Stephane had embedded a screen shot of what should appear and added a text Morphic that had the Smalltalk command to invoke.

Showed faces and voices
Showed Midi
Showed Alice
Showed panda3d
Showed well lots of other things. Lots and Lots…

At the end I had to comment on how much stuff there really is for Squeak out there on the internet and the hundreds (thousands?) of man years that have gone into the creation of this content.

A long evening in a German Italian restaurant were we learned a few things that one can only learn by attending a Smalltalk Conference. Perhaps you didn't come but next year you must. Some serious talks took place about the sharing of… of… well we'll see. Perhaps I do know were the next Camp Smalltalk will be, well… we'll see, and even what will be on the next CD. But on to what I can say. Do you know a Smalltalker here has a wife that designs, well woman "clothing" for the hottest firm of that type here in Europe, yes a very odd fact, but you must attend to learn just who.

However the important thing learned over the last few days was the realization that we managed to do presentations and worked with code using various dialects of Smalltalk, exchange information and knowledge without conflict or friction. Also we managed to ensure all dialects for which there was representation shared in the software being generated.

What's a Ward units? Joseph explained if Ward pair programmed with you at an XP conference you got a one, if Kent worked with you, you got a 2, the further away from the originators of the concept the higher the numbers. At the last conference he noticed that people started the week with numbers in the 8+ range, then as the week wore on they decreased down to 2 or 3. But the point was Camp Smalltalk and the conference is a chance for Smalltalkers to come together and work together and experience things in an environment that they can't duplicate in their work setting.

Programming for charity was another idea discussed. Right now we are tied up building developer infrastructure, but someday this will be mostly complete. At that point should we, could we, also program for charity? Build a system over a week to meet a social need for some worthwhile cause, using all these great tools we are building?

Your scribe, with a ward unit of 1, but granted way before there was XP conferences to attend, when pair programming was just this interesting concept… it's late and bed beckons.

Forward to Day 2