“Plat_Forms” is a contest in which teams of three programmers compete to implement the same requirements for a web-based system using different technology platforms (e.g. Java, .NET, Perl, PHP, Python, Ruby, Scala, Smalltalk, JavaScript or what-have-you). The main contenders for 2011 were Ruby, PHP, Perl and Java. The results for the 2011 are given here. Compared to the 2007 study, the results differ markedly.

The detailed results are yet to come, but you can draw your conclusions from whatever data is currently available.

Further reading:
Chapter 14 – Two comparisons of Programming Language from Making software.

So for example, if we only consider using braces ‘{}’, and semicolon ‘;’ – one of the common punctuation elements in a PHP program, a programmer can get a feel for the structure of a source file. Usually braces delimit blocks and functions in PHP, and many other languages, so this can give a programmer a sense of the length of code blocks or function sizes.

A sample source file taken from a WordPress system, and its signature using select punctuation characters ( ‘{}’ and ‘;’ ) is given below.

Sample WordPress source file – wp-blog-header.php:

<?php
/**
 * Loads the WordPress environment and template.
 *
 * @package WordPress
 */
 
if ( !isset($wp_did_header) ) {
	$wp_did_header = true;
	require_once( dirname(__FILE__) . '/wp-load.php' );
	wp();
	require_once( ABSPATH . WPINC . '/template-loader.php' );
}
?>

Signature of the above file:

wp-blog-header.php : {;;;;}

This shows that the file has one block section (function, class or other), containing four statements. Of course to get a quick intuitive feel for the signature, you will have to work with at least a few diverse code bases. This will prime you to estimate the complexity of the code by just looking at the signature.

If we also include parenthesis ‘()’ in the signature, we get the following. But this looks a little complex and less intuitive than the previous one.

wp-blog-header.php : (()){;(());();();}

Some more signatures of various WordPress root files is given below.

