S3 Group Report
We tackled the Cellular Network --- Metalevel Programming problem. The problem had been kindly prepared by Peter Kriens from aQute.
The following bunch of people worked on this together:
In the classic DesignLab terms, this group was
Two thirds of the morning passed by with discussing the deliverables, methodology issues and finding out what the actual problem was. Also, the nomenclature was clarified. The general impression was that this period was not optimally productive and could have been streamlined. On the other hand, we learnt a lot about the problem domain and we all felt very familiar with the issues afterwards. Everybody was comfortable in the discussions.
Intentionally, not all requirements for the CellKeeper where captured in the use-cases. Once we had realised it, this did not present any problem. Wherever necessary, requirements where simply escalated into use-cases on the fly.
Although everybody had some - quite clear - ideas in his head, we were reluctant to pin-point the key elements in diagrams on the flip-chart. Only scarcely, participating patterns were named (Proxy, etc.). In retrospect, this was considered a mistake - we should have moved to concrete diagrams much earlier.
At some point the impression that we just had to start somewhere instead of trying to figure out what the optimal formal approach would be, became dominant. To cope with the overwhelming number of aspects of the problem it was agreed to make some simplifying assumptions first and work from there. This resulted in the following strategy being used:
After this had been settled, the design phase proper started towards the end of the morning. The discussions became very efficient and deviated rarely from the main path. We all concentrated on what was feasible for the day.
Comparing this unprepared group to the prepared group working on the same problem lead to an amazing result: They had not advanced further than us. While we were exploring the problem domain together and defining our standards, they had spent their time trying to align the various complete design approaches they had brought with them.
During the design phase, the following key aspects of the problem emerged and were captured in a decision log:
This gave rise to the design of a (white) framework.
Cellclass, each instance being of a particular
CellTypecan become a Factory of cells.
CellTypesare defined by a list of
PropertyDescriptionsand a list of
Contraints. They are shared among instances of
PropertyDescription. No properties are directly stored on the cell, since although it is obvious that frequency is a property of all cells, for other properties this is hard and errorprone to decide.
CellTypescan be defined through a meta language. They change, e.g., with a new software release for the base station controller.
PropertyDescriptionis determined by the instance of
PropertyValueassociated with it as default value.
PropertyValuesassociated with a particular
Cellhas to match the number of
PropertyDesciptionsassociated with the relevant
CellImplementorsare Proxies for a real piece of hardware. They know about the implementation details like the communication protocol, but, e.g., nothing about neighbours. They know how to
optimise() Commandsand how to get them to the hardware (C-lib, Command Line Interface). They change if a new base station controller type is deployed.
CellImplementorsare shared among cells. This is possible, since all cell specific information, like the
location()and the freq() are stored on the
Cellscommunicate with their
Commandsare Composites and can be bundled to
Plans. Memento can be used to support undoing.
PropertyDescriptionsand the possible
The human actors in this scenario are the "Operator" (who tunes and splits
Cells and changes the
CellType) of a particular
Cell and the "Cell Type Incorporator" (who adds new
CellTypes). A further actor is the cellular network itself.
The Base Station Controller vendors could support the CellKeeper application by providing new software releases in shared libraries, so that new features could just be plugged in.