The continuing part of the series that looks at developing an application first using Java and then migrating to an interface using a Web interface, through a variety of methods, is now available to read. This second part of the series looks at the main Java application itself and a servlet version.

The series is split into six parts:

• Part 1 looks at the application and sets up an environment ready for building Java applications and serving Java-based Web applications using Tomcat.
• Part 2 covers the main application code and the development of a simple Java Servlet to provide a Web interface to the information.
• Part 3 connects the core application to a DB2 database for the storage of the survey questions and responses.
• Part 4 converts the original application into one that can be accessed as a Web service, and it provides the base for the PHP interface.
• Part 5 builds the PHP interface to the Java application by using the PHP Java Bridge.
• Part 6 redevelops the application to make use of the PHP Java Bridge in place of the Web service interface.

For this second part:

In this tutorial, Part 2 of the series, we are going to build a basic business application based around the Survey application we first examined in Part 1. Once we have a working version of the application in a standalone format we will then examine how to build and develop a web-based alternative that uses Java Servlets.

The tutorial will cover the following points:

• Building the base Survey application.
• Building a simple Web servlet.
• Building an interface to our Survey application using a Servlet.
• How to deploy the servlet to our web application server.

We’ll start by building the Survey application, including providing the base class and extending the class with the question specific elements. The completed application will form the basis of the remaining examples for the rest of the series.

Read: Develop with Java and PHP technology on AIX Version 5.3, Part 2: Building the Java business application

A new round of articles in my System Administration Toolkit has just started, and the first one looks at how to write scripts that can run unattended with logging and error recovery.

To quote the article contents:

Look at how to create scripts that are able to record their output, trap and identify errors, and recover from errors and problems so that they either run correctly or fail with a suitable error message and report. Building scripts and running them automatically is a task that every good administrator has to handle, but how do you handle the error output and make intelligent decisions about how the script should handle these errors? This article addresses these issues.

Read: System Administration Toolkit: Build intelligent, unattended scripts

I used to do my requirements processing using Rational RequisitePro (see Improved application development: Part 1, Collating requirements for an application), but as an Eclipse user I’ve found an alternative in the form of the JRequire plug-in.

To that end, I have a new article on using JRequire to manage your requirements process for your applications. It’s an Eclipse plug-in that can be used by an individual or teams, and can import and export CSV and XML based content. Most usefully though, it integrates with the JUnit testing framework, so you can confirm that your requirements are being met by matching those requirements to your existing (or some new) tests.

The full tutorial goes through all of the options and usage you might need.

Read: Manage Eclipse projects with the JRequire plug-in

I’ve got a new series of articles and tutorials on how to develop an application using Java with a web interface using PHP. The eventual goal is to use the PHP/Java Bridge, but along the way we look at building the main application, redeploying it a Java-based web application, exposing the application through web services, and finally at the PHP/Java Bridge solution.

The series is split into six parts:

• Part 1 looks at the application and sets up an environment ready for building Java applications and serving Java-based Web applications using Tomcat.
• Part 2 covers the main application code and the development of a simple Java Servlet to provide a Web interface to the information.
• Part 3 connects the core application to a DB2 database for the storage of the survey questions and responses.
• Part 4 converts the original application into one that can be accessed as a Web service, and it provides the base for the PHP interface.
• Part 5 builds the PHP interface to the Java application by using the PHP Java Bridge.
• Part 6 redevelops the application to make use of the PHP Java Bridge in place of the Web service interface.

For the first part:

Develop a Java application on AIX and learn how to extend it by using a PHP interface to look at the underlying Java code. It is possible to develop applications that employ both Java and PHP technology on AIX. You can use Java code for the core logic (or redeploy an existing Java-based application), while gaining the benefits of PHP as a Web-based interface platform. This article, the first in a series, examines the basics of the Java environment and PHP integration methods on AIX, provides a quick overview of a sample application that uses this structure, and then looks at the core elements required before you start developing the application itself by installing the Java programming language and Apache Tomcat.

Read: Develop with Java and PHP technology on AIX Version 5.3, Part 1: Setting up the Java environment

Just in case you wonder why it’s been so quiet, I’ve just moved house, which means I’ve got a bunch of things to catch up on…

Despite the fact that I went on holiday and moved house over the period of four weeks the articles and pieces just kept on coming, so expect a sudden rash of follow up posts on the most recent articles and happenings later today.

I’ve been interviewed for IBM’s developerWorks podcast, this time answering questions about my Designing a Scalable Grid series.

Hear the podcast: IBM developerWorks : Blogs : developerWorks podcasts blog

Read about Designing a Scalable Grid part 1
Read about Designing a Scalable Grid part 2

The second part of the two part series on designing a scalable grid system is now available at developerWorks. This tutorial looks at the hardware of the individual nodes and then at operating system and application considerations.

For example, I take a close look at the optimization of CPU and RAM in your grid node selections, and how to identify and resolve issues with RAM limitations. You can also use CPU selections to help drive and optimize your grid.

For the operating system, I look at the different benefits and advantages of operating system choice, including how some operating systems provide a richer security solution out of the box, while others may be better suited for the large memory or storage requirements associated with a grid manage or distribution node.

In terms of the application, I cover the use of a component, rather than a single application model, and how the methods of distribution of information can change the way you design and expand your grid and may ultimately affect the scalability.

Read: Design a scalable grid, Part 2: Operating system and application

Sash Pachev has written a new guide on Understanding MySQL Internals for O’Reilly.

I was one of the technical reviewers on this book and can tell you that it makes a good read if you want to understand more of what is going on under the hood in MySQL. There’s a lot to cover, for example the pluggable storage engine archtiecture, how queries are parsed and executed, and how individual storage engines work.

The book is compact, but very readable, and worth a look if you any interest in how databases are programmed, or are thinking about building your own storage engine to plug into MySQL.

When you build a new grid one of the elements that will make your grid a success is to build one that scales, because if your grid scales well then it should be able to cope with a wide range of load types and situations.

In this first part of a two-part series on designing a scalable grid I look at the main network architecture of your grid and how you can use these different architectures to suit your grid type.

Read: Design a scalable grid, Part 1: Network architecture

The third and final part of my series on using virtualization techniques as an aid to grid enablement is now available on IBM developerWorks.

The tutorial looks at the mechanics of actually turning your virtualized environment into an effective way of executing your newly enabled application. In particular, I cover the differences in the execution process and provide code examples for how to employ the different virtualized application execution techniques covered in Part 2.

From the introduction:

When enabling an application for use within a grid, the first process is to make your application as open and easy to deploy as possible. In Part 1 of this “Application virtualization” series, we examine how that is possible by building a virtualization layer around the original application. In Part 2, we examine the environment to build to support the grid. Now, to wrap up the series, we look at how you turn your grid into a virtualized version of the original application, and how you distribute work internally through the grid to achieve the best performance.

You might want to check out the previous two parts of the series:

• Application virtualization, Part 1: Level 1 - Abstracting your grid infrastructure
• Application virtualization, Part 2: Level 2 - Understanding your virtualized environment

Read Application virtualization, Part 3: Creating your virtualized application for the grid