Flex remains a great solution for developing UI for the enterprise Web applications, and our company,Farata Systems, is committed to support any client who decides to hire us for any Flex/AIR Web/Desktop/Mobile project. But the world of software and hardware is hugely different in 2012 comparing to 2006. And we are stepping into the same JavaScript river once again.

Well, it’s not exactly the same river. It was renamed. The authorities replaced the old road sign AJAX with HTML5, but let’s not get fooled. It was DHTML ten years ago, and it remains DHTML now: HTML, JavaScript, XMLHttpReuest object, and CSS. But the modern Web browsers employ faster JavaScript engines, CSS is a lot more flexible, smart phones come with dual core CPUs, the speed of WAN is faster too (ok, just a little bit).

More and more enterprises are adopting HTML5/JavaScript, but software architects and developers are still looking for the features available only in the VM-based clients. Will an XYZ JavaScript framework manage client state, support atomic transactions and provide server-side push? Will it offer declarative UI programming, flexible layouts, rich component library, good event model? How many extra kilobytes has to go over the wire to the client if you use this framework? Will the XYZ step up to MVC, modularity, and reliable communications? What are the requirements for the developers’ skills? Is the learning curve steep?

Sounds familiar, isn’t it? We had to solve these issues in the past, and we’ll do it again. Promise. After spending some time trying to pick THE JavaScript framework that can address all these demands of serious Web applications, I can report that you won’t be able to find THE framework. But the good news is that by combining more than one framework you’ll be able to create a well performing and reliable Web application.

Based on on the research conducted in the underground labs of Farata Systems, I can report that our JavaScript framework of choice is Ext JS by Sencha. This framework can serve as a solid foundation for any serious JavaScript development. We’ll also use a couple of more lighter frameworks on as needed basis.

I’m also happy to report that we’ve created an alpha version of our Clear Data Builder (CDB) tool that will offer automatic code generation for JavaScript/Java CRUD applications with transactional support and other goodies that will substantially increase the productivity of JavaScript developers. CDB won’t be an alternative, but rather a compliment to any JavaScript framework.

In a couple of months we’ll publish the first demo that will show an automated generation of a CRUD application using use Ext JS, CDB, MyBatis, and Java. Why MyBatis? Because we like writing SQL, but the demo that uses Hibernate will come shortly after. We already started a new consulting project to prove that we can eat our own dog food, and this food has a good taste.

Yakov Fain

There were lots of applications for becoming initial committer to this new Apache Flex project. Only 25 of them made the list, and I’m happy to report that Farata’s own Anatole Tartakovsky has been accepted to this list. Just to make sure you understand Anatole’s caliber, I can tell you that five years ago he sifted through 16 thousand lines of code of Flex most complex component – DataGrid – and turned it into a more elegant object by removing about a half of its code. Back than, we had no easy way to make this component a part of Flex SDK.

The list of committers includes a number of people knowing really well what Flex has under its skin: Alex Harui, Michael Labriola, Peter Elst, to name a few. So the brain power is in place. But there are two sections in this proposal that bother me:

Known risks.
Moving from a corporate-led project to the Apache model of collaboration is a challenge, and Adobe is committed to help making the transition as smooth as possible, by delegating employees to work on the new project. We would like to see more free collaboration from the community but with the same principles that has kept Flex with the high-quality design and ease-of-use it has maintained under Adobe’s governing hand.

If I’d read this paragraph two months ago, it would sound great to me. Not anymore. It includes the words “Adobe is committed to…”. Sorry, can’t trust to any commitments made by this company that published an that infamous blog on a day that should be remembered as 11/9.

The second section that can kill this project is titled “External Dependencies”, but should be renamed into “Strings Attached”:

Some parts of Flex development rely on third-party libraries. The complete list is still being determined but some are:
• Adobe AIR SDK
• Adobe Flash Player SDK
• Adobe Text Layout Framework (TLF)
• Adobe Open Source Media Framework (OSMF)
• Adobe Font Engine (AFE)

Flash Player is a VM. Flex framework is pretty much useless if a VM won’t support it. Even if the next version of Apache Flex will include some killer features, how good it is if Flash Player won’t support them? It’s hard to believe that Adobe will plan future releases of Flash Player based on the needs of Apache Flex. I don’t like the phrase “We have made it clear to our community that going forward, the community, rather than Adobe, will determine the future of Flex.” Dear Adobe, we can’t determine the future unless you open source Flash Player. Open source might have an alternative though – not to use Flash Player as a runtime. Flex compiler makes a couple of passes producing first the ABC code (ActionScript Byte Code), and only then the byte code for Flash Player to run. If an open source community will come up with a compiler to turn ABC code into another run-time engine, Flash Player won’t be needed (this is how Adobe AIR apps get deployed in iOS now). But what other runtime?

The other big ticket item is Adobe AIR SDK. This is an great SDK for cross-platform desktop and mobile software development. AIR relies heavily on Flex SDK, and keeping in sink future releases of Apache Flex and Adobe AIR is not a trivial task.

What about the tooling? Flash Builder is always lagging behind, but Flex developers are using it. The proposal reads, “The existing Flash Builder trademark will be used as a commercial entity.” I’d rather see Flash Builder at Apache, but this is not a show stopper. JetBrains IntelliJ IDEA is a better IDE than Flash Builder and, hopefully, they’ll become a tool of choice for Apache Flex developers.

To summarize, I’m glad that Flex framework is given to the public, but the sky is not as bright as I’d wish it to be.

To make this post somewhat technical, I’m including a code fragment that Flex developers will understand.

<s:transitions> 
    <s:Transition id="greatMove" fromState="Adobe" toState="Apache"> 
       <s:Sequence id="t1" targets="{[p2]}"> 
           <s:Wipe id="ADBE" direction="left" duration="1000"/> 
          <mx:Glow id="ApacheFlex" duration="1000000" alphaFrom="1.0" 
                    alphaTo="0.3" color="0x00FF00"/> 
     </Sequence> 
   </s:Transition> 
</s:transitions>

I didn’t even try to compile the code above. Feel free to try it out, improve, and submit back to share with Apache Flex community.

Yakov Fain

This has to do with fact that the SWF embedded in the HTML Wrapper doesn’t have the focus yet. So you need to ask the wrapper to give the focus to your SWF.

 
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   applicationComplete="giveFocus2SWF()"
			   >
	<fx:Declarations>
		<fx:String id="activateJS">
			<![CDATA[
				try { 
					var el = document.getElementById("%objectID%")
					el.tabIndex = 0;
					el.focus(); 
				} catch (ex) {
					alert(ex);
				}
			]]>
		</fx:String>
	</fx:Declarations>
	<fx:Script>
		<![CDATA[
			import flash.utils.setTimeout;
			private function giveFocus2SWF():void {
				if (ExternalInterface.available) {
					ExternalInterface.call(
						"eval",
						activateJS.replace("%objectID%", ExternalInterface.objectID)
					);
				} 
				userID.setFocus();				
 
			}
		]]>
	</fx:Script>
...

As soon as you leave Flash Player, you run into Web browser compatibility issues. The code above works fine with IE, Firefox and Opera. In order to make it work with Chrome you must define wmode=”opaque” to SWFObject parameters (in HTML template).

It doesn’t work with Safari as of yet, and I’ll update this post as soon as I find the solution.

Valery Silaev

The Flash Player haters quickly picked up this news and to draw attention to their blogs/tabloids started to cash on Steve Job’s name stating that he won the battle with Adobe since Steve was the one who didn’t let Flash Player on iOS.
As of now, I don’t know if these rumors are valid, but even if they are, this ain’t breaking news. Let me explain why in three simple sentences.

