It was a mix of the presentation slides an a live demo of an enterprise application SureLC (an automation of insurance agents’ routines) running on a desktop, Motorola Xoom, and Apple’s iPad shown on the photo above. During the first part of this presentation I was giving a brief overview of today’s mobile landscape and highlighted some issues that any enterprise development shop moving to mobile should consider.

The quality of this audio (61Mb) recording is not perfect, but I hope you may find some of the content useful.

The slides of this presentation can be downloaded here.

Anatole Tartakovsky

Every element of the software I will be showing has to be upgraded from the plain vanilla Flex/BlazeDS/AIR functionality to adjust and match the target audience. The efforts included creation of a brand new sets of controls, mobile devices integration, modifications in communication protocols, PDF/files integration. Everything needs to be consumer-oriented – with touch interface, simple navigation, integration with voice / phone/location services, contacts, etc. And at the same time it should allow repetitive use by an experienced user in the speed of the back-end systems so UI should not stay in a way of productivity. The conventional approach to the user experience fails. Finally, the same application has to be available on all platforms – PCs, Macs, tablets, TVs – to be really accessible by consumers. Its a long journey, and we are not even a half way there.

Let me define this  “pro” in the term prosumer. The term was coined by futurologist Alvin Toffler in 1980,it’s not commonly used today. Loosely, Toffler’s “proactive consumer” prosumers were consumers who were predicted to each become active to help personally improve or design the goods and services of the marketplace, transforming it and their roles as consumers. Basically it is another term of user driven approach, with user feedback as a main driver for new features/streamlined workflow. Simplicity is the king, and the current level of service desk/community driven software makes the whole process both simple and pragmatic.

The most common usage of the term describes the prosumers as enthusiasts who buy products that fall between professional and consumer grade standards in quality, complexity, or functionality. One of my applications (it’s for insurance salesmen) is specifically targeting 250K-1M people that are in that category. I was amazed to find out how many people in banks, investment companies, etc. fall in this category of users.

Finally, the “producing consumer” prosumer creates goods for their own use and also possibly to sell. Wikipedia states it is uncommon usage. I respectfully disagree. At this stage, we all are producing consumers of Google, Amazon and other services. It would be stupid not to capitalize on users experience in our client’s domain field. My post graduate work was on expert systems. I will be showing how AI built upon rule-based expert system for financial services are affected by facts – statistics and field feedback – to produce the results that actually work.

PX is an upgraded, almost a back-office grade software short of administrative and final approval functions allowing users to achieve more of what they want without training with access to a decision making process of the best in business and with amazingly simple interface. As you decide to go down the rabbit hole, more information used to make decision is exposed allowing you either take different turns or ejecting you into different hole. Think of it as a continuous search based process with context that becomes your product – a kind of a shopping cart. Think of the process of buying a new computer when you start with buying a laptop and end up with a server and tablet or vice versa – it’s based on what you really need.

Prosumers are building their world of information, and these networks (unlike the social ones) can become extremely wide-spread and very sophisticated. While Google+ is aiming @ consolidating facebook, tweeter, meetup and linkedin in a better connected net, its search services or verticals are working across all the users, providing much greater value. Capturing the information and applying similar approach becomes the fashion of the day and a foundation of the new business models.

Sincerey,
Anatole Tartakovsky

Here my background story for that. Back in 90s, when PowerBuilder and VisualBasic ruled application development, not a single VB or PB application was “pure” one (ie written only in that language/VM) – they all utilized native C code packaged as DLLs or VBX. Today, AIR provides great UI engine, but all universe of capabilities – quality camera, audio, telephony, notifications, great 3rd party native libraries are out of reach. If I do not use them for the sake of portability – I will loose to applications written for particular platform. During my demo I saw peopled wowed when AIR boundaries disappeared and Android based voice recognition did data entry for the Desktop application. Yes, I know that this will force me to pack the iOS version with the different extensions (when iOS support for Flex comes along in June). I am also waiting on C extensibility toolkit from RIM in May.

So, how does Adobe position itself in reference to integration with the native tools? Air application can be “invoked” from the native Android code, but not the other way around. The only integration approach is mentioned by James Ward, but it is not a part of the RC for Flex 4.5. The availability of Extensibility Toolkit based on that approach promissed, but no date was given. I think support of integration is a matter of survival. The same goes for “remoting” within personal network boundaries? Not supported either. I think it is another gap that Adobe has to fill.

Sincerely,
Anatole Tartakovsky

Our company – Farata Systems – have been working on Flex for mobile technologies for about 16 month now – on IoS and Android. At the conference I presented the View-based application for insurance agents that was written with mobile toolkit. Despite the fact that it was written with mobile toolkit, our application does run in browser, desktop and tablet – all from the same source. We run a small fraction of the app on the phone as well, mostly as a remote assistant to the main application. Here we do high-tech tricks like letting the customer to sign with his finger (or a felt pen), swipe his credit card, speed up data entry via voice recognition etc.

Unfortunately, one can not develop desktop View-based applications out of the box. We had to substantially tweak the components and skins. And I think this shortcoming will hurt success of the Flex, if it is not addressed by Adobe for the benefits of all developers.

Here is why I think it is crucial. There are about 100K Honeycomb devices sold. By the time Flex will catch up with IoS – June – the number of sold iPads maybe will reach 3-4 Millions . My estimate is that less then 20% of the users (in case of our application the clientele are independent insurance agents) would have necessary hardware. However, all 100% have access to web on laptops and netbooks, and 80%+ are allowed to run desktop AIR. We, at Farata, can not justify development of multiple versions of the software for desktop(Air), web (Flex Hero) and mobile (Flex Hero Mobile) – and I can not imagine many other companies doing so! Aside of development issues, I can not imagine training and supporting 3 different user experiences (with obviously different UIs).

Not only Adobe has to fill the gap. Developers should adjust as well: as conventional OS-es are becoming gestures based (please see preview of Apples Lion coming this summer) – and very much like tablet ones, developers should not design and develop multiple experiences either. I mean they should abandon legacy UI metaphor and deliver seamless experience across platforms.

Sincerely,
Anatole Tartakovsky

For the first time in the last 3 years I am unloading Apple stock – almost all of it – as I believe that their current strategy is slowing the long lasting success. There is the point when the pride of job well done turns to hubris and Apple is crossing that line.

Sincerely
Anatole

Sincerely
Anatole

But we also work on the projects for startups in which we are major stakeholders. There we apply our sense of what world becomes and what RIA are meant to be.

I will be talking about one of those experiences during Flex360 in Denver this April. In particular, I will be talking about application for the financial/insurance industry we have been working on for the last 18 months.

It started as a typical AIR desktop application with PDF integration and some Java back-end workflow. As application grew, the clients (200K-1M of prospective paid clients) demanded availability of the functionality on the desktop, web and mobile devices. In this series of the articles I will talk about solutions we had to build in order to provide them with consistent easy to use platform that essentially brings us to the next frontier of the application development.

Enter “virtual solution provider”. A typical insurance agent is 50+ years old (technology challenged) high school graduate with GPA of 3.0 (as your financial adviser) and a single handed to manage both client expectations (CRM) and insurance companies/state bureaucracy (workflow and compliance). We consider it a huge opportunity for an integrated solution (most of the insurance agencies still howl trunks full of paper insurance forms with them) that has to be simple enough so any agent can do it. The insurance agents are not the same users as the corporate ones – they work for a distributed MLM with extremely high turnover rate.

The client base is almost consumer grade. They can have a laptop now with the Internet connection that works 70% of the time. Tomorrow they would rather have a tablet and touch-screen devices – they need simple devices. The phone integration is essential as they spend 50%+ developing leads. Phishing and real-time advertisement by current media/internet companies are the ways they get most of the new clients.

That’s why we build this insurance application as an example of what the platform for the future consumer applications should be. The Internet moved publishing/media closer to consumers and made it more personal. The most successful companies (Google, Facebook, etc) turned hundreds of millions users into their implicit workforce. The next generation of applications needs to do the same. Rather then come with a fixed workflow it has to capitalize on the everyday experiences of the human race and become an expert system in any application domain. That experience should guide your workflow in transparent way, when and where you need it.

The articles in this series will talk about changes we need to make to the features we are embedding in the applications so they become a ubiquitous part of our life.

Anatole Tartakovsky

Case Study: Using Adobe AIR on Android for Sales Automation

In this case study you will learn how to port  a  traditional RIA/AIR application to Android platform – both Smart Phone and Tablet. You will learn how to separate the functionality of the large application depending on the target device and create cloud/ occasionally connected services available across platform. Finally, you will see how to apply simplified Mobile UI to your RIA/AIR applications and maintain a single code base for all target platforms.

My colleague Yakov Fain submitted two proposals:

1. What it takes to be an Enterprise Developer

2. Hands-on 4-hour crash-course style workshop on Java for Flex/Flash developers

