TwinTechs

I recently had the opportunity to integrate the Adobe Flash Collaboration Service, also known as AFCS, with another application.  For those of you that don’t know, AFCS is a hosted Adobe service that gives Flex developers the ability to easily add real-time social capabilities directly into an application.

Getting Started:

Although it’s still in Beta, the product team at Adobe has done a great job with documentation and has released a slew of sample applications. Setting up an initial “Hello World” AFCS project with webcam, text chat, and a white board support can be done in less than an hour. The Adobe “Hello World” code sample is here.

Getting Down and Dirty:

As we all know, sample applications always work perfectly. But if you are trying to do something a little off piste…  well… many times, things can get a bit dicey.  Our application’s requirements resulted in us extending the base AFCS functionality a fair amount.   These extensions can be summed up into two distinct groups:

1. Storage of additional data in AFCS.
2. Enhancements/additions to the current AFCS components (pods).

Storing additional data in AFCS

Luckily, storing additional data in AFCS is easy.   AFCS has a three-deep level data hierarchy,  including:

1. Collection Node: The highest level.  Collection Nodes wrap up functionality stored in components/pods and consist of a collection of nodes.
2. Node: Second Level.   These generally wrap up functionality to a certain section, e.g. a history of a chat window and consist of a collection of message items.
3. Message Item: Lowest level.  Message Item’s support both primitives and simple objects.

In addition, there is a whole bunch of additional goodness relating to all of these data structures including private messaging, session management, and user management.  Also, there is a rather extensive security model that allows you define read/write permissions at a granular level.

Retrieving data and notifying clients of data changes was very easy and the Nodes operated in much the same way as Shared Objects do in Flash Media Player. There were events notifying clients of both data changes as well as synchronization with the server.

I did find a couple of downsides with the data model. Creating a collection node requires owner permissions and  this ended up being a problem as our application had clients trying to dynamically add instances of pods. In addition, the data model is not N deep. This could be troublesome with some data sets, i.e. you want to store the data in nodes as a BST.

Extending AFCS Components

Extending the base components, while not particularly hard, is a little time consuming and does force a developer to get his hands dirty. Fortunately, the developers at Adobe followed some coding rigor and separated most of the pods into two components, model and view. Thus, if you only have to change the L&F of a component and not necessarily its underlying functionality, you can get away with just extending the view component.

In our case, we had to update both the model and the view components. This resulted in reading and understanding the individual components and updating them as necessary.

In hindsight, it might have been prudent to just write our own components.  Once you are comfortable with the API and its functionality, it is easy enough to write your own custom components and interface with AFCS.

Final Thoughts:

Overall, I was very impressed with AFCS and I think it has potential.  The ability to generate an application that gives you chat, webcam, and whiteboard functionality instantly is great. In addition, being able to develop Flex components without the fuss of configuring and installing (not to mention developing!) an app server is a huge plus. Recommendation to Adobe: a desktop sharing component would make this a killer service.

CEO Ben Elmore’s second installment of his four part series on building a a Flex Team was recently featured in InsideRIA.  Read it here!

In our last post, I made the case for building out a Flex team and debunked the current misconceptions surrounding why companies choose not to: that the resources are too scarce, it’s too expensive, and you need a team of experts. With those roadblocks eliminated, the next step is to determine who you need and how to identify them. That’s what we’re going to address here.

Understanding Your Needs
It’s imperative to identify what your requirements are and the number of resources that you’ll need to address them. You must determine what your team needs to accomplish before you begin to assemble it, otherwise you risk redundancy, inefficiency, and slowed or stalled projects. It sounds elementary, but this step can save you a lot of headaches later on. Ask yourself these questions:

What is the size of the application(s) that you need built? You need to know this to decide the size of your team.

Are you building or augmenting your team? If you’re building, a senior resource along with two mid-level resources is ideal. If you’re augmenting, your decision will be based on the amount of work to be done.

Do you have time to train resources? If you do, consider hiring junior resources to pair with a senior resource who can provide mentoring and oversight.

How large and complex is your target application? This question will help you focus the size and needs of your team in direct relation to the duration of the project.

I want to emphasize a couple salient points about building your team. You likely don’t need a huge team (our experience has been that 3-5 resources are sufficient for most projects), nor must that team be comprised of experts with years of experience under their belts. We’ve found that mixed teams of junior and senior level resources are the most productive.

That said, there are times when experience does matter, which returns to my point about clearly delineating the task at hand before you select resources. The key is to realize that while you’ll need an expert to accomplish certain complex tasks like performance profiling an application for scaling or custom visualization, their skill set isn’t typically necessary throughout the entire project.