1. Adobe AIR includes Flash Player
2. Adobe AIR remains the main and the only means (at the time of this writing) for development of cross-platform mobile applications
3. Adobe AIR 3 Captive Runtime is a way of packaging the runtime inside the mobile application.

In other words, a mobile application developed in Adobe AIR and deployed in Android or iOS has inside the entire AIR runtime (this increases the size of the app only by 6-8MB) and won’t require neither iOS nor Android to ship the proper version of the runtime separately.

Once again, your mobile application has AIR inside, which, in turn, has Flash player under the hood. Machinarium is a good example of a console-quality game for iPad written in Adobe AIR.

The only question remains what will happen with Web pages that includes the videos requiring Flash Player. Most likely Web browsers will use HTML5-based video players. But let’s not confuse mobile applications and Web sites.

Anyway, no need to mourn. Have a wonderful day!

Update. The morning after

Next morning, Danny Winokur, Adobe’s VP and General Manager published a blog confirming the information from Adoleaks. This caused a storm of posts in the blogosphere, which predominantly blamed Adobe for betrayal. Peter Elst, an independent Flash developer even started gathering signatures to have Adobe CEO realize that he’s a bad guy and step down.

Our company, Farata Systems, has been working with Adobe’s product that were relying on Flash Player for more than five years, and we managed to build great relations with lots of corporate customers who used our services in building Flash-based rich Internet applications. After the announcement we started getting questions – was Flex the right choice? Can we reuse our investments in Flex in the mobile space? Should we abandon Flex and switched to HTML5 and JavaScript?

Adobe have caused serious damage to their image by having Mr. Winokur writing this infamous blog. I’m sure the top management of the company has approved it so Danny Winokur bears only a partial responsibility for this. My question is why Adobe decided to use one person’s blog for spreading this rather important news instead of publishing press release prepared with collaboration with their PR agency? Were their top executives ashamed to state it in a manly fashion? Professionally prepared press release could have include the proper wording along with the quotes of industry analysts who would offer their interpretation of the news. Have anyone seen an official PR on this subject? I didn’t.

I guess, after Adobe’s executives realized the size of the damage caused by that unfortunate blog (I hope Mr. Winokur is still employed with the firm), they asked other managers and technical evangelists to save the situation. Have a read:

1. Your Questions About Flex by Andrew Shorten & Deepa Subramaniam. Nice try, but these guys failed to deliver the main message: Adobe AIR 3 is a solid replacement of Flash Player for the mobile.

2. Adobe’s technical evangelist Lee Brimelow has mentioned AIR, but has deliver another wrong message, “No longer having to support the mobile browser version of Flash frees up valuable resources that we can redirect to these more important areas.” This is yet another mistake. Does Abobe put their customers first, or the most important goal is to do a reorg after laying off 750 people?

3. Mike Chambers, the lead product manager, speaks about AIR, but this message can be understood only by techies, and not corporate clients who were sitting on the fence trying to decide if they should develop with Flash or go with HTML 5. And we are talking about the corporate world that brings a huge portion of Adobe’s revenues.

4. Ben Forta, the Director of Technical Evangelism stated “For in-browser experiences on devices, browsers can finally do what they really should do, and we have HTML5 to thank for that.” Really? Who’s ready to start the development of their next cross-platform enterprise project using HTML5 and JavaScript? Does Adobe or any other company have any production-grade solution in this area? Would love to hear about such tools.

Why people didn’t realize that Steve Jobs was heavily promoting writing pixel-perfect applications for iOS-powered devices, not Web pages? Adobe AIR 3 fits this bill. And as I wrote earlier, replacing engines in the browser-embedded Flash videos with HTML-5 one is not a major undertaking. So what the mobile world as the result of this misinterpreted Adobe’s announcement? Nothing. MXML, ActionScript, Flex framework, and AIR 3 remain the tools of choice for cross-platform mobile applications.

When HTML5 can be considered as a main choice for development of applications for both mobile and desktop platforms? It may happen several years from now. It’s great that Adobe is working into this direction, but they should have done it in parallel, not by stopping development of Flash Player without offering HTML5 alternative.

Anyway, the damage is done. Adobe spent years to become a recognized tool maker for the enterprise developers. Five years ago they were known as a company that created Photoshop. They managed to change this image. I really hope that they will find a way to remain on this market.

Here’s my message to Flex, Flash, and AIR developers:

“All IT shops that have invested in learning Flex or ActionScript for developing their desktop-based Rich Internet Applications will use these skills in development of the mobile applications in Adobe AIR. There is no need to jump the ship”

Update 2. After publishing this update I’ve learned that Oliver Goldman, a tech lead from the AIR team has been moved to the team that develops creative cloud. It’s time for Adobe to give away AIR to open source too.

Update 3. Two weeks after the infamous blog of Danny Winokur was published, Adobe made a statement explaining its upcoming strategic transformations.

Yakov Fain

Why ClearDS?

ClearDS has been designed for two purposes. Similar to ANE, it allows to code part of your application in Java with full access to Android SDK. In addition, we can turn an Android device into a server, broadening possibilities for application architectures.

Prior to ANE, simple features like Android Toast and Status Bar notifications as well as advanced ones like Text-to-Speech or Speech Recognition were out of reach for ActionScript coders. ClearDS allows you to embed the Android code into a Java class hosted by a servlet container with  BlazeDS and remote to that class with standard and familiar <s:RemoteObject>. There is no dependency on AIR version and you can natively debug the Java portion of your application using Android Eclipse plugin.

By the same token embedding of BlazeDS into  APK turns your application into a server. Now any computer on the same LAN or VPN can remote to your mobile device. Imagine a scenario where your mobile phone is used as a signature pad where you sign to complete an insurance application or  a financial transaction. Here are some other use cases for your mobile phone:

- bar code reader
- better camera for your notebook,
- voice data/entry gadget that renders alphanumeric keyboard useless, eliminating costly clerical mistakes.

How Does It Work?

We fine tuned BlazeDS to be compatible with a set of core Java classes used by Android. To enable HTTP traffic between the SWF and Java portions of your APK we employed Winstone Servlet Container. Since Android APK generated by the Flash Builder generates a single-activity application, we extended this (activity) class. This allowed us to start the ClearDSService when the activity gets created. The service, in turn, starts the Winstone Servlet container. This allows your SWF-based ActionScript code to remote to your Java code within the boundaries of the same APK.

To make the developers’ life easy, we created the ClearDS Eclipse plugin.When you create a new ClearDS project you effectively create two projects: a Flash Mobile project and Android Java mobile project. These projects are related: the additional builder script of the Flash project contributes the SWF as an asset to the Android project. Then you just deploy your Android project the same was as the users of Android Eclipse plugin do. You develop MXML/ActionScript code in Eclipse’s Flash project,  and accordingly,  the Java code in the Android project.

Is ClearDS a Right Approach for You?

Adobe’s AIR Native Extension is a door opener to the world of native APIs of mobile devices. If you find an ANE with the functionality you need – just use it. Unfortunately, there is no way to debug mobile ANE. On the other hand, if you choose the ClearDS route, you will be able to debug the Java code using standard Android ADT Eclipse plugin.

So, as long as you feel comfortable writing Flex and Java code, download the ClearDS plugin and use it right away.

You can also watch this 10-minute screencast of ClearDS plugin in action here.

We also started added the ClearDS-related content to the wiki page of Clear Toolkit located at this URL. You may also subscribe for our new video channel at Youtube.

Victor

On August 12, I participated Farata’s symposium for Enterprise developers for the second time. But unlike the first time, I was on the other side of the barricades. I presented my research in the field of functional testing of Flex-based RIAs. Since my previous preso at NJFlex user group, I  figured out how to include automatic functional testing in enterprise application development life cycle.

