Archive for the '9m' Category

Seth’s 360|Flex Recap

Brian and Seth's trip to 360|Flex. (filler at the end shot this winter at A-Basin, CO)

My first 360|Flex was awesome. It was full of Flex rock stars. Not hard to imagine, I left knowing more than when I had arrived. The best part of the conference for me was participating in the charity Flex Code Jam where we built a Warm Meal Finder application. The app enables (not necessarily homeless) people to search by zipcode to retrieve a map and directions to locations of warm meals in the San Jose area. This app will run on the Second Harvest website as well as locations like libraries and perhaps as a kiosk.

Here's a quick recap of the sessions I attended.

Day 0 - Preconference:
Ribbit. Ribbit is awesome in that they're inspiring new ideas. Some of the new features for their 2.5 release include conference calling, call forwarding, and iTunes-like "app store" called Amphibian, which will allow Ribbit developers to sell apps.

Day 1
Following Adobe's keynote, I jumped in to learn about Merapi. Merapi is pretty cool. It's an AIR to Java bridge. It provides more access to low level hardware on a users machine. Their best example was an app that accessed a machine's accelerometer. It displayed graphics which tumbled to the tilt of the user's machine (see Adam Flater in my video above). Also cool was a bluetooth-controlled Legobot that was controlled by an AIR interface. This was presented by Jordon Snyder.

Mate framework. Laura Arguello's presentation was really well executed. Mate (pronounced like the Maté) uses an EventMap mxml class which provides a quick and easy hook for setting up services and handlers. Its tag based format promotes simplicity and good model/view separation. I'm still concerned with using it on larger projects but we did use it for the Flex Code Jam, and it worked well.Here's the Flex Code Jam code.

Creating reusable components. Ben Clinkenbeard is super smart and provided some good tips, though his presentation ended with about 45 minutes short. Some good tips: Make things easy for other developers. Expose things the framework doesn't. Add default behavior to your components, otherwise it makes more work for those using it. Default behavior can have a flag isDefaultPrevented flag to determine if default behavior was overwritten. He also recommended providing default styles and using selector.defaultFactory rather than selector.setStyle to set default style.

With my additional time from Ben's presentation, I jumped into the Swiz Framework presentation by Chris Scott. It is an inversion of Control MVC framework. I'm definitely curious and would really like to learn more.

I finished the first day of presentations by attending Andy Powell's introduction to Blaze and LCDS. It was a great overview of how Blaze and LCDS compare and contrast. It was also a good starting point for Brian's presentation the following day.

Following the presentation, I joined the Flex Code Jam project and kicked it off Scrumtastic style!

Day 2
Ben Stucki's How to Build a Framework presentation was inspiring. Where does he find the time to make so many useful frameworks? It wasn't a discussion about specific frameworks but rather tidbits of insight he's learned along the way.

"beautiful code represents an idea and the underlying logic exists only to support that idea..."

Stucki also provided simple reminders like a class should do one thing only. He defined simplicity as being achieved through refactoring in two common ways. Seperation - refactor one class into two, and Singularity - combining things together. Always start with interfaces and if you only reference interfaces, you'll come up with a pretty good architecture.

Then I caught SQLite Performance by H. Paul Robertson.
His knowledge on the subject was quite helpful. Here I learned that one should encapsulate sqlStatements instead of reusing them. ie, it's less expensive to store query statements in a Pool than to reuse and rewrite them - hope that makes sense. He also recommended using transactions for batch insert/update/delete - This takes a snapshot of your change and writes it into memory first. Then it sends the completed batch to SQLite. Use indexes but use them wisely. Additional resources he provided include: - uses a vo. Jacob Wright's active-record: and - which uses pools.

Finally, I attended Brian's presentation on Real Time, Collaborative applications. My opinion may be biased, but he did a stellar job. He kept it interesting by showing real world examples, which I think really helped people understand what one can do with a real time application. Examples of projects built on both LCDS and Blaze DS were shown. He also showed a good tour of server side Java code as well as front end Flex code. Go and watch his presentation on Adobe Media Player.

Day 2 didn't end there though. Actually it never really ended. Not long after Brian's presentation we were back in the Flex Code Jam. We had a good Scrum and basically started coding...until 4am. It was good fun, working with new people and apparently Adobe is making a documentary about it!

Day 3, or rather, after three hours of sleep, we were back at eBay for the final keynote. Tom and John announced conference numbers, and revealed that they finally made profit, congrats! A few silly chachkes gifts to each other later, and then they brought Ali, the organizer of Flex Code Jam, to the stage. Ali, who I don't think slept at all, presented our application with great pleasure to one of the Directors from San Jose area's Second Harvest. The app was flawless, and it honestly was a feel-good moment.

