This is a review of Alpha 5, a tool for developing database backed web and desktop applications.

Distributed by: Alpha Software
Price: From $199 for IDE, from $399 for web application server

An awful lot of web and desktop applications are very similar: basically, just front ends to databases. Therefore there is a market for tools that make the job easier or do a lot of the tedious repetitive work for you. This not only saves time over hand-rolling the application yourself, but saves you from fixing the same types of bugs again and again. I've been there and written such a tool for web-based front ends myself. One of the largest challenges is making the most common things really easy without making the less common things really hard or just plain impossible.

What is Alpha Five?

I'm reviewing version 8 of Alpha Five. You can get a free trial version that lasts 30 days, if you want to follow along with the application I'm going to try and build in this review. But first, let's see what it claims to offer.

"With Alpha Five, you can quickly and cost-effectively build fully functional desktop and web database applications. Also included are flexible report writing, intelligent email, data browsers and a full security framework. A rich programming language and tools like Action Scripting combine ease of use and complete extensibility."

So basically, it's something that's going to reduce development time of database frontends, hopefully allowing you to do plenty of stuff without having to write code but providing a powerful language to work in if you need to do so. Let's see how it holds up to these claims.

Getting Started

Alpha Five lets you get straight down to work. The opening window offers you the choice to create a new database, upon which you will then build an application. It also offers to let you import data from elsewhere to base your new database on and a choice of templates, which will get you started for the super-common cases. For my first time, I decided to build from scratch and created a new, empty database. This quickly leads you to the following window:



Where you can start creating your application.

Designing A Database

To give Alpha Five a little workout, I'm going to build a simple application for an imaginary chain of dog rescue homes - places that take in stray or unwanted dogs, look after them and, hopefully, re-home them. For that we're going to have several entities, represented by tables.

• Homes - the dog recue homes
• Dogs - dogs, each associated with a home
• Rehomers - people who have taken dogs from the center; there will be a many to many relationship between this table and dogs

So, let's create a table. Homes should be easy enough - we'll have a Home ID as the primary key, the name of the home and its address.



A few things struck me as I started using the table builder. The first and most uncomfortable one is that I didn't see a way of specifying a primary key. The second was that the types felt somewhat unfamiliar; I guess Numeric is perhaps clearer to beginners than Integer, though. Third, it offers you a length and decimal field for all types, whereas in reality that's only relevant to certain types - a Logical, for example, is a simple true or false value.

I also wanted HomeID to be auto-increment. It turns out that you have to specify this in another place - namely, by editing the Field Rules rather than the Table Structure, which is what the editor we saw before allowed us to define.



Alpha Five offers you other ways of creating tables. One is text-based, using its own database description language. That means that if you are familiar with SQL, that knowledge isn't going to be so helpful.

An interesting feature is that you can also define a table by specifying a list of data and having the table worked out for you. I decided to give this a try for the Rehomers table, entering data as shown below.



Creating a table from this data produces the following results:



It's not bad, though clearly the length of the field has just taken on the maximum length that any of the example data was. Therefore you'll have to go through and review those. However, if you have a chunk of data in a comma separated format, this could be useful.

I went on and created my dogs table, and then wanted to build the relation between dogs and homes. This is done using something that Alpha Five calls sets, though they appear to be along the line of views too. You can create relationships between tables based on certain fields, choosing whether you have one to one or one to many relations.



I found this a little different to the way I'd specified relationships elsewhere. In general, it appears that Alpha Five likes to keep different database concepts separated out. Depending on your database experience, you may see that as a good thing or a bad thing.

One more table was needed to get my many-to-many relation of dogs to rehomers working. I didn't see any way to avoid having to create the link table myself.

Overall, I'd say the Alpha Five team have clearly considered how to break database concepts up to try and make things easier for beginners. The UI could use a little work, but with little reading of the help files I was able to get my data layout defined at reasonable speed. I noticed that you could also import an Access database. Now it's time to get on with building a web front end.

Creating a Web front end

Alpha Five supports static HTML pages and dynamic content pages, which go by the name A5W pages and are along the same lines of ASP or PHP pages. Happily, you will spend little time designing forms yourself, since Alpha Five will generate them and all of the code behind them for you.

To make this happen, you have to create Web Components - something that becomes clear quite quickly if you take a look at the help files. So, I created a component for dog homes. Three possible layouts for the form are offered - column based, tabular and a kind of stacked column (with the names of the fields above the values). You can select which fields are shown, which are editable and so on.



This bit felt much more intuitive than creating the database, and is really where Alpha Five started to show promise. Anyone can implement a fairly mediocre database designer, but being able to build the front end effortlessly is where the tool will start to save a lot of time.

