Slice 'n Dice

Here's the latest on the upcoming MiceOnABeam Release v0.1.3A.

Musings on Methodologies

The MiceOnABeam modeling tool has been designed with an iterative software development strategy in mind. Iterative development has been around for many years and over more recent years, several good methodologies of this type have been developed (e.g., Agile Software Development, Extreme Programming). Typically if one is working as part of a large project, a more heavy-weight solution is chosen for the development team. For a very small group consisting of three or less developers (probably typical for SL), the much closer communication among team members provides the flexibility to adapt these development methods to an even more informal style; yet still retain much of the method's benefits.

For me, a development strategy for such smaller projects (such as used developing MiceOnABeam), consists simply of first developing a requirements specification for what you're trying to do; i.e., the Feature Spec. A rough design framework must then be worked out (to support the Feature Spec.), which typically consists of structural elements and protocols together with main data structures, objects and their relationships. This framework can be specified using a variety of techniques (such as Use Cases) most of which can be found in the UML specification.

At this point, a cycle of iterative software development is started, consisting of a bit of design followed by implementation and testing. This cycle is then repeated with the next feature unit and continues until a sufficient feature set is developed whereby the product can start being released. Initially, releases are done within a trial environment leading from an early limited-availability alpha version through a wider-release beta to a general release. A key point is that at every point between iterations, you should have a working product. Testing always consists of testing the incremental feature(s) within the context of the whole system and ensuring that the previously developed system parts continue to work properly.

The benefits of such an approach are extensive and may include more robust software, features that are better tuned to customer needs (through early trials) and greater flexibility in issuing releases; as releases can more easily be based on an earlier iteration therefore leaving out problematic features.

Cut/Copy/Paste

One of the demands that an iterative software development strategy makes upon a modeling tool is the ability to "slice and dice" model components in a variety of ways to accommodate the evolving nature of the design. The most basic of these is Cut/Copy/Paste. Nothing to crow about of course, but a non-trivial exercise nonetheless for semantic-based graphical models such as MiceOnABeam. Which is all to say that in Release v0.1.3A, a group of selected modeling components can now be cut, copied and pasted within the same or different model.

Aggregate / Decompose

A key element of modeling scripts within MiceOnABeam is the ability to create multiple sub-states contained within any given state to create hierarchical states. This Composite State can then serve as a higher-level abstraction that hides away more detailed behavior. Typically, a designer will start by laying out the high-level view of the script's behavior and then add in additional decompositional detail as the design progresses.

Life however is rarely that linear in practice; particularly in an iterative development environment, the ability to come at a design from multiple directions is essential. To that end Release v0.1.3A now supports the Aggregate operation, whereby a group of selected components can be pushed down a level, to become contained within a newly-created Composite State.

The reverse of this operation is called Decompose, whereby the contained components of a Composite State are removed and brought up a level within the state hierarchy and the (former) Composite State is then removed. Very handy!

Component Library

A sister strategy to iterative development is the use of reusable components to leverage past development. In the small, some reuse can be achieved on the language level via functions or classes and methods. In the large, whole frameworks have been developed (such as .NET among many others) which have greatly facilitated software development.

The key is that within any chosen software paradigm, the ability to reuse components is essential. Release v0.1.3A now provides a simple directory-based component library, where essentially snippets of script models can be saved to serve as templates or even design patterns and later dragged from the Component Library browser and copied into other models. In this case they can be further refined and manipulated, including using the new capabilities described above. In the future, some version of inheritance between model components will also hopefully be provided.

- - -

Over the next couple of weeks, Release v0.1.3A will continue to undergo testing, targeting a mid-December release.

If you're interested in joining the trial, see:  Join the Trial.

Antonius