WIth commercial release of Android the need for socket server might go away as long as AIR provides extended URLRequest object to send all information needed for Android interprocess communications as well as mode for execution of such requests. Would be much simpler task to implement on AIR level of course then building full blown bridge and class loader.

Sincerely
Anatole Tartakovsky

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

• by treating PDF printing as one of the features of your Flex application, seamlessly providing printing functionality (with or without LiveCycle Designer)

• by using Snapshots available in LCDS, which uses bitmaps to represent Flash content
While the first process provides guaranteed quality and predictable results, it also requires a double effort of developing XDP and Flex forms and introduces the model and communications that can be foreign to the application domain.
The third type of printing is good for screen-only PDFs due to low DPI used by the screen snapshots. Flex 3 should provide control over the DPI resolution.
The second process is more applicable when the document structure is dynamic (like the end-user customizable report or form). It often produces better printing quality with the current version of LiveCycle Data Services ES (formerly Flex Data Services) Flex. The idea is to send the server not the data for merging with the form, but already merged compressed document in XDP format containing both data and formatting. In this case LCDS layer just needs to process it with XDPXFAHelper class and returns it as a PDF stream to the browser for displaying.
The next code sample is the server side part written as JavaServer Page (createPDF.jsp). Note, that you need to have a commercial license of LCDS as its Express version does not support PDF generation.
<%@ page language=”java”
import=”java.io.IOException,
javax.servlet.http.HttpServletRequest,
flex.acrobat.pdf.XDPXFAHelper,
java.util.zip.Inflater,
java.util.zip.InflaterInputStream”
%>
<jsp:directive.page import=”java.io.InputStream”/>
<jsp:directive.page import=”java.io.ByteArrayInputStream”/>
<jsp:directive.page import=”java.io.FileInputStream”/>
<jsp:directive.page import=”java.io.FileOutputStream”/>
<%
//Load compressed XDP stream (received from client)
//into a byte array
byte[] result = new byte[5000000];
int resultLength =0 ;
try {
Inflater decompresser = new Inflater( );
byte[] ba = new byte[500000];
ServletInputStream si = request.getInputStream();
int k = 0;
int i = 0;
while (true ) {
k = si.read(ba, i, 500000);
i +=k;
if (k<=0) break;
}
try {//Uncompress data into result
decompresser.setInput(ba);
resultLength = decompresser.inflate(result);
} catch (Exception e) {
System.out.println(e.getMessage());
}
} catch (IOException e) {
throw new ServletException(e);
}

//The next line won’t work unless you have a commercial
// LCDS. It’s not available in Express edition
XDPXFAHelper helper = new XDPXFAHelper();

try { //load the input into PDF convertor
helper.openFromByteArray( result );
} catch (Exception e) {
e.printStackTrace();
}

// Save new PDF as a byte array
byte[] bytes = helper.saveToByteArray();

//Send PDF to the client(GZIP compression can be
// provided by an external filter)
ServletOutputStream out2 = response.getOutputStream();
response.setContentType(“application/pdf”);
response.setContentLength(bytes.length);
out2.write(bytes);
out2.flush();
out2.close();
%>

On the client (Flex) side, you need a few simple classes. First you would need an ActionScript class that sends generated XDP to the server and opens the browser page for displaying the incoming PDF:
import flash.net.*;
import flash.utils.ByteArray;