In these presentations, I demonstrated what a Flex developer needs to know to prepare his or her  application or even a single component to painless UAT or QA testing. Using the tool FlexMonkey form GorillaLogic I demonstrated the basic concepts of interaction with Flex Automation API and components instrumentation. And for dessert, I showed how to automatically run functional and unit tests  on each code commit to the version control system. The screenshot above is an illustration of what I was talking about – instrumentation of components, introduction to FlexMonkey – an open source Flex-enabled testing tool, and Jenkins – one of the best open source continuous integration servers. The entire enterprise RIA development cycle was sampled.

Stop! Why am I trying to write the transcript of my preso?

If you missed the event, you still can download my presentation slides from here. Find the sample source code here. And ask your testing-related (or not) questions in the comments to this post.

Cheers,

Vik Gamov

Today, I’ve been working on an application that was supposed to display a list of orders form a relational DBMS. Not a rocket science. But let’s go over the languages, libraries, tools, and frameworks I had to use for this.

First, I wrote a 20-lines SQL Union statement and tested it in Oracle’s SQL Developer. Then I generated 80% of the code and wrote the other 20% manually. Here’s what I was using:

1. Eclipse IDE for Java EE Developers (Eclipse Foundation), which comes with the WTP plugin
2. CRUD code generator Clear Data Builder (Farata Systems). It generated the initial application written in Java, ActionScript, MXML. It also generated ANT build script
3. Configured Apache Tomcat (Apache Foundation) to run from inside Eclipse – this is where my rich Internet application is deployed.
4. Added to the project the libraries of MyBatis (Clinton Begin and Apache Foundation). This is a light-weight data mapping framework. You map manually written SQL to a Java DTO, which eliminates the need to write JDBC.
5. Spring Framework (Spring Source) was used to simplify wiring of MyBatis into my Java applications.
6. BlazeDS framework (Adobe) is being used for efficient serialization of the server-side Java into client-side ActionScript objects and back via AMF protocol. This exchange happens between the peer ActionScript/Java DTOs.
7. The ActionScript DTOs where automatically generated based on their Java peers by the DTO2FX tool (Farata Systems)
8. Most of the Java code was generated, but I had to write small fragments to be called for data manipulations via SQL/MyBatis
9. The latter would engage the Oracle driver and DBMS (Oracle)

Everything’s ready. Start the server, run the Flex app, and…instead of data I’m getting this error “org.springframework.jdbc.UncategorizedSQLException : Error setting null parameter. Most JDBC drivers require that the JdbcType must be specified for all nullable parameters. Cause: java.sql.SQLException: Invalid column type“.

This error message is misleading. I do insert parameters to the SQL Select, but they are not nulls. I don’t insert anything into the database. The worst part is that there is nothing left to debug. Everything up to the last SQL-annotated Java method declaration works fine. But you can’t debug a method signature, can you? Who is to blame? Oracle driver? Or should I get the source code of MyBatis trying to find the line of the code that blows up?

Enough for today. Going home. I don’t know what’s causing this issue, but I I’ll find the solution. The only question is how much time I’m going to spend on it. Do all these productivity frameworks and tools really save time in the long run? Would I be better off writing JDBC code manually? AS a matter of fact I like MyBatis a lot better than Hibernate, but still…Where are the time savings?

Yakov Fain

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

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

The slides of this presentation can be downloaded here.

Anatole Tartakovsky

But it seems that most of them assume that just spending years working on Java projects is enough for considering themselves Java experts. The fact that you’ve been using Hibernate, Spring, JMS, and some caching framework doesn’t make you a Java expert. Over the years you might have improved your understanding of the architecture of Java EE applications, but this doesn’t not make you a Java expert.

Back in 2004, Java 1.5 has been released. Besides generics and annotations it introduced the library of classes supporting concurrency. I don’t care if you know generics, but this library is golden, especially for Java developers who are applying for working on financial applications. Many of these Java veterans never bothered looking into the latest Java features for years. And if I’m asking any concurrency-related question, a typical answer is “Oh yes, I remember there were some new classes that can do this.” Some new classes? Come on, they were in Java since September of 2004!

If a job applicant believes that the only two ways to create a Java thread are extending a Thread or implementing Runnable, he’s not a senior Java developer regardless of how many years he spent working on Java projects. This tells me that this person doesn’t care about Java and is not interested in keeping his technical skills current.

This is one of these “less is more” situations. People who have learned Java after 2004 are more likely to know it better. My message to Java veterans is simple, “If you want to compete with young kids, spend some time learning Java programming. Become competitive as you were ten years ago. Otherwise your only option is to complain about the outsourcing that may take away your job any day.”

I’ll be giving a 2-hour crash course on Java next week during our Fourth Symposium on Software Development in New York City. Come over. Let’s enjoy Java programming together!

Yakov Fain

The Web browser displayed my window, I filled out the form populating the ActionScript WrapperObject and pressed the button Save. Nothing happened. No errors and no data inserted in the database.


Well, need to start debugging…Let’s see what could have gotten wrong:
1. I didn’t properly populate the ActionScript WrapperObject
2. I didn’t properly configure the Java class/method so the front end didn’t even call it.
3. I didn’t code the database portion properly.

But why there is no errors? Starting the Flex part in the debug mode quickly revealed that the WrapperObject was properly populated and the asynchronous request to the Java server has been sent.

Great. The next question is, “Have I called the proper endpoint (the destination) on the Java side and if the correct method has been really invoked?” Started an HTTP/AMF sniffer, which confirmed that I was calling a method on the endpoint mapped to the class Customer shown below. On the Java side, the class hierarchy looked as follows:

class _Customer {
…
   public boolean saveData( WrapperObject wrapper){
       // an empty method   
   }
}
 
class Customer extends _Customer{
 
   public boolean saveData (WrapperObject wrapper) {
        // the code saving data in DBMS was here
   }
}

Without leaving Eclipse IDE, restarted Tomcat in the debug mode and put a breakpoint in the caller of Java’s saveData. Interesting… The debugger brought me inside the empty method of _Customer.saveData. Do you see any spelling errors in the method signatures? Me neither. This was about time to use a Java annotation @Override, which I was always underestimating. Changed the class Customer to look like this:

class Customer extends _Customer{
 
   @Override
    public boolean saveData (WrapperObject wrapper) {
        // the code saving data in DBMS was here
   }
}

Sure enough, the Java compiler immediately told me that the method saveData has to override the one from the superclass. But I did override it, didn’t I?

The problem was that my project has two different versions of the class WrapperObject located in different packages! The superclass was using the WrapperObject from one package, but the subclass from another! This little annotation caught what my eyes didn’t see. Fixed the import statement in the subclass to properly override the method saveData, re-ran the program and got… an SQL error stating that I have an extra comma somewhere in my Insert statement. But this one is a piece of cake! I was so happy.

Thank you Java @Override – you made my day!From now on I’ll be using this example in all my Java classes.

Yakov Fain

In this blog I’ll be talking about the poor data rendering. Typically, we create RIA where Adobe Flex communicates with the server-side Java using the AMF protocol (Java to ActionScript serialization via BlazeDS).  AMF is an efficient HTTP-based protocol for transferring strongly-typed data (Java Data Transfer Objects).  But on the UI side you may start experiencing slowness even on medium-size data grids displaying 500 rows by 50 columns. Add to such grid poorly written item renderers  (with nested containers) and Flash Player quickly becomes a bad guy.

