Snapshots

Last week I was doing UML diagrams for a colleague to use in building his part of a large application. It occurred to me that the information he actually needed was quite a lot less than what was on the diagram, but as we were doing some test led development, and the model was continuously evolving to reflect the results of our tests, it was too annoying (and unreliable) to have two separate versions of the model to update.

I think the answer to this problem would be for each Identity Project to be able to have multiple 'Snapshots' - as roughly visualised in the pic above. In different Snapshots the state (CRC / Full class element / Collapsed class element) of each element could be different, but making a change to the model would update it overall, and the changes would be reflected in each snapshot. 

I've also been thinking about 'visibility filters' for the snapshots. Being able to toggle on and off all public / private / protected / package attributes and operations in the whole diagram would be useful too - I often find myself running 2 copies of a model, one with the entire structure and one to give to a collaborator which only includes the public stuff.

Apologies if this stuff is already present in existing UML tools - at the moment I've decided to not do any research into what's already out there until the first draft of the Identity spec is written up. At that point I think it'd be useful to compare what we've come up with to what's already available, but I'm trying to keep my thinking coming from 'what do we want this to do?' at the moment rather than 'what do other tools do?', knowing that we can pick the status quo up later.

PureMVC, and the MDI / TDI quandry.

CarnageBlood recommended I check out PureMVC as a framework, and I'm really grateful for the suggestion because it looks excellent.

I have no doubt that using PureMVC is a good move - it's opensource and we can develop any generically useful extensions as plug ins that will be useful to other PureMVC users.  

The big question I have is single-core or multi-core?  How do these relate to interface possibilities?

My favourite applications appear to be a hybrid of TDI and MDI.  Coda is an amazing one-window-web-development tool that has tabbed browsing of files open in each window - one window referring to a 'site'.  Having multiple windows open means I can entirely separate my work by project / client / server.  I love it.  Each window has its own interface - file browser, search tool, activity etc.  A couple of windows - such as 'clips' - a code snippets tool - are shared across the app as floating panels.

Omnigraffle 5 works in a very similar way. Lots of the interface is wrapped directly around the document, but formatting panels etc are floating shared windows.

I've done plenty of standard MVC development but never a multi-core app.  I'm not even sure that what I'm describing is truely multicore?  Whilst there would be many models, views and controllers, the actual basis of the application is perhaps still a single core?

More reading to be done - and possibly the best way forward is to plan version 1 as single window (apart from interface floaters) tabbed documents style, with the multiple project windows version as a major update.

Identity modeller roadmap

If you build it, they will come ... 

That's my mantra at the moment anyway. At times I wonder whether I'll get enough active contribution to this project to make it worth doing open source ... and then I tell myself to shut up, because open source is something I believe in.  Wikinomics, etc.

I have a genuine passion about this project. I guess it's my old production engineer background coming out - I want to fix the process, regardless of the product. In the last year or so I've begun to feel incredibly frustrated by a lot of the work I do, by the sheer pointlessness of it to be honest.  But I still have friends who do OO coding who don't feel able to use UML, or CRC, and I still find I'm having to talk myself into doing it sometimes, and I know that if I had the tool that Identity aims to become I would be a much better coder and technical manager. I know that sharing good code would be easier for starters.

I'm fortunate to be involved in a couple of really, genuinely worthwhile projects - the biggest of which is a training application that runs in AIR. Apart from a really good usable GUI, the AIR-ness means that this app can manage its own updates in a wonderfully smooth way, something which has allowed us to get it out to users much earlier in the process than with a conventional app, where releasing updates might be problematic.  We can get a bug report from the client, engineer a fix and release the new update to all users within hours.

Based on that experience, the Identity modeller roadmap aims to release as early as possible. I'm also a fan of getting the risky bits out of the way as early as you can, so we start up with the data side, and work towards graphics at the end. To begin with it won't be pretty, but it will be working.

You can download the roadmap here. (pdf, 1.4 MB)