At this point we don’t know which of these proposals will make it to Denver in April, but we are certanly looking forward for attending this event.

Anatole Tartakovsky

Adobe can become THE leading force in this transformation. However, I think a major problem needs to be eliminated from the developers life to make them accept the platform – it’s the release policy. Traditional release policy won’t work even though Adobe is releasing AIR more often than in the past. However, with multitude of the devices coming out daily Adobe needs to offer daily builds and the bugs database in order to stay afloat.

AIR and Flash are VMs and they shield most of the new platform features. They have to be available to the developers as soon as they are available – not a second later – to stay competitive to native platforms. Getting the new AIR run-time via the Market application is way too late!

Developers need to start working on the new features months in advance before the public release – the new run-time has to come with new applications for the consumers. Emulators are nice when the development schedule is planned for years to come, but not for the golden rush scenario we are in now.

Essentially we need much faster way to get DEVICE SPECIFIC APKs for testing as soon as Adobe engineers compile it or at least the daily builds. Rather than finishing Android pre-release program they have to extend it to the labs.adobe.com the same way Flex framework is published so developers can see unreleased builds and verify them with their software/build upon them. Market is a nice idea for consumers but Adobe can be sure that anyone serious about Androis development has rooted devices and can install APKs any way they need to.

It takes months to go from prototype to development/sales cycle to the actual release for any tablet application. Starting late is not an option, but rather a  major problem for AIR on mobile devices.

Sincerely,
Anatole Tartakovsky

Temporary links if you are out of luck with locked Markets:

http://dl.dropbox.com/u/17096020/Adobe%20Flash%20Player%2010.1.120.1.apk

http://dl.dropbox.com/u/17096020/Runtime_Device_Froyo_20100930.apk

I delivered 1 hour presentation today at our companies annual “symposium” on Native integration. Techniques are crude but without integration with native APIs AIR is a very limited product.
It is definitely “Gold Rush” time for AIR and mobile platform. The fact that so many people are breaking the walls to enable AIR compete with native apps means that the need is obvious. Adobe will deliver new Visual Basic for the mobiles this fall. All “high level” languages need bridge to “native” level to survive. However, if they will not integrate the way to better integrate native components on target platforms the chance to corner the market will be lost.
Sincerely
Anatole Tartakovsky

In first I will be talking how Android platform changes the way mobile software will be developed and how to make Adobe AIR “platform independent” approach work seamlessly with native platform ones. Part of the second is how to give another lease on life to good old PDFs with AIR applications. Comparing those two I can not help thinking how close the old and new technologies are. Moreover, how much AIR is currently in need in native technologies for integration and extension as oppose to portability.

It has been quite a ride in hacking for me – but now I am more optimistic that AIR on Android can become very usable in the very near future. Moreover, Android is very usable as complementary platform for current mobile workers.

I will beef up demos between now and Friday, but it is definitely worth a look of IT managers – the platform is ready to start development for real world projects.

Sincerely,
Anatole

After 4 month of Android development I have to complement Google on cleverness and quality of their work. There is more innovation in the way applications, security, and new technologies (voice, messaging, small factor UI) become practical than I have seen in all other technologies combined including iPhone (used it for 3 years), Linux on mobile (have 3 different devices), Java ME, etc.

The patents Google allegedly infringed on are laughable from technology perspective as they are not anywhere close to the core technologies. In short term I believe they can be easily bypassed (with actual benefit to the platform!) by minor changes to the VM and transforming engine that repackages Java byte code to the appropriate ARM level, or handle repackaging on the device itself. That would easily solve formal infringement issues but I do not know if it would matter for legal system.

There are few outcomes none of which seems to be good – licensing or forcing Oracles approval on the changes. Second option is even worse as in my mind Oracle stopped being technology company over decade ago. At this time it is holding company that buys and “milks” legacy products – with appropriate mind set and people.

One thing is clear – there is a need to create Java Open Source Alliance to replace Oracle dependency. It has to examine all Oracle patents and steer away in VM implementation that is based on patents that can be challenged by Oracle. That is the only way to keep momentum Android built in Java space and provide Oracle with expiration notice on their stronghold on Java technology. I would also strong backlash from Java community back at Oracle – I would really doubt any Java professional facing Oracle’s strategy that diminishes ones ability to make living would recommend or support their products.

Sincerely
Anatole Tartakovsky

Apple and Google are in open war right now – over tv/media, virtual assistants, navigation and ads. Lately it became obvious that workspace and social networking are also becoming part of the battle – and that is the fields we specialize, so we need to adopt.

I picked up Nexus One recently to do some research work. N1 is a bit better as research device then particular carriers ones as you can share the same providers card with your iPhone (no extra contract). I am quite used of swapping AT&T cards from iPhone with other phones (50$ Samsung phone +iPhone account = better phone + bluetooth/usb network hotspot, etc). It also has no provider’s protection so updating software and rooting is a bit simpler.

Let’s make sure you have been warned: N1 is not a replacement for iPhone for consumer or either status seekers/heavy phone users. It has some significant pluses – better Navigation, voice integration and web experience are superb. Hardware spec beats 3GS easily, but the actual hardware quality is sub par:
- quality of the phone subsystem (signal reception, sound quality, integration with provider) is much lower
- quality of the screen is bad ( easily greased, bad touchscreen recognition, predictable typing is not working as expected)
- touchscreen and buttons do not always respond as expeced.

Once you accept that Google phone is development device and not your primary phone, you can appreciate really great features it provides for software enthusiasts:
- open development environment including AIR with reasonable debugging and diagnostics
- top of the line hardware stack including fast CPU
- standard open OS

The last few weeks spent with physical device were a lot of fun. The development cycle is much faster then with iPhone and the applications perform MUCH better. There are quite few adjustments you need to make to your development in order to deploy application on the phone, but I will talk about it in the next post. For now, grab your Android phone and experience new platform for yourself.

Sincerely,
Anatole Tartakovsky

Unfortunately, living with the problems above is a typical WAN way of life, and TCP/IP protocol provides reliability on LANs only. To make the matters worse, applications are tested on LANs and extremely reliable “local WANs”. As a result, they are not tested at all for this type of the issues. And with thousands of small AMF requests per session even fraction of percent of lost packages affects the reliability of application.

Once application is in this state, typical response from development teams is to add application error handling and do more testing. Unfortunately, this testing is also done on LAN, and reliable WANS. Plus due to the non-deterministic nature of the lost packages conventional testing does not help much.

The advice I usually give to our clients is to fix the problem on communication protocol level (in a layer between the Flex Framework and Application) rather then in the application code. Usually it involves creation “ReliableAMFChannel” ActionScript class on the client side and customized Java Endpoint on the server side. These classes are primarily responsible for the following:
1. Keeping copies of the original requests(client) and responses (server) till they are confirmed or answered by the other side.
2. Managing resending of unconfirmed requests/responses after certain timeout.
3. Filtering out duplicate/already executed requests/responses
4. Fixing the order of requests/responses to prevent execution “out of order”

Usually it is implemented as 5-10 days project to integrate reference implementation code with the client codebase, provide resynchronization logic (login/reconnect) and timeouts’ optimization. I usually recommend to move long running requests to messaging as a part of the same effort as those have a long list of their own related issues, which I’ll cover in the next post.

If you are new to Flex, consider taking this 5-day live online training course.

Sincerely,
Anatole Tartakovsky

Technically Apple’s terms and reasonings are absurd. The quality of the code is not related to the language. Specialized p-code languages sometimes outperform native ones by highly optimizing (even writing in assembly for specific CPUs) critical parts. In case of Flash/AIR a lot was done to support GPU that would take ages for regular C++ developers to even approach. P-code toolkit can include generation of C/C++ code – however it would be just a waste of developers time to do so.

I have been using Apple products exclusively for the last 3 years and I really enjoyed ability not to deal Windows problems during the development process and still reliably deploy (thanks to Adobe) on 100% of PCs regardless of OS. Performance was never an issue for our apps, and we had steady job helping others to achieve good/excellent performance.

Apple has 3 month to fix this mistake. After that developers will make choice – Adobe or Apple. It will mean significant boost for Google, RIM and Microsoft – and end of Apple growth. At that time, if not resolved, I will be selling my Apple stock. Reasons are simple : in the last 3 years I personally spent about $15K on Apple products, planning to spend at least the same amount over the next 3 years. I was planning to replace my development machine Mac Pro dual Xeon/20GB/10TB for faster one by the end of the summer – looks like it will be Linux server as without platform neutrality it will be easier to at least have development and deployment platforms the same. With developers fallout getting tools and new software for OSX will be even more difficult, so developers need to move toward growing platform. It is really a shame, as Apple really had a chance to become the biggest player in the new market.

In meanwhile, it is time to shop for Nexus phone and Linux development machine.

Sincerely
Anatole Tartakovsky