public class FormRenderer
{
public static function openPdf(xdp:String,
target:String=”_blank”):void
{
var req:URLRequest = new URLRequest(“/createPDF.jsp”); req.method = URLRequestMethod.POST;
var ba :ByteArray = new ByteArray();;
ba.writeMultiByte(xdp, “iso-8859-1″);
ba.compress();
ba.position = 0;
req.data = ba;
navigateToURL(req, target);
}
}
}
Now all we need is an XDP file with the data and presentation. While it is feasible to make an XDP file programmatically we usually recommend to start with blank templates made in LiveCycle Designer (comes with Acrobat Professional) matching the printer’s paper size/corporate stationary. XDP documents are XML objects, and EcmaScript for XML (e4x) makes the XDP building process in Flex a breeze. For example:
1. Declare a variable of type XML, and using e4x syntax read the XDP template that matches the document and the paper size. A fragment of XDP template may look like this:
<?xml version=”1.0″ encoding=”UTF-8″?>
<?xfa generator=”AdobeLiveCycleDesigner_V8.0″ APIVersion=”2.5.6290.0″?>
<xdp:xdp xmlns:xdp=”http://ns.adobe.com/xdp/” timeStamp=”2007-01-25T10:40:38Z” uuid=”784f469b-2fd0-4555-a905-6a2d173d0ee1″>
<template xmlns=”http://www.xfa.org/schema/xfa-template/2.5/”>
<subform name=”form1″ layout=”tb” restoreState=”auto” locale=”en_US”>
<pageSet>
<pageArea name=”Page1″ id=”Page1″>
<contentArea x=”0.25in” y=”0.25in” w=”8in” h=”10.5in”/>
<medium stock=”letter” short=”8.5in” long=”11in”/>
<?templateDesigner expand 1?></pageArea>
<?templateDesigner expand 1?></pageSet>
<subform w=”8in” h=”10.5in” name=”YourPageAttachedHere”/>
<proto/>
<desc>
<text name=”version”>8.0.1291.1.339988.308172</text>
</desc>
</subform>
</template>
…
2. Select a Flex container or control that you are going to print, i.e. a Panel, a DataGrid et al.
3. Query the object from step 2, get its attributes and children and create the XML preparing this object for printing. Attach the XML to the template as a page. If you have your own presentation framework, all components can implement your own interface (the code below shows IXdpContent with the only getter function xmlContent) that allows to traverse the list of elements on the screen for their XDP content. You can also have a processor that would provide the XML for standard classes. Here is implementation of generic DataGridItemRenderer to illustrate how you can prepare for printing just one datagrid cell:
package printing
{
import com.theriabook.controls.superGridClasses.DataGridItemRenderer;

public class DataGridItemRendererXdp extends DataGridItemRenderer
implements IXdpElement
{
public function get xmlContent():Object
{
var o:XML = <draw x={convert(x)} w={convert(width)}
h={convert(height)}>
<ui>
<textEdit>
</textEdit>
</ui>
<value><text>{text}</text></value>
<font typeface={getStyle(“fontFamily”)}
size={(getStyle(“fontSize”)*4/5)+”pt”}
weight={getStyle(“fontWeight”)}
posture={getStyle(“fontStyle”)}
underline={getStyle(“textDecoration”)==”normal”?1:0}
>
<fill>
<color value={rgb(getStyle(“color”))}/>
</fill>
</font>
<margin topInset=”0.5mm” bottomInset=”0.5mm” leftInset=”0.5mm” rightInset=”0.5mm”/>

<border>
<edge presence=”hidden”/>
<edge presence=”visible”/>
<edge presence=”hidden”/>
<edge presence=”hidden”/>
</border>
</draw>;

return o;
}
private function convert(val:Number) : String {
return val/96 + “in”; //convert 96 dpi to inches
}
private function rgb(val:Number) : String {

return (val >> 16 & 255) + “,” + (val >> 8 & 255) + “,” + (val & 255);
}

}
}
4. Repeat the process of attaching XML to the XDP template using E4X until all print pages are ready.

In my opinion, this method of printing from Flex requires less efforts for reporting and creation of dynamic layouts. It might also provide better printing quality and searchability within printed document.

The method
Hope this helps,
Anatole

Well, that does not really mean much in the real world. Here I was getting random disconnects, lost, out of sequence, corrupted and duplicate packages. The application was very much confused at best.

By the time it stopped raining I was ready for more. So I set up a Linux server, installed netem’s network emulation software and deployed my application there. By doing that I was finally able to put in order some chaos of disruptive networking issues. Netem allows you to provide any permutation of the latency, out-of-sequence packages, lost and erroneous ones, duplicates over local network – in this case, within VMWare on my laptop.

