Some of the features include:

The app is now live and can be tried out at www.meetingshed.com

The scheduling functionality uses the KMS-dev development platform for logic programming.

I urge anyone reading to please give it a go and any feedback you can provide would be gratefully received!

The platform uses a Java based web service interface to allow communication with an SWI-Prolog instance.

Logic programming is a powerful programming paradigm, offering benefits of decreased development time and increased code readability and modifiability. It is particularly effective for software involving decision making and constraint satisfaction.

We hope the platform will benefit from contribution by the Open Source and Prolog community and we welcome developers to try it out.

A quick start guide, further information and the KMS-dev platform download are available at:

kms.intelligent-architectures.co.uk

Firstly I should probably mention I have worked in a real software development environment coding EJBs and I’m also using the technology in my third year project, so there is a real practical use for it in the big bad world.

So, what the heck is all this EJB stuff?
Well Enterprise JavaBeans allow you, amongst other things, to get data from a database and manipulate it. Using EJBs adds an extra tier to your system architecture, which essentially cuts down on the amount of SQL and database connectivity code you have to write (see here for more info about web application architecture). You’ve got three main types of beans:

• Entity beans – these represent tables in the database. They’re just a class with a few annotations which tell the EJB container to map between the table columns and the fields in the class.

Example:

@Entity

@Table(name=”YOUR_TABLE_NAME_HERE”)