It’s hard to find a Flex enterprise application that doesn’t use DataGrid, and it has to offer responsive UI and smooth scrolling of the data collections that serve as a Model in the MVC-based environment.  When BlazeDS deserilizes large amounts of Java bytes into ActionScript objects, the users may experience a freezing effect, when the UI is not responding to any user’s actions until the serialization is over. The reason being that Flash Player performs this deserialization in the same thread as UI rendering.

When the size of a data collection becomes large (e.g. 30 thousand of ActionScript objects), it’s better to find a way of not bringing all the data at once to Flash Player. This is the main idea of our lazy collections.  It’s about combining smart data pagination and scrolling.

You don’t want to load the entire data set into the Java server’s memory to avoid crashing it. While preparing the screencast that demonstrates advantages of our lazy collections vs. the standard ActionScript ArrayCollection, I had to increase the amount of heap memory on my Tomcat server to prevent Java’s OutOfMemory exceptions – and I was the only user sending data requests to the server! What is a hundred users will cause the server load into memory datasets of a 100Mb each? You need to provide at least 10Gb of memory on the server.

We decided to create data collections that use pagination on the server in conjunction with the smarter collections on the Flex client. We have created beta versions of collections supporting both Halo and Spark Flex components. Even though we are extending standard Flex collections, the processing of the asynchronously arriving data is different in Halo and Spark. Halo’s components are heavier, but smarter when it comes to asynchronous data retrieval. The standard Flex framework (without LCDS support) doesn’t offer any support of lazy loaded collections, and we had to follow our usual path – adding the missing features to BlazeDS.  These are our main collections:

LazyIndexedList – a subclass of ActionScript ArrayList that loads the data objects on demand. For example, the initial data set may contain only a hundred out of fifty thousand objects. If the user scrolls the data in the data grid component and hits the last object of this first hundred, the LazyIndexedList will automatically request the next hundred from the server.

HugeIndexedList adds the ability to unload unused data from memory. This class  monitors the current scrolling position to avoid unloading the data being viewed.

There is some work in progress to complete the functionality required by the Spark’s AsyncListView collection. In the future, these classes will be included in our Clear Toolkit set of components. Meanwhile, you can watch this 9-minute video to see these collections in action.

Valery Silaev

The first challenge was that features like voice recognition, Toast (Android popups) and other dialog functions, are supposed to be run in UI thread vs. a worker thread of the BlazeDS. In particular, startActivityForResult() is a method of Activity class. This was an easy to solve problem, because we could place this code in our own activity and start this activity via Intent.

The real challenge was that the voice recognition software does not return anything until the computer-human interaction is complete. In other words, the Java piece to remote is asynchronous -  you start the Recognizer activity by invoking the function startActivityForResult() and, sometime later,  get notification via an async callback when the results are ready:

public void startVoiceRecognition(int requestCode, String prompt) {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT, prompt); // Customized prompt
    startActivityForResult(intent, REQUEST_CODE_RECOGNIZE_SPEECH);
    return;
}

The low-hanging solution to this asynchronicity  was to push the results from BlazeDS to a messaging destination that would be listened to by an AIR application:

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
        case REQUEST_CODE_RECOGNIZE_SPEECH:
            if (resultCode == RESULT_OK) {
                ArrayList recognizedPhrases = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
                // Now we are ready to pass results back to Air code.
                MessageBroker msgBroker = MessageBroker.getMessageBroker(null);
                AsyncMessage msg = new AsyncMessage();
                msg.setDestination("voiceRecognitionResult");
                msg.setClientId(UUIDUtils.createUUID(true));
                msg.setMessageId(UUIDUtils.createUUID(true));
                msg.setTimestamp(System.currentTimeMillis());
                msg.setBody(recognizedPhrases);
                msgBroker.routeMessageToService(msg, null);
            }
            break;
        }
    super.onActivityResult(requestCode, resultCode, data);
}

This worked, but made the AIR code ugly: we had a RemoteObject with a non-functional result handler plus the messaging destination and a Consumer, which clearly would be replicated for each call of that sort.

LongCalling to the Rescue

And then we realized that this was a déjà vu. We had been there when a stored procedure in one financial application would not return for 3 minutes. We helped that customer without breaking the remoting model. We used the “long calling” instead.

Long calling is Farata’s term to label the customization of a Java adapter and RemoteObject that allows us to quickly receive a dummy return of the original long remote call and reincarnate the mx.rpc.ResultEvent when the real data is ready.  By using a customized RemoteObject the application code becomes agnostic to the fact that remoting operation has “two legs”.  The only requirement that we add is that the name of such remoting method has to end with “AndWait” as in  recognizeVoiceAndWait(). This signals to the ActionScript side that this invocation is a “long calling” and this knowledge is carried forward to the custom Java adapter.

On the Java side, we implemented a PlatformServices object with several methods, most importantly,  startActivityAndWait() and complete(). Here is how we start our own SpeechRecognitionActivity. Notice that the first parameter of the runActivityAndWait() is an intent to start an activity, while the second one is a class of the expected result:

public List recognizeVoiceAndWait(final String prompt) {
    final Intent intent = new Intent(PlatformServices.context(), SpeechRecognitionActivity.class);
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT, prompt);
    return PlatformServices.runActivityAndWait(intent, STRING_LIST);
}
final private static Class> STRING_LIST = null;

The SpeechRecognitionActivity() will start the Recognizer activity precisely like we did in the earlier code snippets. Meanwhile the worker thread that started it will be blocked. It will remain in the blocked state until the onActivityResult() callback from inside the SpeechRecognitionActivity issues the complete() passing exactly the same intent as was used during runActivityAndWait() – this intent is preserved in the onStart() of the SpeechRecognitionAcitivity:

@Override
public void onActivityResult(final int requestCode, final int resultCode, final Intent request) {
    if (requestCode == REQUEST_CODE_RECOGNIZE_SPEECH) {
        final List result;
        if (resultCode == RESULT_OK) {
            result = request.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
        } else {
            result = null;
        }
        complete(originalIntent, result); // We preserved originalIntent during onStart() of the activity
        finish();
    }
    super.onActivityResult(requestCode, resultCode, request);
}

That’s it. The only limitation is that due to the blocking mechanism of runActivityAndWait() only one at a time call can be executed. Accordingly, the AIR application should avoid sending several “AndWait” requests in one AMF batch.

LongCalling in Action

And, of course, the AIR’s code won’t care about runActivityAndWait and complete() pairs at all. For all it knows, there will be regular remoting calls, albeit ending with “AndWait”:

<?xml version="1.0" encoding="utf-8"?>
<s:View xmlns:fx="http://ns.adobe.com/mxml/2009" 
		xmlns:s="library://ns.adobe.com/flex/spark" 
		xmlns:c="library://ns.cleartoolkit.com/flex/clear"
		title="Voice Recognition"
>
	<fx:Declarations>
		<c:RemoteObject id="service" destination="AndroidJavaDestination"/>
	</fx:Declarations>
	<fx:Script><![CDATA[
 
	import mx.collections.IList;
	import mx.rpc.AsyncToken;
	import mx.rpc.Responder;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
 
	[Bindable] private var recognizedPhrases:IList;
 
	protected function onTextInputFocusIn(event:FocusEvent):void {
		var target:TextInput = event.currentTarget as TextInput;
		promptAndListen(target.toolTip || target.id, target);
	}
 
	private function promptAndListen(prompt:String, target:Object):AsyncToken {
	   recognizedPhrazes = null;
	   var token:AsyncToken = service.recognizeVoiceAndWait(prompt);
	   token.addResponder(
	     new mx.rpc.Responder(
		onRecognizeVoiceResult, onRecognizeVoiceFault
	     )
	   );
	   token.target = target;
	   return token;
	}
 
	private function onRecognizeVoiceResult(event:ResultEvent):void {
	   recognizedPhrases = event.result as IList;
	   var textInput:TextInput = event.token.target as TextInput;
           var bestMatch:String ;
 
           .... Find the best match from recognizedPhrases  
 
	   textInput.text = bestMatch;
	}				
	]]></fx:Script>
	.  .  .
	<s:Form width="100%">
		<s:FormItem label="Name:">
			<s:TextInput focusIn="onTextInputFocusIn(event)" 
				toolTip="Employee name"/>
		</s:FormItem>
		<s:FormItem label="Phone:">
			<s:TextInput focusIn="onTextInputFocusIn(event)" 
				toolTip="Phone number"/>
		</s:FormItem>
	        .  .  .
	</s:Form>
