Google AppEngine and BigTable

Bigtable is a distributed storage system for managing structured data that is designed to scale to a very large size: petabytes of data across thousands of commodity servers. 

• A Bigtable is a sparse, distributed, persistent multidimensional sorted map.
• The map is indexed by a row key, column key, and a timestamp; each value in the map is an uninterpreted array of bytes.
• Unlike most map implementations, in BigTable the key/value pairs are kept in strict alphabetical order. That is to say that the row for the key "aaa" should be right next to the row with key "aab" and very far from the row with key "zzz".
• BigTable are built upon distributed filesystems so that the underlying file storage can be spread out among an array of independent machines.

Many projects at Google store data in Bigtable, including web indexing, Google Earth, and Google Finance. These applications place very different demands on Bigtable, both in terms of data size (from URLs to web pages to satellite imagery) and latency requirements (from backend bulk processing to real-time data serving). Despite these varied demands, Bigtable has successfully provided a flexible, high-performance solution for all of these Google products. In this paper we describe the simple data model provided by Bigtable, which gives clients dynamic control over data layout and format, and we describe the design and implementation of Bigtable.

The AppEngine Datastore is

• Transactional
• Natively Partitioned
• Hierarchical
• Schema-less
• Based on Bigtable
• Not a relational database
• Not a SQL Engine

The Basic unit of Datastore Storage Modal consists of the following

1. Kind (table or more correctly Class)
2. Key (Primary Key)
3. Entity Group (Partition)
4. 0...N typed (name value) properties (similar to columns in relational table)

ANDROID Demo

The Open Handset Alliance, a group of more than 30 technology and mobile companies, is developing Android: the first complete, open, and free mobile platform. To help developers get started developing new applications, we're offering the Android Software Development Kit.

Open

Android allows you to access core mobile device functionality through standard API calls.

All applications are equal

Android does not differentiate between the phone's basic and third-party applications -- even the dialer or home screen can be replaced.

Breaking down boundaries

Combine information from the web with data on the phone -- such as contacts or geographic location -- to create new user experiences.

Fast & easy development

The SDK contains what you need to build and run Android applications, including a true device emulator and advanced debugging tools.

http://code.google.com/android/

ANDROID Architecture

1 of 3


2 of 3



3 of 3

Remembering the Tiger (Java 5.0) - Part 1

Before we move onto Java Mustang, let us remember the Tiger! The focus of this part is Multi-threaded programming (usually done in server side applications) with the new features of the Tiger (Java 5.0).

New Multi Threading Features of Tiger Java 5.0

1. New Objects
- StringBuilder Vs. StringBuffer
- Atomic Classes (AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference)
- Concurrent Collection API
- Concurrent Collection - Blocking Queues

2. New Features
- Covariant Return
- Generics

3. Some Optimization Techniques
- Usage of final keyword
- Avoid Enumeration or an Iterator
- Usage of Stack variables when possible
- Minimize Synchronization

4. Threads
- Synchronization Classes (Locks, Barrier, Semaphore, Countdown Latch, Exchanger & Reader/Writer Locks)
- Thread Pool
- Exception Handling

1. New Objects

StringBuilder

Java Architects / Developers who create high performance multi threaded Java Applications are aware of the cost of creating objects and synchronization costs. Following is a simple example of unwanted object creation.

String host = new String("Web Server");
String ip = new String("10.10.10.1");
int port = 80;

String displayValue1 = host + " (" + ip + ":" + port + ")";

System.out.println(displayValue1); // Web Server (10.10.10.1:80)

/**
* java.lang.StringBuffer
* The default capacity of StringBuffer is 16 bytes. When the capacity reaches the limit then
* StringBuffer creates a new array (char) doubling the previous size and copies the data to
* the new array. Old array gets discarded at the time garbage collection. Key to optimization
* is creating a StringBuffer with required capacity.
*/

StringBuffer sbuf = new StringBuffer(64);
sbuf.append(host).append(" (").append(ip).append(":").append(port).append(")");

String displayValue2 = sbuf.toString();

System.out.println(displayValue2); // Web Server (10.10.10.1:80)

/**
* java.lang.StringBuilder()
* StringBuffer is thread safe. However if your data set is thread local then use StringBuilder
* instead. Avoiding unwanted synchronization improves the performance further.
*/