Here’s a handy categorization:

• Expert: min 2+ years experience with Flex. Built and produced highly available and/or interactive Flex application. Unique understanding of specific part(s) of Flex related to complex domain problem to solve. Not typically someone who will lead or grow a team.

 

• Senior: min 2+ years experience with Flex. Been on teams before, led a project, solid grasp of MXML and AS. Understands Flex in context of product life cycle. If ‘Designer’ then custom components and look/feel. Min 2 other languages. Performance best practices on Flex. Implemented min 2 Flex projects.

 

 

• Mid: 6m – 2yr working with Flex. Been on a team before, good grasp of MXML and AS languages. Has some understanding of performance related issues to actions.
• Junior: 0 – 6 months: One other language, preferably scripting language. Has been through training and/or read and walked through good Flex book.

The Hiring Process
The hiring process has three components: identification, qualification, and on boarding. The first step is to make a list of how many resources you want to hire at which level of experience (expert, senior, mid and junior), and what skill set is needed (architect, designer, developer). The next thing to do is to locate them. You can use personal referrals, Monster, or similar sites, user group manager/lists, or a corporate recruiter.

Once a candidate has applied there are some specific things I look for on the resume. The most important thing for me is that the languages listed on their resume are consistent, complimentary, and parallel to Flex. If I need a Flex designer, I look for Flash, CSS, JavaScript, or other visually expressive languages; if I need a core Flex developer, I look for programming languages like Java, Ruby, .NET, JavaScript or CF. I’m looking for consistency here. Too much variety is often an indication of lack of focus.

I also look at experience with Flex itself: the length of time working with it and whether it was used peripherally or as a project core. I want to ascertain how they became exposed to the language to understand how they’ll think when working with Flex If I am looking for a senior level developer or architect I look at frameworks, patterns, and methodologies listed on their resume.

The last things I look for are soft skills and overall work experience. I look for both variety and stability here. Were past jobs remote, on-site, or both? Also, speaking or writing engagements are a good indication of a potential team mentor.

Once you’ve found an applicant that you believe matches the criteria you’ve established, it’s time to move on to the interview. This is the “qualifying” component of the hiring process and, arguably, the most important. The interview is generally where the decision to hire is made, and this decision is critical. You need to hire the right people at the right time and understand that mistakes made here could potentially doom a project. Although that sounds scary, knowing what skills resources need and how to identify them will help you make the most informed choice and that’s what we’ll discuss in our next post.

User Design Expert Will Evans was elected to the Information Architecture Institute today. His term will last three years, and he’ll be responsible for developing and leading initiatives that provide networking opportunities for information architects, education and mentoring, and driving awareness around the evolution of user experience and design.

Will has been a member of the Information Architecture Institute for years, but this is the first time he’s been elected to the board. He’s a frequent guest and popular speaker at IA conferences. Will serves as Twin Technologies’ Director of User Experience, providing visionary creativity and guidance for clients that are interested in redefining how users experience their brand online. Will’s designs explore how people engage on and off-line, which tools act as the right catalysts for online engagement, and what factors contribute to social traction.

The IA Institute is a professional organization dedicated to advancing the state of information architecture through research, education, advocacy and community service.  IA Institute sponsors the IDEA conference each year, that explores the convergence of experience design with social and user experiences, and the growing importance of aligning expectations.

Congratulations, Will!

Twin Technologies was selected as the Adobe Solution Partner award winner for Q2 2009.   Twin Technologies was chosen for the family-friendly web portal we created for ZapMyTV. Using the streaming media functionality of Adobe Flash—along with the agile development and deployment of Adobe Flex, ColdFusion, and LiveCycle Data Services ES—Twin Technologies built an elegant media platform for ZapMyTV from the ground up. The Zap platform will provide live streaming cable television across the internet to any streaming device and integrate it with elements of social media, allowing viewers to extend their television experience with text and video chat, shared remote control, and the opportunity to view TV together in real time.

The Solution Partner Recognition benefit was created to highlight the successes and significant impact and contributions Solution Partners make on Adobe users, prospects, and customers around the world.  The Adobe Partner team, along with a selection committee comprised of Adobe Executives, Business Unit Managers, Sales, Program and Partner managers determine the winners based on all applications received from qualifying partners.

Boston.com featured Twin Technologies Customer Paragon Lake in a recent article covering the start-up trend toward developing software solutions that allow retailers to customize apparel and jewelry for customers.  These services are aimed at consumer base who is comfortable purchasing made-to-order items online.