I've no idea what the timeframe is, which will depend partly on how many people get involved and how their schedules are playing out. If you want to have input into the big picture, in particular the scope of the model and the way data is saved, speak up now.  Thanks to all those already chipping in on email and chat!

If you're not able to contribute in terms of coding or design but would like to do unit testing or alpha / beta testing I'm already taking names for those ... don't be shy.

Identity modeller overview documents

I've gathered together some of the thinking and ideas I've been bouncing around with Jeroen and Weyert, and chucked everything into a 7 page friendly pdf : download it here (1.6MB).

As always, feedback, input, thoughts etc are all very much welcome.

I've also been looking at alternatives to osFlash as they're closed to new submissions it seems.  I think probably Google Code is the right choice - if anyone has direct experience of using it please let me know what you'd advise.

I think the next step is a road map of proof-of-principle steps.  And later, identifying the bridge API requirements for the various plug-ins and components will be a big exercise - so the more brains the merrier!

Combining MVC with the AIR sandbox

Identity seems to be an ideal candidate for the Model-View-Controller design pattern.

I recently converted a large application into an Air app and had to grapple with the differences in how loaded content can access the loader Air file.

There are lengthy and comprehensive white-papers available from Adobe, and they do explain the new model very comprehensively, but I feel quite strongly that the 'What's new in AIR?' overview stuff for flash developers should have had the following simple point:

In order for a loaded swf to be able to communicate with the parent AIR file you must create an API class with public functions within the AIR application and assign this to the loaded swf as a bridge.  The only data which can pass between the parent AIR file and the loaded swf is simple type data : Number, String, Boolean. You cannot pass complex typed data between a loaded swf and a parent AIR file.

The implementation of this into our application was initially a bit painful.  The application is a training environment.  The main AIR app loads external swfs of individual lessons and quizzes. The app GUI has all the interface and the loaded swfs basically only contain a timeline with a voice over and animations and a small amount of functionality.  There is quite a lot of communication between the two however - with the loaded swf prompting the GUI to update all sorts of things - messages on screen, navigation state, icons indicating the availability of other resources.

We had previously achieved a lot of decoupling by using events.  In the new model it was no longer possible for a typed object, such as an event, to pass between the swf and the AIR app. Of course it took a whole bunch of testing and digging through various white-papers to realise that this was the issue ... but we got there in the end.

The result is an even more cleanly decoupled app, with less requirement for the animators to put code into their lessons, and the AIR app is at far less risk of being broken by anything they do.  At the moment there is a small loss in compile-time error checking, though I suppose we could define constants within the local lesson to get back what we had with the events.

So - I am thinking about what the AIR security sandbox will mean for Identity.

It makes sense to have a number of the core functions held in separately compiled swfs, so that they can be extended / swapped easily.  This also gives a lot of protection to the core application as it means that only expected data can pass through.  We can check and place limits on this data before it is used within the app.  Lovely.

For example - the ECMAScript-based parser should be able to handle AS2, AS3, AS4 and probably PHP5 and 6, but I haven't a clue what other languages people might find this useful for.  The logic for creating / stripping an AS3 file is quite clear to me - you need a file that defines how a class is built and then you do some regexy things and some iteration through the properties and functions.  How universal that logic is I don't know.  How much customisation you can do without editing the parser, I don't know.  How much benefit coders might get out of editing the parser to suit a specific need, I don't know.  So - if the parser is an externally loaded swf then you can select a parser to use and introduce a layer of flexibility.  You can even build your own.  People can experiment easily with their parser and make public 'improved' ones maybe.  

[I'd love to see a parser that simultaneously builds your asDoc html, for example ... not sure how this would be possible right now, but it doesn't feel completely unrealistic, if the parser simply called file writing functionality within the API].

You can assign a specific API to each loaded swf, but you can only assign one.  So, that API needs to deal with all relevant aspects of Model, View and Controller in one class, though of course it's just a gateway through which simple-typed data passes.