Couple of smaller sneaks really puzzled me. I am sucker for development productivity and the teaser that allowed you to do code editing while still in debugger session seemed like the greatest productivity boost while providing better developer experience then (my previous benchmark) VisualBasic 6 in-place debugging. For large projects it SAVES HOURS EVERY DAY and allow developer to stay focused on the code writing and debugging instead of going through lengthly mindless process. This is the top feature I want in the next Flash Builder. It took me 3 beers during bash to figure it out – was not trivial (I hope – can’t be sure till tomorrow morning;)) :

The replacement unit is the modified function and not the statement itself or class. Adobe would have to modify compiler/debugger to do MIR or LLVM of the AS3 code and in-place JIT, but once it is done you can do the magic. In case of the modified function being on execution stack, revert the function context to the last entrance point in the modified function and fast forward to the breakpoint – you have in-place editing while debugging. MIR/JIT integration is coming to the FlashBuilder as a part of Mobile Kit integration, and can be incorporated as a layer of compiler callbacks in debugger context. Depending on the integration of native compiler into tool chain it can be feasible enough to do it to the code in constructors or code that gets into _init sections but even pure function replacements will get 99% of the expected functionality.

The best side effect is that in debugging you really need to re-run the last executed statements and scoping to function does just that. Great job, Adobe.

There is no doubt in my mind that Adobe is very close of turning this platform into software revolution over the next few years. I am certain enough that I bought Adobe stock today regardless of the current economic situation as long term impact of their platform is so great.

Sincerely,
Anatole Tartakovsky

This morning I went to the session Model-Driven Development with Flash Builder and LiveCycle Data Services. It was presented using newly minted Flex 4 beta and unlike the beta 1 that I had to fight through to make the sample to build, the wizards and code generators in beta 2 generally worked. There were some “gotchas” in the process but they were either simple to figure out or even had understandable error message so it is quite passable for the Beta product.

But the thing that was crucial for me to watch people in the room. Aside from typical problems of the front-end developers with Eclipse, a surprising number of people sailed through examples with reasonable understanding of the process. The crucial piece in making the non-trivial process of developing a multi-tier application manageable was correct placing of integration in the middle, and visual integration of the functionality directly into Flash Builder painters and property sheets.

There are other non-engineering components like pricing, but this release finally has potential of making LCDS easy enough for developers – assuming it works. It also gets Flash into top rank of RAD tools – for those who will adopt this development model.

As soon as I complete my current Flex projects in release stage, I am switching every new one to Flex 4/LCDS modeling. Flex community can expect the following new goodies from in a Clear Toolkit framework:

• Farata Systems will provide a native (SQL) adapter for data management compatible with Flex 4 later this year.
• Clear Data Builder will have a plugin to synchronize the data model and SQL adapters
• The missing features like client driven transactions will be added to Flex 4 code generators
• Forms and controls artifacts that are not to my liking as this is definitely the first version of this technology will be merged with the Clear Data Builder stack

Sincerely
Anatole Tartakovsky

However, it is announced and will be out in few month (still to be defined) and we need to start working with it ASAP – as people do need mobile computers. I went through few sessions that talk about challenges in development for mobile platform and I do understand that challenges of Mobile platform are too great to hope for simple port. So we will need to add this tool and start thinking/practicing using this model so we can help developers when the product is released.

Underlying technology is not disclosed , just shown add-hoc “Save As” target in Flash Pro CS5 to generate ARM/iPhone code. From the presentation, it looks like they built very limited player as bootstrap code for iPhone, connected ARM codegenerator to MIR/LLVM processor, applied that to generated SWF, linked to bootstrap and produce now native iPhone application. Till I load these applications in my iPhone and find time to look at it more carefully I would assume it is the process.

But here is the second problem – and that is more of personal issue. Are we ready to let Apple force us to compile HTML page and submit it to Apple store every time we decide to write something?

Today 9 out of 10 attendes of Adobe MAX carries iPhone – including me. The percentage of early adopters and trend setters is very high here. IMHO, right now Adobe holds the key to success to Palm/Blackberry/Google platforms.

Sincerely
Anatole Tartakovsky

Sorry for taking it out of context, but I think it will be taken out of context or even becomes a mantra for new development process the same way UML 10 years ago was suppose to produce 80% of the application out of structured requirements. I am certain that this interpretation was not intention of Theodore Patrick or anyone at Adobe.

I would suggest that 80% – 20% separation has to be clarified as it might be used by some as Adobe’s recommendation of budget/time allocation and it could be problematic for the current state of the industry.

Less generalized statement IMHO would be this:
In order for applications to be successful in consumer / occasional user market you will need to increase your typical “functionality based” budget few times for usability, design and testing. You will also need to keep lid on features in order to achieve usability staying within budget constrains.

Applications targeting mobile devices and occasional users on conventional ones are definitely a growing trend that Flash platform is best positioned to take over. Enterprise and niche application will still be out of reach of UX due to budget / features constrains – so the following notes might not apply.

I agree that most of the current design work goes into packaging (opening page(s) and stylesheets) and does not affect the quality of the application. I would argue that cinematic experience is more important than design. For example, in the movie industry films based on beauty rather than the character have higher attrition rates and lower retention.

IMHO, there should be stronger distinction between visual design (how it looks) and “interaction” design (how it does things).

People will adapt to anything that is simple and easy to understand. Current UX wave is driven by people who have taste, which can be acquired over time… even by developers. Time is of essence here – developers just need the same tools and reasonable project deadlines as the rest of the team rather then cram their time toward the end of the project.

In my experience it takes less then 6 month for a developer moved from PC to MAC OSX to “forget” old way of doing things and acquire the same taste for simplicity the designers historically enjoy by using designers products. Adobe developers have long history of using non-Microsoft systems and it is definitely reflected in the way the build applications with or without designers.

At this point any serious Flex developer working on consumer-facing project must go through at least some training in Web Design to the extent that they can modify Photoshop, Illustrator or Flash files to annotate/fix a design flaw and communicate it properly to the designers. That implies to a large extent that 60-80% of the overall time is still in the development as developers extended their reach into modern UI. It also greatly reduces overall project time and mis-communications.

I certainly hope that Flash Catalyst will be bridging the gap for the rest, but expect mixed results if people would not expose themselves significantly to the other side of the fence. Finally, as client portion of RIA becomes simple and intuitive, more work needs to be done on the server to prepare and support such predictable and intuitive behavior.

I lived through few projects of complete picture perfect designs made upfront. Unfortunately, those static pictures are full of loopholes. Good developers are just as good as good designers in interactivity and much better with data models and overall process. In the end, negligible percentage of the picture-perfect upfront design is usable and could be counterproductive for the project lifecycle as compared to conventional wireframes as a common ground. Only from common understanding (the more visual the better, but not ONLY visual – you need to make sure it is also in words so you can ensure common understanding, provide comments and establish two-way process) you can start real team work on your next RIA project.

Sincerely,
Anatole Tartakovsky
Farata Systems

Giving programmable environment to the TV will be as freeing and devastating as Internet publishing for the traditional paper one. Traditional TV is best described by George in early Seinfield : “People will watch the show about nothing because it is on TV”. New environment can completely change not only HOW we receive the entertainment but WHAT and WHEN and HOW MUCH we will watch. Here is how it it works for me.
(Disclaimer: I have not been Cable TV subscriber for the last 8 years – after all I have kid at home. I watch movies that I choose, listen to music libraries collected for over 20 years, and share photos with my friends going back to black and white film. My base entertainment system is built around Macs network with every possible audio and video component not to mention musical instruments).

So last weekend I went to my brother birthday and gave him his first Mac Mini as a present. However, I did not plug it into his office monitor. Instead, it went straight into FIOS connection and HDTV unit. It had bluetooth Logitech DiNovo Edge keyboard and WII remote for mouse (kids preferred to use iPod). Most importantly, it had archive of family resources and was pre configured to securely access my “shared” libraries and gave me access to his “shared” ones. Plus instant video communications, screen sharing and VM remoting. For advanced uses, grid computing and documents backup.

The result was very enthusiastic from mostly skeptic (burned by Vista/Media Center fiasco) audience. Seeing that small box actually working caused quite a stir. I am pretty much set with birthday wish list for the next year. The simple fact that I can share my media and have “family” network and broadcasting, play human games like chess/cards/backgammon while seeing/talking to the opponent has great value to me – with friends and family all over the globe.

There is one small problem – the price for average family. The modern unit with backup drive and all extras costs ~$900. Flash on set-top allows for $0 cost (Ok, $200-300 for decent wireless keyboard and mouse and terabyte storage) while delivering most of the functionality of the above unit. Giving top boxes with HDTV ability to replace computers and TV programming can be a tipping point for the new media and relationship software.

Recently, just about 50% of Americans said that TV is “necessity” – more then 15% drop from 10 years ago. Most of the drop is accounted by the fact that younger generation is getting their entertainment via different (computer based) sources. As growth in facebook and myspace population is currently fueled by people around retirement age, HDTV based living room offers much more comfortable environment for mainstream adoption

