A Simple Disciple's Life

Wednesday

Arrival at Heathrow at 7ish AM. It took forever to go to customs. The flight was OK. I slept nearly 2 hours, which is good for me. I saw Mission Impossible 3 in the non-sleeping part of the travel.
I went to the airport's prayer room to read my Bible and to pray a little bit.
Afterwards, I booked my hotel. I got a B&B in the area where the church service will be on Sunday. All this took more time than I thought.

I took the 10:10 bus and arrived in Oxford near 11:20 or so. I found Jesus College easily, checked in, and got in my room.

Afterwards, I did some shopping (tea!!!) with a british colleague. I refused to pay 10£ (more than 20 CDN) for an Ethernet cable to use in my room. I guess I'll have to borrow it from someone else.
In the afternoon, I fell asleep quickly, and was awoken at the sound of a piper playing near the college.

Walked about Oxford and took pictures and then went to supper. I missed the sessions, and my supervisor didn't pay for me to attend the workshops anyway. After the supper, I grabbed my umbrella and walked in the city in a tour lead by the organizers. We finished in a neat pub called the Turf tavern and I had a "White Horse", a (surprisingly) non-blonde British beer. Got back to my room, watched a bit of that Star Trek fan movie.
(Star Wreck: In The Pirkinning)

Thursday
Woke up early, prayed, read Bible. Watched a bit more of the Star Trek spoof.
Got to breakfast and tried Assam + Lapsang Souchong mix... very good.

The first presentation was by Steve Cook of Microsoft about domain-specific languages. It seems that their IDE allows for the easy creation and configuration of such languages/systems. He has a blog and there are some resources on Microsoft's website that I'll investigate.

After a 30 minute break, there were 4 other presentations: some new features in C# (extended foreach and a new thing: forall that supports parallelism) for multimedia applications [Böszörméyi presented it, I think], implicit and dynamic parameters in C++ [Heinlein of University of Ulm], virtual classes with genericity [Ernst of University of Aarhus] and oberon script [Sommerer of MSR UK].

The first was an implementation idea: foreach and forall in C#, the latter supporting paralellism in the background. The second is something I wouldn't use per se, as I feel they don't bring that much. The third I understood almost nothing and I don't feel they have a real practical use.
The latter was cute: a JavaScript compiler for Oberon that translates it in JavaScript and allows Firefox to render Oberon programs.

I lunched, borrowed a network cable and reviewed the presentation I had to make. Then my plans broke apart, because my mind went blank... I forgot the important parts of what I needed to present. DOH!
So, I barely attended the next session, the time for me to reabsorb the contents of my presentation.
I saw the end of a presentation about reusable components [Acona, University of Genova] that reminded me a little bit of VHDL structural programming, but only so much. It allowed to define unspecified types that can be defined in other modules, and merge them as needed.

It was time for another break, so I got myself a good tea, breathing deeply to take care of my stress. Then, I went to the presentation room and prayed until it was time to talk with the session chair.

My presentation went well and was on time. The questions were simple and I looked like a real expert! One question I could answer quite certainly, the other required me to make a guess based on what I knew, but I think I was accurate nevertheless.

The guy after me [Burgstaller, University of Sydney] presented formal symbolic analysis of programs (something about Control Flow Graphs). I missed half of the screen because of where I was sitting and he was talking to the screen, so I was not getting much. Also combined to that is the fact I'm not good at formal stuff. It allows to combine all program paths in one symbolic notation.

The next speaker [of ETHZ] introduced an extension to Oberon (currently named MathOberon... still in the works) and Zonnon (for .NET). Essentially, an array/matrix library for that language.

The talk afterwards [of Linkköping University] was about another language for maths: MetaModelica.
Modelica allows to model complex physical systems, with a claimed efficiency compared to C. Interestingly, it allows reuse by acausal equations... it keeps R* i = v as an equation, and the compiler will bother about which needs to be assigned based on which data is known. This looks pretty cool! I know what I'll use if I ever need to do real modelization.
MetaModelica adapts Modelica to define semantics of programming languages. You write your language specification, and you obtain a compiler for your language. There is still work to do, but this could be of some use. It even has an Eclipse plugin.

