JumpShip Blog

Announcing JumpShip 4.0

2008-12-16T15:58:00.000-08:00

JumpShip 4.0 has been released. The new version, although not significantly different from the last, takes a slight philosophical departure from the last. And since it was a significant enough change to possibly break compatibility with older version, I've decided to call it a new major revision.

The most significant change in JumpShip 4.0 is that, now the framework actively discourages the use of Singleton that have become widely popular in other frameworks. Although JumpShip has always touted it's diminished use of Singletons and therefore it's advantage when using it a an application framework or a component framework, the framework itself has never taken an opinion on the use of the Singleton pattern and in face included a few Singletons itself.

There has been a recent backlash against the Singleton pattern in the design pattern world ( See the post on http://www.as3dp.com, Scott Densmore's post, or Miško Hevery's thoughts ). The Singleton has been used as a substitue for global variables ( you know, those things good programmers never use ), and have all of the drawbacks of globals. They can be very convenient but make your code hard to read, hard to test, and hard to debug.

For all these reasons, the latest version of JumpShip has removed ( almost ) all of the Singletons in the Framework. The one exception being the JSRuntimeEnvironment class which is used to make your application behave slightly differently ( logging, throwing errors, etc. ) in a development environment than it does in a production environment ( stability at all costs ).

Eliminating Singletons meant eliminating some classes from the framework, namely the service locator classes, and changing others, JSApplicationState and JSRailsGatewayBase, so that they do not have Singleton implementations.

This has effected the Rails Gateway classes the most and hopefully made the easier to use. You now no longer need to extend JSRailsGatewayBase in order to use it. Instead of having to define a service locator in the implementation, you simply pass in the base path of your Rails app when you create a new JSRailsGatewayBase instance.

The JSApplicationState class is also no longer a Singleton which means you can have as many different state objects as you want.

The other big change in JumpShip 4.0 is that now the JSDataRecord class recognizes when another JSDataRecord instance has been added as an attribute and will automatically listen for data binding events, rebroadcasting them upward if one is received. This allows multi-dimensional data structures that maintain data binding all the way down the tree. Although, JumpShip still encourages flat data structures, there may be occasions when you need data binding for multi-dimensional data.

Finally, JumpShip 4.0 includes improved documentation and a few bug fixes for potential memory leaks.

Using JumpShip inside Flex. A roadmap.

2008-07-19T23:33:00.000-07:00

Using JumpShip inside Flex. A roadmap.

All files can be found at: http://www.youbits.com/jumpship/FlexAndJumpShip.zip for your convenience the entire JumpShip Framework is also included.

The JSDataModel and JSControllerBase can be used inside of an mxml document as they are. The only trick to using JumpShip in Flex is in using JSViewBase.

JSViewBase extends Sprite in order to add the ability to add, remove and manipulate DisplayObject's to itself and have those DisplayObjects be part of the Display List. It extends Sprite as opposed to Flex's UIComponent so that it can be used in both Flash and Flex but this decision adds a small amount of complexity for the Flex developer since You can't attach a Sprite directly to most Flex components because all children of a Flex component must extend UIComponent.

There are several ways to get past this small annoyance, however.

First of all you should realize that you don't need to add JSViewBase to the the Display List in order to use it. JSViewBase is Just a mediator between your Model / Controller and a group of one or more components. It is meant to handle communication between other pieces of the MVC framework. This allows you to build components which don't have any code that is JumpShip Framework specific and wrap them in a JSViewBase instance which takes care of all of the interaction within JumpShip.

You can create and use JSViewBase just as if it didn't extent Sprite by creating a new instance but not bothering to attach it to the display list. In this case the only thing you loose is the ability to use add components directly to JSViewBase and have them show up on the display list. Instead you would use JSViewBase to store references to it's components which would sit somewhere on the display list. An example of this is provided along with this post.

Included is a demo Flex project that uses the JSViewBase as a mediator for the Flex compnents contained in the main application.

Another way to use JSViewBase would be to wrap the class in a proxy component that extends UIComponent. The JSViewBase proxy would just pass all references straight to the JSViewBase instance and the rest of the JumpShip Framework would not know the difference. An example of a JSViewBase proxy class is provided as part of this post.

A third solution is just to give up the utility function that JSViewBase provides and simply create a new Flex component that implements IView. Although you would loose some of the nicer things that JSViewBase provides, you may decide that those features aren't particularly useful to you anyway. Or you could implement a subset of the JSViewBase functionality in your new component. But as long as your component implements IView, it is capable of fully participating in the JumpShip Framework. Note that IView doesn't require that your implementation be a DisplayObject at all.

Most MVC frameworks don't even attempt to provide a standard View implementation because as this article illustrates, it can be tricky to implement a View class flexible enough for everyone to use. But JumpShip attempts to go where other frameworks do not, realizing that there is value to establishing conventions even if those conventions get away on rare occasion. But I hope this article illustrates that what may seem like a barrier, really is no big deal when you understand the broader intentions of the JumpShip Framework.

All files can be found at: http://www.youbits.com/jumpship/FlexAndJumpShip.zip for your convenience the entire JumpShip Framework is also included.

JumpShip 3.2 Update Released.

2008-06-16T22:22:00.000-07:00

JumpShip 3.2 Update Released.

This minor update of the JumpShip Framework fixes bugs in the JSDataModel and JSViewBase classes.

JumpShip Framework An MVC Based ActionScript with the following features:

A Ruby on Rails like Data Mode
A Command Pattern Based Controller (similar to ARP and Cairngorm
A standardized View with asset loading tools.
Model / View Data Binding
Controller Before / After filtering
Controller Command Cascading (the ability for commands to call other commands).

The following bugs have been fixed:

JSDataModel: Fixed a bug in the ‘getItemIndex()’ method that returned an improper value.
JSViewBase: Fixed a scope issue that prevented proper data binding.

Awesomeness with JSEnumerable and JSArrayEnumerable

2008-05-21T19:40:00.000-07:00

JSEnumerable and JSArrayEnumerable are included in the core JumpShip library but are powerful classes in their own right and can even be used outside of the JumpShip Framework.

The enumerable classes provide standard methods for traversing and manipulating collections of data. The methods they define are meant to mirror standard Enumerable modules in other programing languages like Ruby. A lot of the time one of the more tedious tasks of managing data is the need to iterate over the entire data set to find the specific piece of data you need to retrieve or perform a transformation on.

The two enumerable classes in JumpShip each provide the same functionality but in two different ways. JSEnumerable is a class that can be extended by your data model so that it inherits all of the enumerable functionality. JSArrayEnumerable is a static class that manipulates the prototype of the standard Array class so that all Arrays in your app gain the enumerable functionality. Even though prototype manipulation has become a frowned upon practice in AS3, the Array is the most often used class for enumeration. If you want to make extensive use of the enumerable methods, using JSArrayEnumerable can save you a lot of work by simply allowing you to use Array objects throughout your application instead of sub-classes of JSEnumerable. Either way is fine, however, and will allow you to take full advantage of the enumerable methods to do some great tricks with your data. Let's see some examples.

Let's start with some dummy data. We're using JSDataModel as our data collection. It extends JSEnumerable:

var test = new JSDataModel();

var rec1:JSDataRecord = new JSDataRecord();

var rec2:JSDataRecord = new JSDataRecord();

var rec3:JSDataRecord = new JSDataRecord();

var rec4:JSDataRecord = new JSDataRecord();

rec1.create({firstname:"joe", lastname:"smith", purchases:10});

rec2.create({firstname:"jamie", lastname:"doe", purchases:1});

rec3.create({firstname:"jamie", lastname:"scanlon", purchases:50});

rec4.create({firstname:"mickey", lastname:"mouse", purchases:16});

test.addItem(rec1);

test.addItem(rec2);

test.addItem(rec3);

test.addItem(rec4);

Let's also turn on the JSArrayEnumerable class to make all Array objects enumerable:

JSArrayEnumerable.enable = true;

Now the fun part. Let's say we want a way to quickly compile a list of all of the last names in our data set.

var names:Array = test.pluck("lastname"); // smith,doe,scanlon,mouse

The 'pluck' method pulls out a filed from the records in the collection and presents it as an Array. If you were to think of the data in the form of a table, pluck returns a column. In this case we pluck the 'lastname' column. Now lets say we want to only pull out the last names that contain the letter 's'.

var sortedNames:Array = names.grep( /s/, function(item, index) {

return item;

}); // smith,scanlon,mouse

Notice that we have called the 'grep' method on the 'names' variable which is an Array. Since we have enabled JSArrayEnumerable, all Array's now have this method. If we hadn't enabled JSArrayEnumerable, this would throw a compile error. The 'grep' method is one of the most powerful. It lets you use a RegExp ( Regular Expression ) to filter which records to return in the form of an Array. The capability to filter the records in your data set is only limited by your ability to create a good Regular Expression. The 'grep' method calls toString() on each item in the data set so it is also valuable to make sure that you implement a meaningful toString() method if you are working with complex datatypes, ( here we are only dealing with Strings and Numbers so this isn't an issue ).

Hopefully you can begin to see the power of using the enumerable classes. We just performed two operations that would normally require a loop and at least one 'if' statement. Here's another example. Let's say we want to get a running total of all customer purchases.

var total:Number = 0;

total = test.inject(total, function(memo, item, index) {

return Number(memo) + Number(item.purchases);

}); // 77

The 'inject' method allows you to specify a variable ( in this case a Number ) that will be submitted to a function for each item in the data set. The function also gets the item in the data set and the index. Whatever is returned by the function is submitted to the next item in the data set. This is a great way to apply a recursive function to every item in the data set. In this case, we use it to tally the values of the 'purchases' field.

JumpShip, an AS3 MVC Framework for Flex and Flash, has been updated.

2008-05-21T19:34:00.000-07:00

JumpShip, an AS3 MVC Framework for Flex and Flash, has been updated.

This update features the following changes:

Addition of a new core class JSArrayEnumerable which adds Enumerable methods to Array objects.
Minor bug fixes for JSDataRecord.

JumpShip mxmlc Compiler Bug

2008-04-10T23:56:00.001-07:00

An email from a member of the community pointed out that certain JumpShip Framework's JSEnumerabler Class and it's descending JSDataModel Class might cause errors due to a compiler bug which is documented here:

http://bugs.adobe.com/jira/browse/SDK-9508

It is a bug that has been fixed as of Flex 3.

I've ditched my site and turned it into a Flash blog.

2008-04-09T23:25:00.000-07:00

I've decided to ditch my two year old web desing site in favor of a Flash blog. http://www.jsjstudios.com.

There you will find articles related to Flash / Flex but not Jumpship specific. There is a lot of great content there already, hope you enjoy it.

Jamie

JumpShip Has Buzz

2008-03-06T23:28:00.000-08:00

I've been monitoring traffic for a little while now but ever since I announced the release of JumpShip 3.0, interests seems to have spiked. So thanks to all who are reading, we are now 63 countries strong!

Jamie

JumpShip 3.0 is Here!!

2008-03-02T11:07:00.000-08:00

JumpShip 3.0 has been released.

www.osflash.org/projects/jumpship

Release Notes:

The main goal of this version of JumpShip has been to lower the barrier to entry both in the learning curve, and in the time it takes to get an application up and running.

Former versions of the JumpShip Framework required you to extend base classes to get even the simplest application working. In JumpShip 3.0, the base classes are still there but they are fully implemented. JumpShip 3.0 lets you extend the framework one piece at a time, leaving the rest to perform in a minimal way. In this way you can get an application up and running almost instantly. Using an agile programming style, you can add and change functionality as you need it.

In order to lower the learning curve, JumpShip 3.0 has come more in line with the way other popular MVC frameworks work. Although JumpShip still takes the unique point of view that it is easier to work with a framework that sets reasonable conventions rather than try to be everything to all people, JumpShip 3.0 brings these conventions more in line with other frameworks like Cairngorm, PureMVC and ARP. The goal was to make the concepts familiar to those who have used other frameworks while still providing all of the great tools that JumpShip is known for.

JumpShip 3.0 has also made significant improvements to the Ruby on Rails Gateway. The new JSRailsGateway takes advantage of the RESTful scaffolding that is standard in the latest version of Rails. The Gateway talks directly to you Rails models, eliminating the need for a Gateway on the Rails side to capture, translate, and send data from Flash to Rails.

So to put it simply, JumpShip 3.0 can preform standard Create, Read, Update, and Delete operations on a standard Ruby on Rails back end with no extra sever-side code. The JumpShip Rails Gateway works with the JumpShip Data Model (JSDataModel) so everything sent and received through the Gateway is understood by the rest of your JumpShip application.

Take a look in the examples folder in the rails package and see how to put together a simple database driven address book in minutes.

Enjoy!

Jamie

2008-01-07T10:07:00.001-08:00

The next release of JumpShip is going to sport some pretty heavy architectural changes in order to bring it more in line with what seems to be developing as a standard way of implementing MVC. The reason for the changes are two-fold.

First, I think it's important to simplify the framework in order to encourage new developers to use it. And letting developers use the same basic approach with JumpShip as they may have encountered in other frameworks like Cairngorm or PureMVC is something I would put under the category of simplification.

Second, lazyness mainly. It will be easier to maintain the framework if JumpShip barrows as much as it can from all the other work being done in this space. Many other people have much stronger opinions on how best to implement MVC than I do.

My main goal has always been to lower the learning curve by taking lessons from folks outside of Flash or Java. Folks who are less interested in design pattern theory and are more interested in getting things done correctly, fast, and without thinking about too much.

JumpShip is more focused on the more practical side of development. Respectful of standards and best practices but not afraid to lay down some conventions that make development with the framework take less thought.

Ultimately I don't want the way JumpShip implements MVC to be a barrier, and in fact I'd like to get to the point where it's almost invisible to the developer who just wants to get their app up and running.

Jamie Scanlon

JumpShip's Birthday!

2007-12-21T12:11:00.000-08:00

Ok, so I realized a little late that it was a year ago that I released JumpShip to the OS world. Since that time I've been personally responsible for introducing the JumpShip framework to more than a few companies I've done Flash work for.

If anything the scope of the project has become more focused on core principles. I've taken some time to lean and use a few different frameworks over the past year and I'm glad to say that while I've learned a lot about the insights and usefulness of various frameworks, I've not needed to adjust the core design principals of JumpShip (which itself was inspired greatly by other people smarter than I).

So although my understanding of how frameworks should be used has changed, so has my understanding of why JumpShip is still a great framework.

As a new year gets started the focus on JumpShip will be to simplify the implementation while keeping the current feature set intact.

My recent experience with Cairngorm leaves me with the impression that Data Binding is a far more powerful tool than I first thought. And although it's implementation in Flex is far too specific and opaque for me (it's not even a standard feature of it's older brother Flash), there is still something about the ease of use as compared to the current JumpShip implementation that makes me think that this area might be a rich vein to mine.

And lets face it, the Rails gateway needs work. I simply haven't kept up with the whole REST movement in the Rails world, and I think adopting more RESTful approach could simplify the JumpShip Rails gateway a whole lot (mostly on the Ruby end).

I'm looking forward to the next year and I'm looking forward to see what becomes of JumpShip.

Jamie

Enumerable Class for Flash

2007-09-06T08:25:00.000-07:00

DOWNLOAD:
http://www.youbits.com/jumpship/JSEnumerable.as

Anybody who has spent any time with Ruby have surely come to appreciate the simple elegance of blocks especially as it relates to enumerable objects like arrays. For those not familiar, you can write something like:

myArray.each {|item|
item.do.something
}

This will iterate over the contents of the array and pass each item to a code block {...} allowing you to perform an operation. In Ruby, variables ( in this case items in the array ) are available within the block by defining them inside the "|...|".

The Ruby syntax makes it elegant but the true worth is in the concept. How many countless hours would be saved over the course of a Flash programmers career if he/she didn't have to always write out "for (var i = 0; i < myArray.length: i++) ...". Well we can't change the language but maybe we can attempt to use some Ruby concepts to make our lives easier.

The ajax library Prototype uses an Enumerable module in JavaScript to Incorporate the Ruby concepts of blocks and the Ruby Enumerable Module to do some pretty powerful things. After taking a look at their work, I thought it would be worthwhile to try to implement an enumerable (JSEnumerable) class in ActionScript that lets you traverse and search any list-based data type that extends it.

The Syntax looks something like:

myEnum.each(function(item) {
item.do.something();
});

You can also add a second parameter to the block function with will contain the index of the item. That would look like:

myEnum.each(function(item, index) {
item.do.something();
trace(index) // 0,1,2,3,...
});

Using the JSEnumerable class requires extending it and defining a hook function called doEach. Since not all enumerable objects are arrays, this class defines how to traverse the data. So if a class extended the JSEnumerable class and had all of its data stored in a private Array called myData, doEach might look something like:

protected override function doEach(iterator:Function) {
for (var i = 0; i < myData.length; i++) {
iterator(myData[i]);
}
}

if myData were an Object, the doEach function might look like:

protected override function doEach(iterator:Function) {
for (var a in myData) {
iterator(myData[a]);
}
}

The JSEnumerable class also includes the following methods:

public function all(iterator:Function):Boolean
true if all items match the conditions in the block, false otherwise.

public function any(iterator:Function):Boolean
true if any items match the conditions in the block, false otherwise.

public function collect(iterator:Function):Array
iterates over the items and returns a new array according to the code in the block.

public function detect(iterator:Function):Boolean
returns the item if the block conditions are true, false otherwise.

public function findAll(iterator:Function):Array
returns an array of all items that match the block conditions

public function grep(pattern:RegExp, iterator:Function):Array
returns the item if the pattern matches the string representation of the item. the item must have a toString() method to produce a result.

public function inc(object):Boolean
true if the object matches an item, false otherwise.

public function max(iterator:Function):*
returns the maximum value as determined by the block

public function min(iterator:Function):*
returns the minimum value as determined by the block

public function reject(iterator:Function):Array
returns an array of all items that DON'T match the block conditions

As far as JumpShip goes, future versions of the JSDataModel and JSDataRecord will extend this class and all the above functions will be available.

2007-09-02T19:45:00.000-07:00

JumpShip for AS3 Released!!!
After an exhaustive port. the AS3 version of JumpShip has been released! The principals differ little from the original AS2 version of JumpShip so there should be very few migration issues (hopefully).

While undergoing the migration I have had a few epiphanies about how to better implement the JumpShip Framework for AS3 / Flex / AIR and the coming months will be devoted to exploring those possibilities. Honestly, most of the room for improvement is on the Ruby on Rails end of the Rails gateway to put in more in line with the REST movement happening over there.

So there are a lot of things on my plate but help from anybody who may be interested is always welcome.

Jamie Scanlon

JumpShip for AS2 Released.
JumpShip, the original AS2 version, has been updated with a major release. It includes several bug fixes to the Ruby on Rails gateway, and a glaring implementation error in the JSDataModel. There are also bug fixes in the JSLayoutManager Class in the extras package.

Since we are all moving rapidly to AS3 I cannot promise that the AS2 version will be updated for much longer. Brave AS2 diehards are welcome to pick up this project where I leave off.

AS3 Version... Really Soon.

2007-07-29T19:35:00.000-07:00

I have basically finised porting the Jumpship Core and Rails code over to AS3. I just need to do do a little more beta testing to make sure it's working. If anybody wants to help beta test, just email me, I'll send you the latest code.

I really should release another update to JumpShip for AS2 also... It's done but I was waiting to reslease JS2 & JS3 at the same time.

Jamie

2007-07-09T20:51:00.000-07:00

Update coming soon! the Rails package and the JSLayoutManager are soon to be updated. I found a few bugs and made a few improvements.

I see the JSLayoutManager class as being really key to the project that I'm working on. I want to build it out so that it can be the base class for a user page layout app. I want to be able to let the users place display elements in absolute or relative positions.

2007-05-16T17:35:00.000-07:00

This is a forum for the JumpShip Framework, an MVC ActionScript Framework developed by Jaime Scanlon and JSStudios. This Blog is very lame, I know, but I'm n the process of acquiring a server to host a blog, and I just wanted to reserve this namespace on blogger. PLEASE feel free to post comments or join our mailing list Here for fuller discussion.