By the end of the day I am able to make the system work on par with the last century cell phone modem connection. That is just a pure luck that the system was designed with all the hooks for custom QoS and did not require rewrite of the communication server.

Quick setup of that VM as a bridge ( VMWare provides virtual adapters, you can just route your local traffic via that VM), and I am testing publicly available AJAX and Flex sites. Very few survivors out there – most of the applications die quietly at best.

Rich Internet Applications are being positioned to replace their client/server peers. It is extremely important that they can deal with disruptions in a robust manner, so the business operation can continue uninterrupted in a slow mode. Breaking transactions is not an option. Given utmost priority to this will affect design of your production-grade application and development schedule.

Sincerely,

Anatole Tartakovsky

Personal note: I noticed today that I am spending less then 30% of my time in Microsoft OS and most of the time in Linux. It appears that all 3rd party system developers are abandoning the platform – there is virtually no shareware/inexpensive or just decent tools for network simulation. As for usability, few times this week I was about to remove Vista from my desktop. It is definitely time to switch from Microsoft to Linux/Mac for base OS. Too bad Apple can’t fulfill on the promise to make OS available on high-end PCs – it just does not make sense to go from thinkpad t60p to Mac laptop – they are virtually identical, with better expandability on thinkpad side.

I wasted a whole day on what should have been a trivial task – adding and ability to send some client context information alongside with an AMF request. Passing the request’s header information (i.e. information that is not passed with the RPC call but can be picked up by querying context mechanism) is quite common in Java programming.

I started by trying to pass the user name across the wire. With RTMP or HTTP requests you just add the objects you need to pass along to the HTTP header.

Setting up the Java side literally took 10 minutes – subclassing the FDS endpoints, creating the context class that would be used for keeping the information within thread execution:

package com.farata.remoting;
import java.util.Hashtable; import flex.messaging.endpoints.*;
import flex.messaging.MessageBroker;
import flex.messaging.config.ChannelSettings;
import flex.messaging.messages.Message;

public class CustomAMFEndpoint extends AMFEndpoint {

public CustomAMFEndpoint(MessageBroker broker, ChannelSettings cs) {super(broker, cs);}

public CustomAMFEndpoint(MessageBroker broker, ChannelSettings cs, boolean enableManagement) {super(broker, cs, enableManagement);}

public Message serviceMessage(Message message) {

Hashtable ht = new Hashtable();

ht.put(“context”, message.getHeaders());

MessageContext.setParams(ht);

return super.serviceMessage(message);
}
}

Here’s the “by the book” implementation of the Context object using Java’s ThreadLocal class:

package com.farata.remoting;
import java.util.Hashtable;

public class MessageContext {

public static void setParams(Hashtable session) { sessions.set(session); }

public static Hashtable getParams() { return (Hashtable)sessions.get(); }

private static ThreadLocal sessions = new ThreadLocal();

}

Let’s use a classical HelloWorld.java for testing:

package com.farata.test;

import java.util.HashMap;
import java.util.Hashtable;
import com.farata.remoting.MessageContext;
public class HelloWorld {

public String hello() {
Hashtable ht = MessageContext.getParams();
HashMap context = (HashMap)ht.get(“context”);
return “Hello “+ (String)context.get(“user”);
}
}

Done with Java, here comes the Flex turn. Now we need to subclass the ActionScript class Operation to update the message headers when the operation is being invoked:

package {

import mx.rpc.remoting.mxml.Operation;
import mx.core.mx_internal;
use namespace mx_internal;
import mx.rpc.AsyncToken;
import mx.messaging.messages.IMessage;
import mx.rpc.remoting.mxml.RemoteObject;

public class ContextOperation extends Operation {

public function ContextOperation(svc:RemoteObject = null, name:String = null):void {

super(svc, name);

}

mx_internal override function invoke(msg:IMessage, token:AsyncToken=null):AsyncToken {

msg.headers.context = {user : “Anatole”};

return super.invoke(msg, token);
}
}
}

Now the client’s test application:

<mx:Application xmlns:mx=”http://www.adobe.com/2006/mxml” xmlns:local=”*”> <mx:Button label=”hw” click=”ro.hello()”/>

<mx:RemoteObject id=”ro” operationClass=”{ContextOperation}” destination=”com.farata.test.HelloWorld” result=”Alert.show(event.result)” /> </mx:Application>

So far so good, we are getting back “Hello Anatole” as expected. Here comes trouble – you can not use mx:method with this solution – operationClass is not being used with the template used by Flex compiler, which generates the following ActionScript code (you can see it with the help of -keep compiler’s option):

private function _RemoteObject1_i() : mx.rpc.remoting.mxml.RemoteObject
{
var temp : mx.rpc.remoting.mxml.RemoteObject = new mx.rpc.remoting.mxml.RemoteObject();
ro = temp;
temp.destination = “com.farata.test.HelloWorld”;
temp.operations = {hello: _Operation1_c()};
temp.initialized(this, “ro”)return temp;
}

private function _Operation1_c() : mx.rpc.remoting.mxml.Operation{

var temp : mx.rpc.remoting.mxml.Operation = new mx.rpc.remoting.mxml.Operation();
temp.name = “hello”;temp.addEventListener(
“result”, ___Operation1_result);
temp.addEventListener(“fault”, ___Operation1_fault);

return temp; }

I did not expect to see “new mx.rpc.remoting.mxml.Operation()”, but rather new ContextOperation.  This is clearly a bug in the template used by the code generator, which I could have fixed myself and returned the fixed version back to Flex developer’s community. Unfortunately, the code of the templates is not available.

Frameworks that use code generators need to open templates so enterprise developers can extend them. Extension of the framework means symmetrical changes in templates, so if you allow one, you should allow the other. Also, in order to take an application framework to the next level, the preprocessor/code generation passes need to be extendable by developers as well .

Please open up AMF/RPC and Flex compiler or at least set up the community process to let us quickly fix such bugs.

Thank you,
Anatole

1. Identify if the player is capable of displaying the Web application on the full screen.
2. Apply ‘fullScreen’ to displayState property of the stage

The first step is usually done by parsing the version numbers (major, minor and build) of the player using Flex regular expressions:

public static function fullScreenEnabled ():Boolean {

var versionString:String = Capabilities.version;

var version:RegExp = /\w\s+(?P<major>\d+),(?P<minor>\d+),(?P<build>\d+),\d+/;

var result:Array = version.exec (versionString);

var majorVersion:Number = Number (result.major);

var minorVersion:Number = Number (result.minor);

var buildVersion:Number = Number (result.build);

enabled = (majorVersion >= 9) && ((minorVersion > 0) || (buildVersion >= 28));

return enabled;

}

If you’ll follow some online suggestions on implementing the second step, you’ll run into problems:

this.systemManager.stage.displayState = state?”fullScreen”:”normal” ;// wrong

this.systemManager.stage["displayState"] = state?”fullScreen”:”normal” ;// won’t work either

Developers in Java and Flex world usually assume that if the code passes compilation ( and here we have strict references ) the linkage issues are resolved. However, this code will throw an exception if executed in older versions of Flash.

Either of the following two approaches will work :

if (“displayState” in systemManager.stage) this.systemManager.stage.displayState = state?”fullScreen”:”normal” ;// OK

try {

if (“displayState” in systemManager.stage) this.systemManager.stage.displayState = state?”fullScreen”:”normal” ;// OK

} catch (e:Exception) {}

It becomes even more relevant when developing components that are reused by both Flex and Adobe AIR.

Thank you,

Anatole

AIR is THE SOLUTION to these problems.

