« BENTO TRAINING TITLE- Now Available! | Main | FileMaker and Flash Integration DVD »
The Return of the Thin Client and the Future of Databases
By admin | August 11, 2008
One of the most interesting trend in computing is the re-emergence of the Thin Client. This time it is more significant than ever.
For those in the software and web development fields, this latest trend should not be ignored. In this article I explore the cycle that brings back what looks like the old mainframe client-server model but is instead something exciting for anyone who develops database or web applications today.
If you currently work with Flash you can now leverage your existing skills to create DESKTOP applications, thus opening up your potential market and making yourself much more valuable. Flex and AJAX developers have probably already been creating Web Applications and now those can be brought to the desktop with additional advantages not found in the browser while still taking advantage of Thin client technology.
Its worth a look. Plus, the AIR showcase has a bunch of really cool free apps if you simply want to get familiar with AIR by using the applications themselves.
One of the repeated cycles in the software industry is that we constantly go through this “thin client / thick client” cycle.
In the 1980s, there was still a lot of software being developed for the mainframe. These were basically “thin client” applications – most of the processing was done on the server and the model was that of centralized computing with “dumb terminals” acting as the primary interface. These dumb terminals were indeed pretty dumb (not much processing power, and character-mode interfaces). But, there were certainly advantages to this centralized model. The software could be updated on a single server, security was simpler, viruses and other malware were not a big issue. An important point to note is that these applications were mostly “stateless”. This allowed a user to believe they were interacting with their application directly, when in fact, 99% of the time, the server was simply waiting for another request and idle users were not consuming any resources. This particular model allowed a very large volume of users to be served, because not each user consumed server resources (CPU, memory, etc.) when they were not active.
Then, came the “thick client” wave in the form of client-server. An important thing to note here was that in the client-server model, we did not simply transfer all of the power back to the desktop – but a lot of it. The reason for this shift to thick-client applications was simple: There was a lot of horsepower in the PC and it could be leveraged to create better and more usable applications. It seemed a waste to let all that horsepower sit idly around and use the PC as just another dumb terminal. So, with this shift to client-server, we saw a rethinking of how applications were designed, built and deployed. The server, in most of these applications was a database server and did nothing more than act as a persistence layer to store and manage data. Along with the shift came new tools and technologies to help make it easier to build applications for the new paradigm (one that comes to mind is FileMaker).
In the late 1990s, we saw again a shift to “thin client”. Now, this client was a “much smarter dumb terminal” in the form of a web browser. This trend was fuelled by a number of things:
1. It was painful to manage desktop applications on hundreds and thousands of desktops
2. There were classes of applications where the server horse-power and data storage required exceeded the power of most PCs
3. Internet standards made it relatively easy to build applications that would work across a variety of hardware platforms and operating systems
So, everyone started creating web applications. Interestingly, and not surprisingly, these web applications too were “stateless”. So, the web application could serve tens of thousands of users using the same model made popular in the mainframe days. Instead of CICS or IMS-DC we now had HTML. This made the user interface better than the mainframe terminals but still was a huge step backwards compared to all the progress that was made in the user interface arena in the client-server days. But, this new thin-client model solved a lot of problems with the thick-client apps. You could leverage the resources of huge servers, do things you simply couldn’t do on your desktop and had a nice, consistent set of behaviors from hundreds and thousands of applications that were just a browser-click away.
However because it was browser based, we couldn’t access the desktop and couldn’t store applications locally. Also mixed platforms could cause issues for both running your applications and installing them. What the world needs is a Thin client that solves these issues but still provides the ability to make changes on the server to push out to clients, make management and support of your system easier and control costs while maintaining a secure enviornment.
Enter the modern day Thin client applications enviornment. There are many popping up that require notice, but the most significant has been the recent release of Adobe AIR, a cross-platform runtime environment for building rich Internet applications using Adobe Flash, Adobe Flex, HTML, or Ajax, that can be deployed as a desktop application.
Adobe made a public preview release of AIR (then called Apollo) along with a software development kit (SDK) and extension for developing Apollo applications with the Flex framework, on March 19, 2007. On June 10, 2007, Apollo was renamed to AIR and a public beta release of the runtime was launched. Public beta 2 of AIR SDK was released on October 1, 2007. Public beta 3, was released on December 12, 2007, and version 1.0 was released on February 25, 2008. 
AIR is intended to be a versatile runtime environment, as it allows existing Flash, Actionscript or HTML and JavaScript code to be used to construct a more traditional desktop-like program. Adobe positions it as a browser-less runtime for rich Internet applications that can be deployed onto the desktop, rather than a fully-fledged application framework. The differences between each deployment paradigm provides both advantages and disadvantages. For example, a rich internet application deployed in a browser does not require installation, while one deployed with AIR requires the application be packaged, digitally signed, and installed to the user’s local file system. However, this provides access to local storage and file systems, while browser-deployed applications are more limited in where and how data are accessed and stored. In most cases, rich internet applications store users’ data on their own servers, but the ability to consume and work with data on a user’s local file system allows for greater flexibility.
This provides developers all the advantages of the Thin client, yet AIR applications can operate offline, and then activate further functionality or upload data when an active Internet connection becomes available. So no pendulum swing back to Thick client as the happy medium has been discovered.
Adobe currently provides three ways of developing AIR applications:
- HTML/Ajax, either via Adobe’s own Dreamweaver CS3, another HTML editor or a normal text editor in conjunction with the AIR SDK.[9]
- Flex Builder 3
- Flash CS3
Dreamweaver CS3 requires an additional extension to compile AIR applications, as does Flash CS3 in the form of an update. The cross-platform nature of the runtime means any HTML editor, coupled with the AIR SDK, can create AIR applications. AIR itself uses the WebKit HTML rendering engine, along with Flash and PDF technologies.
You can experiment with Adobe AIR by visiting the Adobe AIR website. You can also download AIR for free to be able to run all of the applications currently available to play with.
The Adobe AIR Showcase has all sorts of existing applications with many already created by some top notch companies. 
There are several interesting case studies from The New York Times as well as AOL, eBay, NASDAQ, Yahoo, Nickelodeon and many more companies who have already made the commitment to AIR.
However this is not just a call to developers about the next wave, its also a call to software companies. The old model of thick client/server architecture is dead. Web 2.0 has ushered in a new platform for both the browser AND the desktop. Within 5 years this model will overtake current models and software companies will need to take note and adjust accordingly.
Some companies are already offering platforms that are using the browser to become the development and working environment for database systems. They are worth a look because a hybrid of these applications with a deployment environment like AIR could become the next big thing. Right now that prototype doesn’t exist, but check out these offerings for the closest thing to a preview.
dabbledb
Dabble DB helps you create online databases on the web. It’s easy to use yet extremely flexible and powerful. Check out this demo video to get a better idea of how it works.
Awareim
Aware IM is a web application builder that requires no programming, no scripts, no HTML, no database, web or user interface knowledge. Driven by business rules Aware IM works on any platform and supports all popular databases (MySQL, SQL Server, Oracle and others). Deploy your web application on the Internet or on your company’s LAN.
Check out the demo of awareim here.
Rollbase
Rollbase is a new Internet platform for business users and web developers to rapidly create on-demand applications using point & click, drag & drop tools in a standard web-browser. Simply put, Rollbase allows businesses to focus on application innovation rather than software development and all of the infrastructure behind it.
Check out the Rollbase demo by clicking here.
So its coming…or maybe its here. Its at least worth a look for both developers and software companies alike.
Topics: FileMaker |
Comments are closed.