I do not really care for twitter from anyone – especially paid editors to bombard me with clever sales pitches of 140 characters or less. If they have some thoughts to share, lets keep it real – 300 words at least, I would rather read or better yet listen to podcast/youtube from the people I trust. Trust is the key here. Once there is enough alternative information, the whole media structure is going to change. Advertisement as we know it will not work if people have alternative and more trusted source of information. In the end who do you trust – Amazon reviews or magazine editors dependent on the advertisement of the products they review?

Internet has not fulfilled so many predictions of the past millennium – like destroying the malls and making home shopping personalized and fun experience – but it will happen soon enough with the current economy. With so many people becoming disposed by Wall Street and Madison Ave the Silicon Alley gets all necessary talent and technology. It is going to be fun year, with more startups getting into RIA and streaming technologies – and I am looking forward with playing with new ideas and approaches to make programming more humane experience.

Sincerely,
Anatole Tartakovsky

The idea of this presentation came to me during one of the Flex conferences about 6 months ago. The presenter asked the audience of about 100+ Flex developers if they used Data Management Services. Only handful of them did. Hefty price, learning curve and general attitude toward payware seem to be  winning over advantages of excellent productivity and robustness of LCDS solution that is years ahead of commonly used techniques. Interesting enough, during subsequent conferences, similar question revealed that many more developers lean toward using BlazeDS.

So in that first session I will cover how to fill the BlazeDS gaps in the most important areas for enterprise developers:

– how to get virtually unlimited push scalability ( AMFStreamingEndpoints using new Servlet 3 NIO API )

– how to create Managed Data Collections and provide seamless integration of the data update / push through multiple clients

– enabling server-to-client RPC –  “the server calls the client”

– How to add quality of service, reliability and application protocols to both LCDS and BlazeDS

– how to generate PDF on the client ( I may move this part to another session devoted to reporting and data entry solutions for application developers)

All my code examples work with Adobe’s sample applications, with minimal changes on the server side  thus minimizing the need to re-train developers and providing an easy migration path.

I will post the slides after the event.

Hope to see you there,

Anatole Tartakovsky

The idea is to make states more declarative and eliminate scripting as much as possible (completely in most cases). That should allow better model for programmatic skins for designers and simplify integration points.

Personally I think it is much simpler model, and it is going to get better acceptance just because of that. I would reserve my final review till the time new code generator is available so I can see integration points for really cinematographic applications our clients learned to love.

It looks also that MXML compiler goes through major overhaul. Please note “color.down” syntax – finally we see departure from old conventional XML markup toward DMXML ( Dynamic MXML). Seriously, if the new compiler is going to depart from pure XML syntax, let us talk about the new MXML syntax now – including color.runtime.down and other data related things that go way over simplistic CSS model.

I would also expect States have extensions for substate or at least device formats given Flex 4 release timeline. In other words,  what works for desktop is different from console and definetly from the phone – including selection of the controls, events and scripting. I would expect compiler to emit different SWFs for different format with full support through hierarchical states.

For majority of applications it is very significant change in the way customization and skinning is done. Switching to programmatic skins approach allows significantly reduce the size of flex applications and provide “streamable” applications with core functionality loadable fast. I do believe that major overhaul of tools to support it even with current model has to be done way before Flex 4 release. For large applications I have seen benefit in 30%–40% size application reduction and main problem for wide adoption is “dark programming” that makes it art of few.

Well, thanks to Flex team for “heads up” – back to daily tasks

Sincerely,

Anatole Tartakovsky

Farata  Systems

The fact that increasing the number of parallel connections increases throughoutput is very simple to understand. Today’s Request/response approach to communications is very similar to village bike concept – you have few very limited resources that travel back and forth, you wait till it is your turn, and hope that the guy before you does not get lost – otherwise you need to wait till all hopes are gone (called timeout) and the community provides you with a sparkling new bike circa 1996. In most cases it is too late anyway and user moved to a different page/site. As the travel destinations become more distant (WAN) you are exposed to real world troubles of commuting – latency (500ms for geostatic satellite network), bandwidth limitations, jitter (errors), congestions (your local ISP is also trying to be TV broadcaster AND new AT&T), unrecoverable losses, etc.

Obviously, more bikes mean that with some work on street and traffic planning you can get much better performance and reliability. You might even go crazy and allocate one bike to sheriff/fireman/village doctor so he will provide information on conditions and lost/damaged goods. You can route important goods in parallel so they would not get lost or damaged that easy. You can really start utilizing long running connection for real “push” now.  But before we do go crazy let us look carefully what has been happening in the last 10 years – how early adopters of AJAX/RIA survived.

Increasing the number of HTTP connections was ugly trick most of enterprises we worked with quietly rolled out in the browser builds/service packs in the beginning of the century. In IE you apply changes to registry keys:
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings
MaxConnectionsPer1_0Server    10
MaxConnectionsPerServer          10
With Mozilla you recompile the whole browser and apply few other performance tricks along the way. It does solve most of performance and reliability issues for a SHORT WHILE. The main reason is that without imposed limits, software increases in size faster than Moore’s law for electronics. And , unlike private networks in enterprises, without proper “city framework” rampant requests will cause overall Internet meltdown as initial rollout of more capable browser will give them unfair advantage in terms of bandwidth share – 3 times as much compare to current crop, causing QoS problems on older and slower networks. In other words, it potentially has very real potential to cause more of the same problems it tries to solve.

Most enterprises had to control QoS of communication for their clients. They created and adopted number of p2p solutions that provide more efficient communication models. Basically they fall into 3 categories:
1. HTTP Batching
2. Binary components dealing with sockets directly
3. Pluggable protocols

The last option did not really catch up in popularity, even though it allows moving most of the problems from the browser level to OS level. We will cover only the first 2 options.

HTTP Batching is combination of few technologies with close resemblance of Tokyo metro ushers working on family motorbikes. As an example, Flex/Flash AMF protocol tries to squeeze every bit of bandwidth and optimize queuing of the requests in the most efficient way – both on client and server. The result is very good – you use maximum bandwidth, and lines are kept short. As a matter of fact, the results were so good, that most of our clients, even if they need to use WebServices or conventional HTTPServices, use AMF to proxy requests via AMF enabled server, making it deliver results from legacy servers more efficiently. It is loads better than non-batched requests/responses. And it plays nicely with current infrastructure as it piggybacks on the existing browser HTTP requests. However, for critical applications or plain bad infrastructures the problem remains: there are no QoS or QoE (quality of experience) built on HTTP level, so there are potential problems with queues overruns or lost packages.

From purist point of view it was a mistake to let mathematicians and physicists mess with communications and come up with HTTP model. Binary “always on” (re)connected socket protocols are way more logical and efficient. Unlike request/response model typical socket connection is like 2 way highway, with data moving in opposite directions independently.  But before we would fully depart into Communications 2.0 world, let us talk a bit how HTTP shapes up these days.

As I was saying, disconnected model of HTTP 1.0 was not practical. Overhead of connecting/disconnecting was not tolerable, and for the last 8 years I have not seen single desktop browser using it. It has been completely replaced by HTTP 1.1 – the protocol that keeps connections open beyond request/response so next communications happen faster. Underneath, of course, there are 2-way sockets that stays open – but browsers diligently follow old model and ignore the possibilities.

As browsers started to get into real applications, the need for real-time data forced people to look into better solutions then polling for data – and few “push” solutions appeared. While they were different in implementations, the main theme was the same – browser gets requests, holds it for long time, flushing packages down when it becomes available. The packages reach the browser and are either interpreted by programs upon arrival or executed (if packaged as <script/> sections). The important part is that people started to see that server driven model is valid and better for some applications.

J2EE final specification and standards (JSR 315: Java Servlet 3.0 Specification) are planned for the end of the year, however, there is a number of open source and commercial implementations of proposed “Comet” model today (including Python-based and others). They can be very different in approach and implementation – capitalizing on new non-blocking io, optimized threads or more efficient native sockets implementations – but they are fundamentally common in breaking request/response paradigm. The idea is that the server provides second model for requests handlers in addition to conventional one. Handlers that are marked to support that model will receive 4 events – “connect”, “read”, “error” and “disconnect”. Adding event model to the server side brings symmetry to the client/server programming model and greatly simplifies asynchronous programming code. “Connect” and “Disconnect” events define lifespan of the “connection” object available for communications. “Error” event notifies of low-level errors in the transmission protocol. “Read” event means that there is request coming from the server and allows server to read and process it. Server keeps “connection” and “response” objects and writes/flushes information to the client as needed.