StringBuilder sbuild = new StringBuilder(64);
sbuild.append(host).append(" (").append(ip).append(":").append(port).append(")");

String displayValue3 = sbuild.toString();

System.out.println(displayValue3); // Web Server (10.10.10.1:80)

Atomic Classes (java.util.concurrent.atomic.*)

From the performance perspective, one of the key objectives of the thread safe programming is shrinking the synchronization scope. When ever we use primitives which need to be shared across the threads we make the primitives volatile or synchronize that section of the code.

Volatile variables can be safely used only for a single read and write operations. It cannot be used for an operation like ++ / -- because it contains multiple operations like read, modify and write while the new Atomic Classes can be used for similar functions atomically. However, these new Atomic Classes require hardware support to make the multiple operations (like read, modify and write) atomic. The hardware guarantees that these operations are atomic.

Compare and Swap (CAS)

Compare and Swap is a special CPU instruction (used in multi processor systems) which takes three values: A memory location (L), expected old value (O) and a new value (N). The Processor will atomically compare the contents of a memory location to the expected (old) value and if they are same, then it modifies that content to a given new value (N) other wise it will do nothing. However, in either case it returns the value that was at the location prior to the CAS instruction. (Some flavors of CAS will instead simply return whether or not CAS succeeded.)

Intel processors implements CAS by the cmpxchg family of instructions, while MIPS and PowerPC have a pair of instructions. MIPS has “load linked” and “store conditional” while PowerPC has “load and reserve” and “store conditional”.

- AtomicBoolean
- AtomicInteger
- AtomicLong
- AtomicReference

As part of Tiger (Java 5.0) release java introduced Atomic classes like AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference which handle integers, long, Booleans and Objects respectively. These classes allow multiple operations like read, modify and write in a single atomic operation. Most of the functionality in the ReentrantLock class (Mutex) uses Atomic classes for the implementation. Atomic classes can be even used to avoid synchronization at the cost of complex code and design. This functionality is implemented at the native level.

// Testing AtomicInteger Class

AtomicInteger ai = new AtomicInteger(10); // Initialized with value 10

System.out.println("Value Get-And-Set(2) = "+ai.getAndSet(2)); // Displays 10
System.out.println("Value Get() = "+ai.get()); // Displays 2

In the above example getAndSet() method returns the original value (10) before setting the new value as 2. However, as these operations are atomic this doesn’t require any synchronization locks. Similar methods are incrementAndGet(), getAndIncrement(), decrementAndGet(), getAndDecrement(), addAndGet(), getAndAdd().

The conditional modifier methods compareAndSet() and weakCompareAndSet() takes two arguments – the expected value and the new value. If the current value is not the expected value then new value is discarded and the method returns false else the new value is set and the method returns true. The weakCompareAndSet() returns false then the variable is not set with new value, however, that doesn’t mean that the existing value is not the expected value.

Atomic package also supports Arrays, AtomicIntegerArray, AtomicLongArray and AtomicReferenceArray. You can’t modify the whole array atomically; however, you can modify one indexed variable at a time. There are no implementations for an array of Booleans as this can be achieved by using AtomicIntegerArray.

Other classes in the package to complete this brief overview of the Atomic package are AtomicMarkableReference and AtomicStampedReference. The former maintains an object reference along with a Boolean that can be updated atomically while the latter maintains the object reference with an integer “stamp” that can be updated atomically.

Concurrent Collection API (java.util.concurrent.*)

- ConcurrentHashMap
- CopyOnWriteArrayList
- CopyOnWriteArraySet
- ConcurrentLinkedQueue

All the above classes are nearly Thread safe. ConcurrentHashMap uses less synchronization than the Hashtable. CopyOnWriteArray List and Set provides unsynchronized iterator access, while ConcurrentLinkedQueue an unbounded thread safe non blocking FIFO queue.

Concurrent Collection API – Blocking Queues (java.util.concurrent.*)

- ArrayBlockingQueue (Bounded FIFO Queue)
- DelayQueue (UnBounded Queue with time based order)
- LinkedBlockingQueue (Bounded / UnBounded FIFO Queue)
- PriorityBlockingQueue
- SynchronousQueue (Bounded FIFO Queue)

All the above classes are thread safe and notifies the thread when the content changes. It implements BlockingQueue interface that allows the threads to wait either if the queue is full (when the thread try to store data) or if the queue is empty (when the thread tries to retrieve data).