Paragon Lake enlisted Twin to help them create a Virtual Display Case, an online jewelry platform, so customers could help choose, design, and view their selections online before they buy them.  These reduces the amount of inventory retailers need to keep on hand, allows customers to choose and see exactly what they are ordering, and improves the manufacturing process by organizing the workflow between artists and designers.

Twin Technologies’ start-up assistance program gives companies like Paragon Lake technical and business consulting expertise so they can get products to market quickly and start making money.   For Paragon Lake, the Virtual Display Case makes them more agile than traditional retailers, which potentially gives them an edge in a sluggish economy.

Twin Technologies’ Gus Holcomb spoke at the first ever InsideRIA conference this week in San Francisco.  Java engineers interested in learning how to program iPhone apps came to hear his presentation.  

Gus says people are often intimidated by programming for the iPhone  because the language is weird and while there are a number of tools you can use, selecting the right one for what you want to do can be tricky.  Gus talked about what makes the iPhone  language different,  the language features you need to know about.  By using the right tools, what might initially look daunting, gets a lot easier when you look at how to link objects together.  

Gus showed two code examples… enough to get people to get out and start working on it, so they knew enough to start getting their programs out.   Since the audience was already fluent in Java, Gus used Java to prove concepts that appear tricky on the surface so he could relate them to familiar material.  

Look for Gus’ lunch and learn on iPhone development coming this fall!

Design Patterns have always made me bristle a little bit.  Maybe it’s just my inner contrariness but I believe that each problem has it’s nuances and that too much faith in Pattern will make you graft simple pre-made solutions on to complex real-life problems.  I’ve always felt that it’s necessary to know the patterns, to have them in your tool-belt as a starting point for ideas, but that to be insistent about, or dependent on, the Design Pattern, confuses Pattern with Solution; the Starting point with  the Finish line.

Sadly, I am not so articulate as this guy when it comes to this issue: http://blog.plover.com/2006/09/11/

On the face of it, his claim is that Design Patterns represent “signposts to the failures of the programming language”.

I think his larger claim is about the evolution of languages; that each language should be looked at as just the middle ground on a long uphill climb toward more expressive power, and that each Pattern codifies the frustrations of the programmers using it to do these often-needed things.  To drive innovation, he would say, one should always be looking for ways to take Design Patterns and co-opt their power by making them invisible.

I couldn’t agree more.

And the corollary of course is that Design Patterns should be bristled at, used grudgingly, and as the starting point for discussion.  Another way to say it might be, compliance with a Design Pattern is not a very good measure of Quality.

One of the most important tasks that an engineer or architect is asked to do is evaluate the quality of a potential design.

I’d like to present here an informal framework for reasoning about what makes a good design.  I think these rules apply to all human-facing products: software, architecture, etc.

So, without further ado, I think the rule for good design is: taking something non-trivial, and providing a trivial user interface.

This applies not only to software, but the design of anything useful.

Take for an example, a bridge.  Given the non-trivial task of getting something heavy (that doesn’t float) across a river, a bridge provides a trivial interface.

To better formalize this, I propose the following formula, the Quality Quotient:

Q = 1 – (triviality of new interface / triviality of old interface)

For simplicity’s sake, I will use a scale of 1-10, where 1 is very easy, and 10 is very hard.

In the bridge example, if you are on one shore in a heavy truck, and need to get to the other side and have no bridge, I’d call that a 10.

With a bridge in place, the use case is as trivial as it gets: keep moving forward. I give that a 1 on the scale of Moving Things Around.

So, Q(bridge) = 1 – (1/10) = .90 = 90% awesome design.

No wonder they have stuck around. It could only get better if somehow we instantly teleported across.

Now, my claim is that the process of making anything complex involves the iterative process of choosing between competing designs for the system as whole, and subsequently for each component. Successfully making something that works and is useful and usable, involves only allowing your self to make choices that score highly.

Another example, this one from the software world.  What makes some code libraries stick, and others fade away?  Take the javascript library jQuery as an example. The initial problem is two fold: dealing with the variations among browsers, and finding a natural way to deal with so much tree-like data in a procedural language. On the scale of software annoyances, I give this problem a 6.  It’s been done several times, so it’s very doable, but you still don’t want to do it yourself.