Application-sandbox loaded components do have a lot more potential for interaction with the parent AIR app, but I think the outside-the-app model offers a much more secure and controlled environment for plug-ins, so this seems like the best route.  Identifying the kinds of functionality each of the plug-in API classes needs to have is a pretty big task in itself ... doing the planning for this project is making me more certain that I need this piece of software though!

(For mac users, if you don't already have it then you should check out Omnigraffle Pro 5 - the best piece of software I've ever used just got a whole load better.)

Project language spaces & class interchange

I'm definitely hooked on the idea of being able to model once and export stub code in multiple languages.

The potential benefits in terms of providing shared 'Class swatches' are pretty attractive.  

So far what I'm imagining is that when you start a new project you select a language space for that project.  You would then be able to drag previously defined classes from a classes swatch thingy (best to be specific about the lack of definition here!) into that project - and the app would translate unsupported types according to the type mapping spec for that language. Swatch classes would only be able to be edited within the language space they were defined in - so you couldn't start adding MovieClip types to a class which you've created in ECMAScript.

You would also be able to create a new class 'based on' an existing class in your class swatches - this would import the class types into your project language and allow editing within that language.

Making sense?

Introducing identity modeller

Dauntless pointed out on email that I can't keep calling it "Air UML tool thing" ... and I thought coming up with a half-decent name would take ages, but here I am already, introducing Identity modeller.  Whadya think?

I wanted it to convey the fact that the code and the model are intended to stay in step with each other ... and 'congruent' isn't exactly catchy.

Plus, like all good math-geeks, I'm a long term fan of Euler. Couldn't resist ... sorry!

Air UML Tool : File formats and more on typing

I've been trying to wrap my head around the xmi specification for describing UML models using xml.  The purpose of the spec is obviously to allow models to be imported / exported and switched between different UML tools.

It has given me a focus for the core functionality of the application - to be able to read and write both xmi models and language specific class files.  The application would then also have the ability to write extended xmi files, containing the compliant xmi model stuff but also the project data relating to everything else - non uml stuff to do with getter/setters, positioning, etc etc. 

The language specific element will be provided by external xml configs - one to describe how a class file is structured, and one to map generic types to language specific types.

I've been having a bit of useful exchange with Dauntless on the types issue.  The thinking I have at the moment is that some classes are clearly language specific - anything using or extending MovieClip for example is only useful in Actionscript - whilst other classes might be much more generic, in which case it would be nice to be able to move them across different language projects.  I have a few utility type classes which I use in both AS3 and php5.  

The most basic type set is that provided by UML itself: boolean, integer, float and string.

Then there is the set provided by ECMAScript 4 - discussed in the previous post.

As Dauntless pointed out, Java has useful stuff like Enum. 

I think I've almost reached a clear enough understanding of the multiple-languages issues to be able to post more detail of that tomorrow.

As always - the more the merrier - please chip in if you're interested in contributing.

Meantime - if anyone can think of a good name for this baby ... Dauntless has rightly pointed out that AIR UML Tool is getting a bit dull ...!

AIR UML tool : Working with types across different languages

One of the most obvious changes when switching between AS2 and AS3 is the difference in built-in types.

I'm talking Number vs int / uint. Void vs void.

From time to time I plan something that I want to execute in more than one language - in php5 or Actionscript 3 ... I've been fortunate to be able to leave AS2 behind but I know a lot of people are working on legacy projects.

With Colin Moock already talking about Actionscript 4, the focus for future-proofing seems to be on ECMAScript 4.

The release data for the new spec isn't til December 2008, but I'm guessing the end of the year will be upon us in no time.

Reading through the ECMAScript 4 Overview, it's struck me that building with this spec in mind will force us to include the kind of flexibility that will make it easier to extend this app to other languages.

For example - some of the Number types proposed - byte, int, uint, double and decimal - may not make it into the final spec, and we may continue to have the current AS3 set: int, uint and Number.

