When you put a readme file into a folder that file is formatted and presented nicely through GitHub’s file browser. For example:

https://github.com/visionmedia/uikit

Scrolling down a little we can see a nicely formatted readme file.

GitHub strongly recommends adding a readme file to the root of your repository, but what I didn’t realise until recently was that it works for any folder in your repo. GitHub already has the best online file browser out there, but this specific feature can turn your source tree into your documentation.

For Robotlegs 2 I decided to try it out:

Async
MessageDispatcher
Extensions

Almost every package in the entire repo has a readme file. The best way to learn about Robotlegs 2 is to browse the source and readme files on GitHub.

http://oreilly.com/catalog/0636920021216

Written by the amazing @stray_and_ruby and @jhooks

If you want to try it out, you can download this zip-ball:

git-prompt.zip

Unpack that into your User folder, and add this to your bash .profile:

# Git Prompt - Modified from: http://volnitsky.com/project/git-prompt/
[[ $- == *i* ]] && . ~/git-prompt/git-prompt.sh

Tip: You can open your .profile from your terminal like so:

open ~/.profile

Note: You will need to start a new shell session after editing that file in order to see the changes.

I use Nano as my default bash text editor. If you want that, add this to your .profile:

# Use the nano text editor
export EDITOR="nano"

And for the Terminal.app style:

Power-User-Pro.terminal.zip

The shell commands (copy-paste):

mkdir Test
cd Test/
git init
touch somefile
git add somefile
git commit -m "commit message"
echo "hi" > somefile
git add somefile
git commit -m "second commit"
git checkout -b temp
echo "hello" > somefile
git add .
git commit -m "3rd commit"

• RobotLegs Image Gallery Demo
• RobotLegs and FlexUnit 4

I’ve also pushed out quite a couple of framework updates (currently at v0.6):

• Mediator onRegisterComplete hook -> onRegister (for those coming from PureMVC)
• Spring ActionScript adapters (as an alternative to SmartyPants-IOC)
• Namespace changed to org.robotlegs.*
• Logging now uses as3commons-logging

That last change means that RobotLegs is now dependent on the AS3 Commons logging library. It also means that RobotLegs logging is now standard, and can be easily configured or turned off. Try it out with the PowerFlasher SOS Max tool.

Module Demo

I’ve started putting together another Flex example, called the Acme Widget Factory, which can be found here:

RobotLegs Demos on GitHub

The demo is a little convoluted, but exists to illustrate a couple of things:

• Working with Flex Modules
• Communicating between Contexts via Interfaces and Events
• An alternative to Named Proxies

The demo only works with the Spring ActionScript adapters for now – due to what I believe to be a bug in SmartyPants (but I haven’t had time to build isolated tests to prove this).

The Module side of things needs a little more thought, but I think it is fairly clean and usable for the time being.

Review

As Joel mentions in one of his posts, RobotLegs hasn’t had much peer review. This is very true, and needs to be remedied (besides, I’m DYING for some technical feedback!). I have some theories as to why this is:

1. Some developers really dislike PureMVC (probably for many of the same reasons that I started RobotLegs in the first place) and so have disregarded RobotLegs because it can be viewed as a rebuild of PureMVC.
2. Many Flex developers who work on large enterprise applications seem to dislike the idea of using 3rd party Architectural Frameworks, preferring to hand-roll their own solutions on a per-project basis.
3. Dependency Injection sounds complicated to developers who are new to the pattern.
4. Many intermediate Flash developers have only just started getting into PureMVC. It will take some time for them to fully understand it’s strengths and weaknesses.
5. Experienced developers, on the other hand, are probably bored of the whole “Architectural Framework” trip, and are tired of trying out new frameworks. By now they’ve picked their favorite, learned how to be really productive with it, and have built code-generators and other such tools to work around the bad/boring parts of their chosen framework.
6. Setter injection turns some people off.. which it shouldn’t.
7. I’m not very “connected” in the developer circles. RobotLegs is my first Open Source project, and is the first time I’ve really put myself “out there”. I don’t have a very impressive online portfolio – the portfolio pieces on my blog are mostly just the small things (often built for friends) that I’m allowed to list publicly.

If you are an experienced Flash/Flex developer, and can bring yourself to review yet another framework, I would love to get some technical feedback on RobotLegs as a framework. Harsh criticism welcome.

And remember, RobotLegs is on GitHub – if you like some of it, but want to change other bits, all you have to do is click that little “fork” button and go crazy. Git For The Win!