2. New Features

Covariant Return

Java 5.0 introduced the concept of covariant return where you can override the return type of a method in a class where the return type is the subclass of the overridden method (of the super class return type). Let me show that using a sample code. The following code shows two vehicle types Car and Van (Van extends from Car).

The following code shows two Vehicle Factory types NormalVehicleFactory and FamilyVehicleFactory (extends from NormalVehicleFactory). However, what’s odd is the getVehicle() method call. The FamilyVehicleFactory overrides the getVehicle() method and return a sub class of Car (which is Van).

3. Some Optimization Techniques

Similar to the usage of StringBuilder and other new Collection API’s, as an Architect / Developer you need to keep in mind on performance optimization techniques to build a scalable performance focused application. This part will be concluded in the next few days…..

Resources

1. Answers.com – Compare and Swap
2. Answers.com – Double Compare and Swap
3. Wikipedia.org – Compare and Swap
4. IBM – Hardware Support for Atomic Classes: Going Atomic By Brian Goetz
5. IBM – More flexible, scalable locking in Java 5.0 By Brian Goetz
6. WARPing – Wait Free Techniques for Real Time Processing
7. Wikipedia.org – Lock Free and Wait Free Algorithms
8. Non Blocking Synchronization By Yi Zang
9. IEEE – A Nonblocking Algorithm for shared queues using Compare and Swap

10. Sun Microsystem – Untangling the Threads

11. Answers.com – Load Link / Store Conditional
12. Intel – Multiple Approaches to Multithreaded Application
13. Intel Research Cambridge – Software Transactional Memory should not be obstruction Free
14. Web – Memory model for multithreaded C++ Issues

Books

1. Addison-Wesley (May 9, 2006) – Java Concurrency in Practice By Brian Goetz
2. O’Reilly (Sept 13, 2004) – Java Threads (3rd Edition) By Scot Oaks & Henry Wong
3. O’Reilly (June 25, 2004)– Java 5.0 Tiger A Developers Notebook By B McLaughlin, D Flanagan
4. Addison-Wesley (Feb 4, 2000) – Practical Java By Peter Haggar

5. Prentice Hall (Sept, 2000) – High Performance Java Platform Computing By T.W Christopher, George K Thiruvathukal

(Part 2 of this series will focus on Threads and new Synchronization techniques...)

Rich Internet Applications

Rich Internet Applications are the next wave in User Interfaces (Google Gmail, Google RSS Reader, Google Finance etc). AJAX (Asynchronous JavaScript and XML) is a key technology in this direction. RIA’s are designed to deliver 8A’s of software simplicity. 8A’s is Bill Gates old information at your finger tips or IBM SAA (System Application Architecture). According to Gartner (Article: RIA’s are the next evolution of the web by Mark, Ray, Gene) at least 60% of the application development in 2010 will include RIA technologies and 25% in that will primarily on RIA.

Applications Able to deliver Access to Anyone Authorized Anytime, Anyplace on Any Device.

Evolution of the Application User Interface

From the command line user interfaces in the 80’s to the Client Server based Graphical User interfaces in the early 90’s to the Web based applications in the late 90s and currently to the Rich Internet Applications which has the thin client framework with features of the Thick Clients (Client Server GUI).

Main Frame Text UI > Client Server Apps GUI > Web Apps (Web Pages) > RIA

AJAX technologies are not new. All the components in Ajax technologies existed from 1998 onwards. The term AJAX was born in 2005 and made it popular by Google applications like Google Suggest, Google Maps and GMail. Even Microsoft through its Atlas project is pushing the AJAX developments. The term AJAX was coined by Jesse James Garret of Adaptive Path. The Following diagram shows the comparison between a traditional Web Application with an AJAX based web application. In the traditional model all the request are based on a user action and every request require a new web page to be returned by the web server. In the new model initial request is based on the user action and then lot of asynchronous request(s) were made from the RIA (the client) to the server to give a traditional thick client user experience.

New Architecture Model – Four Layers of App Stack (FLAST)

This New Architecture model is similar to the IP Protocol Stack. Following diagram illustrates the details of each layer. Client Layer focuses on the Browser with AJAX Engines / Macromedia Flash Engines etc. This layer gives a Rich Interface to the end user similar to Client side heavy GUI applications. This layer transparently talks to the back end presentation layer build using JSP, ASP, PHP or Servlets. Asynchronous calls where made from the Client layer to the Presentation Layer. Presentation Layer talks to the Business Layer for handling the Business functions which in turn talks to the infrastructure layer to store and retrieve the data.

