Moose 6.0

We are happy to announce version 6.0 of the Moose Suite, the platform for software and data analysis built in Pharo:
http://moosetechnology.org/#install

Moose-6-0.png

Description

The key highlights are:

  • It is based on Pharo 5.0 including the latest version of the Glamorous Toolkit.
  • It includes the SmaCC parsing framework together with parsers and abstract syntax trees for Java, JavaScript and Swift.
  • Roassal2 comes with several enhancements.
  • Famix features a new and generic query API engine.
  • Moose Finder and GTInspector come with more custom presentations and visualizations.
  • SmaCC comes with a dedicated debugger.
  • The debuggers for Glamour, PetitParser and Announcements received a new update.
  • DeepTraverser is an order of magnitude faster.

Extra highlights:

Installation

The Moose Suite 6.0 comes for each platform as a separate bundle:

The Moose Suite 6.0 can also be loaded in a Pharo 5.0 image either from the Configuration Browser, or by executing the following script:

Metacello new
smalltalkhubUser: 'Moose' project: 'Moose';
configuration: 'Moose';
version: #stable;
load.

Enjoy,
The Moose team

Posted by Tudor Girba at 15 August 2016, 2:14 pm with tags moose comment link

Moose 5.1

We are happy to announce version 5.1 of the Moose Suite:
http://moosetechnology.org/#install

Description

This is a minor release. The key highlights are:

  • It is based on Pharo 4.0.
  • Roassal2 comes with several new builder, most notably the new Mondrian builder (RTMondrian) and the chart drawing engine (RTGrapher).
  • GTSpotter has preview abilities and was extended for multiple search use cases including the navigation through Moose models.
  • GTPlayground was extended with sharing possibilities and transparent backup.
  • GTExample now offers support for documenting classes with example instances.
  • Moose Finder and GTInspector come with more custom presentations.
  • PetitParser has seen performance corrections and has been extended with the ability to parse whitespace languages.

Installation

The Moose Suite 5.1 comes for each platform as a separate bundle:

The Moose Suite 5.1 can also be loaded in a Pharo 4.0 image either from the Configuration Browser, or by executing the following script:

Gofer new
smalltalkhubUser: 'Moose' project: 'Moose';
configuration;
loadStable

Enjoy,
The Moose team

Posted by Tudor Girba at 4 June 2015, 8:33 am with tags moose comment link

Humane assessment keynote and tutorial at "Be Fast & Curious", Cluj

Next week, on December 13, I will have the pleasure of giving a keynote and tutorial around humane assessment and Moose at the Be Fast & Curious event in Cluj, Romania.

The event is organized by 3Pillar Global. This is the first time that I am talking about these topics in Romanian, so this will actually pose a little challenge. But, considering the fact that the event poster has my head on it, I will certainly enjoy it.

If you are in the neighborhood, come and join us (the registration is free).

Poster.png

Posted by Tudor Girba at 5 December 2014, 11:07 pm with tags assessment, presentation, moose comment link

Moose 4.8

We are happy to announce version 4.8 of the Moose Suite: http://moosetechnology.org/download/4.8

Description

This was supposed to be a minor release, but in the end it turned out to be a major release with significant improvements.

The key highlights are:

  • Based on Pharo 2.0.
  • All built-in visualizations use Roassal.
  • Roassal received a significant performance boost and new smart graph layouts like TreeMapLayout or ForceBasedLayout.
  • Roassal uses Athens for nice looking vectorial graphics.
  • New charting engine based on Roassal: Graph-ET.
  • Glamour changed to enable dynamic scripts, while still remaining backward compatible.
  • Glamour received a RubricTextPresentation for using the new Rubric text morph.
  • Glamour, Roassal, EyeSee, Graph-ET editors are more robust when dealing with errors in scripts.- New GTDebugger with dedicated workflows for Announcements, PetitParser and Glamour itself.
  • Extended GTInspector for several object types.
  • Usable version of GTMetaceller for handling Metacello configurations.
  • FAMIX was strengthen to handle functions better in various programming languages.
  • New free type fonts and simpler whitespace-loving theme.
  • Lower memory footprint for large models.
  • Faster MSE import.

A list of issues addressed in this release can be found at: http://code.google.com/p/moose-technology/issues/list?can=1&q=status=Fixed%20milestone=4.8

Installation

The Moose Suite 4.8 comes for each platform as a separate bundle:

The Moose Suite 4.8 can also be loaded in a Pharo 2.0 image either from the Configuration Browser, or by executing the following script:

Gofer new
smalltalkhubUser: 'Moose' project: 'Moose';
package: 'ConfigurationOfMoose';
load.
((Smalltalk at: #ConfigurationOfMoose)
project version: '4.8-snapshot') load
Posted by Tudor Girba at 13 September 2013, 7:01 am with tags moose comment link

Snapshotcello: take a snapshot when you're ready

Metacello is a configuration management system that allows us to specify dependencies in Smalltalk projects systems. Like any similar system, the dependencies are defined at two levels:

  • dependencies between packages and sub-systems (captured in the so called baseline specifications), and
  • actual package and sub-system versions (specified in version specifications).

Having a configuration makes many things cheaper. Here are two: you can easily automate the image creation and blend it in a continuous integration job; and you can have nesting of projects. The second point is particularly interesting. For example, in the case of Moose, we have 32 nested projects.

One way to work with Metacello is to define your baseline, and for each commit to update the current development version. This can work well in small projects, but as soon as you go into larger projects with distributed teams that work on different schedules, it can be less appropriate. The greatest challenge comes from synchronization needs when versions are too fine grained: Because there is no merging support of configuration specifications, if the configuration changes too often (due to versions update), it can become a pain to handle the modifications. This can be solved with appropriate tooling, but at present time, it poses a significant problem in large projects.

In the case of Moose, we work in a distributed fashion, and the development philosophy that matches best is to work on the very latest of package versions and integrate aggressively all the time. To match this mode of development, we have introduced the rule that all baselines in Moose-projects only depend on #development versions of other the Moose-projects. Furthermore, the #development version always points to a baseline.

For example, ConfigurationOfMoose looks like:

development: spec
<symbolicVersion: #'development'>

spec for: #'pharo2.x' version: '4.8-baseline'.
baseline48: spec
<version: '4.8-baseline'>
spec for: #common do: [
...
spec project: 'Glamour' with: [
spec
className: 'ConfigurationOfGlamour';
file: 'ConfigurationOfGlamour';
version: #development;
repository: 'http://www.smalltalkhub.com/mc/Moose/Glamour/main' ].
...
]

In this way, when we load the #development version, we actually load the very latest of all projects. This works well when in development mode, but it is a pain at release time.

Theoretically, we would have to release all sub-projects at the same time and hard code all versions. Given that in Moose we have some 161 packages, it would be a very tedious job to do manually. We need a tool that provides some snapshotting capabilities.

Meet Snapshotcello, a little utility that St├ęphane Ducasse and I worked on, and that enables you to freeze a snapshot of a given configuration based on what is already loaded in your current image.

The idea is simple. You develop against the latest versions of all packages, and commit your changes for each package. When you are ready for a release, you assemble your image, and construct a snapshot version that can be reloaded later.

As an example, suppose you want to take a snapshot of the current Moose baseline and publish it under 4.8-snapshot. The magic incantation goes like:

Snapshotcello new
configurationClass: ConfigurationOfMoose;
configurationVersion: #development;
publishVersion: '4.8-snapshot'

After a couple of seconds, the result looks like this:

version48snapshot: spec
"generated by Snapshotcello"
<version: '4.8-snapshot'>

spec for: #common do: [
self populateSpec: spec with: self snapshot1 ]
snapshot1
"generated by Snapshotcello"

^ #(
#('ConfigurationOfFame-TudorGirba.19.mcz'
'http://www.smalltalkhub.com/mc/Moose/Fame/main/'
'ConfigurationOfFame' )
...
#('Glamour-Announcements-TudorGirba.7.mcz'
'http://www.smalltalkhub.com/mc/Moose/Glamour/main/'
'Glamour-Announcements' )
...
)

The snapshot1 method lists all packages that should be loaded from all included projects in the right order. version48snapshot: provides a wrapper to make the code loadable through Metacello. Why not have the two in the same method? A technical limitation: we cannot have that many symbols in one Pharo method. To go around the problem, we create only one literal array with the data tuples and manipulate them through the populateSpec:with: utility method. The good news is that it works.

Snapshotcello is light. In fact, it comes with 2 classes of which one is an Error specialization. But, I think it opens doors to less constrained development. To give it a shot, you can load the code via:

Gofer new
smalltalkhubUser: 'girba' project: 'Snapshotcello';
package: 'ConfigurationOfSnapshotcello';
load.
(Smalltalk globals at: #ConfigurationOfSnapshotcello) loadDevelopment
Posted by Tudor Girba at 23 July 2013, 10:37 pm with tags pharo, moose comment link
<< 1 2 3 4 5 6 >>