Jquery takes this non-trivial problem and wraps it up in a safe and simple package where not only are the browser-dependent features smoothed out, but the actual language syntax is flexed to its limit to provide for a more natural way of finding and mapping operations over sets of DOM nodes.  I give it a 2 on my made-up scale… there is maybe room for improvement, as real-life software is always evolving and improving, but they have succeeded in hiding the most cumbersome pieces.

Q(jquery) = 1 – (2/6) = 66% awesome.

If you aren’t using any javascript library, here is a successful one.

This reasoning on many individual levels becomes, on a macro level, the definition of success or failure for a code library, or product.  If you wanted to compete with Jquery you would have to either tackle more complexity (solve a bigger problem), or solve the same problem with a simpler interface, or some combination of the two.

Another example, this time from the mobile world, and this one comes with a prediction (like all good pseudo-science).

The WebKit rendering engine. WebKit is the rendering engine used in the iPhone, Android OS, and the Palm Pre. The problem faced here is one of rendering degenerate HTML into what the author intended, and it is one of the trickiest problems in web software development today.  It’s so hard in fact that no one does it correctly, or even the same, not even WebKit.  On a scale of software challenges, that makes it a 10 in my book.

Because WebKit is open-source and has a rich community and it supports such a broad range of contexts, it’sthe kind of thing that an experienced programmer can get to render html in relatively short order.  Orders of magnitude faster than trying to render it yourself.  But it certainly is not as easy as possible (I think in order to get a 1, you have to be functional with a couple of lines of code), so I give it a 2.

Q(webkit) = 1 – (2/10) = 80% awesome.

My prediction here is that WebKit and other’s ability to render degenerate HTML has crossed the threshold of good enough, and the barriers to success are now more heavily weighted on ease of implementation and flexibility of context.  Since WebKit scores so much higher in these areas than other browser options, I think WebKit is going to become the reference HTML renderer, on mobile platforms and elsewhere.  Probably not an earth-shattering prediction, but there it is.

So far, all our examples have been positive-valued successful examples, but there are two other ranges of scores that are very interesting: near 0, and less than 0.

Scores near zero mean that you are just wasting time.  The Auto Industry is a good example of this:

Cupholders; taking a pretty trivial initial problem, and giving it a trivial solution.  No surprise that few people really care.

Q(Cupholders) = 1 – (1.5/2) = 25%

Vehicle Diagnostic Computers; diagnosing and correcting vehicle components is difficult and nuanced at best, but after a generation of adding expensive maintenance computers, we’ve just shifted the complexity to learning how to operate, diagnose, and correct the diagnostic computers.

Q(Vehicle Diagnostic Computers) = 1 – (8/9) = 11%

From the average consumer point of view, practically nothing has changed in 25 years with regard to getting their car serviced.

The lowest range, less than zero, represents those times when people over-think a problem, or over-engineer solutions.

The early years of the web are a good source of such things.  Take the success of Google, which hinged in large part on their streamlined interface.

The problem a search engine faces is certainly not trivial, and it comes in two parts: specifying what you want, and then finding it.

In 1999, when Google came out, Yahoo and AltaVista were the search engines I remember, and I remember them both looking like this:
Yahoo.com circa 1999

Now, we are looking at just the part of this task where you specify what you want, and Yahoo decided that a Taxonomy of Everything was the best solution.  Their idea was very Renaissance in a way: that they could file everything neatly into these categories, and users would naturally understand the categories they made and use them to find what they want.  But, the last several hundred years have not been kind to this idea that taxonomy alone can tackle complexity.

So, Yahoo starts with a problem that to the user (inside his own head) is quite easy; I know what I want, in some internal language.  So, to me, this is one of the easier things that people do: communicate what they want, once they know.  It’s not the easiest thing in the world, since we mess it up all the time; and Natural Language, while wonderfully nuanced, is often not precise enough.  So, all in all, I give it a 3; not that hard, but sometimes subtle or tricky.

Yahoo takes this problem of getting what I want out of my head, and they decide they are going to try and tease it out of me by asking a whole lot of hierarchical questions: “Is it an Automotive thing you want? An Entertainment thing?  How about one of these Quick Links, maybe they would be Quicker?”.  Once I answer that question, it asks slightly more refined questions, “Is it Dining, or Music related? etc.”  This process, as anyone who remembers the web of 1999, could take hours to find what you want, and you might have to answer hundreds of little questions along the way.

If expressing what you want is a 3, Yahoo gave us a solution that’s a 5; its do-able, in fact it might often succeed, but it is a painful and arduous journey with more missteps available then correct ones.

Q(Yahoo 1999) = 1 – (5/3) = -66%