First thought: version 2 is exactly what I’ve been trying to build with RobotLegs.

I’ve only briefly skimmed through the manual, but it really looks promising. I have some initial concerns (the use of Static methods for example; see: http://misko.hevery.com/2008/12/15/static-methods-are-death-to-testability/), but need more time to play around properly.

The forum pointed me to these two handy example projects:

http://www.sitronnier.com/blog/parsley-2-basic-flex-example
http://www.sitronnier.com/blog/parsley-2-basic-flash-example

Find them on the forum here:

http://www.spicefactory.org/forum/viewtopic.php?t=247

All the Spice:

http://www.spicefactory.org/

The First Stab

Here’s my initial attempt:

Mac OS X Eclipse Logo 256x256 on Black

I’m not entirely satisfied with it, but it’s a start. Here’s how it looks in my dock:

You can download the Icon (and it’s “source”) here:

Mac Eclipse Icon Pack

If you know of any cool Eclipse icons please leave a comment below. Thanks!

From here…

Pimp My Eclipse by Lee Brimelow

Update: My Terminal Icon

Well, you might enjoy RobotLegs AS3: yet another lightweight micro-architecture for Rich Internet Applications.

It’s got the bits that I like about PureMVC (Mediators, Commands and Proxies) without any of the bits that I’m not so fond of (Service Locator, Singletons, casting casting casting!).

I’ve put the source up on GitHub, so feel free to Fork it and make it better:

http://github.com/robotlegs/robotlegs-framework

Discussion Group:

http://groups.google.com/group/robotlegs

Here’s a little demo:
(Please note: the API and usage has cleaned up a lot since this demo was built)

You can also view the demo here (with view source).

The demo app is perhaps not so great, but it demonstrates many of the framework’s features. AND, there isn’t a single cast in there! No actor casting, no payload casting, not any casting, not even for fun!

I have much to say about this little framework, but it’s the wrong side of 5am and I’ve had a crazy long day. In the meantime, you can find some background info here and here if you’re interested.

Update: RobotLegs Lives!

http://code.google.com/p/smartypants-ioc/

I guess that means that it’s time for me to release RobotLegs – an MVCS micro-architecture for Rich Internet Applications inspired by PureMVC, Mate and Swiz! But first, I have to write a little demo application for it.. coming soon!

I’ve recently switched from using SVN to using Git as my source control management tool of choice. It took a little while to get to grips with, but it rocks!

Git is not an evolution of SVN. It is entirely different. Git is a distributed revision control system – everybody working on a project has their own full copy of the repository and its entire history.

Git does not require the presence of a network connection: most commands in Git operate locally, allowing you to review your project history, make branches and tags, merge changes, but most importantly, allowing you to commit while offline.

If you’ve used SVN you’ve probably noticed the littering of .svn folders across your entire project tree, requiring the need for an export tool to retrieve clean copies of your code, and introducing problems when you delete, rename or move files or folders in your project. Git takes a slightly more sensible approach: it creates one folder (named .git) in the root folder of your project.

Git Concepts

With Git there are 3 important things to be aware of: the Git object database, the “index”, and your working area.

The Git object database contains a bunch of stuff that you typically don’t need to worry about. Essentially it’s the repository.

Your working area is the collection of files currently sitting in your project folder. You should treat these files as if they are temporary – because they are! Things you want to keep should be committed to the repository.

The Index is sometimes referred to as the Staging Area. It’s a list of what will get stored on your next commit. Conceptually it sits between your working files and the Git object database. Files that haven’t been staged to the index will be ignored when doing a commit. This gives you great control over what gets committed when.

A branch is a cheap copy of a particular state of the Git object database. Branches are easy to create and switch between, giving you a safe way to try out ideas quickly and easily. Switching to another branch updates your working area to reflect the state of that branch – this is why you should consider your working area temporary.

Installing Git on Mac OS X

Grab and install the latest OS-X Installer from:

http://code.google.com/p/git-osx-installer/

Configuring Git

You need to tell Git who you are – it uses this information for your commits etc.

Fire up your terminal, and type:

git config --global user.name "Your Name"
git config --global user.email your@email.com

Using Git

Once Git is installed on your system, creating a Git repository is easy: open your terminal, cd into the root folder of your project, and type: git init

That’s pretty much it!

After initialising your Git repository, it will most likely be empty. In order to commit files to the repository you first need to “stage” them by adding them to the index. To add all the files in your current project to the index type:

git add .

To commit these files type:

git commit -m "your commit message"

To view the status of your repository type:

git status

To Summarise

[Download and install Git]
[cd into the root of your project]

git init
ls -la
git status
git add .
git status
git commit -m "a useful commit message"
git status

[change some files in your working area]

git status
git diff
git commit -a -m "commit message. -a adds all files from your working area to the index"
git status

[delete some files from your local working area]

git status
git add -u
git commit -m "commit message. -u adds deleted files to the index"
git status

Ignoring Files

You will probably want to ensure than certain files don’t ever get committed to the repo:

http://www.kernel.org/pub/software/scm/git/docs/gitignore.html

Extra Configuration

You can enabled colorful output:

git config --global color.diff auto
git config --global color.status auto
git config --global color.branch auto

Some Bundled Visual Tools

gitk
git gui

Git Screencasts

http://gitcasts.com/

Installing Git on Windows

http://gitcasts.com/posts/git-on-windows

Some Other Git Links

• http://git-scm.com/
• http://www.eecs.harvard.edu/~cduan/technical/git/
• http://git.or.cz/index.html
• http://git.or.cz/course/svn.html
• http://git.or.cz/gitwiki/GitFaq
• http://learn.github.com/
• http://code.google.com/p/git-osx-installer/
• http://www.kernel.org/pub/software/scm/git/docs/user-manual.html
• http://tomayko.com/writings/the-thing-about-git
• http://video.google.com/videoplay?docid=-3999952944619245780

Eclipse Integration

Point your eclipse update manager to: http://www.jgit.org/update-site

More info: http://www.jgit.org/

Some Commands

Add all working files to the index:

git add .

Add deleted files to the index:

git add -u

Create and switch to a new branch:

git checkout -b newbranchname

Review last commit:

git show
git show --stat
git show --name -status
git show HEAD

Review commit history:

git log
git log tag..branch
git log -10
git log --since="May 1" --until="June 1"
git log --author=fred
git log -- some/file

Creating branches:

git branch name
git branch name commit

Switching branches:

git checkout name
git checkout -f name

Lately, however, I’ve been building an application for which PureMVC has turned out to be a pretty poor fit. The term that some people have used to describe this kind of application is “Document-Based”.

A benefit of MVC is the ability to easily create multiple Views of the same Model. Document-based is roughly the opposite of that: the ability to create identical Views of different data. Think OS X Finder (or Windows Explorer if you must!): multiple windows that look and function the same but show different parts of your filesystem.

I spend a lot of my time trying to learn as much as possible about programming. This means subscribing to a huge number of feeds and bookmarking obsessively! Looking for solutions to my current problem I re-discovered Mate. I hadn’t looked too deeply into it before as I needed an ActionScript Framework that wasn’t bound to the Flex Framework (ruling out pretty much every framework except for PureMVC). This time however, I didn’t mind binding(!) myself to Flex.

Central to Mate is the concept of an Event Map. UI components dispatch events that bubble up the display list and get caught by one or more Event Maps: loosely coupled goodness. Mate also employs Dependency Injection instead of the Service/Model Locator pattern used by Cairngorm and PureMVC. And no Singletons! Suitably impressed.

I highly recommend you check out Mate, and if I were you I’d do it in this order:

• Mate Presentation by Laura Arguello: fairly long, and a bit slow, but quite fun and covers some really important concepts – not just for Mate, but application architecture in general
• Hello Mate by Neil Webb
• Mate Overview
• Mate Document-Based Example by Theo Hultberg/Iconara: lots of great info

Ok, time for me to calculate how painful it’s going to be to switch my application over to Mate.

UPDATE: I posted my thoughts (as best as I could gather them) on the PureMVC forum here:

http://forums.puremvc.org/index.php?topic=1000.0

UPDATE: I decided not to switch to Mate for my current project. I wrote a little MVC framework (much like PureMVC), that uses Dependency Injection, and switched to that instead. More here:

http://shaun.boyblack.co.za/blog/2009/02/24/pijinnet-v3-progress-update-24-feb-2009/
http://shaun.boyblack.co.za/blog/2009/03/13/as3-dependency-injection-and-autowire/

MAJOR UPDATE: RobotLegs 0.1, with demo Flex app, has been released. More info here:

http://shaun.boyblack.co.za/blog/2009/04/16/robotlegs-an-as3-mvcs-framework-for-flash-and-flex-applications-inspired-by-puremvc/