If each language contains a type mapping spec for the core types then AS3 can map byte, double and decimal to Number, and if AS4 supports them then they can be supported.

eg:

translations/as2/typeMapping.xml :

<typeMapping>
<type_byte>Number</type_byte>
<type_int>int</type_int>
<type_uint>uint</type_uint>
<type_double>double</type_double>
<type_decimal>decimal</type_decimal>
<type_Number>Number</type_Number>
</typeMapping>

translations/as3/typeMapping.xml :

<typeMapping>
<type_byte>uint</type_byte>
<type_int>int</type_int>
<type_uint>uint</type_uint>
<type_double>Number</type_double>
<type_decimal>Number</type_decimal>
<type_Number>Number</type_Number>
</typeMapping>

translations/as4/typeMapping.xml :

<typeMapping>
<type_byte>byte</type_byte>
<type_int>int</type_int>
<type_uint>uint</type_uint>
<type_double>double</type_double>
<type_decimal>decimal</type_decimal>
<type_Number>Number</type_Number>
</typeMapping>

So far, the types I can identify in the ECMAScript 4 list are:

null, undefined, void

Object

Number, byte, int, uint, double, decimal

Boolean, boolean

String, string

Array

Vector (a strictly typed array?)

Function

Map (binary relations)

Date

RegExp

Name, Namespace, NamespaceSet, NamespaceSetList

Error, EncodingError, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, UndefinedError, URIError

AnyString = (string,String)
AnyBoolean = (boolean,Boolean)
AnyNumber = (byte,int,uint,double,decimal,Number)
FloatNumber = (double,decimal)

XML, XMLList, AttributeName, AnyName

IterableType, IteratorType

I've also spotted a few more in the documentation - FieldIterator and ControlInspector perhaps?

Either way - this strategy allows us to be highly specific in our documentation, and then water that precision down for each language. Of course, coming back the other way it's trickier. Do we want reverse engineering to simply pick the most generic type, or do we need a special comment that can specify how types are backward translated? Something like ... (for AS3)

// *strictType:decimal //
public var salary:Number;

Obviously the app also needs to support types from your own library.

Something else I've noticed is the support for ! ? notation to specify that an object can / can't be null. Eg

// "!" indicates that v can't be assigned null
var v : MyType!

// "?" indicates that v can be assigned null
var v : MyType?

