Hello World on Android

Well, from tiny acorns mighty oaks do grow… I really should be asleep, but here’s a screenshot of my new Android tablet (an EKEN M-001) running my first Android application.

I will leave any comments on the development SDK till later. Generally seems quite painless to write small applications, complying with Android standard app architecture and following an appropriate UI style might take a bit more getting used to.

One very simple method to use is the following:

glassfish + ant(!)

After spending some time now using the ThinWire RIA platform I can honestly say it is definitely a mature and powerful tool for building web applications that require complex user interface features. While my test application still does not extensively test every feature one may require, it shows ThinWire is a highly viable candidate for developing business applications.

Additionally this has been a useful learning experience from my personal point of view, as a good example of deploying an EAR (Enterprise Archive) carrying a distributed system using sophisticated persistence architecture.

The platform makes producing an application from scratch relatively effortless. There is some initial set-up involved – including removing the Mac files and folders from the ThinWire installation if you’re using Windows (there must have been a better way than the route I took which was to manually delete every one). But I found creating a buildable and deployable application, with an associated Eclipse project, was a very rapid process. The sample applications are fairly sensibly structured in order to give you a very good idea as to an appropriate development pattern to follow.

I now have an application in a healthy enough state to start testing things like persistence of entities to and from a database. It will be interesting to see if there are any behavior quirks due to the design pattern of the platform or if, as claimed, it really can cope with any Java feature you would wish to integrate into your user interface.

Some nice things that you get include a ready to start apache tomcat application server, but also more usefully an apache ant build script for both example applications.

The build script is an excellent addition for any developer looking to rapidly develop deployable and fully functional applications. As far as I can see from examining this script and building my own test app out of it the build and deployment procedure is one of the most straightforward I have come across for an AJAX / RIA platform.

I strongly recommend developer who has never used an apache ant build script to develop and deploy their applications to look into it for future applications they may develop. IDE based deployment tools can only go so far to helping you develop and implement a web application.

My take – brilliant; put yet another spanner in the works delaying Oracle’s acquisition of Sun and therefore jeopardise all of Sun’s products including Java which put simply seems to me much more important than MySQL.

At the end of the day business decisions are all about compromise, sometimes you have to sacrifice certain things in order to save others. In an uncertain economical climate the more the buy-out of Sun by Oracle is delayed the more damage could potentially occur. To take it to an extreme Oracle may never actually complete the purchase of Sun and then the future is bleak for all Sun technologies which would be a very bad thing indeed.

While I’ll refer in particular to the Java Enterprise Edition based (J2EE) solutions, the principles of structuring an application are the same in other development platforms.

So from a high level perspective, the following components are common to most web apps:

Server Side Components

Permanent data store: Most usually a relational database (RDBMS), which can be interacted with through SQL. This can take any form of interaction; from other parts of the application simply manually connecting and running SQL statements to quite complex persistence management components which automatically update and query the database using the objects in the system.

Data model: An abstraction of the information that the application needs to manipulate, generally always defined as classes in an Object Oriented manner in the relevant programming language. They may for example mirror members of a particular web-site and their member details, or items in a catalogue. These model classes take varying levels of complexity; in Java they may be Plain Old Java Objects (POJOs) or more complex Enterprise Java Beans which can directly linked to the database using a persistence management component.

Persistence manager – A layer which acts as a middle-man between the data model classes and the data source.

Interaction controller: The controller manipulates the data model based on the interaction the user carries out in the user interface. This can be a very thin layer, but it’s existence is important to act as the entry point to the server side components – seperating business/application logic from the user interface. In Java web development this is usually a servlet.

Client Side Components

User interface: A full blown application or website that is run on the client machine, most often in a web browser. There are a variety of technologies which may be used here. It could simply be a HTML page using HTML forms or it could incorporate an AJAX-style language that uses javascript, or converts its code into javascript. The primary reason for using javascript as a client side run time technology is the convenience provided by the incorporation of javascript interpreters into nearly all web browsers, meaning users needn’t first download anything to use the application. Often as far as a user is concerned a web-app is simply another web-page offering more interactivity than is usually available. The complexity of this layer depends on the complexity of the UI components required.

The separation as to where certain code and features of an application should go is an important business issue, as there are certain issues relating how thin the client side is. Generally it should be as simple as possible, as it is harder to maintain client side code and carry out complex processes there.

Anyway that’s a very straightforward summary of the common structure of web applications. The specific technologies used to implement web app solutions vary incredibly and there is no right or wrong mixture of technologies. It is important not lose sight of the overall architecture of web apps and not get bogged down with doing too much with one very specific technology and try to do everything in that space (which you might do if your very familiar with it or like it better than another). The fact is that development is a process of breaking down problems into ever smaller chunks which often require different approaches to solve.

While I don’t have the time to cover many of the issues relating to general usage of the API, from time to time I hope to post some useful information about it. Using GWT and the extension is a learning curve as it has some foibles and a unique deployment procedure to be aware of, but I’ve very much warmed to it as a tool in web user interface development.

So the issue at hand – a null pointer, which will not be picked up until run time and you will only see if you explicitly look at the javascript errors when browsing to your page. If you have unusual behaviour of a component or panel where it is not displaying, check your browsers javascript errors for complaints about null pointers.

The cause – very often simply that you declared something and tried to use it without first instantiating it.

E.g.

Panel otherpanel;
Panel panel;
panel.setTitle(“Hello mate”);
otherpanel = new Panel();   <– you instantiated this one here, but not the other one
otherpanel.add(panel);

Here ‘panel’ has not been instantiated before it is used, a simple but easy to miss error especially and it is not always picked up by the IDE and java compiler.

So check if you’re trying to use something without being instantiated first, before you start tearing your hair out about why its not working!

the styling interface

The data entry interface for the menubuilding app

I’ve gradually been developing my menu building application into a distributed web system. It uses OpenLaszlo for the building front-end, java & jsps for the database storage and retrieval facilities and OpenLaszlo to correctly display the menu from provided settings.

Here’s a few screenshots to spice up this at times rather bland blog!

Some nice features to note:

• dynamic data entry facility with ability to add and remove data as desired (I’d hope to standadise it into a generic ‘data entry’ class so it can be reused under different circumstances).
• color swatch components with preset colors to select as well as RGB color pickers
• dynamic example that updates as styling options are chosen

Plus, while I can’t easily show it, there’s a little bit of animation involved too.

I hope that any developers out there looking to make use of OpenLaszlo find this article useful, and by all means do reproduce it, keeping mindful of the Creative Commons licence on all of the work found on this blog.

http://blog.ssims.co.uk/index.php/deploying-openlaszlo-applications-a-crash-test-manakins-guide/