index.php : ;;
wp-atom.php : ;;;
wp-blog-header.php : {;;;;}
wp-comments-post.php : {;;;;};;;;{;;};;{;;}{;;}{;;}{;;}{;};;;;;{;;;;
{{;;}}}{;};{;;};;;;;{;;;;};;;;
wp-commentsrss2.php : ;;;
wp-config-sample.php : {};;;;;;{};;;;;;;;;;;;;
wp-config.php : ;{};;;;;;{}}{{{;{};;{;;{;{};{{{;{;}{;;;;;;
wp-cron.php : ;;;{;};;;;{;{{;{;;};;}}};
wp-feed.php : ;;;
wp-links-opml.php : ;;;;{;;};;;;;;;;;;;;;;;;
xmlrpc.php : ;;{;};;{;;;;};;;;;;{;{;;;;;};};;;;;
wp-load.php : ;;{;}{;}{;;;;;;;;;;;;}
wp-pass.php : ;;;;;
wp-rdf.php : ;;;
wp-register.php : ;;;
wp-rss.php : ;;;
wp-rss2.php : ;;;
wp-login.php : ;{{;;}{;;}}{;;;;;;;;;;;;;;;;{;;;;{;}{;}}{{;}};;{;;;}{;;
;};;{;;}{;;{;{;;}};;}}{;;;{;;}{};;;}{;;{;{;}{;{;;}}};{;}{;}{;;{{;};}{{
;;}{}}}{;;;;;};}{;;;{;;}{;;};;{;;};;;;;;;;{;;;};;;;;;;;;;;;;}{;;;;;;;}
{;;;}{;;;{;}{;;}{;}{;}{;;;}{;};;;;;{;;;};;;};;;;;;;{;;;};;;;;{;;;;;;{;
{;;;}};;;;;;;;;;;;;{;;};{;}{;;;;};;;;;;;;;;;{;;}{;;};;{;;;{;;;}};;;;;;
;;;;;{;{{;;}}}{;;}{;};;;;{{;;{};;;}{;;;};;};;;;;;;;;;;;;;;;;;{}{;}{;}{
{{{;;}{;{;}};;}{}};}{;};;;}
wp-mail.php : ;;;;;;;;;;;;;;{;;;};;{;;;;;;;;;;{;{;}{{;;;;{;;};}{;;;;;}
{;;;}{;;{;}{;};;}{;;;{;;{;}{;;}}{;}}{;;{;};;;;;;;;;;{{;}};;;;;}}}{;;}{
;};{;;{;;};};;{;}{;};;;;;;;;;;;;;;;{;;;}{;}};
wp-settings.php : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;{;;}{;};;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;{;;;};{;};{{;};};;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;{;
;};;;;;{{;;};};
wp-signup.php : ;;;{;;}{;};{;}{;;}{;;};{{;;}{;}{;;;;;}{;;;}{;;}{;;;;}{;
}{;;;;;}};;;{;;;{};;{;;;}{};;{};{};;}{;;;}{;{;};;;{}{;};}{;}{;;{;};;;;;
{;};;{{;;}};;;}{;;;;;{;;};;;;;;}{{}{}{};;;}{;;;;;;;;;;;{}{}{}}{;;{;;}{;
;};;;}{;;}{;;;;;;;;;;}{;;{;;};;{;;};;;;;;}{{}{}{};;;;;};;;;;;;;;;;;{;}{
;;;;}{;{;;;;;;;;;;;;;;{;;;};}};;
wp-trackback.php : {;;}{;;{;;;;;;}{;;;;}};{;;};;;;;;;;{;;;};;;;;{;;}{;;
;;;;;;;;;;;;;;;}
wp-activate.php : ;;;{;;};;{;};{{;}{;;}{;}{;}{;;;;;}};;{;}{;;{{;;;{;;
;}{;;;};}{;;}}{;;;;;;;;;;}};;;

To generate the signatures yourself, you can use the following shell script or a PHP program. The shell script is shown below.

for i in *.php; do
    echo -n "$i: "
    sed 's/[^{};]//g' $i | tr -d '\n'
    echo 
done

And below is a PHP version to do the same.

<?php
 
/* Get all PHP files in the current directory */
$dir = './*.php';
 
/* Use the SPL Iterator class */
$files = new GlobIterator($dir);
 
/* Get the signature of each file */
foreach ($files as $file) {
    $data = file_get_contents($file);
    preg_match_all('/[{};]/',$data,$out);
    $signature = '';
 
    foreach($out[0] as $line) {
        $signature .= $line;
    }
 
    echo $file->getFilename() . " : " . $signature . "\n";
}

Furthermore, we can make the output more attractive and user friendly, by outputting it to HTML, with links to each source file.

OPA is concise, simple and readable, it is also provides concurrent, dynamically distributed, and extremely secure programming model. Opa is designed to make web development fun, secure and right. Opa is a complete language and not just a framework, the unified approach of Opa delivers a new level of developing experience with unmatched ease of use and security.

While Opa offers all the features that developers have come to expect from a high-end web server, a high-end distributed database management system, frameworks or distribution engine, Opa does not resemble Apache or Tomcat, MySQL or Oracle SQL, Drupal or Ruby on Rails, Google AppEngine or Hadoop.

Developing with Opa is as simple as it gets: first, you write your code with the Opa programming language — and only the Opa programming language, no JavaScript, no SQL, or anything such (this is something new, will take sometime getting used to). Then compile the code, and let Opa analyze security, generate the code for the browser, for the server, for the database, and combine it with the web server. Finally, launch your executable and your browser. No need to independently deploy, administer or maintain a database management system, a web server, frameworks or middleware. And, of course, the application works on any recent browser, whether mobile or desktop. Oh yes, and it is right away “Cloud-ready”.

Let us take a sneak peek preview and take a look at the simplest application: Hello, web.

server = one_page_server("Hello", -> <>Hello, web!</>)

This is the full source code of the application. Without any setup (besides the installation of the compiler), obtaining a complete, deployable application is only a matter of one step:

opa hello_web.opa

This command produces a stand-alone executable binary, containing everything required for execution, including database management, compiled requests, server code, client code, user interface and everything that may be needed to connect them or to handle malicious connections or inputs. Opa generated and checked all this code for you. You may now launch the server:

./hello_web.exe

Or, if you prefer, you may deploy it to a cloud:

opa-cloud hello_web.exe --host localhost --host my@server1 --host my@server2

Your application is launched, load-balanced, and servers share whichever information is necessary.

Although I’ve yet to develop an OPA application of more than average complexity to gauge the actual benefits of it; it looks promising and also something new to try. The OPA API also looks quite complete and well documented.

Now contrast this with my typical interaction with a website. Last month I’d planned a tour itinerary for my relatives who had been travelling around Europe and had been using tripadvisor.com extensively for my research. Tripadvisor is an indispensible tool for travelers and offers some good features, but like most sites it is still dumb. Take for example the restaurant selection menu on the site from were you can select your preferred cuisine type. Being Indian my relatives naturally prefer eating at Indian restaurants. The hitch here is that every time I choose a different city the menu resets to its default and I have to re-select the ‘Indian Cuisine’ menu; which becomes exhausting after some time. Of course I can signup with the site and store my preferences, which is what most other sites do. But what I really want instead, is for the site to “learn about my preferences” as I go along interacting with it. After selecting the ‘Indian Cuisine’ menu for maybe six cities in a row, the site should understand that I’m interesting in ‘Indian Cuisine’ and automatically select the relevant menu for my next city.

Of course not every site is dumb in design; some big sites use sophisticated machine learning algorithms to help the user, but they are few and far between. And by intelligence I do not mean the ‘Semantic Web’ – which is a different beast altogether. By intelligence I mean an intelligent UI. Interfaces that cleverly help the user as he works around a website. Interfaces which, like a dutiful servant, anticipate the users’ needs and works accordingly. Are such kinds of artifacts hard to build? With so much programming talent around, I don’t think so.

I think we have had enough of jQuery plugins that show yet another photo gallery; or a new PHP framework, that like dozen others, promises to reduce the development time and make programming fun. Yes, programming should be fun, but what should be more fun is the final application we produce. A web application that users will love to work with.

$alphanum  = "123456789";
 
# $insertedId is the id of the last database insert
# $verification_code is saved in the database
$verification_code = (substr(str_shuffle($alphanum), 0, 5)) . $insertedId;
 
# Good till here, but the following line botches it up,
# the generated number is further multiplied by a constant.
$verificationCode  = $verification_code * (12345) #ouch!;

# $verificationCode is now sent through the email link as a GET parameter,
# e.g http://www.xyz.com/verify_email.php?vid=$verificationCode

When the user clicked on the verify email link the verification code was retrieved from the GET parameter, divided by a constant number and the result compared to the original verification code stored in the database.

$verificationCode = $_GET['vid'];
$verifyCode = $verificationCode / 12345;

The problem was that once in a while the random string generation code would spew a somewhat larger number, which PHP would happily convert to a exponential format and pass it over the email link in the GET parameter.

http://www.xyz.com/verify_email.php?vid=6.9833696969697E+19

The number which when retrieved by the system would obviously not compare with the original and the system would flag the email link as invalid, robbing the site owner of potential subscribers.

Rather than go with all the rigmarole, a good way would have been to generate a random string using the following.

$verificationCode  =  md5(uniqid(rand(), true)) . time();

The point being that you cannot be too careful when dealing with numbers, a single overlooked fact can trip you.

Apdex: Measuring user effectiveness

Apdex (Application Performance Index) is an open measurement standard developed by a group of companies. It is a numerical measure of user satisfaction regarding performance of web or desktop applications. It enables management to gain insights about user satisfaction with respect to the developed application.

Apdex converts multiple measurements into a single number on a scale of 0 to 1 (0 = no users satisfied, 1 = all users satisfied). This metric can be applied to any source of end-user performance measurements that gathers timing data.

The index is based on three areas of application responsiveness, we will see this in the context of web applications. The three areas are partitioned by two time limits, T and F. T (satisfied-tolerating
boundary) represents the base time limit (in seconds) below which the application is responsive; and F represents the maximum limit after which the application response drops considerably and the user may close the application or navigate to another site. F is taken as (4xT) or four times T.

■ Satisfied—The user is completely productive. This represents the time value T below which
users are not impeded by application response time. For e.g when a web page loads in less than 3 seconds.

■ Tolerating— With response time greater than T the user starts noticing the performance lag but continues the process. E.g. when the page takes around 10-15 seconds to completely load.

■ Frustrated—Performance with a response time greater than F seconds leads to frustration and the user usually navigates away from the site.

So if we need to measure the Apdex score for a 75 page enterprise web application, we have to initially set the target times T and F around which our three measurements will be based.

Lets set T to 3 seconds and F to 12 seconds. After measuring the load time of the 75 pages we find that 28 pages load in less than 3 seconds, 40 page load between T and F seconds, and the remaining load in more than F seconds. In short:

Load time of 28 pages <= T
T < Load time of 40 pages <= F
Load time of 7 pages > F

We can then calculate the Apdex score using the following formula:

Which in our case will give a score of 0.64:

The score gives a value of ’1′ when all the users are satisfied with the application performance, a ’0′ when no one is satisfied and ’0.5′ when all the users are tolerating the application performance. For other variations the score can range between 0 – 1.

Advantages of Apdex

The main advantage of the metric is that it provides a single score that lets the IT manager easily compare performace between different applications or different versions of the same applications. In the context of web applications a IT manager can easily compare the Apdex score before and after optimizing a web application.

References:
http://en.wikipedia.org/wiki/Apdex
http://www.apdex.org/index.html

Take an example class method addUser() shown below. When the query is executed the result is logged in a file with the function name and a user_id or a serialized error string in case of an error. Whenever the application is in a testing phase, the error logs are an immense help in diagnosing error points. This is better than a splattering of print_r statements all around the code.

define("LOG",  true);
 
/** Add new user to the system
 *
 *  @param array $user_data
 *  @return boolean
 */
public function  addUser($user_data)
{
.
.
    if(!$sql->execute()) {
        if(LOG) {
            $err_string = serialize($sql->errorInfo());
            $this->_log->LogError("addUserd | error | " . $err_string);
        }
        return 0;
    } else {
        if(LOG) {
            $this->_log->LogInfo("addUser| no. | " . $user_id);
        }
        return 1;
    }
}

The contents of a sample log file are shown below.

2010-07-31 4:52:58 - INFO  | addUser | no. | h1280551978 
2010-07-31 4:53:04 - INFO  | user edit | no. | 1 
2010-07-31 4:53:06 - INFO  | user edit | no. | 1 
2010-07-31 4:53:07 - INFO  | addUser| no. | 1 
2010-07-31 4:53:09 - ERROR | addUser| error | 
a:3:{i:0;s:5:"23";i:1;i:148;i:2;s:30:"Column 'fileno' cannot be null";}

Although logs can add some overhead to your code, it is a small price to pay for the benefits it provides. And if you do not want the logging feature you can easily disable it by setting the LOG constant to ‘false’ in the above code.

Which logger to use

Although there a variety of libraries, I prefer KLogger as it has a small footprint and is easy to use. Other more advanced contender is Log4PHP, a PHP port of log4j, a Java logger. Zend_Log also looks nice but I am yet to give it a try.

Analyzing logs

For big, frequently used applications, log files can quickly get quite huge. The easy way to analyze them is to use GUI tools like LogMX and Apache Chainsaw. But if you just need to get some simple statistics from your logs, you could use the trusty old grep and other *nix utilities. For example to count the total error lines having the string ‘mysql’ you could use the following code.

$ grep 'ERROR ' activity.log | grep 'mysql' | wc -l

The advantage of scripts over GUI tools is that you can automatically process them using CRON jobs, e.g – emailing the admin if some particular type of errors in a log reaches some critical limit.

In conclusion, logs are one of the simplest ways of keeping track of your code problems or to check the execution sequence of your statements. This can be immensely helpful during development and for tracking down bugs.

The following two videos provide a stark reminder, that for most of the time these are the people we develop software for.

Although the above videos are in the context of the users familiarity with the concept of a browser, it brings home the point that for the user the interface is everything, which most of us developers give little thought. Most users don’t care what browser or the version thereof they are using, they just need to get the work done somehow.

People are not idiots as the above videos may have you believe, on the contrary we developers are not smart enough to create usable software.

Writing software, once we become comfortable with the language and environment is easy. But crafting software that the user will love and admire is a lot harder, which in the end is what really matters. Not that I’m downplaying the importance of good code – testing, security, code efficiency are all important elements of a good product. But for the user, the interface is the product. Apple seems to get it, so why can’t everyone.

The path out of this quandary is to really understand usability. If you are a freelancer developer get some good books on interface design and usability, read them, try to implement as much good interface designs into your current project as you possibly can. Over time this will become almost second nature to you. Below are some of the books related to good interface designs that I personally like:

Many readers will be surprised by the absence of Coopers’ About Face 3 here. Coopers’ is a decent book, but I somehow do not like it. It is a tad wordy and preachy, most of which I do not agree on.

As a small reminder, below are six of the most important expectations the client has from the developed software, every other thing hinges on these:

1. Revenue generation from the new application
2. Cost reductions from the new application or upgrade
3. Indirect revenue generation
4. Increase in exiting user base due to some new features
5. Increase in market share
6. Revenue increase in companion application

The points raised above may come as common-sense; but how many times when developing for a client, have you given thought to these matters. We developers and usually busy thinking about the best way to structure the application, the best way to run a SQL query, the best MVC framework; leaving the business and value aspects of the proposed software to the management; who usually do not find it prudent to enlighten the developers’ in that matter. It’s not that the technical issues are not important; what is wrong is the predominant focus on technical issues.

Taking the business and value aspects into consideration during development enables you to view the project from the clients perspective. This in itself makes taking decisions regarding certain technical issues easier. It is even more important for you to take the business issues into consideration if you are a freelance developer, where you are solely responsible for bad project outcome, unlike a company where you can play the blame game and walk away from the mess unscathed.

In a nutshell, a client does not care if you have used the latest MVC framework, or used your expert programming skills to design that perfect algorithm. What they truly care is whether the developed software will garner them some intrinsic value more then what they paid for, which in business parlance we know as ROI. Everything else is just details.

Consider those matters when developing your next project and you will have a win/win project in your hands with a satisfied and smiling client as a bonus.

The most common sense thing you can do is to test your code even for small changes; whether you are testing it yourself or sending it to the testing team. Seems simple, but how many times have you really done that. Its not that we are stupid, rather software was never so simple. Maybe we are careless sometimes. The moral is plain – treat even small changes important, and move it through a test before committing it to a version control.

The following figure from Steve Mcconnell’s Code Complete shows the relation between lines of code changed and errors introduced.