We have been developing large AJAX applications for enterprises between 1999 and 2005.
Along the way, we had to “upgrade” the browsers our clients used with extended HTTP protocol for reliability and performance.
We had to complement browser security model to allow business printing and controlled file access.
We had to provide framework of high level controls like datagrids, treeviews and tabfolders to make AJAX programming more productive.
And we made JavaScript pre-compilation available so large applications can load and interact faster. Most of AJAX frameworks are still in infancy because the bandwidth and JavaScript performance /precompilation limit what they can do.
In short, by building real-world application we had to build proprietary AIR/Flex platform for our clients.
When we talked to Microsoft 3 years ago of what the next version of IE could be – and explained our vision – they bluntly said that it would be a competition to Vista. They wanted the browser dead and Vista replacing everything as an application platform.
Here is a funny part – since then they spent billion of dollars buying technology to catch up in their AJAX offering. They did it for a reason – AJAX is what businesses are spending on NOW. It is GROWING not because of the technical merits, but because of the KISS (keep it simple stupid) aproach and speed of delivery using existing trained staff. We are spending time and money making our Flex controls like interactive reporting tool to be available as Flex component for AJAX – there is huge market there as AJAX can’t compare with the power and reliability of mash-ups.
Marketing at Adobe needs to take higher aim with this product�- they need to appeal to the right people�NOW to make the product success – and these are the people way outside of Macromedia / Adobe camps.
Sincerely,
Anatole Tartakovsky

The implementation shown below is based on FDS 2.0.1. I might have separate entry on implementation with MidnightCoders product or openAMF/Tomcat with non-blocking IO Connector later this Summer.

Step 1. Teach Messaging to understand RPC calls:

This code is a slight variation of the BatchGateway AMF “batch handler” from the book. Optimization is removed for brevity. You create new descendent of RTMPEndpoint class that would watch for message coming through RTMP channel to be “RemoteCall” :

private Object processCall(String destinationName, String methodName, List parameters) throws IllegalAccessException, IllegalArgumentException, Throwable { Object result = null;

initRemoting();

RemotingDestination remotingDestination = (RemotingDestination)srv.getDestinationByName(destinationName);

FactoryInstance factoryInstance = remotingDestination.getFactoryInstance();

Object instance = factoryInstance.lookup();

MethodMatcher methodMatcher = remotingDestination.getMethodMatcher();

Method method = methodMatcher.getMethod(instance.getClass(), methodName, parameters);

try {

result = method.invoke(instance, parameters.toArray());

}finally {

factoryInstance.operationComplete(instance);

}

return result;

}

public Message serviceMessage(Message message) {

if (message is AsyncMessage and message.body is RemoteCall)

RemoteCall bm = (RemoteCall)((AsyncMessage)message).getBody();

try {

Object o = processCall(bm.destinationName, bm.methodName, bm.parameters);

AsyncMessage am = asyncMessage(message);

am.setClientId(/*you need to pass rtmp consumer id here – will add later*/ “1″);

am.setBody(o);

rtmpServer.push(am, am.getClientId() ); }catch(Exception e) {…}else return super.serviceMessage(message);}private AsyncMessage asyncMessage(Message message) { AsyncMessage am = new AsyncMessage();

am.setClientId(message.getClientId());

am.setCorrelationId(message.getMessageId());

am.setMessageId(UUIDUtils.createUUID(false));

am.setDestination(message.getDestination());

return a;

} Now register new RTMPEndpoint in services-config.xml and you can execute POJO calls over RTMP.

Now register new RTMPEndpoint in services-config.xml and you can execute POJO calls over RTMP.

Step 2. Call to the server is implemented with single API in descendant of Producer:

public static function call(rc:RemoteCall, r:Responder = null, noneOneMany:String = “none”) : AsyncToken {

Messsage m = new AsyncMessage(rc);

var t : AsyncToken = new AsyncToken(m);

ConsumerForRPC.calls[m.messageId] = t;

send(m);

return t;

}

Step 3. On the client side, establish Consumer receiving point. You will need just descendent of Consumer object to be connected to the same destiantion so you can start receiving the messages. You will also need to provide Producer/Consumer association to the RTMPEndpoint (see commets in the code) so the responses are sent to the appropriate client.

Here is a piece of code in the consumer that allows you to do RPC from the server to the client:

private static function processMessage(message:IMessage) : void {

if (message.body is RemoteCall) {