Features of AJAX

• GUI Widgets Rich Applications in the Web model without the support Java or Flash compared to the static or dynamic HTML pages.
  
• It uses existing technologies like JavaScript, XML. The backend can be written in PHP, Perl, Java, C# etc. This helps to avoid any new technology learning curve for the developers. So, the developers can use their existing skill set to develop highly interactive AJAX web based applications.
  
• AJAX applications run on any browser which supports JavaScript (and enabled). This makes a wide Browser support under all platforms at any time.
  
• These applications even run on low bandwidth environments.
• RIA is deployed without a separate installation process.

Key points to consider and aware of when you build an application using AJAX.

• AJAX apps are not traditional ‘Web Page’ based system where you can bookmark a page. It’s an application so what is more important is to think about the application states rather than pages.
• Keep in mind the behavior of ‘Back’ and ‘Forward’ buttons of the browsers. As this is not a ‘Page’ based system. AJAX applications refreshes internal areas with out reloading or changing the ‘Web Page’.
• Spiders (Search Engine Crawlers) will not be able to index your pages for searches.
• Users may disable JavaScript in their browsers.

AJAX Quick Start Development Kit

The packages identified in this section are for development purposes only. You need to take extra care to secure the PHP, MySQL and other packages with proper passwords and other security controls. XAMPP is a collection of popular open source tools. Developers at Apache Friends did a great job in bringing all these together and the installation and configuration is absolutely smooth. Download XAMPP (v1.5.2) from http://www.apachefriends.org/en/index.html available for both Linux and Windows. This will install the following packages.

o Apache 2.2
o PHP (5.1.2)
o MySQL (5.0.20)
o Perl
o FileZilla FTP Server
o Mercury Mail Server

There are lot of popular JavaScript libraries which gives table grids, pull down menus, drag and drop features, tree widgets etc. One of the most famous is ‘script.aculo.us’. Download the latest JavaScript library from http://script.aculo.us/ and the 'OpenLaszlo' open source development platfom for the Rich Internet Appliations.

Other JavaScript Library Collections
o http://www.mochikit.com/demos.html
o http://edevil.wordpress.com/2005/11/14/javascript-libraries-roundup/
o http://cross-browser.com/
o http://www.rawdata.net/developer/web_developer/ajax_javascript_librabries.php
o http://www.ajaxmatters.com/r/resources?id=17

Conclusion

Rich Internet Applications using AJAX technologies looks very promising. Thanks to Google and others they showed how to use existing technologies to change the way we access internet based applications. Most of the software giants like Microsoft, Adobe and others are coming out with AJAX based software development toolkits which shows their commitment to the new model of web based applications. Following sections gives references (links) to AJAX technologies and other resources.

Examples: Popular AJAX Applications on the Web

Google Suggest - http://www.google.com/webhp?complete=1&hl=en
Google Maps – http://maps.google.com/
Flickr - http://www.flickr.com/
Odeo - http://odeo.com/
Backpack - http://backpackit.com/
Basecamp - http://basecamphq.com/

RIA - Software Development Kit

Microsoft Atlas: http://atlas.asp.net/
Adobe Macromedia Flex 2.0: http://www.adobe.com/products/flex/
Backbase Ajax Development Framework: http://www.backbase.com/
Tibco General Interface: http://www.tibco.com/software/ria/gi_resource_center.jsp
JackBeNQ Suite : htttp://www.jackbe.com/
Open Source - OpenLaszlo: http://www.openlaszlo.org/

REST – Representational State Transfer
SOAP – Simple Object Access Protocol
AJAX – Asynchronous JavaScript And XML
ECMA – ECMA-262 Specifications
CSS – Cascading Style Sheets

Demo

• Open Source Openlaszlo Demos
• Adobe Macromedia Flex 2.0 Demo 1
• Adobe Macromedia Flex 2.0 Demo 2
• Backbase Demo 1
• JackBe Demo 1
• JackBe Demo 2 Bank

AJAX Blogs