// "!" indicates that this whole class is non-nullable
class MyClass! { ...

The idea is that this will allow earlier detection of null-pointer errors - ideally at compile-time rather than run-time. That would make me very very happy!

----

It's a pain that ECMAScript 4 is still six and a bit months from completion, but I think the rigour that having to build for an almost-complete standard gives us is probably a good thing.

AIR UML Tool : Defining the UML scope

UML 2.0 is pretty vast.

This is an attempt to summarise the parts of the UML that need to be available within the tool. My current thinking is that different languages will have an xml spec file that maps these UML Language elements to the translated element for that language.  We should begin with AS3 as a primary goal, but ensure we support parts of the UML which aren't yet available to actionscript but might be included in PHP6 or AS4.

For example - AS3 doesn't support 'private' or 'protected' on a constructor, so the AS3 xml config might map it to 'public' in this case.  AS3 also doesn't support 'abstract', so that would be skipped when constructing the stub AS3 code.  

The list below is probably incomplete but it's a really good place to begin.  Strict UML terms are given in (brackets).

Stuff

• package
  
• class
  
• interface
  
• property
  
• function (operation)
  

Visibility

• public
  
• protected
  
• private
  
• internal (package)
  

Scope / implementation modifiers

• static
  
• abstract (unsupported in AS3 but we can hope and at least add to comments)
  
• const (readOnly)
  
• binds
  
• dynamic (not sure this has a strict UML equivalent?)
• overrides [thanks dauntless]
• final [thanks dauntless]

Class relationships

• extends  (generalizes)
  
• implements (realizes)

Any glaring errors?  If you're out there following this and it makes sense to you please do speak up, encouragement, questions, interrogation and the pointing out of obvious fundamental flaws are all appreciated.

[edit]: Dauntless has also mentioned composition, which is definitely required within the laying out of diagrams / relationships, but doesn't really map to an AS3 file other than by declaring a property of that type - or am I missing something?  

We'll also need to represent the Aggregation / one-to-many : many-to-many : many-to-one type relationships as well, and also event listener lollipop etc, but again I don't think they map into the final exported AS3 files.

Dauntless also brought up the issue of types - something I've been thinking a lot about and hope to post some ideas for a strategy later today.

AIR UML thingy overview

So ... here's the overview of the project.

The green box contains the most basic possible release of the software - no real whistles and bells beyond getting something useful that we can start using / testing.

The boxes above that are the language / saved file format stuff.

The blue boxes are things for versions 2 to 100 ... 

All saved data / parameters / language specs etc will be in xml.  The entire app will be written in AS3 only - nothing specific to Flex or Flash.  No assets ... well, maybe a png library later, but it should be possible to compile the project from either an empty FLA or a simple Flex project without requiring any assets.

So - with the whole project written in pure AS3, anyone who uses the software will also be able to modify / adapt / enhance / reskin it.

In terms of UML elements, I think we should start with the most commonly used elements and then add further ones later.  

As far as interface / usability goes, my 2 favourite pieces of software are coda, by panic, and omnigraffle by omnigroup.  If we get anywhere near to something as beautifully usable as those two I'll be a very very happy bunny.

The 'class swatches' add on is something I'm kind of excited about myself.  It would allow you to have templates for classes / design patterns that you drop in and edit.  

I'll expand more on the diagram above as soon as I get a chance, and it's by no means a concrete solution, just the one that I've come to so far - all feedback / ideas gratefully received.

Open-source Saffron-like UML tool

Saffron is / was an AIR-based UML tool that promised great things, but so far has yet to deliver even an Alpha.

Like many others I've binned my own UML tool project believing that Saffron was just around the corner and far exceeded my own project's limited capabilities.

The AS3 community's response to Saffron has been overwhelming - we want this tool. Badly.

Whatever the reasons for Sam's non-delivery on Saffron - and frankly it's not like he owes us as all we've invested is our hope - I’ve given up on Saffron appearing anytime soon.

Leaving behind the rumours, Saffron would be a fantastic tool and Sam has clearly solved a few of the usability issues that bug me about other UML tools. Whether or not he has been able to execute it, his concept is seriously good.

If a bunch of us got together I believe we could do this open-source quite rapidly. If there is interest I’m prepared to get the ball rolling - if we all want Saffron so badly then we need to deliver it ourselves!

I am looking to gather together contributors to work on the project, taking this (scaled down) vision as a starting point:

Project scope:

• The tool will run on AIR in multiple windows.
  
• It will allow you to generate AS3 stub code + asdoc comments from your diagrams.
  
• It will allow you to generate diagrams from AS3 code (with asdoc comments).
  
• It will allow you to add additional commenting to classes / functions.
  
• It will stick as closely to UML 2 as is feasible and support the core OO concepts.
  
• The API will be built with expansion for other languages in mind - all they would require is a new parser logic.
  
• There will be autocomplete / prompting for classes already included in the project diagram.
  
• Data / projects / configs will be held in XML files.
  

Ethos

• There will be a focus on releasing usable builds as early and as often as possible - even if they are ugly! Provided we maintain backward compatibility it's more valuable to have a tool that helps us do some of what we need than nothing.
  
• All project components / specs etc will be open-source and public.  
  
• All development will be test driven - tests written before code.
  
• Refactoring will be encouraged.
  
• No effort is too small - write just one class that solidly delivers and passes its unit test and your contribution is valuable.
  
• The project will be cross platform Flex / Flash to maximise the number of possible participants.  (Yes, it's a pain, but I think it's worth it).

If you're interested please say so below ... with the right approach and the right numbers of people this thing could fly quite quickly, don't you think?