Then you can create an A5W page and add the component to the page. To test this out, you need to start the application server - there's a big red button on the toolbar to do this. With that done, you then have to Publish the site to the application server. Finally, you can go to your web browser, bring up the page you created and see the form. It isn’t exactly pretty yet, or quite what you might want, but it took less than ten minutes and delivered add/edit/delete functionality.



One curious quirk is that it doesn't take the maximum length of the field as defined in the database and use it as the maximum length of the input field; instead, it defaulted to 20 characters. Having to fix that slows things down a bit - it's the kind of bug that takes away from the overall effect of, "wow, that was easy", which is what makes it desirable.

Next up was the manage page for Dogs. This is a more interesting case than the previous one, because this time the table contains a foreign key - namely, the home that the dog is at. I wanted to see this rendered as a drop-down so you could select the home. This turns out to be relatively easy. First, you select that the field should have a dropdown box control. Then there is another dialog to specify the source of the values for the dropdown. In there, you specify the table that is the source of the data. Finally, the fields from that table which will supply the name and the value for the dropdown entry need to be specified. The interface for this last step wasn't entirely obvious, but I had something working relatively quickly.



The table to enter the details of people who have rehomed dogs was as straightforward as the first table. The table for mapping a rehomer to a dog was like the dogs table, apart from it just had two dropdown fields rather than one. With this, we now had a basic, but working interface for managing the dog rehoming database. With time and experience that could be built into something more user friendly that fits the look and feel of the site in question.

The time it took for me as a new user to go from having nothing to having something that basically worked - without having to write a single line of code - is a pretty encouraging sign. Having a GUI driving the process makes it easier to get started with and opens it up to non-coders.

Adding Security

We don't want just anyone accessing our web application. Alpha Five handles user authentication, allows users to be placed into groups and then allows access to pages and/or components to be assigned to these groups. First, security needs to be enabled and configured.



After that, users and groups can be created. You have a choice of where user data is obtained from and stored; one option is to have it in a database table, which will make sense for many applications. Users can then be put into groups; I didn't see a way to store user/group mappings in a database table, but I imagine there must be some way to achieve programmatically creating new users in the correct groups.

You can do security at a page level or a component level. Moreover, you can restrict actions on components by group: for example, you can allow everyone to insert new dogs, but only allow some groups to delete them.



Finally, you need a way to allow people to log in. To do this is a few steps: first, create a new login component, then create a page and insert the login component that you created into the page.



Here we can see one other nice feature that I haven't mentioned before: inserting the component actually inserts a couple of things that you can position independently. That means you can display the errors wherever you want in relation to the form, to fit the look and feel of the site.

The security model seems fairly configurable and appears to support a form of level-based rather than group-based access control, though I didn't explore this path. The only potential danger I see is that if you do not select any security groups for some aspect of a component, then it assumes there are no restrictions.

Deploying Alpha Five Applications

Alpha Five web applications are deployed onto an Alpha Five Application Server. It appears that this is the only option you have, which may be a bit limiting. For example, it means you can only host Alpha Five applications on platforms that the application server will run on. I can't find anything to suggest that it will run on anything besides Windows. Further, since it runs as a web server, if you want to serve the application on port 80 then it won't play well with hosting non-Alpha Five sites on the same server. It would be nice if there were an option to "compile" the application to some other scripting language to allow a greater range of deployment opportunities.

Note also that the web application server that ships with the Alpha Five development environment is for testing purposes only; to actually deploy the site you need to purchase an application server license too. If you plan to deploy desktop applications rather than web applications, be aware that the pricing of the runtime that users will need depends on the number of users. That is, there is no free runtime engine, so don't expect to be able to be able to distribute your application as you could if it were written in .Net or Java, where many people will have the runtime anyway and if they do not it's a free download.

Final Thoughts

I've been impressed with just how much you can achieve with Alpha Five without a single line of code and only the odd glance at the documentation. Certainly there are things they could improve on: the database designer felt a little clunky and the integration between web components and the database definition could have been stronger. I also worry about deployment issues - I can imagine that the restrictions I described will put some people off.

However, if things seem workable from the deployment angle and you're looking to build database-backed web applications or desktop applications for internal use, it's certainly worth downloading the 30 day evaluation. It may well handle what you're wanting without a great deal of effort, as in my example. And as you get bigger in the future, it's good to know that it can back onto SQL Server for safe, high performance data storage and has its own scripting language to let you do the less usual things.

While I wouldn't recommend it for every situation where you need to build web or desktop frontends to databases, it is well suited to intranet and in-house corporate applications. If you put the deployment issues and niggles aside, it provides a far better way to develop database-backed applications than the widespread "hand-rolled" approach, and is certainly the direction that web development should be heading in: eliminating code when we can generate it by simply declaring what we want.