Now, this doesn’t mean that the world got worse when Yahoo came around, we are only looking at the first half of their problem; and for this one specific facet, they didn’t “bring the machine to me”, they tried to force me to think like a machine, to sub-divide and re-divide the world in a way that is very un-natural.  So they did make this process of identifying what I want harder than it was.

Along comes Google with the absolute simplest interface you could possibly create.  It’s so simple you can even skip the results page. You do the same thing you would always have to do: condense your inner language to relevant Natural Language keywords.  So, Google replaces a 3 with a 3.

Q(Google 1999) = 1 – (3/3) = 0%

You can see where this is going.  Google did not try to solve a bigger problem, they just presented the simplest possible interface to the one at hand.  They let the natural work, that my brain had to do anyway, fall directly out onto the interface.  Now, they can focus on the technologically difficult part, the second part of the problem: actually finding what you want.

You can also see from this how far we have to go. We are stuck in a primitive world of text, with limited keywords, and a poor grasp on the conceptual structure of most problems, except bridge-building.  We got that one down now, only after several millennia of small improvements.

Whenever you are evaluating designs, you must ask yourself these questions: “Am I tackling a non-trivial problem?”, and “Am I providing a trivial interface to that problem?”.  If the balance of these questions is not right, you must bravely return to the drawing board.

Today, according to BusinessWire Twin Technologies’ partner and customer ZapMyTV has signed an agreement with Paramount Digital Entertainment to license content for live streaming broadcast across the Internet.  Under the agreement, viewers will have on demand access to Paramount’s vast library of movies and content.  Zap subscribers only have to access one web site to watch live television, view movies on-demand, search the internet, email, chat, video conference, and blogging. 

Viewers expect more control over their content and flexibility in where it’s consumed and how they share and discuss it.  To offer licensed, live cable TV to any streaming device, combined with social networking, interactive video, text and audio chat together in one place, Zap enlisted Twin Technologies to help create a multi-functional digital platform from the ground up using tools like Adobe Flash, Flex and ColdFusion.  This is the first web-based platform to offer live, fully licensed television over the Internet with picture-in-picture, recording capabilities and the ability to watch what you want, when you want it, wherever you are.

Before ZapMyTV, most TV content available on demand was pre-recorded and encoded into a format for viewing on a computer or mobile device. The few streams that are live are owned and managed by broadcast organizations, so users have to visit mul­tiple web sites for their favorite content.  Moreover, current platforms did not offer options for chatting or social networking with people watching different channels, and many required custom software that was limited by operating systems and browser.

ZapMyTV is currently in an early beta test period. Consumers may sign up for the beta at www.zapmytv.com. The site is currently streaming live cable channels, and at the time of its official public launch plans to have 50-100 channels in addition to Paramount’s theatrical motion picture content.

Zap is lining up additional content providers and studios, so viewers have lots of content to choose from.  This announcement is the first of several key strategic alliances with entertainment companies that ZapMyTV will announce in the near future.

“Twin’s combined expertise in digital media and product manage­ment and development allowed us to get our product up and run­ning quickly,” says Steven Turner CEO of ZapMyTV.

Senior Vice President and Managing Partner Robi Sen launched his blog series, Building Higher Performance RIAs for Smart Phones today on InsideRIA. The series will address the challenges of optimizing software for mobile platforms.

Today’s smart phones are not only used for making calls, taking pictures, and listening to music; now people are using their phones to do business, build presentations, make quick edits to important files, and even surf the web.

Yet contrary to what the commercials would have you believe, few smart phones provide a web experience equivalent even to a netbook. In large part this is because web application developers rarely consider the memory and CPU constraints of smart phones. At the same time, an increasing number of people are using their smart phones as a secondary or even primary method for accessing the web (http://www.theiphoneblog.com/2009/03/02/iphone-mobile-browser-share-67/). This becomes problematic because most websites are slow to download, hard to navigate for mobile users, and, most importantly, often take a long time to render, which is driving more and more mobile users away from the interactivity and power that Rich Internet Applications promise to deliver. The answer to this dilemma is that developers need to create RIAs, generally using AJAX, that are specifically designed and optimized for mobile phone users. In this series of blog posts, we are going to look at how to make applications that are not only rich and powerful, but respond quickly and offer users the experience they have come to expect from the web.

Leveraging its digital media and RIA expertise, Twin Technologies is creating web applications for the mobile platform.  These are optimized for use on mobile devices and offer the  functionality of desktop software and the agility of RIAs so users can access the material they need whenever they need it.