Brian Shearing did an improvised presentation on malleable software. He states that the problem is that information hiding is wrongly done... as it should be about relationships. They are moving architecture specification languages to a smaller scale. Those were slides that he did in collaboration with Peter Grogono (one prof I love at Concordia).
The basic idea is to have process-based organization, in "cells".
A few principles:
. same notation at all levels
. properties are not part of the object model
. arguments should be passed by value only, and let the compiler decide otherwise
. objects normally have encapsulation, relationships and identity. The cell should have encapsulation only. Cell have data, methods and processes are all private. It has ports and they can be imported by another cell. ports = capabilities. They are defining interfaces: ports, protocol. It is process-centric. instantiation of cells is very tricky.

In the evning, we had the banquet, and Niklaus Wirth (the man behind Pascal and Oberon) was present to celebrate the 10th anniversary of Oberon. He made a short speech that concluded in the importance of the artistic side of programming, making things beautiful and understandable.

Friday
First prsentation from Oderski (EPFL) presenting the new Scala compiler. He introduced a new thing from a type theoritical perspective: path-dependent types. He also talked about the Scala compiler, written in Scala. Their solution was to have abstract classes and abstract types with mixin composition. They introduce self-types, which will be the type of the this operator. The advantages is generality, documented interfaces for dependencies, allows multiple instanciation. They also implemented pattern matching over classes. Functions are all objects, etc.
The scala compiler works over Java, and generate Java executables. It can be downloaded at scala.epfl.ch.

Then, we had a presentation on a new language by Bläser (ETHZ) that allow to specify components with interfaces for solid parallelization. It allows to dynamically arrange components network. The performance level for very large networks is great, whereas C# crashes. It is still in the early stages, and can be downloaded from the web. There were many questions and many looked very interested.

The next speaker was Puntigam (TU Wien) on token-based synchronization. He first described the types of synchronization.
Internal is about atomicity. External is about protocol sequences.
His tokens are based on petri nets, although it just looks like a Java-like syntax with a precondition specified in the signature. From this older research, he moves on to some other issues.
Internal synchronization is solved by a lot of tokens everywhere, and "atomic" blocks. Then he talked of tokens on "this" by the concept of internal and external tokens.

After the break, Wolfinger (Johannes Kepler University) showed a component plug-in framework for .NET. It is called CAP.NET. It supports contracts and contraints in source code, hot plugging, plug-in unloading, updates without restarting. However, it is not downloadable for now, as it is part of a larger project. There was a few comments about making it available, which is to be seen.

It was followed by Schwarzinger (Racon Software GmbH Linz), who talked about connectors. Its an architectural style with fancier connectors than I saw in the Siemens model. Connectors are sets of interfaces, support config files, can be symmetric or assymetric, light (interface declaration only) or heavy (including non fonctional services such as logging and profiling), they can be single-part or multi-part, and there is a matching notation. Light and heavy connectors can be interchangeable too. Its architecture has a connector manager, that allows dynamic management of connectors and functional components.

We had a demonstration of Starfire by Garaio (Garaio Technologies) and Gutknecht (ETHZ). Its a language for web application that runs over .NET.
It starts by the problems we see in webapp development.
1. "Tower of Babel": many languages and techonologies mixed together.
2. Noise & Overhead: unnatural complexity (ex: OR mapper, binding, integration, etc.)
Assumptions: 50% of code is overhead/noise, complexity increasing
Aims:
one language, integrates helper languages under the hood, good model for GUI/dialog-oriented interactions, integrate DB and webservices.
The demo was way cool: We had a database query that was AJAX enabled and could go through the list very smoothly. A single click on a record made an editing menu appear too. It allows to put HTML in, but that's optional.
One of the samples was 15 lines long... I know for sure that the same thing in Perl would have taken forever. We would have needed to put the HTML, receive the GET/POST query, save each input query somewhere, fetch it, etc. Database interaction was super simple... only one example he showed was more than 20 lines long.
If I'm moving to webapp development, this is a technology I'll consider.
From the security standpoint, there is work to be done. At least SQL injection is taken care of.
It is in beta testing, with final release in 2007.

After lunch, Ulrike Glavitsch demoed AOS (Active Object System). It is an operating system that supports multithreading (multiprocess kernel), UTF-8 output, etc. Their programming language allows localized programming (i.e. chinese variable names if you want).

Then it was Reed who demonstrated an Oberon live CD. It is... minimal. I tried it beforehand on my laptop and I wasn't impressed by it.

The next session was on automatic object colocation, presented by Wimmer (Johannes Kepler University Linz). Object colocation is for heap optimization to improve data locality. The project aims to use the dynamic behaviour of the VM. Problem: what to colocate? They detect the hot fields and optimize those. They have "read barriers", every time a field is read, a counter is incremented. At a certain point, the barrier is removed and the field is put in a special table and stored in a special part of memory that is optimal.