</s:View>

If you are interested to see this solution in action, I’ll be showing it in August during our fourth annual symposium on enterprise software.

Victor

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

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

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

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

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

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

Sincerey,
Anatole Tartakovsky

1. Show of Hands. This is popular but bad habit. Have you ever been to a presentation that starts with 3,4,5 questions like “Raise your hand if you are using so and so software for less than 1 year”.  “”Now, between 1 and 3 years?”  “Let me see a show of hands: who used this framework in a real project?” And on and on and on. Why wasting time of the audience on this BS? You’ve got only 45 minutes to make your point. Just get straight to the meat of your talk.  People in the audience are not idiots. They’ve read the description of your talk in the conference brochure, and decided that your talk has some value. They are sitting here for a reason. What if the show of hands reveals that 70% are mid-level developers and 30% are beginners? Will you ignore the interests of these 30% and cover the subject addressing only more experience crowd? This is dead wrong. This is a conference and not a private tutoring gig, where you can cater to the needs of the single person.  Include in the description of your talk the expected skill level of your audience and present.

2. Masturbation. The goal of your presentation is not to enjoy yourself and please your ego. People should get some satisfaction too. They came here to learn from you not because you’re God, but because you had a chance to research this particular subject better.  Showing your expertise is fine, but give people something they can use in their daily routines.

3. Timing. People prepare slides without bothering if they’ll have enough time to go through all of them during the available time slot. Recently I asked someone to give a 45-minute talk and send me his slides in advance. When he sent me a 30-slide deck, it was clear that he won’t make it in 45 minutes. I use a simple rule – you need two minutes per slide (I’m not talking about Steve Jobs type of slides containg just one word iPhone or iPad). Time your preso or you’ll end up with “How are we doing on time? Only 5 minutes left? OK, I’ll wrap up real fast. Anyone can grab me in the corridor. ” Yeah, right!

4. Visuals. Some presenters believe it’s cool to bash powerpoints and start their presos with statements like “This is a one slide show. I won’t waste your time flipping slides – we’ll get straight to coding!”  The crowd roars in joy – finally, the real geek is on stage. No fluff! The presentation went fine, the star is gone, and what are you left with? Nothing. Yes, he proved that he could do it. Now what? Can you repeat it at home without any visual materials supporting this talk? Most likely not. Prepare your slides and upload them to YOUR server BEFORE your talk regardless if the conference organizers promise to publish them after the event. Include the link to your slide deck on the first or last slide. And please, use the largest font size you can so people on the back can read it.

5.  The 2-Minute Rule. This pertains to a classroom situation, when one student can’t complete the exercise because he ignored some required configuration steps. You were trying to help him… 5, 7, 10 minutes passed, but it didn’t work anyway.  Other students start browsing Internet or check their emails.  Last week I was running a training class where students were supposed bring their laptops with installed Eclipse 3.6 for Java EE developers and Apache Tomcat 7.  But some students decided to do better. They’ve upgraded to Eclipse 3.7 that came out one day before the class. One guy had Eclipse for PHP developers. One person had Tomcat 5.5 installed 3 years ago. They started to have all sorts of errors.  In cases like this, if I can’t fix the issue within 2 minutes, I ask the students to re-install the software as per instructions. You can’t steal time from other students just because some early adopters ignored your instructions. Even if this issue is not caused by the student’s wrong doings,  move on with the class. Make an early break and help this person, but not at the expense of other people.

6. Ignore the Bosses. In the beginning of  a hands-on class, I always ask about the students’ expectations. Yes, 9 out of ten are software developers, and here’s their boss. No he’s not coding, but wanted to join the class to get a better understanding of what tool his people are using. Teach your class as if this big shot is not even there. This is a class for programmers, so keep it this way.  Offer the boss-student a 30-minute one-on-one session to give a 30000-feet view of the software, but don’t waste developers’ time just to give the boss a chance to catch up with a group.

7. Frequent Feedback. In hands-on trainings, ask the students every 20 minutes, “Anyone needs help?”  Some people are afraid to ask and prefer to struggle with issues alone, while you could have resolved them in a second.

I hope this quick writeup will help you preparing your next presentation. My next presentation is scheduled in New Your City at our annual symposium on software development. Come over and see if I follow these rules myself. If not, grab me in the corridor…

Yakov Fain

Yakov Fain

To develop a front end I use, at a minimum, HTML, MXML, ActionScript, and Flex framework (add Eclipse with WTP and Flash Builder). The server side’s consists of a Java Servlet Container with installed BlazeDS Web application (throw in some XML configuration files) that talks to the business tier of your application, which ideally, has just Plain Old Java Obects (yeah, right!) that embed SQL queries talking to a DBMS using some JDBC driver. Almost forgotten about the ANT build tool.

Have I mentioned that this dozen of different pieces of software is a bare minimum? The client-server technology of early 90th with its 3-piece set (e.g. VB-SQL-Oracle) sounds like a toy these days.

Each of these pieces of software (a.k.a. moving part) can, potentially, give you some problems. That’s why I’m and always was against bringing into the architecture any additional tools or framework that require developers writing more code and make this card house more shaky and the finger-pointing game more likely.

That’s why I don’t like any Flex MVC framework that requires you to write extra code. That’s why I don’t like Object-Relational Mapping frameworks like Hibernate.
That’s why I don’t like Java Persistence API with its 500-page spec that, supposed to “make your life easier” comparing to elegant SQL.

To make the long story short, whenever I can, I use our own open source code generator Clear Data Builder that generates the basic CRUD application from requiring very little of manual coding. As for the communication with the database, there is a light-weight (no, really!) SQL mapping framework called MyBatis (formerly iBatis). It’s not an 800-pound gorilla Hibernate, but requires you to supply your own SQL as Java annotations and map it to Java DTOs. It’s a nice and easy process (see this tutorial).

My yesterday’s morning started as usual – CDB obediently generated CRUD, and started the program that was supposed to execute my SQL query and bring the data first the Java and then to Flex UI. MyBatis conveniently displays in Eclipse console the SQL it executes and the returned result set. Here’s my SQL, but there is no data ands no errors. Trying the same SQL in Oracle SQL Developer – the data’s there. The cleaning of the project didn’t help. Log files show no errors. Who would you blame next? MyBatis doesn’t generate any code – it just executes my SQL. I started to think of jdbc driver. When to Google – no one blames this Oracle JDBC driver in no reporting errors.

Here comes the BlazeDS little dirty secret. Its folder WEB-INF/classes has a little used by the Apache Commons Logging configuration file commons-logging.properties :

Here it is:
# suppress logging for 3rd-party libraries using commons-logging
# Flex logging is not configured here. It is configured through in the logging section of flex-config.xml
org.apache.commons.logging.LogFactory=org.apache.commons.logging.impl.LogFactoryImpl
org.apache.commons.logging.Log=org.apache.commons.logging.impl.NoOpLog