http://www.ajaxian.com/
http://www.ajaxmatters.com/
http://www.ajaxpatterns.org/
http://www.ajaxinfo.com/
http://www.ajaxblog.com/
http://ajaxguru.blogspot.com/

Books

Amazon – AJAX and PHP: Building Responsive Web Applications
Amazon – AJAX in Action
Amazon – AJAX Patterns and Best Practices (Experts Voice)
Amazon – Foundations of AJAX
Amazon – Essential Actionscript 2.0
Amazon – Developing Rich Clients with Macromedia Flex
Amazon – Professional AJAX (Programmer to Programmer)

Resources

AJAX Magazine – W3C Working Draft on the XMLHttpRequest Object
AJAX – Getting Google Calendar Data on your site
Sun – AJAX made easy
Microsoft – AJAX for ASP
Rich Internet Apps - http://theopensourcery.com/xmlria.htm
ECMA Script - http://en.wikipedia.org/wiki/ECMAScript
ECMA International – ECMA Script - 262
ZDNet - RIA Clients: Not just for the web anymore
Java Lobby – RIA and AJAX: Selecting the best product
AJAX Magazine – Yshout a PHP and AJAX powered shoutbox
AJAX Magazine – PHP and AJAX

Multi Core Mania

In December 2005 I blogged about the new set of programming languages (Metaphor and Fortress - New programming Languages) and how multi core systems could change the computing scenarios. Here is something more on multi core systems. Last week Azul systems announced a 48 way multi core chip, redefining the enterprise computing. However, the current hurdles for the Intel, Sun, IBM and other Hardware vendors with multi core CPUs will be picking the right memory technologies. "If you can't keep the cores fed fast enough from memory, you haven't gained anything," says AMD chief technology officer Phil Hester.
The Vega 1 chip (from Azul) can support a maximum of 384 cores while the new chip supports a whopping 768 cores which takes up 11U of rack space. Like Vega 1, Vega 2 is a 64-bit and all its cores are cache-coherent (fully independent). Intel uses Smart Cache technology to share the level-2 (L2) cache among the cores instead of dedicating a L2 Cache per core. The immediate benefit of this is that both the core has the entire 2MB of L2 cache. The data (in the L2 Cache) can be changed by one Execution Core and subsequently be utilized by the other Execution Core without the need to first write the data to DRAM. As the data is shared with L2 Cache, the traffic on the FSB (Front Side Bus) is minimized.

Today we have single CPU with 8 cores and 32 parallel threads from Sun Microsystems and 48 Core Chip from Azul Systems - imagine the state of these technologies after a decade. GRID computing for the common man (a digitally connected world) will be a reality.

Imagine the year 2015. Parallel computing with Autonomous Executable Entities will be a reality!

Further Reading

1. Azul Systems – Vega 24 Core chip Azul Compute Appliance
2. Techworld – Azul launches 48 core processor
3. Sun Microsystems – Sun UltraSPARC T1 Processor
4. Sun Microsystems – Multi Core Processor Comparisons
5. Intel – Dual Core Processor Demo
6. Intel – Smart Cache: Sharing L2 cache among the cores
7. Intel – Next leap in multiprocessor Architecture: Intel Dual Core
8. Intel – Intel Core Duo Processors
9. Intel – Dual Core Intel Xeon Processors
10. Silicon Graphics - ccNUMA
11. Wikipedia – Non Uniform Memory Access (NUMA)
12. MIT Technology Review - Faster Plastic Circuits
13. MIT Technology Review – Multicore Mania
14. MIT Technology Review – Making Multicore Fly
15. MIT Technology Review – Good bye, Gigahertz
16. InfoWorld - Sun charges Sun Fire T2000 with UltraSparc
17. Wikipedia.Com – Cache Coherency
18. MIT – Cache Coherence
19. Webopedia.Com – What is Cache Coherence?
20. Princeton – A survey of Cache Coherence Schemes for Multiprocessors.

Metaphor and Fortress - New programming Languages

Advances in programming languages from Assembly, C, C++ to C# or Java absorbed the complexities of programming. However, modern software development is not just programming. Lot of work happens outside the programming. Dr. Alan Perlis a prominent US Computer scientist said that “A good programming language is a conceptual universe for thinking about programming.” Metaphor is such a next Generation Language by Victoria Livschitz of Sun Microsystems.

Features of Metaphor

Following are the Four Features of the Metaphor Language