public class EntityName implements Serializable {

private Integer id; //column 1

private String name; //column 2

private List<AnotherEntity> otherEntities = new ArrayList<AnotherEntity>(); //a one to many relationship

public EntityName () { }

@Id

@GeneratedValue(strategy=GenerationType.IDENTITY) //container generates id

@Column(name=”id”) //here we tell the container the name of the column this field maps to

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

@Column(name=”name”)

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@OneToMany(cascade={CascadeType.ALL},

fetch=FetchType.EAGER,

orphanRemoval=true)

@JoinTable(name=”YOUR_JOIN_TABLE_HERE”,

joinColumns={@JoinColumn(name=”entity_id”)},

inverseJoinColumns={@JoinColumn(name=”another_entity_id”)})

public List<AnotherEntity> getOtherEntities() {

return otherEntities;

}

public void setOtherEntities(List<AnotherEntities> entities) {

this.otherEntities = entities;

}

…

• Session Beans – this is where you stick all your actual code which does stuff with the entities.

Example:

@Stateless

public class DoStuffSessionBean implements DoStuffInterface {

@PersistenceContext(unitName=”PERSISTENCE_CONTEXT”) //defines where mapping to database

private EntityManager entityManager; //entity manager allows you to insert, update and delete tables in the database

@Override

public AnotherEntity findAnotherEntityById(Integer id) {

try {

return entityManager.find(Location.class, id);

} catch(NoResultException e) {

return null;

}

}
… (thats a pretty boring session bean, see entityManager.merge, entityManager.persist and entityManager.remove for more things you can do

• Message Driven Beans, these are nothing to do with the database but are very useful for delivering messages for event driven processes, not really covered in the module we are carrying out though

Great, but how do I set it all up in the first place?
That’s half the battle with this sort of stuff. I use Eclipse IDE, you can create a new enterprise application which gives a nice structure to your project, NetBeans will also do this for you though. Its worth noting our lab machines have no facilities for developing EJB components as NetBeans doesn’t link to any EJB compatible server (e.g. JBOSS or Glassfish, it does have TomCat but this is only a servlet container so can’t do it), and the version of Eclipse is not Enterprise Edition.
So its down to using your own machines for development and then deploying on JBOSS when you’re done, or fiddle with the lab machines a bit… Eclipse runs out of a directory (of course you would ask a member of staff first before doing this in case we are not supposed to do this…)

OK what’s the point in doing it this way?
Aside from the benefits already mentioned, EJBs are very scalable due to session beans. Instead of opening and closing database connections specifically, the EJB container manages all this for you and selects a bean out of a pool of them which are ready and waiting to process the method you want to perform. Basically when you have thousands of users of a system, all heavily hitting the database it enables your web application to still respond quickly.

How does it fit in with the rest of the application?
Well, you use your session bean to gain access to, create and modify your entity beans. You can access the session bean from a servlet (using a JNDI lookup or dependancy injection – a simple @EJB annotation). There is some setup to do in the way of XML files, but IDEs can get you a long way in that respect.

Anything else?
There are loads of great tutorials but be aware there are a shed load of different ways to implement EJBs, so make sure at the very least its an example for EJB 3.0 you’re looking at. If something isn’t working out from one tutorial, take a look at some others and see what the most commonly used approaches are. 

I hope that very short intro is in some part useful to people. I have very little time to put into something like this, but I know there are going to be people tearing their hair out (to put it mildly) with this particular course work.

I’m working with the Google Data APIs at the moment for my project, for which an app needs access to google accounts, cue OAuth.

Anyone who doesn’t agree it is difficult to use need look no further than the exceptions you can expect if something goes wrong:

Yay! There’s no short-cut either. One thing to be thankful for is the fact that the ClientLogin authentication mechanism (really only meant for installed apps) can be implemented in two lines of code and provides a great way of testing web apps in the development phase. Unfortunately eventually you’ll have to implement OAuth if you want a properly secure web app for your users.

I will try and post some advice to others that need to implement OAuth once I figure it out. Even Google themselves admit in the documentation it is not the easiest of things to use, which does speak volumes. Supposedly however it helps make your apps authentication extensible if using other providers web services, although I’ve yet to check how many other web service providers use OAuth.

Lately I have been using Vaadin which provides an excellent environment for rapid web UI development for Java developers. Vaadin is actually built on top of GWT, the principle advantage of which was that it required no hand-coding of javascript which is notoriously fiddly. GWT works by compiling Java code into javascript. Vaadin takes this concept a step further and renders javascript on the fly, essentially pushing everything the developer writes server side. This eliminates the need for RPC calls to deal with more complex features (not appropriate to be running on the client’s browser) such as object relational mapping with EJBs.

Essentially Vaadin allows Java developers to work solely in Java with whichever APIs and libraries they wish without thinking about what’s happening in the client and what’s happening on the server. In addition Vaadin provides some very slick, open source visual components to use in one’s application which certainly speeds up development time.

This approach is very similar to that taken in the ThinWire AJAX platform, however ThinWire unfortunately hit a lack of community support and current development has slowed right down. In contrast Vaadin, created by a Finnish company (previously called The IT Mill, now simply Vaadin Ltd), has a commercial backing from consultancy and support as well as a vibrant open source community.

For now, I think that suffices as a good introduction to the framework. Now I’ve worked with such visually and programmatically appealing platforms as this, I find it quite surprising there are not more development companies using these kinds of technology particularly if they are develping web apps and hand coding large amounts of javascript. A good starting point is the Vaadin component sampler which can be found here.

Never try to invoke a method on a Java web service using the source of the web service, e.g:

@WebServiceRef(wsdlLocation=”http://localhost:8080/blah/blah?wsdll”)

private static BlahService blahService;

blahService.myBlahMethod();

My new task management / to do list android app, Organisa Lite, has a few features I think some people will like:

• Organise all your notes in a unique tree-like hierarchy
• An innovative user interface where everything is managed from one screen – no clumsy flicking between multiple menus to get things done
• Put notes under different headings called projects which can be maximised or minimised as required
• Export the workspace to backup and use on other android devices – email your workspace and share with others
• Update your Android calendar(s) with the dates that you put into Organisa Lite at the touch of a button

Organisa Lite is available from the Android Market and has now been reduced to £1.65, due to a slow start with downloads. I didn’t necessarily expect a high volume but want to get some feedback and start the ball rolling. I hope people enjoy the app and if they have any problems I’ll be happy to assist.

Nevertheless I found it very easy to get started developing android apps using their developer site. The SDK and associated Eclipse plug-in they provide makes creating a new project from their template extremely easy and thankfully the template project is very minimal. This is definite boon as it can be extremely frustrating chopping out all the rubbish some Eclipse plug-in developers add to their template projects. As far as I’m concerned I always want to start more or less from scratch with this sort of thing.

With that said there is a certain app development pattern that you simply have to follow because of the way in which android apps get packaged and deployed on mobile devices. Therefore there are some concepts developers must familiarise themselves with and get used to because there is no alternative.

If you’ve used GWT you’ll notice there are some similarities in the SDK style. The Android SDK does try to do a bit too much for you: it generates the resources (‘R’) class on the fly for the purposes of updating Eclipse’s auto complete facility and to avoid IDE compiler errors. Which on one hand is a good thing, but I think that this, in combination with other automatic actions it carries out under the covers while your writing code, contribute to the fact that it seems somewhat buggy. Anyone who regularly uses Eclipse will know that from time to time it gets itself into a state of confusion, not surprising when you consider that it is constantly compiling code as you’re writing it to pick up compiler errors on the fly.

Also provided with the SDK is the facility to test your apps on virtual android devices. This is a very useful feature but occasionally you will find it gets itself into a state where you have to close the virtual device and start it again. This does take some time and I actually found it quicker to build the apps using Apache Ant and copying it across to a physical device connected by USB. This brings up some additional points  - the USB debugging feature was not possible with my device as the number of drivers for different platforms is fairly limited. But in actual fact its probably a more useful and realistic test to simply copy your apps (using the debug .apk which you can build with the ant ‘debug’ task) to the device and install them and run them properly.

I should probably mention that the supplied ‘tools’ which live in the SDK directory where you extracted the SDK to, include a useful tool called ‘android’ which allows you to generate an empty project. This allows you to edit and build runnable .apk files without using the Eclipse plug-in and indeed in any other IDE you may choose. Building the project is possible as mentioned using the Apache Ant script which the android task generates for you. This ability to generate a bare-bones buildable project is probably the most useful feature of the SDK in my opinion. Other platform tool developers could do well to follow this example, I know of plenty of open source projects that could certainly benefit from such a feature as much of the learning curve is often just getting everything organised so you can run anything at all.

I think this would be a convenient point to break my analysis of android development platform until I get a bit more used to it. Apart from anything else, I need to reboot my machine because Eclipse has become well and truly stressed out by the whole thing! Still its all good fun…

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.

For further information, see the new site in its all its tentative but nevertheless functional glory here:

Intelligent Architectures