I had the pleasure a couple of weeks ago of being interviewed by the ravishing Dousa Dragonash on Metaworld3's Nightly News channel www.livestream.com/metaworld3.

She had heard about the recent beta release of MiceOnABeam and had all sorts of questions on the rationale for developing the program and it's applicability for new SL scripters as well as experienced ones.

Well, being interviewed on a virtual world live broadcast was certainly a new one for me as you'll notice by the stiffness of my body throughout the interview. (My avatar has yet to learn to walk & chew gum at the same time. :-)  But it was a great experience none the less.

The Nightly News is filmed at MetaverseTV's neat studios in world. Dousa will also be known to fans of the MBC News virtual news cast.

The interview can be found here.

Antonius

A critical bug has been reported in v0.2.0B that occurs when using a Final State modeling component. MiceOnABeam will crash when drawing a transition to a Final State.

The problem was introduced by a small last minute addition to v0.2.0B that ensured that a transition with a Completion event could not be directly connected to a Final State (thereby creating an infinite loop in the model).

Fortunately there's a simple workaround: Just create the new transition first to another state. Then select and drag the transition's end-point over to the Final State.

Sorry for any inconvenience that this may have caused anyone. The has been fixed for the upcoming v0.3.0B release due out the week of March 22nd.

Antonius

With the completion of the development and testing of version 0.2.0B, I'm happy to report that MiceOnABeam has reached a critical mass of functionality and stability that makes it ready for a wider distribution through an open beta release. Any Second Life user can now download the release here.

Chief among the new features that this release provides is the re-architected code generation which now runs within the single default LSL state, while still continuing to support all of MiceOnABeam's advanced modeling features.

Aside from reducing memory requirements in the generated code, MiceOnABeam models with the new code generation are no longer limited by LSL's side-effects when using multiple states, such as purging the message queue and cancelling listens or sensors. 

A search feature is also now provided which can search for text throughout the model and provide categorized lists of model components that match the search string. The search is hierarchical, and so can be scoped to just a portion of the model! Model components found in the search can then be opened up to with the location(s) of the found text highlighted.

Finally, tired fingers will appreciate that code completion for LSL functions and constants is now provided within the built-in LSL code editor.

Aside from the above features a number of bug and usability fixes have gone into the release thereby improving the user experience.

At this point I also want to thank all of you who took part in the Alpha Trial. Your participation has been instrumental in helping achieve this release.

Antonius

MiceOnABeam Version 0.1.3 Alpha is now available for downloading to trial members!  Aside from bug fixes, this release provides several new features including:

• Cut/Copy/Paste of model component

• Aggregate or Decompose states

• Component Library for managing reusable modeling components

• New option to select the mouse double-click action when editing script models

• New System Debug options to automatically report MiceOnABeam issues

Trial members should have already received an email with details on how to download the release.

With this third alpha release of MiceOnABeam we're opening up the trial to more participants. For those of you reading this who are not part of the trial, consider joining in order to try out this upcoming new modeling tool for the SL world. (Join Alpha Trial)

Antonius

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