A web that is not a global digital library, but a global digital nervous system

After nearly a two years gap i am filling up my blog with something for my readers who have been disappointed with no updates at all. Recently i was sitting with my friend Nandan and discussing some core concepts of programming and where would the web end up totally. I had discussion with ma amigos and my big brother over this, but eventually he is a management guy who just worries about the sales. But it’s a lot of work to rewrite everything in sight and I suppose managers are reluctant to invest in that just because something or other is cool.

LAMP, DOT NET and Java is DEAD or would eventually die someday

LAMP architectures are dead because few web applications want to ship full payloads of markup to the client in response to a small event; they want to update just a fragment of the DOM, using Javascript. AJAX achieved this, but when your server-side LAMP templates are 10% HTML and 90% Javascript, it’s clear that you’re doing it wrong. Since the birth which happened two decades ago, there has been fundamental shifts in the web with content, protocols, servers and clients. Together we can mark as three ages of the web.

It seems that every few years a new technology comes along which gets a bunch of people excited and they want to rewrite the world in this new thing because it’s so cool. But it’s a lot of work to rewrite everything in sight and I suppose managers are reluctant to invest in that just because something or other is cool. On the other hand the LAMP stack has serious architectural problems and PHP is a horrible language. There are a few things which event driven servers do a zillion times better than LAMP – research the beginnings of COMET and you see people describing a need for which Node.js is the perfect solution.

What is Node.js?

Basically, it is a lightweight framework wrapped around Google’s V8 JavaScript Engine. V8 is the JavaScript engine that powers Google Chrome, their open source Web Browser. Another part of Node.JS is that it is event based, which can make is very quick and efficient.
I’ve been tinkering with Node.JS for a couple of weeks, and it is very interesting and has a lot of potential. It’s unique scoping with JavaScript and event-based methodology makes certain things easy to accomplish that are more difficult in other traditional tools. There are some pretty cool libraries for Node.JS like Socket.IO, a library to support multiple transports using feature detection. So if your browser supports WebSocket or Adobe Flash Socket, it will use that, or AJAX long polling and multipart streaming, or even the Forever Iframe technique. So your application will use which ever type of communication is most efficient.

Node.js – the Future

The JavaScript age is about event streams. Modern web pages are not pages, they are event-driven applications through which information moves. The core content vessel of the web — the document object model — still exists, but not as HTML markup. The DOM is an in-memory, efficiently-encoded data structure generated by JavaScript.

The one thing that worries me about Node.JS is that even though you’re locked in this jail with no easily available blocking operations, you still need to know (arguably advanced) knowledge regarding how to debug race conditions and how an event loop works (and even how a call stack works due to recursive callbacks smashing the stack). Because of that, the control flow is very strange and mind-bending to people that have been writing C for 20 years, and even junior engineers that are just getting into programming (unless they are web-focused engineers that are used to jQuery-esque continuation passing style). This is pretty much proven by all of the arguments and libraries popping out of the woodworks to deal with control flow in some elegant way (fibers, chaining, etc).

[codesyntax lang="php"]

<?php

include('escape_arr.php');
//create an array
$sets=array(
'userid'=>$userid,
'mimetype'=>$mimetype,
'bytesize'=>$bytesize,
'filename'=>$filename,
'extension'=>$ext,
'lastmodified'=>time(),
'height'=>$height,
'width'=>$width,
'binarydata'=>$data
);
list($sets,$cols,$values)=escape_arr($sets);
$insert_sql="INSERT INTO `avatars` ".implode(',',$cols)." VALUES(".implode(',',$values).")";
$update_sql="UPDATE `avatars` SET ".implode(',',$sets)." WHERE userid=$userid LIMIT 1";

if(!$avatar_exists)
{
$result=mysql_query($insert_sql) or die("Insert query failed!");
}else{
$result=mysql_query($update_sql) or die("Update query failed!");
}
echo 'Avatar updated!';
?>
escape_arr.php
<?php
function escape_arr($arr)
{
$out=array();
$sets=array();
foreach ($arr as $key => $value)
{
$k="`$key`";
$v="'".mysql_real_escape_string($value)."'";
$out[$k] = $v;
$sets[]="$k = $v";
}
return array($sets, array_keys($out), array_values($out));
}
?>

[/codesyntax]

escape_arr.php

[codesyntax lang="php"]

<?php
function escape_arr($arr)
{
$out=array();
$sets=array();
foreach ($arr as $key => $value)
{
$k="`$key`";
$v="'".mysql_real_escape_string($value)."'";
$out[$k] = $v;
$sets[]="$k = $v";
}
return array($sets, array_keys($out), array_values($out));
}
?>

[/codesyntax]

Although the above code is elegant, an associative array forces me to think of my queries as objects. After putting my head to work, I found that a blank INSERT could put my mind at ease.

[codesyntax lang="php"]

<?php
$sql="INSERT INTO `tbl` (`id`) VALUES(NULL);";
$sql.="UPDATE `tbl` SET `f1`='v1',`f2`='v2' WHERE id = LAST_INSERT_ID();";
mysql_query($sql) or die(mysql_error());
?>

[/codesyntax]

Conclusion: both solutions are equally valid. You may also hard-code your queries but such coding is bad practice. There are many drawbacks for using this approach.

1. First of all, such strings can span several lines of code and make your PHP file hard to read and understand.
2. Secondly each one of your strings becomes a debugging red-flag.
3. And thirdly if you ever decided to add a new field to your table – say “birthdate” – then you will have to run through each of your hard-coded strings and add-in a field name and value for each of the strings respectively. Each string will then have an added chance for a syntax errors and make debugging harder. And since such coding practice lacks versatility, a simple task such as adding a “birthdate” field later in the future can become a nightmare.

One could also use REPLACE. However I strongly advise against using this approach since it reserves the potential to wipe your database clean due to its DELETE + INSERT logic. A better solution would be INSERT … ON DUPLICATE KEY UPDATE. However this query doesn’t address my syntax difference emphasis.

They both are different in implementations. LinkedList implements it with a doubly-linked list. ArrayList implements it with a dynamically resizing array. If you take up Linklist you can walk the lists forward or backwards, but grabbing an element in the middle takes time which depeneds upon your size of the list.

ArrayLists allows you random access, but adding and removing from anywhere smells your time which requires shifting all the latter elements. When you add more elements more than the capacity, a new array twice of the default size is allocated and the older array is copied to newer one.

When should i use LinkedList?

1. When you need efficient removal in between elements or at the start.
2. When you don’t need random access to elements, but can live with iterating over them one by one

When should i use ArrayList?

1. When you need random access to elements (“get the nth. element”)
2. When you don’t need to remove elements from between others. It’s possible but it’s slower since the internal backing-up array needs to be reallocated.
3. Adding elements is amortized constant time (meaning every once in a while, you pay some performance, but overall adding is instantly done)