This last option (NoOpLogs) means suppress errors! I was mad. I could understands if my fellow developer from the BlaseDS team wanted to minimize the output and temporarily change set this option. But the comment in the file explicitely states that the was done intentionally to “suppress logging for 3rd-party libraries”! Changing NoOpLog to Log4JLogger fixed the situation, and I started seeing a lot of output on the console. Sure enough, there was a run-time error returned by the Oracle driver that explain the problem…two hours later.

Hopefully, revealing this BlazeDS little dirty secret will same someone a little grief. But I’m still wondering, “Why the NoOpLog proudly made it into BlazeDS?”

For more little secrets, attend our 4th Annual Symposium in New York City in August.

Yakov Fain

Every year we start with putting together a list of suggested topics that Farata’s engineers want to present on. Here’s what we have so far (it’s subject to change):

Yakov Fain wants to deliver the following two presentations:

1. Networking WebSockets – the most interesting offering of HTML5

2. Hands-on Java EE 6 – the no-slides demo of programming Java with the current server-side technologies

Victor Rasputnis is heavily into Android these days and may talk about:

1. Squeezing Adobe AIR, BlazeDS, and Java inside Android

2. Something introductory about productive way of development for Android

Anatole Tartakovsky is obsessed with tablet devices and might talk about this :

1. Case Study: A salesman with Adobe AIR and a Tablet

2. Maintaining a single code base for Android and iOS applications

Possibly, yet another Viktor from Farata will talk about the automation of the functional testing of UI in Flex applications.

Now comes a one million dollar question. Who is this seminar for? This is a one-track/one-day event. In the past three years this event was aimed at Enterprise Flex developers. But what’s the profile of \an attendee who would want to hear all of the above? I’d call such a person a Current Enterprise Software Professional. This can be an enterprise architect or a developer from a startup. These days no one can survive by committing to any single programming platform. To become current, a technology stack of a seasoned professional must include more and more tools each year.

As usual, we’ll keep the price for this event anywhere between $100 and $150 just to ensure that random people won’t be in the room, but those who care can afford it. This amount will cover our expenses on renting a meeting place, serving lunch, and paying for the beer after the formal part is over.

The registration page will be up next week, and the event will take place in early August at the same venue in New York City. Meanwhile, we’d appreciate your suggestions regarding the content/organization of this event.

Yakov Fain

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

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

Sincerely,
Anatole Tartakovsky

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

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

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

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

Sincerely,
Anatole Tartakovsky

If you are attending the 360 Flex Conference in Denver, attend Anatole’s presentation on this subject.

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

Sincerely
Anatole

Sincerely
Anatole

Sincerely,
Yakov Fain
@yfain

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

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

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

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

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

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

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

Anatole Tartakovsky

Bashing Java is popular these days, but is it justified? I don’t believe so. Unfortunately, people who state that Java’s dead are not the people who use the latest Java technologies day in and day out. Sure enough, people are overwhelmed by the amount of news generated by iOS and Adnroid, while Java (the most popular programming language) gives a perception of a stagnating platform.

But in this presentation the author made a number of statements that show that his perception of Java platform is based on the status of the platform several years ago. The main issue is that he’s not aware of how things are done in Java EE 6, which has been released more than a year ago. All accusations that Java developers have to use a “frameworks galore” slowly but surely becomes a history. I had a chance to learn it first hand while working on my Java book published earlier this month.

While the author states that “Java innovation failed to reduce complexity” referring to JSP, JSR, and Struts (?!), in my opinion Java EE 6 is a light-weight and elegant platform. No more heavily configured EJBs. Here’s all you need to create a session EJB. Check this POJO – it’s a stateless session EJB:

@Stateless
public class HelloWorldBean {
 
    public String sayHello(){
        return "Hello World!";
    }
}

No need to write any XML. Just call the method sayHello() from any other Java class. Below is a Java servlet that can be used as a client for our session bean (don’t look for missing JNDI lookup – the @EJB injects the bean into a servlet):

@WebServlet("/HelloWorldServlet")
public class HelloWorldServlet extends HttpServlet {
    
  @EJB HelloWorldBean myBean;
 
  protected void doGet(HttpServletRequest request,
        HttpServletResponse response) throws ServletException, IOException {
 
       PrintWriter out = response.getWriter();
       out.println(myBean.sayHello());      
  }
}

JPA 2.0 replaced entity beans. Why do you need Hibernate if in Java EE 6 here’s all it takes to define the Employee entity mapped to a database table:

@Entity
public class Employee{

  @OneToMany (mappedBy = “employee”)
  public List<Address> adresses = new ArrayList<Address>();  
 
}


I’m not going to bore you with Java code, but it’s really easy now. The statement of the Forrester’s analyst that “Java was not designed to increase productivity of business application” doesn’t bear much weight after you look at the code samples above. Java EE 6 doesn’t stand on the way of application developers. Just put your business logic in the sayHello() method with no or minimum boilerplate code to add.

The author correctly blames Java Swing for being overly complex and JavaFX for failing to present a competitive product. Today this is true. But this is just a small part of a solid platform that enterprises rely upon during the last decade.

Mr. Gualtiery suggests using “better alternatives” as he put it. Namely, Business Process Management (BPM) tools, BI, Business rules management systems. He forgot to mention though, that you’d need to rob a bank first to acquire them. And after this part is done, you’ll still need to do some scripting plus a lot of voodoo dancing around these generic packages to make sure that they perform well with YOUR business application.

He claims that “Newer programming languages are designed to make certain apps easier”. Guess what’s the name of this new language? Ruby on Rails. First, this is not a language, but a 7-year old Web-application framework. Second, during all these years it was not able to become a noticeable tool in the enterprise development field.

The author also mentions some other programming languages forgetting to mention that they run on Java Virtual Machine (JVM), which has been greatly improved over the past years.

The last couple of slides contain recommendations. The author claims, “If you are using Java successfully, there is no reason to abandon the ship right away”. Thank you very much! And then, “If you are using Java unsuccessfully, then look first at your software development life cycle… The platform you use is only as good as people and process…” I can’t agree more. If your organization is full of mediocre software developers, switching Java to any other tool or programming language won’t make a difference. Here’s yet another vague recommendation “Don’t think how you can develop Java applications faster. Instead, think how you can develop applications faster. This opens your mind to look outside Java to these alternatives.” I wonder, how much Forrester charges for this report?

Disclaimer. The next verse has been written neither by me nor by the Senior Analyst from Forrester.

Dm F G My mind is clearer now at last all to well
F G Dm I can see where we all soon will be
Dm F G If you strip away the myth from the man
F G Dm You will see where we all soon will be

Dm Em Jesus!

Yakov Fain

If only they knew Java…But they often just can’t get off billing to learn Java. Besides, what does it mean to learn Java? Learning the syntax of the language? There’s no demand for people who just know the syntax of Java, or as a matter of fact any other language. So what to learn? The Java ecosystem is huge – there are lots of technologies and frameworks. People get scared. People don’t want to boil the ocean.

Employers are looking for people for solid understanding of Java and Java EE  technologies. So if you are looking for the guidance and are motivated, enroll in my online training class that I’ll be teaching starting from March 8.  The classes will take place on Tuesdays and Fridays from Noon to 2:30PM New York time (GMT-5). Resident of the Eastern states of the USA can take a long lunch twice a week and attend these classes without leaving their offices. For people who live in Europe, India, or Middle East this is an evening training (sorry Australia, Japan, and China). You’ll be surprised, but not every person who lives in India knows Java yet.

It doesn’t matter in which country you live now, as long as you have stable Internet connection (e.g. watch American youtube videos without pauses), you may benefit from this training.

You’ll hear my voice and see my computer screen. You’ll be using the fresh Java Tutorial that I wrote for Wiley. You’ll be able to ask questions and do the homework.  Visit this Web page for  the program description and registration.