Let us see how this model is different for fine granularity requests common for today’s AJAX applications. Pretend you are sitting ( like me now ) at a coffee shop with lousy Wi-Fi connection sporting 1 sec latency for typical webservice eBay response, watching for 30 items. With current browser settings, it takes you 15 seconds to refresh all 30 items. With 6 connections, it will reduce it to 5 seconds – but will require 3 times infrastructure in between. With “Comet” type requests you can send all 30 requests without waiting for single response ( the same will be done with AMF HTTP batching) and will receive all 30 responses asynchronously – usually within 2 seconds. With HTTP Batching, you would get all 30 responses at once, and need “sorting” adapters on both sides to distribute pieces to proper responders.

Great advance, and just in time when other commonly available technologies were about to make the whole  model  obsolete. Surprisingly,  it also strengthen the position of competitive technologies – but that is to be covered in Part  2.

Sincerely,
Anatole Tartakovsky

For the last 2 years we have been using different linux boxes (VMs and physical ones) to simulate different WAN problems. The setup process is tedious, and has limited resolution as most of the linux kernels are working on 100/250Hz. Fortunately, finally there is a product that solves most of setup problems with simple portable appliance that has to be in the toolbox of any Web 2.0 professional.

Mini Maxwell – Easy to Use, Portable, Network Emulator

Bringing latency up to realistic 200ms and package loss to unrealistic 10% would quickly expose problems in error handling code. It will also give you quick feel for robustness of the code. Next to check if duplicate/out-of-sequence packages affect the application. Financial applications also need to check for effect of corrupted data.

Depending on the protocols used by application, different remedies are available. Obviously, if you are using WebServices and similar old high-level protocols you have very loosely bound communications making implementation of QoS layer impossible. As number of HTTPRequests is limited by browser (2 for IE), latency can cause performances slowdown and timeouts. Missing packages escalate the issue with connection startving even further.

If you are using any AMF implementation, your case improves significantly. First, latency is less of a problem as Flex would automatically batch the requests together. Implementing symmetrical checkpoints on both client and server endpoints allows trivial package recovery in case of loss and duplicates. Nevertheless, lost packages are still a problem as they cause timeouts.

Robustness gets much better if you move to connected protocols – either RTMP or new BlazeDS long pull. Usually you can service anywhere between 80% to 100% of the users with them. Using opened connections and 2 way sockets is ideal for high performance and reliable protocols. Comparing them to HTTPRequests is like comparing highway with multiple lines going in each directions to single-line road. More applications started using connected solutions for tasks different from regular RPC to modules loading implementing streaming the same way you stream movies. As they evolve, we should see more open source products that provide transparent implementations using mixture of protocols. In meanwhile, we can do most of it using Flex built-in fallback channels.

Hope this helps,

Anatole

This morning started with keynote by Adobe – obviously product announcement, but also detailed explanation of things going OS. You can not underestimate the importance of that step. It removes a lot of obstacles in wide adoption of Flex platform – both in developer and tool making communities. As a matter of fact, it makes almost impossible for anyone in toolmaking market not to provide open source version of their product now. So we will have few announcements to make about changes in pricing model ( how does FREEE sound ?) this week. 

My session had a late start – keynote was running late and projector would not connect to my MacBook Pro ( next time I will pack my trusted thinkpad along). Interesting enough, the questions asked after the session were from the slides I had not have time to go through. So I will run the same session on Wednesday, 2:30 – will go through the remaining slides, and I will also add a lot of stuff based on the questions asked. Bring or send the questions – I will make post show video with the sessions materials.

Oh well, time to go to another party….

File Attachment: 360flexAtlanta.ppt (1569 KB)

However, it can be solved much easier with usage of transient tag/keyword during data transfer:

AS3:

package com.farata.datasource.dto
{
import flash.events.EventDispatcher;
[RemoteClass(alias="com.farata.datasource.dto.LineItemDTO")]
[Bindable(event="propertyChange")]
public dynamic class LineItemDTO extends EventDispatcher //implements IManaged
{

private var _myDate : Date;

public function get myDateUTC() : Date{
return _myDate ==null?null:new Date(_myDate.valueOf() – _myDate.getTimezoneOffset()*60000);
}
public function set myDateUTC( value : Date ):void{
var oldValue:Object = _myDate;
if (oldValue !== value) {
this._myDate = value == null?null:new Date(value.valueOf() + value.getTimezoneOffset()*60000);
}
}
[Transient]

public function get myDate() : Date{
return _myDate;
}
public function set myDate( value : Date ):void{
var oldValue:Object = this._myDate;
if (oldValue !== value) {
this._myDate = value;
dispatchUpdateEvent(“myDate”, oldValue, value);
}
}

Java:
package com.farata.datasource.dto;

import java.io.Serializable;
import java.util.*;

public class LineItemDTO implements Serializable
{

transient public java.util.Date myDate;
public java.util.Date getMyDateUTC()
{
return myDate;
}

public void setMyDateUTC(java.util.Date value)
{
this.myDate = value;
}
}

That is all – you have normal public variables on both sides, and serialization works transparently, keeping Date in UTC zone on both sides (you also need to set JAVA VM timezonne to UTC) – and now you are always in the servers timezone.

Enjoy,
Anatole Tartakovsky

PS Please evaluate your need for local vs global time – otherwise you would have cases like Dell’s support center in India when they were asking for feedback on service 8 hours before it was suppose to happen – I once got a call @ 2AM about delivery set up for 10AM – plan carefully.

On average, I am working with technologies that are from 2 to 4 years ahead of mass adoption. With that in mind I think 2008 will be the year we start the “personal assistant” war. The short term goal of the game is to make people heavily dependent on the simple and convenient services provided by slightly upgraded gadgets.

The first grand frontier (2008-2009) will be the battle for your cell telephone. 2007 was year of IP telephony making into the masses. Skype was good example of building proprietary platform and luring a lot of people in it. There were bunch of companies that make Skype look like Scrooge – offering similar services at fraction of the Skype’s price. My favorite scheme is MagicJack – for $20 bucks a year you can have unlimited phone service in the US or anywhere on the planet for that matter – while robbing AT&T and other telecoms. There is a number of products coming to market that are going to be just as good for you and just as bad for telecoms. Obviously, it will be followed with legal changes in the next few years that will change the way we pay for regular phones. Second, we will stop using old phones altogether.

It is not too futuristic, and Google and cable/media companies are in the midst of taking over the telecommunications as we know it. It will be replaced with DVRs with VoIP servers in them.
To see it, just look what happens around you. GSM is moving in, with a lot of upgraded infrastructure. I travel a lot, and in my experience I get much better 3G speed/coverage on AT&T then on Sprint or Verizon. With that also comes freedom – unlocked phones, different OS, ability to choose from the much wider range of product. In US the “main” operating systems – Windows, RIM and Apple have 90% of the PDA market. Worldwide, they are less then 20% combined – about as much as Linux ones.

My cell phone is Linux smartphone with a touch screen and VoIP/802.11g. It is in a regular candy bar format, with a normal phone keyboard I can use while driving. It is a bit smaller then iPhone and fits into the same holder. When I am at work or home, calls are automatically routed to VoIP providing better call quality and extra features like unified messaging to boot. When I am on the go or outside of the 3G/WiFi coverage – I have a cell port on the VoIP appliance – so all my calls are routed for free as well. There is no comparison to the Blackberry or Windows devices – at about 50% of the cost with the plan. I would estimate that move to “aggressive” VoIP saves me personally about $1000 in telecom charges – and about as much per telecommuting employee for the company.

Google is about half way there in terms of service offering with GrandCentral VoIP solution. It needs just enough bandwidth – either on its own or with cable/media companies – to offer Gizmo ( standards based/open source Skype alternative) like service in well rounded package for the mass adoption – with “free” adapters converging your phones and PCs into “gvoice” service. If played well, Skype would either have to give in its “lock”/switch to VoIP or face massive drop out rate in the phone area – the main source of their income.

With “always on” network devices in our pockets we are looking at almost unlimited set of applications – personal automated voice driven assistants that would help you to choose (from the “advertisers and rating lists”) all the services and products based on location, preferences and “history” that you might have for better or worth. And believe me, these are very addictive – more then music or video on the go. That means more c/java me for selected few and a lot of Flex apps for convergence UI for the rest of us.

Happy New Year!

Sincerely,

Anatole

Š

On the technical side, BlazeDS provides a lightweight replacement for LiveCycle Data Services ES. The remoting part seems to be identical to the LCDS offering. If you just use BlazeDS WAR, just roll out a regular “LCDS-like” deployment, and the chances are it will work without the need to do any changes. For the messaging and data management services, however, there are significant differences. You might want to analyze those before plunging into either product.

The client-side of the messaging stays very much the same – you use the same Producers and Consumers, so there are virtually no changes in the client code. The BlazeDS is packaged with a pre-configured Tomcat server with messaging built-in (an open source ActiveMQ), greatly reducing the complexity of the initial setup.

The implementation of the server piece is very different though. Unlike LCDS that launches an independent Java socket server within each application, BlazeDS uses the regular Web server sockets. LCDS uses non-blocking IO that offers better scalability (we had it @ 10000 users / CPU till we maxed out on the outgoing bandwidth). With LCDS, you need either a separate port or an IP address to handle the data stream. BlazeDS does not use non-blocking IO – so you can not expect to have more than a few hundreds users per CPU at best. On the positive side, it makes the process of application development a bit simpler as the session context becomes available.

With BlazeDS going open source and abundance of Java expertise in the market place you can expect non-blocking I/O offerings from third parties shortly after the BlazeDS release. It would also mean faster recoverability of the connections that is important for the real-time applications.

The Data Management Services interface is COMPLETELY omitted from the current BlazeDS offering. This SUCKS. While it is understandable from the marketing standpoint, it will hurt Adobe in the long run. Some trivial, non-functional classes have to be included in both client and server version of BlazeDS libraries. All datatypes that go over the wire and allow users to maintain compatibility between BlazeDS and LCDS are desperately needed. A short list would include ChangeObject interface, DataSyncException and such that are used in the custom server and client code.

I could care less about a Hibernate Assembler and implementation classes but high-level WIRE PROTOCOL has to be the same. As a solution provider, I have to go with the lowest denominator of what is available across platforms, and lack of common classes interfaces hurts the code portability. Given the current license restrictions on the “mx” and “flex” namespaces in the current open source sdk it makes impossible to provide such solution in the nearest future.

Other thing people often forget about the PDF support in LCDS, which won’t be available in BlazeDS. The printing support in Flex is very light, and PDF generation is often a preferred solution for printable documents. Fortunately, you can split your application deployment now and have dedicated “print server” with LCDS or any other Adobe enterprise product that includes that capability.

Sincerely,
Anatole Tartakovsky

Recently we’ve got a number of calls from both startups and established IP telephony companies looking to put RIA into work for the phone market. The telephone industry is going through a major shift in the next year. 3G becomes a standard feature of the cell phones, very much like cameras 3-4 years ago. Combined with GPS and phone service, and upcoming voice/text automation it becomes a very powerful device.

I will run this project as a research one, to see the problems and opportunities. My initial set of “phones” will include a reasonably small set, but I welcome any suggestions of what will get us close to the perfect phone. I will run the “mini” review, pros and cons, what works (for me), designs, etc.

Here is the initial set:

AT&T Tilt Windows smartphone

Sprint Blackberry – current “business phone”
E28 Linux Smartphone

Nokia tablet

iPhone – UI design concept

Also will see what can be done with personal gateway – basically will use SIP Asterisk PBX connected with cell gateway as an application platform for SIP/Telephone integration

I will start sharing my initial thoughts on the perfect business cell phone and home automation this week.

Hope it will be fun

Anatole

import mx.messaging.config.ServerConfig;
 
private function preinitializeApplication() : void {
   const reUrl:RegExp  = /(http|https):\/\/(([^:]+)(:([^@]+))?@)?([^:\/]+)(:([0-9]{2,5}))?(\/([\w#!:.?+=&%@!\-\/]+))?/;
   const appUrl:String = Application.application.url;
   const parts:Array   = reUrl.exec(appUrl);
   if (!parts)
      throw new Error("Invalid URL: " + appUrl);
      /*
      ("Protocol:" + parts[1]);
      ("User: "    + parts[3]);
      ("Pass: "    + parts[5]);
      ("Host: "    + parts[6]);
      ("Port: "    + parts[8]);
      ("Path: "    + parts[10]);
      */
      if (parts[1] == "https" ) {
         const channels:XMLList  = ServerConfig.xml..channels.channel;
         for (var channel:String in channels) {
            if (channels[channel].@type=="mx.messaging.channels.AMFChannel") {
            channels[channel].@type="mx.messaging.channels.SecureAMFChannel"
            var endpoint : XML = channels[channel].endpoint[0];
            var uri:String = endpoint.@uri
            uri = uri.replace( /^http:/, "https:" );
            uri = uri.replace( /\{server.port\}/, "443" );
            endpoint.@uri = uri;
         }
      }
   }
}

As you can see, we check if the application is deployed over https and redirect regular remoting requests to https thus modifying deployment descriptors in the runtime.

Enjoy,

Anatole Tartakovsky

Flex Framework usage of binding is one of the most important productivity features. Ability to declaratively define reaction to the changes in the data or components state greatly simplifies programming and reduces errors related to low-level coding.

In order for binding to work you need to make sure changes to the data are known to the framework. Unlike most of dynamic languages implementations, ActionScript 3 is built for speed and heavily utilizes direct access to the properties and methods. In this situation the only way for data to notify the world about the changes is to embed the code to fire chamge events.

Flex compiler helps in a big way by introducing [Bindable] and [Managed] tags. If you prefix your variable with [Bindable] tag, compiler does the following:
1. Inspects every public property and setter of you variables class and generates wrapper getters/setters that adds event notification.
2. Every time “bindable” property is being used, compiler references these getters/setters instead of original properties

Obviously it does not work too well with dynamic data of type “Object” coming from server. The problem is alleviated a bit by the fact that Flex would automatically wrap the Object in the ObjectProxy if default value of “makeObjectBindable=true” of the service is not modified. However, it will wrap only the top level and not the individual array members making changes to those undetectable. For example, if you are passing set of the objects from assembler, and the members can have arrays, the changes to the rows are not going to fire change events unless you explicitly wrap every array element in the object proxy.

Here is an example:
private function onResult(r:ResultEvent) : void {
var quotes:ArrayCollection = r.result.quotes;
var wrappedQuotes = new ArrayCollection();
for each (var quote in quotes)
wrappedQuotes.addItem(new ObjectProxy(quote))
view.dataProvider = wrappedQuotes;
}

ObjectProxy is very expensive and should not be used with large amount of data. For large datasets please consider strongly typed classes that will support [Bindable] on members level.

I am talking about PHP, Rails and the likes developers, which are being treated as first class citizens in the new Adobe world. There were very few of them in the audience. Most of them work as independents – the cost of the show was prohibitive to many. Nevertheless the sessions were stacked in favor of “lighter” server and protocols integration. New announced Flex pricing also lowers the entrance cost for non-enterprise developers.

That is also evident in the way Flex tooling progresses. New wizards for server binding are “classical” for PHP/old ASP folks that recently moved to AJAX world. They are nowhere close to the enterprise-level DataServices introduced in Flex 2. The communication libraries have been separated recently, with a lot of work being done to make WebServices and other XML-based technologies viable for larger Flex applications and mash-ups.

So far, Flex adopted  was mainly driven by very few groups – Flash programmers and J2EE developers. Resources are scarce, and Adobe marketed Flex as a new generation of Flash – very high risk proposition in this situation. It is common believe that programmers can’t do good design. It is equally harsh on Flash designers to write the programs. There is a limit beyond which art-oriented people find themselves  in a completely foreign territory. Companies that hire Flash developers to lead Flex projects will learn it hard way.

How will it affect Flex adoption and positioning in enterprises and mid-sized businesses? The next year will be interesting one. Finally there is a competition from Microsoft. Keep your flame mails to yourself – it does not matter how much better or worse their product is – it is up to people to choose the tool and build something with it. People go either for easy or familiar first. I do believe that tools will be just as important as the player ubiquity or appeal.

As far as tooling goes, Flex usability is definitely improving. Aside from the performance, Java developers can use Flex 3 almost “naturally”. Great job, Flex Team. Making working environment easier is what Flex really needs in the coming year. The only “deciding” complaint I have heard from Eclipse and MS Visual Studio users was not about framework or integration, but about the environment.

That brings in the third “main” Flex theme of the MAX – going Open Source(OS). Open Source appeals to a lot of people, and Adobe certainly hopes to increase community involvement in their products. With the end of J2EE era, it is expected that companies and individuals who championed OS 5-10 years ago will come aboard. Again, MAX might have been running ahead of their attendants here – not too many showed up at OS gatherings.

There were very few sessions on the open source (the most complete was done by Matt Chotin, need to publish my notes or find link online), and they did not bring large crowds. Interesting news were circulated in form of rumors, which means that we can expect big announcements in this area in 3-4 months.

There are high hopes of the OS movement for Flex. But this time around it might be a different game. Reliance on OS to win enterprise and businesses adoption seems to me the most difficult and risky part of Adobe strategy.

Do not get me wrong. I love open source – it is definitely a relief after 20 years of breaking and fighting “black boxes”. I gladly read and “adopt” open source libraries and contribute the results back. As a company we release significant part of our research and development as open source as a way to insure we can reuse our code for different clients as well as share it with the community. Releasing something as an open source product and driving adoption is the simplest way to protect IP for small companies and insure they keep control of the process.

Businesses grew a bit tired of OS over the time, and going in with OS solution sometimes means more trouble than it is worth.

First thing is the licensing. Relationships between enterprises, developers, distributors, etc are often “interesting”. Quite often the companies require you to not have or use OS software in your product.

Second is the effect of old switch-and-bait game. Open source was at its peak when software industry was in recession; selling support for OS products was the only source of money. Industry moved from software as a product (cheap and working) to software as a service (needs a little push from knowledgeable person, info is scarce) – and the real cost of software for enterprises skyrocketed. Even if the intentions are good this time and we get commercial grade software as OS the perceptions are there.

I am looking forward to get my hands dirty with Flex compiler as soon as it goes OS – we have loads of things we need to expand there or have to keep “external” for now. The goal is to make it usable for our enterprise and business clients. Large applications need better tools for modularity and build process, performance, diagnostics, language extensions, etc. It will be very interesting to see how this last big “problematic” piece is going to sail through the community process.

Sincerely,

Anatole Tartakovsky

The reason being that we walked that road in the past; we still are using that methodology in our Flex work. Having support for it from the tool vendor will change both adoption rate and the way people approach it.The idea behind new set of tools in development is pretty powerful and simple:

Take large controls that we have in frameworks and libraries and layer them in relatively small and specialized layers of loosely bound reference implementations.

The layers can be UI elements, skinning, layout, data binding, view controllers, etc that compose a typical framework control. Each layer is completely replaceable or better yet each control is being assembled for an application from “parts” by a team of designers, programmers, model designers, etc. As long as it can be expressed as an XML markup, design tools can produce these layers thus providing interchangeable implementation of design or other aspects.

We used this approach as core methodology in the past and were very happy with the results. In the beginning of RIA era (1999) IE version of DHTML had so-called “behaviors”. You could have attached these XML/script combo components to any tag or create your own tags. They could be small – just to add a presentation/effect like rollover or provide intelligent links or tooltips. We also had the “monster” ones representing DataGrid, Report, Tree, and TabFolder to name a few. You could have attached multiple behaviors to a single tag providing control with a superset of functions – the same rollover/selection effect would work on DataGrid and Tree in the same way.

Data binding was just another behavior shared across multiple controls. Within a year after adoption our home-grown framework had over a hundred of such components that we customized and delivered to clients in a way that was the most beneficial to them. We’ve also built an IDE to support these components, but for me it was simpler to “notepad” it with a smart XML editor.

It was a very simple model as it was built on top of C++/OLE world supporting multiple inheritance/vtables. Each behavior would automatically expose its public methods, event model and properties. The order of attachments would define the priority. If you wanted to specify particular behavior, you just use behavior name as intermediate selector before property/method name. You can even layer different languages as behaviors – we would use XSLT styling as one of the behaviors. That was the simplest aggregation model I ever seen in world of C++/OLE or anywhere – even in the modern dynamic languages.

Flash 9 VM does neither supports multiple inheritance nor dynamic resolvers (to the best of my knowledge), and Proxy approach might not be good for regular application developers. Now it might be a good time to start adding that functionality back in Flash 9 sub releases and definitely in the Flash 10 to go head-to-head with rails and other modern languages. You really need to apply aspect based programming methodology on system level to afford this approach – or have tools to do it under the cover. However, I feel that the tools approach will take longer and will cause slower adoption.

The power of externalizing the functionality is just awesome. You clean up a lot of code, and get more choices in the process. Reusability of the code becomes obvious. It takes some time to learn, but it makes you a better thinker. All cumbersome patterns go away as you concentrate on one thing at a time.

We never gave up on this architecture, and it proves to be the most powerful feature of our current framework of Flex components. I will publish some samples this week to show how trivial the code looks like in comparison to typical Flex programs yet delivering more functionality.

Ely presented architectural diagrams illustrating how things are interconnected now and how they can change in the new architecture, and I could not help seeing it as a live biological system going through a major transformation. Application components are the cells of the living and breathing application. In the current development we are integrating more and more specialized creatures without their own DNA (hence viruses) directly in the cells using ever extending set of backdoors. Managing viruses is a nasty business, taking all kinds of the resources. Proposed architecture is more of bacterial helpers, attaching to the cells, but not breaking in, exchanging energy and processing waste. It holds better promise over brutal methodology of “gene engineering” and provides open space of growing specialized “cultures”. Count me in.

Sincerely,

Anatole Tartakovsky

I do not know. Let us do a mall exercise first. Open a new Flex project and create a new FDS application project. Before you even write a single line of code Flex creates 30 files and 120+KB of code in background. You can see them by adding –keep switch to the compilers command line. Before you are finished with login screen you have 100 files in the generated folder. Is it good or bad?

It is expected. It is good in a sense that you do not have to write this code yourself. It is good that it will be compiled rather the interpreted giving you the best performance possible.

Code generators are essential part of every IDE product and there is not need to debate this. Every productivity language/compiler (starting from Assemblers to C to C++ and the modern ones) has some code generators built into it. Most of software development tools I know are using code generators of some kind. Another example – if you are the programmer who are just filling the blanks in someone’s framework as oppesoed to being a creative writer – you are also a code generator to some degree.

There are good and bad code generators, but they are not solving their problems, but rather helping you in solving your application’s problems. They are just the power tools that implement best practices for solving domain problems.

People take domain-specific problems (either in the form of code annotations or just a as a standalone resource like UML in which you embed a host language) and generate the code that you can see and modify. You are doing it every day. For example, Flex processes annotations embedded in the ActionScript and MXML. So when you use [Bindable], [Managed] , [Event] or just include CSS references you are telling Flex code generators that you want certain patterns applied to this code fragment, and Flex generates a bunch of files in the background. You really have to be hands-off to use and denounce code generators in the same time.

Code generators are getting better and better. Bugs are eliminated, the language flexibility increases, new domain problems are added and automated. The best optimizing compiler produce better code (efficient, compact or anything in between) then any human. With alphas and betas of Flex, I’ve been studying the code in the folder generated . After a wile, the entire process became completely transparent to me.

Our code generators belong to the 3^rd generation. They work in background, generate and insert the into “invisible” locations. You do not need to see this code or build the resulting code separately. They perform hot deployment and provide automated and visual test code. You apply your code changes directly in the mix of the application code and domain annotations. You never have to see generated files – or at least not more often then you have to see files generated by Flex. For certain types of applications one person can be as productive as 3-4 developers. He does it faster and with less effort. The concepts of code visibility and rules of generated code invocation are identical with Flex even though the products are coming from different environments, but after all these are common best practices of the modern software development.

I think the problem is that most of the people think of generated code as source. Let me give you another example. We take a Java file with some SQL or other annotations and run it through our code generator. It produces the DAO and Assembler classes, multiple DTOs, deployment descriptors, deploys the jars and places all low level artifacts that you do not need to touch (ever) in your Flex project. That is where most code generators stop. We made sure that our generators are fully open; you can add templates for generating other type of code and modify the existing ones.

Over time, your reference implementations will have templates for databound datagrids, forms, master/details forms, reports, TreeGrids and other TEST samples for people to try the power of really fast development. The main target with the products are metalanguage files disguised as MXML extensions. However, people can take test the code and happily embed it in application. The changes come and they have to propagate these changes manually – and they say the process does not work.

That process indeed does not work – but it’s not the code generator’s fault. It just means that while the tool was working with annotations in Java and users somehow expected it work transparently on Flex side (and we did not have any annotations there yet). In order to achieve the  synchronization between Flex and Java,  you need another code generator that would allow you to process Flex annotations in the Flex compiler. We requested that feature in compiler over a year ago, and I was told it is in the plans for Flex 4 . However, as soon as Flex compiler goes open source, it should be fairly simple to embed your own code generators that would enable synchronization. For now, when we need to augment Flex with business domain functionality like business expressions a la Excel or Powerbuilder, we run source-to-source generators that are transparent to the developer.

Sincerely,

Anatole Tartakovsky

PS. I wrote these notes on the flight home. These morning I thought about other things, and I believe I got an idea why some people  do not believe in code generators:

1. They were much younger than me. Coming from the times when bytecode referred to bytecode of CPU, quest for Productivity Holy Grail is automatic for me. And experience with preprocessors, RADs, 4GLs and metalanguages allows me to see different implementations of generators as probably the most powerful way to incorporate best practices . Here is how I see it: It is ok to teach people how to recognize patterns and communicate among themselves using these patterns. A code generator is a way to communicate these patterns to the computer in the best possible implementation using the input provided by people using the patterns.

2. Somebody needs to explain people the difference between code generators and source code generators. A lot of people went to preceding Flex 3 sessions where they saw dialogs based code generation for PHP. They automatically associate (that’s what people do best after all) the CRUDe source generator with the similar functionality provided by domain extensions of our code generators. Well, if I’ll ever be invited to participate in a keynote, I’ll try to explain it to more people so there won’t be any confusion

Anatole Tartakovsky: We are trying to balance it by type of the functionality and type of the people writing the code. As David said, with pure UI markup you are better off with MXML as it generates tons of ActionScript behind the scene you would have to write by hand otherwise. MXML is painless and easy. For framework and reusable layer you are usually better served with ActionScipt as it gives you better control of object oriented features and forces you to think in more traditional environment. Also, based on the people involved in the project, I want to throw few more things in the mix. First, you might want to add CSS to your MXML files so designers can start playing too. Then you might want to extend MXML with data driven UI or business functionality so business analysts or end-user directly affect UI and behavior of the application. Data-driven is extremely important as it really enables personalization and gives a lot of control either to the systems administrators or end-users. Finally, Java back-end developers really prefer ActionScript classes before they become comfortable with the MXML, especially with automatic code generation of these proxy objects directly from Java code. These criteria’s allow having more people working together without stepping on each other’s toes. In the end, it will all be either compiled or interpreted by ActionScript, but it maximizes the reuse and makes process more manageable.
…
JB: On the subject of bindings – it is such an interesting feature and it adds so much to language – one person in the company said that binding is feature that violates encapsulation in very special way. You think you are making just an assignment and all sequence of changes start to happen throughout the application. And I want to hear from the panel what kind of the problems they encountered by using the binding?
AT: There are cases when binding is not very useful – cases with XML data structures or data that is not strongly typed. Binding of dynamic data classes require you to use descendents of ObjectProxy and that is often more challenging then what it is worth. Another case when it is difficult is when you use controller on the data object and it is not coded properly – you usually want to have either binding or controller – and I personally usually go with binding.
On the other hand, for majority of the applications binding is true blessing as it allows you to write very generic helpers that will do state management, synchronize data with the server, and generally write less code. Flex compiler/framework will generate quite a lot in background, and I encourage you to look in generated code to understand how it will impact your application.
But having automatic end-to-end data binding is a very important feature. Having the ability to load data, modify it and apply on the server represents significant portion of the code you write daily. We are using code generators to produce most of the code on both server and client side: deployment descriptors, DTOs, actual DAO and View MXML, etc..
Code generators support both [Bindable] and [Managed] versions of code binding. We also roll out few our own versions of the implementation, adding events that are part of the client’s requirements or changing timing of the standard events as an example – sometimes it is more appropriate to use them in asynchronous models.
The key is to keep binding “contained” and Flex uses [Array]Collection and their descendents to encapsulate data and act as thin controller that will consume most of the events, and will propagate “aggregated” events to the listening object. It is perfect place to put both generic (like state management) and business (like calculating totals) functionality. Small framework allows you to isolate your application from data binding implementation – including data retrieval and synchronization. We actually provided “open source” implementation of flex data services client in the book and articles.

JB: Moving on other topic, I would like to talk on frameworks. Cairngorm and some other frameworks that I call “shallow” frameworks. They are not necessarily provide a lot of functionality in a sense that Flex frameworks does. It provides what you might call Superpad – a set of interlocking patterns. I wonder if a shallow framework provides cure or actually causes disease by blocking developers from providing solutions and analyzing the problems.
AT: That is exactly the problem we are seeing. People come to us to rewrite Cairngorm projects. Cairngorm is answering to “how” question, but “why” or “what” just is not in the picture at that point. We believe that you should take some patterns – and enhance them on individual basis for a particular application, but the “meat” of the solution is in the developer’s framework. People need to have big pieces of an application available as components, customizable products that can perform common functions and transparently be used in the application. They are tested and give you the functionality that you want right away. You can start with small, single function components like logger or “caching logging” screen David mentioned, or you can try deep waters with complete set of components that very much fill the gaps in the current Flex frameworks. Over the years, we added objects like Report, DataForm, TreeGrid, OlapTreeGrid, etc. We added the functionality that is important for reliability of your applications like robustness layers for communications. Architectural frameworks are very much like skeleton of the application, and Application Framework is actually adds muscle – you can’t have one and not the other.
JB: The next question is if you use default HTML template in Flex builder or you feel it is necessary to customize?
AT: We usually customize the template – primarily for interoperability with external applications or system functions. Typical example is when you need to transfer data to Excel, mashup/history/Search Engine Integration and other system functions. The other sample would be to pass extra flash version specific parameter – for example, the code that would allow application to go full screen.
JB: What do you think of Designer/Developer workflow?
AT: I believe that while there are cases when you have designer and developer working “sequentially”, it can greatly extend the development time, which should not be a problem for consulting companies .. If you take this process to extreme, a developer will also wait for the back-end developer to complete code. In turn, a designer would have to wait on business analyst and back-end developer waits on architects/model designer. Given the way things usually are Flex developer will have a tiny fraction of the time to actually implement the application.
The other option is to start working from the functional spec in parallel. It is very much like digging a tunnel from both ends. While there is a chance of meeting somewhere in the middle, it is not easy.
I actually think that you should start from something that is agreed by everyone – start in the middle and dig out. We use Flex in a way that every person on the project can work in parallel. You start with a rather crude version of the generated screen and model, and you do refinements as you go. It is more manageable then it sounds and it is the direction taken by Flex Team for the next versions of the product.
Question from the floor: How do you deal with the problems with tag like event handling, debugging, etc.
AT: Modules are designed to be separate applications and while you can establish some patterns via use of interfaces any attempt to make them “friendlier” will require more custom code on both sides. We do not to use mx:Module but rather create library projects and turn them into “self-initialized” libraries/swfs with automated build process. Every library becomes “swc library” for references from outside code so you can reference classes, get strong data types resolved, etc., It is also compiled and deployed by mxmlc compiler you use to compile Modules as application. The auto generated main object is inherited from SimpleApplication object to save space ( but can be inherited from Module) to be loaded instead of module. In that case you have advantages of referencing the code the same way you would reference object in any other SWC library (you just need to mark it “external), have strong type support, and load it on demand.
This technique is described in our book and in Flex Developer’s Journal – it’s available online – just google it.

I will be posting on some random thoughts I had during that sessions – hopefully tonight on the way back

Anatole Tartakovsky

This is embarrassing as you can kind of derive it from documentation if you know it is there, but I asked few Flex experts if they knew about this compiler feature – feel much better now as nobody knew as well.

OK, we are talking about <strong>keep-as3-metadata</strong>=<em>class_name</em> [...] option -  here is excerpt from help:

Specifies metadata that you want to keep.

By default, the compiler keeps the following metadata:

· Bindable

· Managed

· ChangeEvent

· NonCommittingChangeEvent

· Transient

If you want to preserve the default metadata, you should use the += operator to append your new metadata, rather than the = operator which replaces the default metadata.

This is an advanced option.

That means that you can ask compiler to keep information about events your objects declare. You can define your own metatags, and they can be persisted in the class definition as part of objects XML definition.

You still cannot use metatags at the compile time as compiler stays closed till (and then some time after they open sources it due to standard “acceptance” process), but you can use these annotations in runtime. That opens a whole new world of embedding and using metadata information – that is really a major feature for any framework/component developer.

I need to do some performance and usability tests, but the way it looks like now it is the most straightforward and efficient way to embed/carry the metadata.

Sincerely,
Anatole Tartakovsky

Come say hello if you are at MAX, I will also be in the “ring” for “Best Practices” session on Tuesday.

Anatole Tartakovsky

I am an old user of SQL tools that allow you to use SQL as a language, provide metrics, execution plans, use statistics, etc. A typical enterprise query can take seconds or hours – it is up to the programmer in most cases. As far as updates go, they never come by themselves. Transactions, workflow triggers and messaging are just a beginning.

You can try to wrap the generated code or service with additional assemblers. You loose development transparency as these are the wrappers for thing that are going to be re-generated. Additional management, build and fixing errors eats up all time saved by the code generation.

The second problem is with generics. I love to do more stuff with collections, arrays and lists. I also like Object and HashMaps – in some portions of the code. But strong typing provides performance, size and coding benefits that are hard to overlook.

I am guilty of building both types of code generators in the past. After using them for different industries and applications, I can say that their applicability is very limited: these code generators work for the low-end systems that have very limited use for them in the first place. For most of the systems you have to have a two-way tool, which allows you to write your own code in addition to the generated one.

The productivity environments that interpret back-end data are mixing SQL as first-class citizens with the application code. That is the only way to reach required flexibility. With compiled languages like Java it is not that simple. In order to achieve high performance and flexibility you need to mix the code but generate artifacts to work with SQL during the compilation stage. Java annotations (and SQL embedding for C++) are typical technologies that we use
The concept is very simple – you use abstract classes to mix your application code with the abstract methods for SQL code. This abstract methods are annotated with SQL. You can code against strongly typed classes and if the code generation fails, your compiler complains about abstract methods.

With the single point of maintenance we eliminate most of the integration/build issues. You can get the same 55 minutes application done in 5, but important point is that you will not be stuck for days afterwards.

If you have just five (not fifty five) minutes, please watch this pre-recorded demo of our code generator called Clear Data Builder.

Sincerely,

Anatole Tartakovsky