The next speaker (Hames, University of Sydney) is about register allocation. The central element is the live ranges of the variables. Their approach is different from typical interference graph. They use partioned boolean quadratic programming. They manage to have about 1% more optimizations than classical methods.

Then, it was the turn of Pereira (University of Victoria) telling us about partial redundancy elimination. They identify "hot regions" and "warm regions", and you move the redundant computations to all the entry points in the cold regions.

I chatted in the break with Brian Shearing, an old friend of Peter Grogono. The latter is a professor I looooooooooove at Concordia.

After the break, Gutknech (ETHZ) revisited the dining philosophers problem. He starts saying that his result is useless, but its the methodology that is interesting. Uses the generalized Peterson algorithm for mutual exclusion. He presents a proof for his solution. He uses only atomic read and atomic write, and no concurrency constructs like semaphores.

Then, it was Paulino (Universidade Nova de Lisboa) talking about mobile agents. The system is called Mob and looks complete enough to be useful.
It operates on an abstract machine. It is however built from a calculus... useful, but headache-causing in my case. The system design is interesting nevertheless.

The final talk was by Glavitsch (ETHZ) on active objects. It is based on Active Oberon on AOS/Bluebottle. AOS is a multi-processor kernel, and Bluebottle is a thread-safe multimedia and GUI framework. Active Oberon is a variant of Oberon for multithreading.
An active object has its own thread of control normally. In Active Oberon, its an object with a body that runs in a separate thread. She described how she implemented a multithreaded file search tool using those technologies.

After the conference, I chatted with a guy from MSR Redmond that was working on Project Singularity, that looked very interesting. Let's see if Microsoft will actually go through and offer that.

We went punting by the park and it was nice and relaxing.
I afterwards went to take the bus. I left one hour early to get my ticket and eat a nice thing. There were no ticket office open at that time, and I had to go to the ATM to get some £££ to pay the driver directly. When that was done, I barely had the time to order a panini and get going.
I was the only one on the bus, which was quite a weird feeling.
I was welcomed by one brother in Hounslow Central and he took me to his place. I slept at his apartment, although the noise of the street made it an issue on the sleep quality side.

On Saturday, we woke up late, read our Bibles and had a prayer walk. We got to a traditional British restaurant for breakfast. Going back to his place, dropping my luggage to the B&B and blablabla took forever. On our way to Hounslow Central, we met a guy doing some street preaching. That was pretty cool. We went to London's core and straight to the Parliament building and the surrounding area. We walked along the Thames, and were in the Thames Festival. There were quite a few clowns, shops and so on. There was a lot of people and we weren't walking fast, so we crossed at Blackfriar's bridge and got on a bus because our feet started to hurt. We went to Liverpool Station, then to the Tower of London. Time was running by, so we just looked at it from the outside. He took a picture of me with the Tower Bridge in the background.
We returned to the public transit and passed by Canary Wharf (the tallest building in London) to go to Greenwich. We had a meal there: Mashes and Pies: meat pies with mashed potatoes. Quite filling. Then, we went to a brother's birthday party.
I met a sister I lost touch with for more than a year and we talked a lot, although at some point I forced the conversation away from McKeanian matters. There was some techno music that played and I had a good time dancing over those!
I went back to the B&B and crashed on my bed.

On Sunday, I went to the church service in Hounslow. From 11AM to 1AM, in a hot room... that was brutal. Combined with my generalized lack of sleep and a very hurting troat (sincerely, and the pharmacy wasn't selling zinc lozenges!!!), I was out of patience. Then, after the service, a sister starts giving me the specs of the husband she'd like me to find her. "hmm... I need to go to the airport"... "I mean, I need to go now" ... "look, my flight is in 2 hours" ... "are you coming with me to Heathrow or what?"
Once there, I had to wait forever for the luggage drop-off because the Air Canada employee did something that wasn't her job and that took 10 minutes. Then the security check was overly full of people. They had those videos of what to do to make it faster and I made sure I complied with them. Once cleared, I saw that my flight was boarding now... more than 5 minutes in advance! So I hurried there only to find... a room full of people who aren't boarding. No seats left, I sat on the floor. Here goes last minute shopping in the tax-free zone.
No, I'm not complaining too much :P Don't worry.
My trip back was fine. I saw The Sentinel. The rest is too average to be documented. I'm glad that my roomate picked me up at the airport. The first thing I did was to go to the pharmacy to buy those zinc lozenges to take care of my throat!