Interested? Then enroll in this class and get in charge of your career.

Yakov Fain

I also like quality software, but don’t agree with most of the author’s conclusions and recommendations.
First, I’d like to make a statement that proliferation of free and open source software is one of the main reasons of the low-quality software. The premise that the software has to be free means that there is no funding for these expert developers working hard in a sound-cancelling place.  In reality, a number of contributors work on pieces of software whenever they have a minute after spending most of the day earning a living. What quality can you demand from them?

Of course, one may say that some projects started from donation of a large code base of a professionally written software (e.g. IBM/Eclipse). There are companies like SpringSource that charge you an arm and a leg for other professional services so they can fund R&D of open source framework. Can they afford rare and quality releases? I doubt it. Everyone has to survive in a very competitive world and pushing the software out the door asap is a way to show that the product is alive and being worked on.

Let’s take the big guys. The last major release of Java is four years old. How good it is for the quality and the reputation of the product called Java? It’s bad.
It took Adobe 2 years to release version 4 of their flagship RIA framework called Flex. Was this beneficial for the quality of the product? Not at all. It still has bugs and Adobe engineers were able to complete transition to the new Spark architecture of only 20 out of 50 UI components. During the same period of time Microsoft released versions 2, 3,and 4 of Silverlight – direct competitor of Flex, which seriously improved their positioning in the RIA space.

Markus Karg suggests to release late and rarely assuming that a small of smart guys know exactly what the customer needs. I don’t believe this is the case. IMO, it’s much more beneficial for the quality of the product to release a product that has some bugs and 90% of the planned functionality so the users can play with it sooner shaping out the final features of the product.

Then, the author explains why many companies produce crappy software: “The reason is simple and let’s tell it clearly: Off-Shoring.” I can’t agree with this conclusion either. I keep insisting that the reason of failing off-shore projects is the legion of mediocre American enterprise project managers that run these projects. They don’t have balls to fire ballast offshore workers and keep dragging the project along extending the lifespan of low-quality applications by applying sort of chemo-therapy and radiation.

Mr. Karg believes that American and German engineers would produce quality software, while we’re getting “pure crap from Bangalore”. If you get crap from Bangalore, you deserve to get crap from Bangalore.  I don’t know about Germans, but let me say loud and clear: “American engineers are not smarter than the Indian ones”. They happened to live in better and more creative environment, that’s all.  I’ve been working with lots of great Indian engineers here in the USA. The quality of the Indian engineers who spent 3-4 years in the USA is substantially higher than of their peers who work from India.
The ecosystem makes a huge difference. Attend Google, Oracle, Adobe, Microsoft conferences – you’ll meet brilliant engineers of Indian descent.  Important: they all live and work in the USA for years. No, it’s not about food. Indians continue eating curry and don’t like hamburgers and the yellow liquid called Bud Light.

In addition to consulting business, our company develops open source software.  I’m always fighting for fast releases otherwise we’d never release anything useful. We’d be just enjoying the process of developing software. Sure, it’s our baby. Let’s add the feature #273 and then…No, wouldn’t be nice to squeeze #274, 275, 276, and 277 into 1.0?

Some Flex developers like using frameworks. One of the popular ones is Mate.  After about 4 years of development it reached the version… 0.9. I’m not even talking about the quality here – most of the enterprises simply won’t accept the project that was not officially released!

Anyway, I don’t agree with rare releases. The bird should leave the nest as soon as possible. So release fast and then fix the bugs and adjust the product based on the user’s feedback.

Yakov Fain

Case Study: Using Adobe AIR on Android for Sales Automation

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

My colleague Yakov Fain submitted two proposals:

1. What it takes to be an Enterprise Developer

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

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

Anatole Tartakovsky

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

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

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

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

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

Sincerely,
Anatole Tartakovsky

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

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

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

An application A is being developed using Flex-BlazeDS-Java, and it needs to integrate with a third-party Java-based Web application B, where the users must register, otherwise they can’t continue using the application A.
Of course, to implement this scenario you can engage some of the business process management software packages that will allow you to describe and configure the workflow with minimum or no coding. But the less moving parts are used in the architecture the better. Here’s the pretty simple way to implement our scenario.

Step 1. When the user presses the button on Flex view, the code is being executed inside the virtual machine – Flash Player, which in turn is sitting inside HTML wrapper.    So the first goal is to make a call from inside the Flash Player to the outside world. Using the ActionScript class ExternalInterface you can map the internal function, say registerUserAS() to the wrapper’s JavaScript function registerUserJS(). You have to write both of these functions yourself.

Step 2. The JavaScript function registerUserJS() opens the URL of the application B in a separate Web browser window, where the user registers as required by the application B.

Step 3.  In the application A, develop and deploy Java servlet, say RegistrationCompleteServlet that can be called by the application B when the user successfully completed the registration. During this call, the application B will pass to the servlet a Data Transfer Object  RegistrationInfoDTO, with all required registration details.

Step 4.  The RegistrationCompleteServlet and BlazeDS are collocated in the same Java Servlet container(e..g. GlassFish, Tomcat, et al). The RegistrationCompleteServlet initiates a push of the RegistrationInfoDTO to the BlazeDS destination RegistrationDest with the routing to the proper client. How to push the data to the client over the AMF protocol is described in our book Enterprise Development with Flex.

Step 5. Almost forgot to mention that during the startup, our Flex application has created a Consumer subscribed to the messages from the destination RegistrationDest. As soon as the RegistrationInfoDTO is published to this destination, Flex client will receive it and let the user into the next view with a nice greeting, “Thank you, Yakov for registering. Your credit card information has been validated”.

That’s’ all there is to it. I’ve included “Part 1” in the title of this blog, because hoping that this will become a series of writeups on integrating Flex and Java EE.

Yakov Fain

1. “Recently, I’ve been running a seminar for a small group of Java developers. Several times they’ve asked me, ‘Is this code an example of MVC pattern?’ I got the impression that implementing MVC had become an end in itself. Using Design Patterns is not a dogma. Just write the code that makes sense. Not everything that makes sense has a named design pattern.”

2. “Abusing design patterns is not always the fault of Java developers. I find the approach used in the enterprise software shops similar to medicine in the US. In my opinion, lots of doctors here practice ‘protective medicine.’ They are trying to protect themselves from malpractice law suits. Enterprise managers and tech leads also try to minimize the risk introduced by lower-skilled developers who are part of every team. Yes, abiding to object-oriented principles definitely helps in making code readable, but this does not always translate into better performing applications. If hacked-up code produces great results, apply it without worrying whether another developer will have problems understanding it.”

I work for Farata Systems, a consulting company that makes a living by developing rich Internet applications utilizing Adobe Flex and AIR and Java EE. We are a small company (about 30 people). We do consulting as well as develop our own software (both commercial and open source).  The number 30 is important here. Many years ago, a respectful person taught me that until the company is under 30 people it’s efficient because there is no need to hire middlemen managers. The founders of the company can run the projects themselves, and there is no ballast.

After several years of running the company with two other geeks, I couldn’t agree more.  We can afford to cherry pick developers, which large company can’t.  I’ll tell you more – we can afford having people who don’t have to stick to design patterns just to ensure that Joe Smith who became a programmer after attending 6 months of vocational school will understand the code. We can afford to build teams not with code monkeys who were shoved into our throats “because XYZ is our offshore partner and we have to keep them busy”. We are also working with offshore developers, but only with those who can do the job and can read/write the code regardless if it belongs to M, V, or C tiers.