1. Distributed Runtime Environment
2. Contextual Programming
3. Support for autonomous executable entities
4. Support for Software evolution and re-use

1. Distributed Runtime Characteristics of Metaphor

A Distributed Runtime Core (DRC) will have the functionality of the current application containers and the middleware. DRC comprises of a P2P (peer-to-peer) network of Virtual Machines (Local to every host on network - LVM).

For example (from Victoria's interview with Janice - Dec 1, 2005) if a developer specify a program that a car has 4 wheels, at runtime the executable for each wheel may be loaded in the available LVM (Local Virtual Machine) by the Distributed Runtime Core (DRC). The communications between wheels and the rest of car will be handled by the DRC (even if it is inter process communication or computer to computer communication) without the explicit control by the developer or the network administrator.

Distributed Runtime Core will provide some basic needs of Distributed Applications such as

• Load Balancing
• Fault Tolerance
• Remote Communications
• Mobility of Services and their containers
• Quality of Service
• Service Level Management

All the above can be embedded into a runtime environment for the language.

2. Contextual Programming

Contextual Programming defines applications abstractions and codifies a programmer’s thought process. It doesn’t do any real work; it creates logical entities and not executable entities. It will be used by the designers who need to fix, extend or reuse the context.

3. Autonomous Executable Entity

Executable Entities are the loosely coupled constructs in the Contextual Programming. Executable Entities makes a program to be practical use to end customers. The real work will be done by the Executable Entities in the Contextual Programming. Now why is it Autonomous Executable Entity? Even if we talk about concurrent programming, It is still on top of sequential automaton. New Multi Core CPU’s (Sun UltraSPARC T1 Single CPU with 8 Cores supports 32 Threads running parallel while Intel dual Core single CPU runs 4 threads parallel) stresses the concept of multi threading applications and the future belongs to these types of new CPUs.

As per Victoria, The application runtime consists of Autonomous Executable Entity interact with their environment and each others asynchronously, respond to external environmental changes and take decisions accordingly. This means that behavior of an Autonomous Executable Entity might differ from environment to environment!

4. Software Evolution and Reuse

Metaphor focuses on three types of reuse mechanisms.

1. Derivation

A new metaphor is created by changing the properties of an existing one.

2. Composition / Decomposition

A new metaphor is created by fusion of several existing ones or fission of an existing metaphor (into several metaphors).

3. Adaptation

A new metaphor is created for a different domain by morphing certain properties. This differs from derivation in the sense that the two metaphors are properly isomorphic. i.e., It looks similar in structure or appearance however different ancestors.

Fortress: A New Programming Language for Scientific Community

In the internet era Java brought down the software development time (of ‘n’ tier applications). It eliminated lot of common programming errors and made programmers more productive by providing API’s for everything (from networks, to threads to GUI), doing automatic memory management, getting rid of platform dependencies, and of course multi threaded programs to utilize multi processor hardware.

Fortress builds on these strengths and goes beyond these. It is specifically designed to be an adaptive language which means language features are pushed into libraries rather than warped in compilers. Fortress assumes that parallel processing is the norm, using thousands or millions of threads. Fortress supports source code in three (ASCII, Unicode, Two Dimensional) formats to support mathematical notations.

Multi Core CPUs

Birth of Multi Core CPUs is going to change the way multi threaded applications were built. The difference will be like the usage of sockets API in C or Java or the usage of Threads in C or Java. Java abstracted a lot of complexities away in these two critical APIs for distributed computing, which brought down the development time of building distributed applications. With more CPUs (and least expensive) with parallelization capabilities ‘n’ tier computing will be the way to go.

Current hurdles for the Intel, Sun, IBM and other Hardware vendors with multi core CPUs will be picking the right memory technologies. "If you can't keep the cores fed fast enough from memory, you haven't gained anything," says AMD chief technology officer Phil Hester. Couple of interesting articles on MIT Technology Review titled Multi Core Mania and Making Multi Core Fly.

Conclusion

Today we have single CPU with 8 cores and 32 parallel threads (Sun UltraSPARC T1) and imagine the state of these technologies after a decade. GRID computing for the common man (a digitally connected world) will be a reality.

With new direction in chip design which focuses on parallel computing (with multi cores) on least expensive hardware, and new programming languages focusing on abstracting away the complexities required for parallel computing will lead to true GRID computing to the common man (a digitally connected world).

• Digitally connected Home appliances (Air Conditioner, Refrigerator, Washing Machines etc)
• Convergence of the Media Centers (Sony® VAIO® VGX-XL1 Digital Living System™)
• Convergence of Apple iPod, Cell Phones, Handheld Devices. I know this will be controversial – However, carrying to many devices doesn’t sound too exciting either.

Imagine the year 2015. Parallel computing with Autonomous Executable Entities will be a reality!

Further Reading

1. Janice J Heiss – Envisioning a New Language: A Conversation with Sun Microsystems' Victoria Livschitz
2. Alan F Blackwell and T R G Green – Does Metaphor increase Visual Language Usability?
3. Peter Norvig – Design Patterns in Dynamic Programming
4. Gregory Neverov and Paul Roe – Metaphor: A multi stage Object Oriented Programming Language
5. Sun Microsystems – Sun UltraSPARC T1 Processor
6. MIT Technology Review - Faster Plastic Circuits
7. Sun Microsystems – Fortress: A new Programming Language for scientific computing
8. MIT Technology Review – Multicore Mania
9. MIT Technology Review – Making Multicore Fly
10. MIT Technology Review – Good bye, Gigahertz
11. InfoWorld - Sun charges Sun Fire T2000 with UltraSparc
    

3 Players, 2 Visions and 1 Destination

3 Players

Microsoft, Sun, Google

2 Visions

Microsoft – A Desktop (Computer) in every home.

Sun Microsystems – Network is the Computer

Microsoft’s vision of ‘A Desktop in every home’ has helped the spread of internet and its economy which is considered around $100 billion dollars (The Search by John Battelle). This indirectly helped to realize the vision of Sun Microsystems ‘Network is the computer’. Sun Microsystem's Java platform, fast tracked the internet software development (Web site / portal development using Java technologies like servlets, enterprise java beans etc) which helped the normal users to get more value out of internet and letting it being part of their daily life.

Most of the computing for the common person revolves around the web browser and it became the interface to giant network (or should we say the Computer) called internet.

What did Google do over here?

Google not only made internet a utility for the common person, it became an infrastructure for the small-scale business industries, which revolves around Google Search. Google’s $3 billion dollar Advertisement revenue in the last 3 years shows a new business model where a 3000 strong Google engineering team busy building software’s (Gmail with 2.5+ GB storage with POP3 access, Google Earth, Google Maps, Google RSS Reader, Google Desktop Search) to give away free (The Google Future by George F Colony – CEO Forrester). This new business model is credited or known as Google’s model however the actual credit goes to Bill Gross the Chairman and Founder of the Idea Labs.

1 Destination

An inter-connected digital world where all the electronic devices are connected (computers, cars, cell phones, house hold appliances, RFID enabled passports etc) together creating a single giant computer ('The Network is the computer').

Owned by everyone and owned by none!

Two great visions from two rival companies merged into a single destination.

Here is the role for the fourth player, the player who focuses on Security and its vision.

‘Secure every digital bit’

A bit which is getting transferred on the wire or getting stored in any storage devices (hard disks / memory sticks / DVD's etc) or processed inside any CPU’s (Central Processing Unit of any devices – like computers, cell phones, cars etc).

Here is an interesting thing I found about what Google could do (potentially) in the future from New York Times :-)

By RANDY SIEGEL (the president and publisher of Parade Publications).

Google 2084 - Copyright 2005 The New York Times Company

http://www.nytimes.com/imagepages/2005/10/10/opinion/1010opart.html

Cache SOAP services on the client side

Design patterns let you cache SOAP services and improve performance

SOAP (Simple Object Access Protocol) services are progressing from lab prototypes to real-world applications. If, while developing distributed Java applications that interact with SOAP services, you experience network-traffic overhead issues from repeated SOAP HTTP calls, read on. In this article, Ozakil Azim and Araf Karsh Hamid describe how to create transparent, client-side caching for SOAP services using the Business Delegate and Cache Management design patterns. (2,700 words; March 8, 2002)

By Ozakil Azim and Araf Karsh Hamid

Read more in Javaworld -
http://www.javaworld.com/javaworld/jw-03-2002/jw-0308-soap.html

I co-authored this article with Azim when we worked together in netForensics (the best times of netForensics) and we build one of the best architecture for SIM Solutions.