• AnimateAvatar: Animates an avatar with a set animation.
• AnimateOnSit: Animates an avatar that sits on a prim.
• ChatAnimate: Animates an avatar that chats a desired animation.
• ChatCommands: Chat command processor.
• FollowAvatar: Causes a prim to follow it's owner.
• MoveAvatar: Moves an avatar via a prim.
• SetAvatar: Chat commands to animate; set floating text; turn on a face light.
• ShowMenu: Displays a menu & waits for the user to make a button selection.
• Timer: Shows how a model can be subject to an overall timeout constraint.
• And more...

I'm working on more model examples for inclusion in the library down the road. A Community Library has also been set up where you can share models that you think will be useful to others.

Antonius

Free and Professional Versions of MiceOnABeam

With the general release MiceOnABeam is now provided in Free and Professional versions. A Free version will always be made available with each new release as I feel strongly that's it's important to get the program out there and make it available to everyone regardless of their ability to pay.

Aside from a couple of restrictions (code generation is limited to a maximum of five states and the new Performance Analysis feature is disabled) the free version is otherwise fully functional and can be used to create scripts for the Second Life world.

At the same time I'd like to defray some of the expenses involved in developing the program so I've created a Professional version which has no restrictions.  A license for this version can be purchased for $L3000 at Second Life's XStreet Marketplace.

The Model IS the Implemention

One of the key benefits developing a MiceOnABeam model for a script is that the script's architecture not only becomes clearer to understand, but is actually represented by concrete design components that are automatically translated to LSL code. In other words, the model is the implementation!

This enables the development of a whole range of features that can operate at the abstraction level of the model itself and provide higher-level insights into the design than would otherwise be available through a similar analysis of a script coded directly.

The new Performance Analysis feature is an initial step in this direction. Read on below for full details.

Performance Analysis

Delays and lag are significant issues to be considered when developing scripts for the Second Life world. As a result scripters must pay careful attention to the execution times of processing intensive activities or algorithms.

To address this need, MiceOnABeam models can now be automatically instrumented with LSL code to measure and report execution timings for selected components within a script model. This is a powerful new feature that can help users identify performance bottlenecks in their designs.

Each model component type can be configured to monitor either all usages (e.g., monitor all States in the model) or only particular instances of that type.

For monitored components users can select to output the number of times a component's code has been executed, it's cumulative execution time and it's average execution time.

STATS>> *** PERFORMANCE STATS ***       Count   Tot Time  Avg Time
[09:14] Object: STATS>> EVENT_listen:     3     2.940365  0.980122
[09:14] Object: STATS>> EVENT_sensor:     0     0.000000  0.000000
[09:14] Object: STATS>> EVENT_timer:      8     0.719490  0.089936
[09:14] Object: STATS>> EVENT_touch_end:  2     0.789647  0.394824

Down the Road

Next up is the development of a library of free re-usable MiceOnABeam script models. Given that visual scripting is new for many scripters (or perhaps they used modeling techniques for analysis and design- but not for implementation), I recognize that it is essential to have a set of reusable building-blocks to help new users get started.

The availability of building-blocks together with MiceOnABeam will also hopefully encourage and enable Second Life members who have been intimidated by the complexity of programming to augment their SL experience by being able to add behavior to their SL creations.

An open library will also be made available on the MiceOnABeam website where contributions by users will be made available for anyone to download and use.

Later in the year and contingent upon Linden Lab plans, MiceOnABeam will support the use of the C# language for use within a script model and will generate a complete C#-based script.

For full details on the release please check out the Release Notes.

Antonius

This is primarily a maintenance release that fixes some important bugs, but I did take the opportunity to add in two key optimizations to the code generation.

Code Generation Improvements

The Group Transition was a prime candidate for some improvement. Recall that a Group Transition is used when the code handling a particular LSL event is common to two or more states, e.g., an on_rez event. This is a very powerful and useful feature.

In the generated code, the transition action code was shared, but the Guard Condition code together with setup code to invoke the Group Transition was not.  With this release all such code common to several states is now shared where possible.

Another feature whose code generation has been optimized is the Final State which signifies completion of the script model or portion thereof. A Completion Transition is used in conjunction with a Final State to indicate the next state to transition to when a Final State has been entered from within a Composite State.

In previous releases, if a Composite State had a Completion Transition, then it would be propagated to each substate, whether or not the completion event could have been generated from within the substate. With this release the code generator will only create a Completion Transition on those substates that contain a Final State somewhere within their nested context.

Code Generation Options

For convenience a new menu item Generate LSL (Optimized) has been added to the Script menu within the main menu bar. This temporarily adjusts the code generation options resulting in more compact and optimized LSL code generated.

If you are using an external LSL simulator for debugging your scripts the non-optimized version may be desirable so that you can read the self-commented code and can take advantage of the execution tracing options. However the optimized version should almost always be used to generate the final, tested script for the SL environment.

Support for Pre-Release LSL functions

Also of interest in v0.3.0B is support for upcoming LSL functions that will be supported in a future SL release (functions relating to getting & setting individual prim link parameters & various prim media functions & constants). These are now supported by the MiceOnABeam parser and code editor for the convenience of those users using pre-release versions of the SL server & viewer.

For full details on the release please check out Release Notes.

Antonius

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

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

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

• 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

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

Some highlights:

• Nifty new application and window icons as well as a splash screen (yes- it can be turned off)
• Support for Conditional Compilation
• Compiler directives to automatically propagate code to all Leaf States within a Composite State
• and more...

Antonius