Design patterns were not created equal. It’s OK to bash Singletons.  They are easy to be blamed for being a replacement for global variables. But MVC is still considered to be good.  Unfortunately, it’s not about three tiers any longer. Java architects enjoy creating layers. They’ll be happy to explain anyone how these extra layers will make your application very configurable and flexible. Layers are best friends of consulting firms who have sharpened their skills in creating beautiful powerpoints with nice round-square rectangles filled with color gradients. Thick arrows going from left to right shows how “with our consulting company you’ll move from here to there in just a couple of years”. The arrows must leave no doubts in the minds of hiring managers that “these guys can do it”.

And most importantly, these multi-tiered diagrams will explain the hiring manager of a large corporation that it’s OK that Satish is weak on the front end and Boris never worked with the back end…if you know what I mean. This multi-tiered design can turn both Satish and Boris into code monkeys who will do nothing but inserting their business logic into easy to understand location and the framework will do the rest. Design patterns promote the lowest-denominator-skills software development.

You may be surprised, but even such a sacred cow as dependency injections is not a must. Believe it or not, pretty much any application can be created without DI. I’m not kidding. No XML configuration files to process. Popularity of dependency injection in the middle tier is based on the necessity of integration techniques to allow upgrades and replacement of large pieces of technology with their new implementations. To be fair, I need to praise Java EE 6 for smart and light implementation of DI that doesn’t make you drown in XML.

Applying DI in the front-end applications on top of the frameworks with well designed event model is an overkill on the desktops and suicidal on smart phones and tablets that need to be optimized for memory and speed. We see bigger consultancies still doing it because it is a proven and easy to sell solution. Unfortunately, starting a new Flex project with an analysis of which MVC framework to choose seems to become a habit in enterprises.

My interview statement that writing the code that works is the ultimate goal is applicable only in teams that can afford to employ skilled professionals. If for whatever reason you can’t, go with the flow and rely on injections that somehow will put the collection of Orders into your Customer object.

Finally, to make this blog even more thought provoking, I’ll touch upon yet another sensitive subject. Who do you need to write code for – humans or computers?  On one hand, the code must be readable, cause the same piece of code is being read a lot more often than being written/modified. On the other, the code must be efficient.  For example, in financial trading applications adhering to design patterns is a low priority item. Speed is the king there.
Recently, I showed one chapter of my new Java tutorial to a very experienced Java developer. He was surprised that I included an example of BitSet there. This is what he said – word for word, “Perhaps your experience is different than mine, but I don’t think I’ve ever seen this class used in practice. It really feels a bit old-fashioned, and C-like. In 2010 I’m not sure anyone writing code in Java really worries about this level of saving bits. Maybe it still relevant in some embedded systems, but do those systems actually run Java?”

Ten years ago I was working on developing an equity trading system for a Wall Street company.  It was a J2EE application with a heavy use of messaging. A trading order had to be sent to a queue, and this was an object with about 50 fields with yes/no values.  Using BitSet for sending a set of flags (bits that are set to 1 or 0) instead of text or numbers is the most economical way to do this. Did I care that a programmer who’d be reading my code a year from now won’t immediately understand that just a couple of bytes carried had tons of information about the order? I did not. This piece of code was not readable, but efficient.

IMO, in the ideal world of inhabited by skilled software engineers, the code has to be written for computers. But we don’t live in the perfect world. So I don’t insist.

Yakov Fain

I was there for a very practical reason trying to evaluate this hardware to be a platform for the mobile version of our software product – Licensing and Contracting for insurance agents. The desktop version of this product is a pretty advanced Adobe AIR application that automates processing of lots of PDF forms, engages OCR technologies, uses Web Services, et al.

While we are already working on creation of the Android of this product and have concrete plans for iPads,  it would be simply wrong to ignore the company that have already sold 115 millions of Blackberries and is about to release a tablet that will compliment their hugely popular smart phone.

Adobe and RIM work very closely on this device. All applications that come with Playbook are written in Adobe AIR. Flash Builder Burrito IDE streamlines creation of the mobile application s in general and for the Playbook tablet in particular.  Of course, the entire platform has a room to grow, but I have no doubts that next year AIR will feel at home on the Playbook’s OS called QNX.

The tablet looks likes a smaller version of iPad. The screen resolution is 1024×600. The 600 seems a bit low for the enterprise applications though.  The video rendering is really fast. Flash Player 10.1 is supported.

Based on the needs of our insurance application, we’ll have to wait and see, because today’s Playbook doesn’t support working with PDF, which is crucial for us. Next year this device will support Blackberry Java Development Environment.

Overall, it’s a nice device.  Currently there are no fees for joining  Blackberry Application World, where early adopters can get all required software for the creation of applications for Playbook. Adobe evangelists have already created a handful of applications demoing features of this new device.

I have one more concern related to development under MAC OS (based on my observations, 50% of developers who work with Adobe software are carrying MacBooks). The requirement to have a full version of VMWare Fusion will make development for Playbook not overly productive unless you have 8Gb or RAM.

The Spring of 2011 will be a very exiting time for those who already understand that tablets are the new trend. Variety of new devices are going to be released soon, and don’t forget about Apple engineers, who I’m sure, are working hard on a dual CPU successor of the iPad.

Next year, we’ll definitely release a new version of our application – an insurance agent will be selling you term life carrying a small tablet talking to a cloud in occasionally connected environment. The trucks full of paper forms will become history. We’ll just need to decide, which tablet will become our pilot.

Yakov Fain

This is not to state that you can learn the software covered in this book within 24 hours of studying. This is about having a trainer that’s with you 24 hours a day. This book is a set of short chapters with minimum amount of theory but with an instructional DVD, with screencasts recorded by yours truly. There is a screencast for each lesson except the last one.
This relatively small 500-page book consists of 38 lessons and covers both Core Java and Java EE 6.  Each lesson is from 10 to 15 pages long so you won’t even have time to fall asleep. Each screencast is from five to ten minute long so you won’t have time to get bored. At the end of this lesson is an assignment to complete. In this book I use Eclipse IDE and GlassFish v3 is the application server that I like.

Just look at these thirty eight lesson titles and give me a good reason why you shouldn’t be pre-ordering this book. Know Java already? Doesn’t really matter. I thought I knew it too before I started writing this book. Now I know it better. It’ll help the newbie’s to learn and seasoned Java programmers to refresh their knowledge, especially when it’s time to make a career move. These are the lesson titles:

1    Introducing Java
2    Eclipse IDE
3    Object-Oriented Programming
4    Class Methods
5    Back to Java Basics
6    Packages, Interfaces and Encapsulation
7    Programming with Abstract Classes and Interfaces
8    Introducing the Graphic User Interface
9    Event Handling in UI
10    Introduction to Java Applets
11    Developing a Tic-Tac-Toe Applet
12    Developing a Ping-Pong Game
13    Error Handling
14    Introduction to Collections
15    Introduction to Generics
16    Working with Streams
17    Java Serialization
18    Network Programming
19    Sending E-mails with Java
20    Introduction to Multi-threading
21    Digging Deeper into Concurrent Execution
22    Working with Databases Using JDBC
23    Swing with JTable
24    Annotations and Reflection
25    Remove Method Invocation
26    Java EE 6 Overview
27    Programming with Servlets
28    JavaServer Pages
29    Developing Web Applications with JSF
30    Introducing JMS and MOM
31     Introducing JNDI
32    Introduction to Enterprise JavaBeans
33    Introduction to Java Persistence API
34    Working with RESTful Web Services
35    Introduction to Spring MVC Framework
36    Introduction to Hibernate Framework
37    Bringing JavaFX to the mix
38    Java Technical Interviews

This book will hit the bookstores in February and you can pre-order it on Amazon at this address. I hope you’ll enjoy reading this book as much as I enjoyed writing it.

Yakov Fain