Following keynote, I attended one of the best presentations, in my opinion, Renaun Erickson's presentation on Test Driven Development. We've been looking for a good solution to unit test for Flex, his RIALogger could be the one. It seemed simple and easy to understand. I learned that TDD is more of a work philosophy than just a tool by requiring you to write your tests before writing code, it forces you to think in terms of usage rather than methods. Now I just need to start doing it. :)

I then attended Jun Heider's presentation on the Flex 3 profiler. The profiler is something I also need to use more of. Although my own concentration was diminishing from sleep deprivation, Jun showed the important parts of using the profiler to test performance and memory usage.

Following a nap next to eBay's koi pond, I finished 360|Flex by listening to Eric Ko discuss reflective programming. Honestly, I saw what he was doing, but I couldn't understand it's real world use.

So that's it. If you read this far, thanks! Now get back to work!


Why We Scrum

In the past years I've worked on numerous Flash projects with various teams. While I have witnessed enjoyable and even successful results from sheer creativity and enthusiasm for the medium, I have seen a limit to the amount of complexity that can be handled without a good process in place.

When I joined 9mmedia two summers ago I found a team who had already been investigating and experimenting with their process. It was around the time Flex 2 came out. Our team's efficiency has been ever increasing and we soon found out the natural interaction within our team and with our project goals had a name: Scrum.

When you have the mandate of creating a piece of software you are given a set of high level goals for a product that has yet to see the light. Experience will tell you there is no way to plan all the functionalities and underlying details of a good application because to be called good, an application needs to have been tested and improved. And until functionality exists, it cannot be tested. "Planning ahead" has its limitations and doing Scrum means being aware of these limitations.

At the beginning of a project, an inclusive to-do list is written with no particular order or specifics but with just enough detail to convey the goals of the project. That big list, called the Product Backlog, is then reviewed and prioritized. The most critical tasks are moved to a smaller list, called a sprint, so they can be executed first. Once the first sprint is completed, the remaining items on the Product Backlog are re-prioritized and the new top priorities are moved to a new list through which the team sprints again. This continues until the product is delivered. The duration of our sprints is usually 1 month. Daily 10 minutes meetings are performed to make sure the team's resources are always best allocated and to let everyone interact directly and get on the same page.

In our projects, nearly every feature involves actionscript coding, service architecture, usability and graphic design. While Java services may pass unit tests, custom Flex components may function perfectly and comps may look great on their own, the need for integration is omnipresent. Scrum allows us to arrange our sprints to timely bring these elements together with a minimum of time wasted. To kick off development we use a lot of default Flex components, create more basic services allowing the core functionalities of the application come to life more quickly.

Having a testable product from an early stage is invaluable. It empowers us with knowledge that constantly improves our decisions about when and how to start working on custom components, expand our service APIs and tweak our graphics. Add to that the constant and early catching of bugs, tight team collaboration, complete project management transparency, real priority driven workload, and the confidence our team is always firing on all cylinders and you will understand why we scrum.

Synchcronicity project from sprint to sprint


High Altitude Coding

9m has taken a hiatus from the hustle and bustle (and smog) of NYC this month. We traded it for 5 weeks in Breckenridge, Colorado, trying to find the perfect balance of snowboarding, coding, and skiing. While not all of us are experienced boarders or skiers, I think it's pretty safe to say we've all been having a pretty kickass time out here.

Normally this late in the year Breckenridge would have significantly less snow than is currently piled up in our front yard, but lucky us, we're getting plenty of late season days on the mountain. But on the days that we happened not to have a foot of fresh powder, we managed to get some work done.

I've been spending some time out here working with Flex Charting. Being my first time even looking at charting, I was expecting something a little more difficult than I found. Seems that all chart types extend CartesianChart which can handle displaying any ArrayCollection of data. Here is an example of a basic chart that takes a small XML dataProvider and displays it in an AreaChart. I modified it to display blank labels on the horizontal axis instead of displaying the year by setting the labelFunction for the LinearAxis to blankLabelFunction.

The difficulty in what we are aiming to do with our charts, is that we need to add the ability to pan and zoom on the charts we display. So to avoid creating something that's already been done, I went looking for some scrollable, zoomable flex charts. And this is what I found:

Joel May over at has created a series of customizable scrolling charts in his blog post Big Data Scrolling Flex Charts. He shows a way to display scrollbars on a chart as well as a way to zoom in on large amounts of data.

Another good resource to check out is the Chart Sampler app over at Quietly Scheming. It's got a good variety of chart types, series, styles, and effects. While not exactly what I was looking for, it showcases tons of ways to use what's already built into charting. Also from Quietly Scheming is the Interactive Bubble Chart which includes some cool dragging and panning, but also a somewhat awkward mechanism for zooming.

Needless to say, I didn't find exactly what I was looking for. But these charting examples do serve up some good inspiration. Not that spending a month surrounded by the tranquility and beauty of snowy mountains isn't inspiration enough in itself...