This page provides some comparison between PHP, ASP and Whitebeam in order to introduce Whitebeam to people familiar with those
technologies. If you haven't used these technologies then you may be better placed reading the
full tutorial on writing Whitebeam applications.
The subjects covered are:
- The layout of pages - comparing Whitebeam against PHP and ASP
- Markup - How Whitebeam uses XML to move beyond scripting
- Libraries - Interfaces to backend technologies
- Scaleability - What happens when your application outgrows your current server - or the currently available fastest serer?
- ...and finally a Summary
ASP, PHP and Whitebeam all store programs in text files, and each of those files contain special markers that highlight where
to insert dynamically generated content. In the Whitebeam environment these files generally have the
extension '.rhtm' or '.whtm' but of course you can use any extension. The following shows two similar pages - one for PHP
and one for Whitebeam
// Server-side PHP
$msg = "Hello World";
<?= "The message is'$msg'" ?>
var msg = "Hello World";
<?= "The message is '"+msg+"'" ?>
The major difference between the structure of Whitebeam pages and those of the other two technologies is that Whitebeam files must
be valid XML markup. Whitebeam is an XML Application, while the other two are more simply text substitution
processors. XML is an inherent feature of Whitebeam. Although PHP uses XML 'friendly' syntax - the files are not XML. This
is illustrated by the perfectly valid PHP file:
<?php $aValue = 22 ?>
<table border="<?php echo($aValue)?>">
As far as PHP or ASP are concerned - a program file has no structure - it is a text file on which simple text
substitution is performed.
- Whitebeam is an XML engine that invokes a script engine as necessary. A Whitebeam file is an XML file and can
be manipulated as such and used with existing XML editing tools.
- ASP, PHP are text based technologies - they have no intrinsic awareness of XML or document structure
the differences will probably not be apparent. However by making Whitebeam an XML application - and having the programs structured
using valid XML unleashes a whole set of additional facilities such as:
- Use XML and HTML editors to see document structure
Many PHP and ASP applications hide all their output in streams of print statements. The only way you can see the output structure
is by running the application and looking at the output. A Whitebeam page allows you to represent the application structure in XML,
which can be modified using commercial XML/HTML editors such as dreamweaver.
replaces the tag in the output document sent to the client.
You can also use this behaviour to 'transform' existing tags. I could for example redfine <h1> tag to automatically insert a
link at the start of a page whenever it is encounrtered, providing an automatic table of contents.
- DOM manipulation of the source
Because a Whitebeam page is an XML document at the lowest level - Whitebeam provides a DOM like access to that document structure at
run time. You can included a number of XML sub-structures within your doucment - then select the appropriate on for output, maybe based on browser
or current section number or type of person logged into the site.
ASP and PHP provide mechanisms that can substitute 'output' in place of 'script'. In the ASP and PHP the only way of achieving this
is through script, which can make the pages being generated look very clumsy, which in turn makes maintainance and development more difficult and
best described in an XML markup language, which Whitebeam provides as a set of XML markup that is embedded
in application pages.
To illustrate how this improves the structure of a page consider the following simple example of repeating a block of output for rows in a table:
<td>Row <?= $i ?></td>
<td><?= $rows[$i] ?></td>
<rb:repeatfor expr="var i=0;i<rows.length;i++)">
<td>Row <?= i ?></td>
<td><?= rows[i] ?></td>
Or an even simpler example - conditionally including a block of text if a user is logged into the system
<p>Welcome back to our application!</p>
Welcome back to our application
This latter example also illustrates the power of a system that understands the XML hierarchy. An entire block of XML can be
Whitebeam provides a rich set of XML markup to allow you to define your pae structure rather than having to use PHP
between Whitebeam, ASP and PHP. The XML structure of a Whitebeam page makes it very easy to build XML
based applications. By itself this functionality has little practical use. It could for example be used as a more understandable translation language than
XSLT, for those familiar with standard procedural languages, but that's about it!
To write an application requires access to a number of underlying functional technologies. Obvious among these are the ability to store persistent data
between page access, recognise client sessions and associated data, implement a robust security model etc. Each development environment provides these in
a different way, but in each as an underlying application programming interface (API).
The PHP approach
PHP provides a very rich API built as a set of function calls to underlying modular interfaces. As PHP has developed and grown a larger following so more
effort has been placed into adding interfaces to just about any kind of function you could need for a web application. This is perhaps one of the strengths, and
weaknesses of the PHP environment. The libraries cover a lot of functionality, but has been implemented by a wide variety of organisations and individuals.
The result is a feature rich environment, but one that can be daunting to new users of the environment.
The APIs provided to PHP developers also tend to be very thin, in that they map almost directly down to an underlying applications interface. The result is
very little consistency and very little abstraction, leading to a different API to talk to, for example, Postgres, mySql and DB2, despite the fact that they are all
SQL databases. To see the breadth of coverage visit the PHP documentation library
The philosophy followed by the PHP libraries tends to mean that you have to know a lot about the underlying technology before you can use an API.
PHP effectively provides a procedural interface allowing direct access to underlying software, but to use that technology you must learn both PHP - and how to use that
technology. To write a database driven application using PostgreSQL for example you to learn PHP, HTML andSQL.
Whitebeam provides an intuitive, well documented object orientated set of APIs
that abstract away the underlying complexity in order to reduce barriers to entry
for new users. While developers can get down to the underlying functionality,
it is perfectly possible to build a feature rich database driven application without
ever having to learn SQL. Even where the user wishes to get to the underlying
functionality the Whitebeam aim is to provide a consistent interface to similar
techologies. You really shouldn't have to change your code substantially
to move from one database technology to another!
Whitebeam library functionality falls into two main categories:
- Session/request related functions
For example sending text to the browser, reading data from a form, accessing session information associated with this request.
- Other associated objects
Covering making HTTP requests, sending emails, making database connections etc. These are generally objects that are transient and last for a single browser page request only.
The first of these is represented as an object called 'rb'. This object contains a
set of objects representing different aspects of the current operating environment,
for example sessions, catalogues, sessions and the page generation itself.
You'll find a list of all the Whitebeam classes here.
The second, transient objects, are represented by a number of classes within the system. So an HTTP request is represented by an instance of the 'HttpRequest' class.
PHP has evolved over time from a fairly basic origins - the system developed from the scripting language. Most of the functionality available to developers is in the form of
added libraries. Most of these have been developed to for the most common 'single-server' web application environment. Scaleability has never been a major issue addressed by the
developers of PHP. There is no doubt that you can develop reliable, scaleable applications, but in that case you have to write your own framework to make it happen.
The core libraries provided with PHP lend themselves to single server applications. The standard session management functions store session information in a file on
the local file-system. If you have a vedry successful site and your server can't cope, your general solution is to get a bigger server. If you have the biggest server you can afford
then your only options are to replace the core functionality with your own session tracking code, using for example a database to store session information.
Our interest was not in providing the language but rather in how to harness that language to develop scaleable applications. All of the standard libraries
in Whitebeam have been developed with scaleability in mind. Using standard libraries, if you have performance issues, you can make use of industry stanard
load balancers to run your application on two servers concurrently. None of your code has to change because the Whitebeam architecture separates session data
into a separate service accessible by all servers.
Whitebeam has a number of similarities with PHP and ASP. Page layout can look very similar and you can do very similar things with each of these
Whitebeam very much builds on these architectures using internationally standardised building blocks of XML and ECMAscript. Where PHP and ASP
process a text page for embedded script, Whitebeam introduces a two-parse approach, processing an properly formatted XML file and then executing
behaviours associated with specific XML markup within those pages. Whitebeams knowledge of the structure of the page as a hierachy of tags
allows some very sophisticated manipulations to be achieved very easily.
Alongside the core page structure, Whitebeam provides a rich set of data storage and manipulation allowing sophisticated database driven applications to be written
with no knowledge of the underlying technologies. Whitebeam abstracts away the need to learn SQL or other technologies. At the same time it provides those interfaces
if required for specialist applications.
Finally Whitebeam addresses in a transparent manner the issue of scaleability and reliability, allowing a developer to take an application
initially running on a single server and to run that same application unchanged on multiple servers using standard load-balancing products.
The quickstart guide will give you more details about Whitebeam