The Portal Challenge: Integrating software developed in isolation

I have a strong interest in developing approaches where software is not only developed in a modular way, but also in a way where each module can be mashed up with other modules from other software that was developed in isolation. This interest was first sparked when I encountered the JSR286 Java Portlet specification for portals a few years ago. Portlets are a good candidate for software modules, though in order for them to become this, they need to communicate. JSR286 brought more standardised IPC (Inter-Portlet Communication) to the Java portal world, though it did not go all the way. I feel I have achieved some nice composite applications with reusable portlets by creating strategies on top of the events publishing & processing framework that JSR286 IPC brought. This approach is working well whenever a small team is developing all the portlets, but becomes more challenging when integrating portlets developed by other teams in isolation. By integrating I mean without writing code. This is where I feel the problem with JSR286 IPC resides and it is a major problem in a world where app stores are king and mashups are gaining popularity.

In 2010 I posted in this topic (Achieving a federated single view of the customer) and it remains a challenge. I still feel this is a good approach, but it does require a bit of code to be written for each integration. Can we do better?

Moving towards full automation for build, test and deploy

A couple of topics which have interested me for a while now is CI (Continuous Integration) and automation. I’m introducing tools to provide developer support using these approaches for my team to enhance the experience of new application builds and regression testing. The latter is of particular important as this removes the need to hassle the original developers of applications whenever a change has to be made, to a large extent. There are also benefits in the area of handing over support more effectively to first and second line support teams. However, achieving CI and automation is a complex challenge because our applications are loosely coupled n-tier, spread across three core platforms: Liferay Portal 6.1 EE, Orbeon forms 4.0 PE and Weblogic 12c middleware (coming soon!).

For those who are not familiar with CI, this is the practice of integrating code changes frequently into a shared code branch, often your mainline (a.k.a. trunk or master). The theory is that by integrating frequently, you will be integrating smaller changes, and in larger teams this means a decreased likelihood of code branch merge conflicts. As it turns out, this is true. It is made easy with support from powerful SCM (Source Code Management) solutions like Git where branching, and more importantly merging, is a low cost activity. To get the full benefit it is recommended that you integrate your SCM with an issue tracker and branch for every issue, no matter how small, and make include issue IDs in commit messages when you commit the code changes that represent fixes. This facilitates automatic generation of release notes for builds and issue trackers are often able to tell you which commits resolved which issues.

The fall and rise of XForms

Yesterday I gave a talk about the W3C XForms specification at the @Exeter_Web (http://www.exeter-web.org) web developer meetup. Unsurprisingly only 1 out of the 30 or so strong audience had heard of this specification and that’s why I called this talk “The fall and rise of XForms”. XForms really is one of the hidden gems of the web and there seems to be strong interest in learning more from many of those who attended. Hopefully we will have opportunity for more great conversations about this topic in the future and who knows, maybe next time you’ll be tell me about the great solutions you have been able to create using one of the many implementations of the specification. So if you found the talk interesting, why not leave me a comment below! The slides from the talk are available and linked from this post.

• The Fall and Rise of XForms – slides

17th September Liferay UK User Group meetup in review

September was an interesting month packed full of interesting meet ups and opportunities to put into practice concepts that I have been evolving over the past couple of years. In this post I will cover the Liferay UK User Group (@LiferayUKUG) meet up on the 17th September hosted on LGA (Local Government Association) premises in Westminster (London).

Intelligently merging XML documents using XForms

Looks like my blog is withering a little bit. To help bring it back to life, I thought it would be good to start a series of shorter postings that are quick to post, hopefully meaning less time in between!

These days I spend a considerable amount of time developing applications and forms using Orbeon Forms, which if you are unfamiliar, is one of the leading implementations of the W3C XForms 1.1 recommended specification. For the most part I use this for intelligent data capture and validation, but XForms is a very versatile technology with far reaching potential and is a very useful tool for any developer working with XML technologies. In particular for those already familiar with XPath and XML Schema. The local authority I work for is quite SOAP webservices centric, which is why I advocating XForms as a strategic tool for building user interfaces to our SOA.

I recently had the need to intelligently merge a series of XML documents valid to the same XML Schema. It was important that the merge only merged in elements from the second document that did not already exist in the first document. This required a definition of XML element equality.

The role of public sector IT in a commissioning centric future

The UK public sector remains in a state of flux. The recent spending cuts have meant that good people have been lost, and authorities have been forced into thinking differently about how services are delivered. Working in a local authority IT department, this has manifested in a shift away from building solutions in house. Which brings the question, what is the future role of public sector IT?

Can we assert online identity whilst preserving autonomy and anonymity?

I recently attended #ukgc12 (UK Gov Camp 2012) for the first time. For those who are not familiar with this conference, it’s a gathering of 300-400 individuals with ties to UK central or local government, who want to innovate using technology or debate ethical issues surrounding the use of technology. The conference spanned two days this year: the first day focussing on debate and the second day on workshops.

Although I found all the sessions I attended very inspiring, my personal favourite has to be the debate on “democratic identity” chaired by @curiousc. I found this debate intellectually stimulating because identity management is something I have been interested in from a technical perspective for some time. My focus has been focussed using identity management techniques to help make web applications convenient for users to use, with the belief that this will increase convergence. However, I had never approached it from a democratic perspective before.