As mentioned in an earlier blog, a rules engine is used in our architecture for validating business objects, routing and business process instantiation. The general idea is to pre compile the rules and make them available in a cache that can scale and is backed by persistence.

Rules are stored in a repository (LDAP, RDBMS or files). When applications or processing units need to access the business rules they are read from the rules space.

The rules are first read from the repository, pre compiled and written into the JavaSpace. The loading of the rules into the space can be accomplished in different ways. XAP from GigaSpaces provides several options for this process or you can write your own. You can also configure a Local View or a Local Cache for the business rules according to your requirements.

We are using the Drools engine version 4.0.7 in our project (the latest version of Drools has some serialization problems) . In Drools rules are built with a RuleBase and Packages.

Here is an example:

The RuleEntry class is used for the space operations and the persistent backend. There is nothing special about this class besides the RuleBase attribute which holds the compiled rules.

   1: package gov.mz.framework.rules;

   2:

   3: import gov.mz.framework.rules.error.RuleError;

   4: import gov.mz.framework.rules.msg.IRulesMessages;

   5:

   6: import java.io.Serializable;

   7: import java.io.StringReader;

   8: import java.sql.Timestamp;

   9:

  10: import javax.persistence.Column;

  11: import javax.persistence.Entity;

  12: import javax.persistence.GeneratedValue;

  13: import javax.persistence.GenerationType;

  14: import javax.persistence.Id;

  15: import javax.persistence.Table;

  16: import javax.persistence.Transient;

  17:

  18: import mozgif.error.UserTypeError;

  19: import mozgif.space.ISpacePersistence;

  20:

  21: import org.drools.RuleBase;

  22: import org.drools.RuleBaseFactory;

  23: import org.drools.rule.Package;

  24: import org.springframework.stereotype.Repository;

  25:

  26: import com.gigaspaces.annotation.pojo.SpaceClass;

  27: import com.gigaspaces.annotation.pojo.SpaceExclude;

  28: import com.gigaspaces.annotation.pojo.SpaceId;

  29:

  30: @javax.persistence.SequenceGenerator(name = "SEQ_GEN", sequenceName = "RULE_SEQUENCE", allocationSize = 20)

  31: @SpaceClass

  32: @Repository

  33: @Entity

  34: @Table(name = "RULE_BASE")

  35: public class RuleEntry implements ISpacePersistence<RuleEntry>, Serializable

  36: {

  37:     @Id

  38:     @Column(name = "ID")

  39:     @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_GEN")

  40:     private Long id;

  41:

  42:     @Column(name = "TIMESTAMP")

  43:     private Timestamp timeStamp;

  44:

  45:     @Column(name = "VERSION")

  46:     private String version;

  47:

  48:     @Column(name = "RULE_BASE_NAME")

  49:     private String ruleBaseName;

  50:

  51:     @Column(name = "RULE_CONTEXT")

  52:     private String ruleContext;

  53:

  54:     @Transient

  55:     private RuleBase ruleBase;

  56:

  57:     public RuleEntry()

  58:     {

  59:         super();

  60:     }

  61:

  62:     public Timestamp getTimeStamp()

  63:     {

  64:         return timeStamp;

  65:     }

  66:

  67:     public void setTimeStamp(Timestamp timeStamp)

  68:     {

  69:         this.timeStamp = timeStamp;

  70:     }

  71:

  72:     @SpaceId

  73:     public Long getId()

  74:     {

  75:         return id;

  76:     }

  77:

  78:     public void setId(Long id)

  79:     {

  80:         this.id = id;

  81:     }

  90:     public RuleEntry toSpace() throws UserTypeError

  91:     {

  92:         try

  93:         {

  94:             StringReader reader = new StringReader(getRuleContext());

  95:             Package pkg = RulesFacade.getFacade().load(reader);

  96:

  97:             this.setRuleBase(RuleBaseFactory.newRuleBase());

  98:             ruleBase.addPackage(pkg);

  99:

 100:             return this;

 101:         }

 102:         catch (Exception ex)

 103:         {

 104:             throw new RuleError(IRulesMessages.RULE_BASE_ERROR, this

 105:                     .getRuleBaseName(), ex);

 106:         }

 107:     }

 108:

 109:     // Transient in the Space World

 110:     @Column(name = "RULE_CONTEXT")

 111:     @SpaceExclude

 112:     public String getRuleContext()

 113:     {

 114:         return ruleContext;

 115:     }

 116:

 117:     public void setRuleContext(String ruleContext)

 118:     {

 119:         this.ruleContext = ruleContext;

 120:     }

 121:

 122:     public String getVersion()

 123:     {

 124:         return version;

 125:     }

 126:

 127:     public void setVersion(String version)

 128:     {

 129:         this.version = version;

 130:     }

 131:

 132:     public String getRuleBaseName()

 133:     {

 134:         return ruleBaseName;

 135:     }

 136:

 137:     public void setRuleBaseName(String packageName)

 138:     {

 139:         this.ruleBaseName = packageName;

 140:     }

 141:

 142:     public RuleBase getRuleBase()

 143:     {

 144:         return ruleBase;

 145:     }

 146:

 147:     public void setRuleBase(RuleBase ruleBase)

 148:     {

 149:         this.ruleBase = ruleBase;

 150:     }

 151: }

When rules need to fire within an application or a processing unit they are requested through a RulesFacade. The method fireRules() is called with the rule name and the objects to be asserted as arguments. This method creates a RuleEntry and queries the space to retrieve the requested precompiled rule. This is accomplished in the getInstanceFromCache method. (line 10)

   1: @Transactional(readOnly = false, rollbackFor = UserTypeError.class, propagation = Propagation.REQUIRED)

   2: public void fireRules(String ruleName, ArrayList<Object> list)

   3:         throws Exception

   4: {

   5:     // Create a new RuleEntry

   6:     RuleEntry entry = new RuleEntry();

   7:     entry.setRuleBaseName(ruleName);

   8:

   9:     // Get the RuleEntry from Cache

  10:     entry = this.getInstanceFromCache(entry);

  11:

  12:     // Get a working Session for this rule

  13:     StatelessSession session = entry.getRuleBase().newStatelessSession();

  14:

  15:     // Assert all facts and fire rules

  16:     session.execute(list);

  17: }

If the rule is not found in space it will be read from the repository(line 9) The rule is then compiled and written into the space( line 15) The repository holds the plain text version of the rule not the precompiled rule. The toSpace() method accomplishes the compilation of the rule before writing it to the space.

   1: protected V getInstanceFromCache(V template) throws UserTypeError

   2: {

   3:     // Try to read the instance from the Space

   4:     V instance = gigaSpace.readIfExists(template);

   5:

   6:     if (instance == null)

   7:     {

   8:         // If none found in the Space load it from the repository

   9:         instance = daoFacade.findOne(template);

  10:

  11:         // If we got an entry from the repository

  12:         // we will put it into the space

  13:         if (instance != null)

  14:         {

  15:             gigaSpace.write(instance.toSpace());

  16:         }

  17:         else

  18:             throw new RuleError(IRulesMessages.RULE_DOES_NOT_EXIST);

  19:     }

  20:     return instance;

  21: }

The toSpace method is a Drools specific implementation. The PackageBuilder parses the rules context and creates a Package, a new RuleBase is created and the package is added.

   1: public RuleEntry toSpace() throws UserTypeError

   2: {

   3:     try

   4:     {

   5:         StringReader reader = new StringReader(getRuleContext());

   6:         Package pkg = RulesFacade.getFacade().load(reader);

   7:

   8:         this.setRuleBase(RuleBaseFactory.newRuleBase());

   9:         ruleBase.addPackage(pkg);

  10:

  11:         return this;

  12:     }

  13:     catch (Exception ex)

  14:     {

  15:         throw new RuleError(IRulesMessages.RULE_BASE_ERROR, this

  16:                 .getRuleBaseName(), ex);

  17:     }

  18: }

We have implemented a cache that loads rules on demand. There are other ways to implement this cache. XAP from GigaSpaces provides several other options. (All in cache, LRU cache)

This implementation should work for other rules engines as well. The only requirement is that the rules class like RuleBase is Serializable.

With the many requirements we are facing for a framework like this we need to find a common object repository that can be accessed via a unified API regardless of origin and type of object including Business Objects , Business Rules, Configuration parameters, Instrumentation and logging. We also need to be able to cache the information, provide scalability, failover and recoverability within the framework.

JavaSpaces will do that for us in a simple and elegant way. The Event Bus (EB) just became a Space Bus (SB). The SB is the backbone of this framework.

After researching the different vendors that provide JavaSpaces implementations we have picked XAP from GigaSpaces. XAP provides unique features like DataGrid, Caching, mirror service, recovery and many more that are part of our requirements. XAP also uses Hibernate and Spring which we use in many of our other projects. Further more XAP provides a simple integration with the MULE ESB which we are using to bridge heterogeneous platforms and environments.

Terracotta, an open source Java caching vendor, announced it has acquired EHCache earlier this week.  This is interesting for two reasons.  No, it’s not because I thought EHCache was a Canadian company because of the “Eh” in their name.

EHCache provides an alternative approach to Java caching than Terracotta’s approach.  While Terracotta’s approach can be at the JVM layer without application changes, the EHCache approach requires the application be modified with caching in mind.  Terracotta founder and CTO, Ari Zilka, explains the benefits of the combined company:

“Terracotta’s interface in more than 50% of use cases has been EHCache. Basically, developers design applications to use EHCache and use Terracotta’s EHCache clustering module to get massive scale and high availability at runtime.

The two together will provide the most seamless path from 1 node up to 100. Instead of having to worry about which version of EHCache Terracotta supports, or if your EHCache integration will work well with Terracotta, EHCache’s and Terracotta’s users alike can rest assured the two will always work in perfect harmony from today forward.”

The second interesting aspect of this acquisition, and not mentioned by Ari, the combined company looks much more attractive to VMware/SpringSource.  IBM WebSphere eXtreme Scale Chief Architect Billy Newport had predicted that VMware would acquire Terracotta after news of the SpringSource acquisition hit the wire.  Billy may be on to something.  Terracotta can offer both an unintrusive caching solution that could be married alongside future JVM work that VMware is sure to do, and also offers a caching API that could find its way into SpringSource products. Smart move on Terracotta’s part.  Although, to be fair, this acquisition was in the works before the SpringSource acquisition was made public.

Terracotta is positioning the acquisition as a major competitive coup versus the likes of Oracle Coherence, GigaSpaces and WebSphere eXtreme Scale.  Leaders from Oracle Coherence and WebSphere eXtreme Scale had a more measured response:

Oracle Coherence’s Cameron Purdy commented:

“Competition is good, and Terracotta has a different approach that may prove to help with some needs that had gone unaddressed by products such as our own (Oracle Coherence). Greg’s got a good track record with ehcache and now he’s getting paid to do what he loves. While the competitive hyperbole is silly, I nonetheless find it flattering that we (collectively) are building technology and businesses that have gone from niche to central in enterprise software (despite all the competition, our business continues to grow at “ludicrous speed”), and I find it even more flattering that companies want to compare to and compete with the product that I work on “

WebSphere eXtreme Scale’s Billy Newport commented:

I agree with Cameron, competition is good and while we’ve (from an IBM WebSphere eXtreme Scale point of view) previously only seen Terracotta on small setups (2 nodes or so), I’m sure the new capabilities (static striping etc) and that it fits into EHCache which has a lot of prewritten adapters in open source software will mean we see more of him   It’s all good for growing the market and increasing customer awareness. “

As Cameron and Bill point out, the acquisition is definitely goodness for customer awareness and adoption.  To date, the market has been dominated by commercial products.  However, open source vendors such as Terracotta and GridGain want to change that.  Interesting times ahead.

Follow me on twitter at: SavioRodrigues

PS: I should state: “The postings on this site are my own and don’t necessarily represent IBM’s positions, strategies or opinions.”

Elastic Compute Cloud

Elastic Compute Cloud (EC2) is an Amazon’s web service that provides resizable compute capacity in a cloud. One of the main characteristics of EC2, and at the same time one of its great advantage, is that it was designed to make web-scale computing easier for developers.

Amazon EC2’s simple web service interface allows to obtain and configure capacity with minimal friction. It provides as well a complete control of the computing resources and lets run on an Amazon’s computing environment.

Between the advantages that one can find using EC2, we could mention the reduction of time required to obtain and boot new server instances to minutes, allowing a quickly scale capacity, both up and down, as the change of computing requirements. Other advantages are the possibility to count with a diversity of Operating Systems, the possibility of run on multiple locations or utilize static IP endpoints.

To use EC2, it is necessary to sign up to the Amazon’s web page, and with this, get the two keys to use the web service; on of them is the Access Key ID, and the other one is the Secret Access Key, that can be generated as many times as one desire, depending on the security requirements that one has. With these two keys it is possible to access to all the web service’s facilities, depending on the type of account created.

To see EC2 in action, first it is needed to create an Amazon Machine Image (AMI) that will contain the application, libraries and the configuration settings. It is also possible to use one of the image templates to achieve the same objective, and one can do this using a firefox extension called “ElasticFox”, that can be download clicking on the next link: http://developer.amazonwebservices.com/connect/entry.jspa?externalID=609, once it is installed, you will see a GUI like the one is showed on the figure 01; once this extension is launched in firefox, it is possible to create the AMI, using the keys obtained on the Amazon web page, as it was explained on the previous paragraph. A really helpful tutorial to create a simple AMI can be found on the next link: http://www.youtube.com/watch?v=9QKnORsJKt4&annotation_id=annotation_297897&feature=iv, that explains how to create an Amazon account, the installation of the ElasticFox extension, and finally the creation and test of the new AMI. Once the AMI is created, the next step is to upload the web application to the Amazon Simple Storage Service (S3); between the tools used to accomplish this task, there is a firefox extension that can be smoothly installed on it, that is called “S3 Fox”, this extension can be downloaded clicking on the next link: https://addons.mozilla.org/en-US/firefox/addon/3247. Finally, it is possible to configure the security and network access, with the ElasticFox tool.

Figure 01. The ElasticFox extension

GigaSpaces XAP

GigaSpaces XAP (eXtreme Application Platform) is a scale-out application server. Among the advantages that one can find working with GigaSpaces, we can mention:

- High-throughput

- Low-latency

- Scalability

and these advantages give the possibility to use GigaSpaces to build the next generation class of applications.

It can be said that a usual Web-Application that stores its data within the IMDG (In-Memory Data Grid) would basically have the next machines:

- GSM Machine

- Load-Balancer Machine

- Database and Mirror Machines

- GSC Machines – Running Web Application, IMDG and Services

Figura 02. A basic Web Application running on a cloud.

As can be seen in the last figure, the whole cloud is composed for many machines that can be created very easily editing a XML file and uploading it, with the aid of the GigaSpaces Cloud Console that can be found at the GigaSpaces web page (http://www.gigaspaces.com/mycloud), this console has many tools to create and manage all the clouds that one needs or have already been deployed. Comparing this tool, with the one that creates an Amazon’s AMI using the ElasticFirefox, this console is specially oriented to the creation and management of GigaSpaces clouds.

About the XML file that has to be edited for the creation of all the machines that one needs in a cloud, a basic template can be checked on the lines below this paragraph.

<cloud-config>

<cloud-name>my-data-grid</cloud-name>

<license>

Nov 16, 2009~CloudTestUser@bPS8NOufjXOuPNSYMWPO#PREMIUM^7.0XAPPremium%UNBOUND+UNLIMITED

</license>

<gigaspaces-build-location>

gigaspacesversions/gigaspaces-xap-premium-7.0.0-m9-b3496-87.zip

</gigaspaces-build-location>

<ami-id>ami-91db3cf8</ami-id>

<machines>

<!– Insert here –>

</machines>

<start-ui>admin-application</start-ui>

</cloud-config>

Between the “machine” tags one can create all the machines required for the Web Application; referring to the example of the figure 02, the XML file can be downloaded from the next link: http://cloud.gigaspaces.com/cloudtools/session-resources/demo/files/petclinic-mysql-example.xml

To upload this file, and by this way create the required machines, follow the next procedure:

01. Log into the Cloud Console using your GigaSpaces and Amazon Web Service (AWS) keys on this web page: http://www.gigaspaces.com/mycloud

Figure 03. Log into the Cloud Console

02. Upload the XML file that has all the information of the machines to be used in the cloud, filling the “Deployment Descriptor” field and clicking in the button “Deploy”

Figure 04. Deploying the machines with the Cloud Console.

Now to upload the Web Application to the Amazon’s S3, an easy way to do this task is using the “S3Fox” extension, following the next procedure:

01. Start the S3Fox extension signing up with the Amazon’s Access Keys.

Figure 05. Signing up to the S3 through the S3Fox

02. Create a test folder at the root level of the S3 account by clicking the button at the right side panel.

03. Upload all the necessary files from the left side of the panel to the right side that, by the way, corresponds to the S3.

Finally for testing the web application, observe the link next to the “Load_Balancer” field in the Cloud Console and click on it, the application that you upload on the S3 should be displayed on the web browser.

Figure 06. Checking the Web Application deployed in the S3.

Conclusions

After reviewing the documentation found in the internet about GigaSpaces, I think that is a technology very promising for the future developments of applications that will need to be reliable and at the same time very flexible.

Talking about the service given by Amazon EC2, I think that the price they offer to have a cloud deployed on its servers is very reasonable, knowing that taking care of a Data Center needs people specialized on its maintenance and management.

GigaSpaces Technologies, provider of application middleware platforms for Java and .NET environments, announced the launch of eXtreme Application Platform (XAP) 7.0, an enterprise-grade application server for deploying and scaling distributed applications. XAP 7.0 is the only product that provides all middleware functions for the entire application stack within a single platform.

“XAP 7.0 is based on a unique architecture designed to manage the most complex environments as experienced by our Fortune 100 customers,” said GigaSpaces CTO Nati Shalom. “With this new release, scalability is made so transparent and easy that organizations can leverage existing skill sets and historic investments to develop highly scalable applications that can meet fluctuating, unpredictable demand, with guaranteed performance and no downtime.”

GigaSpaces XAP 7.0 enables organizations to do more with less while meeting and exceeding the most demanding business requirements. XAP is the only product that offers all of the following:

• Single Platform – One middleware platform provides data, messaging, processing, high availability and deployment, resulting in reduced complexity, no middleware integration, and fewer license fees.
• High Performance – Proven in mission-critical applications with the highest throughputs, largest data volumes and millisecond-level latency.
• Scalable On Demand – Unlimited, linear scalability with predictable consumption of resources, performing real-time capacity planning by re-assigning unutilized resources to applications experiencing high loads.
• Always On – Eliminates unplanned downtime under extreme, unpredictable load by reacting to loads in real time and automatically provisioning more resources to meet service levels.
• Open – Minimizes vendor lock-in by supporting major open frameworks and standards, providing native support for Java, .NET and C++, and running on any existing infrastructure and public and private cloud environments.

“Extreme transaction processing is making its way into mainstream adoption because of the exponential growth of Web-based transactions, even within the ‘traditional’ business environment,” said Massimo Pezzini, VP and Fellow at Gartner. “Companies are seeking tools to help them cost-effectively manage variability between times of high and low demand; therefore, they are considering technologies that support both in-house and cloud-based processing.”

Additional enhancements include:

• 40X faster data access for extreme speed;
• Increased utilization of multi-core machines by up to 300%;
• Revamped Management Center GUI for improved development productivity;
• Administration API for fine-grained control of the entire deployment environment from within applications;
• Simpler APIs for writing easily maintainable code;
• Improved packaging for effortless deployment of Web applications;
• Updated security model; and
• Improved logging and troubleshooting for product robustness.

Now, potential clients can evaluate XAP online, observing real enterprise applications running within a production-ready environment, without having to download the actual software.

www.gigaspaces.com

I feel myself at the junction of “Pure Message Passing” and “Space Based Architecture”! which one is more suitable for developing high-throughput systems?

The first solution pure-message-passing  (where i feel myself quite a habitat) comes from the world of functional actor based systems well developed in Erlang and followed by its successors in Scala, Kilim or even JUC. Its side effect free nature makes it a perfect choice for highly concurrent, multi core domains but enforces its own programming model using messaging boxes and actors.

The second one, SBA (where i have applied for residency) comes from tuple spaces. a simple but strong paradigm first developed in Linda and followed by its worthy successor javaspaces and successfully used in domains such as orbitz and gigaspaces xap. Its share-take nature makes it a perfect choice for caching and in memory solution but again enforces its model to some extend which is well documented in xap’s PU.

These two model, although seem quite obverse in first sight, but share a lot in nature. they both introduce the separation of data and processor in an even driven paradigm. Even driven nature of these two models make both very strong for suitable todays complex and high demanding nature. and yes, both have their own mathematically proven theory behind.

Now the question comes in mind, which will be superior or will the both remain as competitor? maybe SBA since dummies don’t enjoy immutables? or maybe they collide into one single computational model? mixing quantum physics and relativity? cloud-computing? anyone?

It’s hard to believe that Terracotta with its great simplicity is in fact 10x times faster than Oracle Coherence?! Idea’s matter but after all Oracle is a multibillion company and Terracotta Tech is much smaller!

The point is, most of these benchmarks are from their vendors and obviously in this way it’s easy to find and obtain test which outperform in the specific cases.

What I am eager to here is this domain, is a vendor independent benchmark, not those from Oracle, IBM or Terracotta themselves! Do you know any?!

Identity platform with the new hosted services

Microsoft has announced a new version of Windows that will run over the Internet from data centers hosted by Microsoft. Called Windows Azure, the idea is that developers will write software that runs within the “clouds” as opposed to the traditional approach of residing within servers owned and managed of a given business. The official word came at the start of Microsoft’s Professional Developer Conference 2008 this week. It is not known how Microsoft will charge for Azure at this point, but it will be free during the preview period. Azure would allow software developers to create new applications that can be operated on the Internet rather than on the developers’ computers.

Azure Services Platform

Microsoft will use the Azure platform to run its own web applications and will also open the platform to outside developers for building and running their own apps. Azure will compete with other cloud platforms, such as Amazon Web Services, Google App Engine, and Salesforce.com’s force.com, and, given Microsoft’s enormous scale and influence in the software industry, its launch marks a milestone in the history of utility computing. The cloud is now firmly in the mainstream. Or, as Microsoft puts it: “The truth is evident: Cloud computing is here.”

Microsofts Cloud Computing

The announcements come at the start of Microsoft’s Professional Developer Conference here. On Tuesday, Microsoft plans to go into more detail on Windows 7, the successor to Windows Vista, due out by about January 2010.

Cloud Computing Technology Providers and Contributors in 2008-2009 The following companies are among the providers and contributors of Cloud Computing technology, 10Gen, 3Leaf, 3Tera, Absolute Performance, Accenture, Akamai, Amazon.com, Appirio, Appistry, Areti Internet, Boomi, Box.net, Canaan Partners, Cloud9 Analytics, CloudWorks, CNI Systems, CohesiveFT, CSRware, DataDirect, Dell, DNAmail, eBay, Elastra, EMC, EngineYard, Enki Consulting, Enomaly, Excelian, Flexiscale, Fortress ITX, Forum, GigaSpaces, GoGrid, Google, HP, IBM, IBRIX, Joyent, JumpBox, Layered Technologies, Level 3 Communications, Linxter, LongJump, MDV, Microsoft, Moka5 (MokaFive), Mosso, NewServers, Nirvanix, Ocarina Networks, OpSource, Panorama Software, Peer1 Networks, Pervasive Software, Platform Computing, PLX Technology, Qlayer, Rackspace, RampRate, Red Hat, RightScale, rPath, Salesforce.com, Saugatuck Technology, ServePath, Skills Matter, Skytap, SnapLogic, SOASTA, Sun Microsystems, Symphoniq, Symphony Services, Tap In Systems, Teneros, Terremark, Transitive Corporation, Univa UD, Verizon Business, Vertica, VMware, XCalibre, Zabovo.com, ZOHO and Zuora.

After tracking down numerous alternatives to Google App Engine after hitting a wall on Project Fangorn, I looked at the most promising alternatives in more depth. Here is what I found.

GigaSpaces

Using GigaSpaces XAP would mean–at a minimum–creating Python bindings to their C++ API and re-writing my data model. Actually running on their EC2 value added service costs a significant premium over what Amazon EC2 costs. While they do offer XAP free to startups, in that case then you have to operate your own servers and the list of alternatives in that space is quite large. I also couldn’t find any statements by GigaSpaces that indicated that you could have no instances running and have one spun up if a web request comes in, so it looks like at least one small instance would have to be running constantly putting the minimum cost at over $200 a month to use their EC2 service.

10gen

Using 10gen would currently mean a total rewrite as it currently supports Jython rather then Python and the effort to get Pylons working on Jython is not yet complete. Once that effort is complete 10gen becomes more promising as then I should only need to rewrite my datamodel and I might not even need to do that at some point as the 10gen folks have indicated they are willing to take on the portability issue. In their alpha stage, they are providing free hosting with quotas and their FAQ states “but will be competitive with other offerings, and with a very low minimum bill size”.

For those using Django rather then Pylons 10gen is working on putting the DJango data model on top of their API.

Amazon EC2 & SimpleDB

Running Python is no problem on EC2, nor is accessing SimpleDB since it is accessed via a REST API. So after rewriting my datamodel I would get the joy of managing my own instances and a minimum bill of over $70 a month. I could add third party instance management for an increase in my monthly minimum to over $100 a month.

UPDATE 10/23/2008: Amazon has announced a private beta for their own monitoring, load balancing, and automatic scaling service offering. No mention of price and it seems likely to be simply included with EC2 service.

Now waiting…

to see who gets there first. Will it be:

• Google by raising their mcycle soft cap, excluding the mcycle consumption of puts from the calculation, or reducing the mcycle consumption of puts?
• GigaSpaces by lowering their EC2 premium, allowing an app to go offline until a web request comes in, and providing Python bindings?
• 10gen indirectly with the help of those working on getting Pylons working on Jython (or directly by providing the DJango data model for those using Django)?
• Someone else?

If they all take too long?

Then there are numerous options and a few of them follow.

The one that might involve the least changes to my existing code could be continuing and expanding the work of this project to make the GAE SDK portable. While doing this work would also help other GAE refugees to just change providers without changing code I don’t feel a great need to tie myself to the GAE API/object model.

An interesting project is Terracotta which uses Aspect Orient Programming to distribute existing multi-threaded Java apps. It could be possible to reuse everything in the project except for the part doing the aspecting, which would need to be rewritten to Python. Such an effort could potentially be combined with the work of continuing and expanding the work of making the GAE SDK portable.

Another interesting project is OpenSSI, which basically does the reverse of what is of virtualization. Rather then allowing multiple virtual machines to run on one physical machine, OpenSSI allows multiple physical machines (and virtual machines to I’d imagine) to be treated as one machine from the perspective of a virtual process (and thus from the developer’s perspective). You still have to deal sychronization just like writing a multi-threaded process as well as inter-process communication between different virtual processes, but you don’t have to deal with writing distribution code. This may not be a great thing to use for Python because of its global interpreter lock. When I started getting into Python a couple of years ago I made the decision to multiprocess rather then multithread because of the GIL. This has a couple of advantages anyway. One being robustness and the other being just a step away from being a networked distributed app. If something could be developed to allow the use of Terracotta with Python, then its likely the same could be done to make take advantage of OpenSSI as well.

The PyPy project could be useful in combining Terracotta or OpenSSI with Python since its goal is to let you create a custom interpretor for Python.

Another interesting project is Hadoop which is a distributed filesystem and its derivative HBase which is a distributed database.

Durus could be a starting point for distributed transactional memory in Python. I say starting point as it’s home page states “Durus is best suited to collections of less than a million instances with relatively stable state” so clearly it doesn’t scale as is.

This Wikipedia entry also lists numerous other software transactional memory implementations although most are not distributed but OpenSSI could be utilized to provide that.

As I hit a wall in my development of Project Fangorn on Google’s App Engine platform I started looking around for alternative platforms. While there are numerous providers that claim to provide a cloud very few of them actually have a distributed datastore and a hosting environment that automatically expands and contracts (i.e. scale) the resources allocated to the running of your app, so the service they provide is either utility computing somewhere in between utility computing and cloud computing.

True Clouds

There is Google App Engine of course, but they aren’t currently up to what I’m trying to do.

Amazon has SimpleDB plus their Elastic Compute Cloud (EC2). While EC2 requires you to manage virtual machines, there are a number of third party providers of VM managers for EC2 that fluff up EC2 into more of a cloud. Two of these providers are Enomaly (general VM scaling) and Heroku (rails specific scaling).

UPDATE 10/23/2008: Amazon has announced a private beta for their own monitoring, load balancing, and automatic scaling service offering. No mention of price and it seems likely to be simply included with EC2 service.

One particularly interesting EC2 third party provider is GigaSpaces with their XAP platform that provides in memory transactions backed up to a database. The in memory transactions appear to scale linearly across machines thus providing a distributed in-memory datastore that gets backed up to persistent storage. A lot of the docs reference Java, but the page returned by the aforementioned link states “…deploy applications that use Java, .Net, C++, or even scripting languages…” so after a cursory investigation it is not clear what aspects of their platform is only accessible via Java and which aspectes are generally accessible. Bears more investigation.

10gen has a service in alpha preview that has a distributed datastore called Mongo and a hosting environment called Bable that automatically scales the resources hosting your app to fit current demand. Like Google 10gen doesn’t provide VMs that you can run just anything on. Currently apps can be written in server side JavaScript, Python, and Ruby (Update 10/21/2008 – it is only Jython and JRuby that are supported), so they are ahead of Google with respect the number of languages supported.

Cloud Processing but Utility Storage

The combination of Amazon’s S3, EC2, and third party auto-scaling VM managers falls into this category.

FlexiScale and Mosso both look to provide services similar to Amazon’s combination of EC2 with third party auto-scaling VM managers and Simple Storage Service (S3), as they make not claims to to have a distributed datastore, but just a SAN/NAS that can be accessed from the VMs.

Just Utility Computing

The combination of Amazon’s S3 and bare EC2 (i.e. no third party VM managers) falls into this category.

GoGrid has persistent storage that backups your server image, but it appears to be limited to just backups and doesn’t appear to be a persistent datastore.

AppNexus, Joyent, and Sun’s Project Caroline all look to provide services similar to Amazon’s combination of bare EC2 and Simple Storage Service (S3).

Future offerings

Sun also has Network.com but that site doesn’t say much beyond “Network.com is in transition…” which isn’t very informative.

Microsoft is supposed to be announcing something in this space at PDC at the end of this month. From what I remember (can’t find the article now) it will provide a .Net only hosting environment but I don’t recall if there was going to be any kind of distributed datastore or just MS SQL Server. I came across mention of an MSFT project to distribute SQL Server so I would guess there will not be a distributed datastore at this time.

3Tera is working on turning their AppLogic grid computing product into a cloud computing service offering but it doesn’t appear that a preview is available yet and remains to be seen if it will really be cloud computing or just another utility computing provider.

There’s already a ton of activity taking place in the cloud computing space, so much so that it can be hard to know who to watch. In many cases, it’s too early to pick winners. But there are distinct sectors of the IT industry that are particularly well suited to the on-demand, pay-as-you-go economics of cloud computing. Here are eight segments — and one company that’s a segment all its own — that we’re tracking closely.

Hosting companies that make the jump: When it comes to reliable managed hosting, Rackspace leads the pack. (Its VMware-based Mosso offering may appeal more to enterprises trying the cloud for the first time.) Clouds like XCalibre’s Flexiscale and Joyent are already there, but don’t have Rackspace’s installed base.

Stack-specific clouds: While Google and Amazon get the headlines, Engine Yard is heavily involved in the Ruby on Rails development community. Competitor Heroku is also Rails-focused, but relies on Amazon for its hosting platform.

Tools to wrangle virtual machines: To manage your EC2 machines, you’re going to need help. RightScale makes software for managing machines in the cloud; its tight focus on Amazon has made it an early favorite. Elastra, Enomalism and others have similar solutions.

Testing sandboxes: For many enterprises, a testing sandbox is the perfect way to start using on-demand infrastructure. CohesiveFT’s Skytap (a sister to Flexiscale) spins up testing machines in a cloud, but incumbent Surgient and recent entrant StackSafe aren’t far behind. And once you’ve tested a machine and seen that it works, why not leave it in the cloud?

Cloud-based development platforms: Companies like Rollbase and Coghead let non-developers build data-driven applications of any sort (as opposed to more specialized platforms like those of Salesforce and Ning.) But Intuit’s Quickbase, which now has access to Quickbooks data, has a head start: Millions of small businesses. Is this how SMB gets cloud?

Scaling frameworks: Wall Street needed fast, reliable applications that grew easily. Instead of adding more, bigger servers, they used Gigaspaces to bundle whole server clusters into discrete “processing units” that can be cloned to add capacity. In addition to being faster and scaling better, these units don’t care whether they’re in a private data center or a cloud.

Application delivery networks: What has tens of thousands of servers worldwide, a global network connecting them, and isn’t Google? Akamai. What was once a way of getting bits to far-flung corners of the Net is an often-overlooked cloud: Akamai has been able to run code at the edge since 2000. Its 2007 acquisition of Netli made it matter to enterprises even more. Akamai can weather heavy load and may be able to withstand attacks better than centralized clouds.

Cloud builders: 3Tera lets companies get into the cloud business. Enterprises can make in-house clouds on existing data centers; or service providerscan build their own cloud offeringsin the way Enki and others have. In 3Tera’s model, subscribers drag and drop the firewalls, servers and appliances they need. The company’s software then maps these virtual application stacks to servers and network segments. The results are impressive: On seeing 3Tera for the first time, ESM guru John Willis was so impressed he insisted on logging in to the icons on his screen to verify that it wasn’t just a demo.

The obvious one: Of the three big virtualization firms, only one (Microsoft) also has millions of desktops, two handset platforms, licensing for desktops, servers and applications, synchronization, and a huge online presence. Up until now, the Redmond giant has been treading carefully; it has to convert billions of dollars of shrink-wrap sales to on-demand revenue streams. But Microsoft’s going to be a huge player in the cloud.

For more insights into cloud computing trends, check out the recent GigaOM/Bitcurrent briefing on cloud computing that was launched at Structure 08.

I was invited by Techvibes to write a blog post about the first ever Structure 08 conference hosted by GigaOM, which I attended and my company PEER 1 sponsored. It was held on June 25th in San Francisco at the Mission Bay Conference Center:

Just got back from the Structure 08 conference hosted by GigaOM and headline sponsored by my company, Vancouver-based PEER 1. The sold out event was a tremendous success with over 600 people in attendance representing companies like Google, Facebook, Microsoft, and VMWare. A third of the conference room was allocated to media alone.

Making the decision to sponsor Structure 08 was an easy one. It is so rare to have a room full of the brightest minds discussing and debating the latest technology impacting IT infrastructure. “Cloud Computing” was by far the topic of the day, a buzz term that seems to encompass anything related to virtualization or on-demand scalable web hosting, which is sometimes, well, cloudy.

The line up of speakers included Jonathan Yarmis of AMR Research, Mendel Rosenblum of VMWare, and a heated discussion that included panelists from Google, AT&T, GigaSpaces, Mosso, Joyent, and XCalibre. Read more

Oooh, our first panel of the morning, Working the Clouds: NextGen Infrastructure for New Entrepreneurs. We’ve got a six-person lineup to give us their perspectives, and our own Alistair Croll to throw them questions. The lineup includes:

• Christophe Bisciglia, Senior Software Engineer with Google
• Jason Hoffman, Founder, CTO of Joyent
• Tony Lucas, CEO of XCalibre Communications
• Lew Moorman, SVP of Strategy and Corp Dev, Rackspace
• Geva Perry, CMO of GigaSpaces
• Joe Weinman, VP of Strategic Solutions at AT&T

Here are some notes:

Alistair: When we are moving to clouds, are we selling our souls? Should we be happy with our cloud overlords?

AT&T Joe: I have a prediction that is not surprising. There will be a proprietary stack and there will be an open business model based on the cloud that will leverage standards, commodization, price-compression, and differential vs dynamic pricing.

GigaSpace’s Geva: There’s room for both models. People are talking about specialized clouds.

Joyent’s Jason: The question is is it about selling your soul. You can’t leave. Until Google open sources Big Table . . .

Alistair: Fluffy clouds was coined here at Structure 08 (chuckles).

XCalibre’s Tony: Google’s Big Table is basically a lock in.

Google’s Christophe: I claim that Google is possibly a little bit ahead as far as Big Table. But people can build a better mouse trap and come in and compete. It’s a developer preview, but the theory is that the API is open and not locked down.

Joyent’s Jason: There’s been a lot published on what an open, loving cloud should do. We should give people real assurances that the cloud is a good place to be.

Google’s Christophe: When we publish something on Big Table it is not to say that it’s a lock-in, but it’s our attempt to say that this is something that worked for us.

XCalibre’s Tony: Why not open Big Table completely if you know better than everyone else?

Google’s Christophe: Big Table is a compromise that is scalable. There’s nothing about the API that says you have to do this with Big Table.

XCalibre’s Tony: One of the big problems that companies need to figure out is licensing.

AT&T Joe: The dirty secret of the cloud is that companies need to figure out the licensing models, or it will be forced to fold. The whole idea will drop dead of its own weight.

Alistair: There are two theories: put everything in the cloud and put more out at the edge. What’s the setup for Google?

Christophe’s Google: We have geographically distributed clusters. A lot of services are replicated. We want to make sure that if you trust us with your email, the most current copy might be in a datacenter closer to you.

AT&T Joe: “Architecture 3.0.” We don’t have all the nuts and bolts that will work it out. But an optimal mix of edge and keeping core information in the data center.

Alistair: Can we have our old toys? Can we put all our toys in the cloud environment?

Joyent’s Jason: Absolutely. If we want people to be on the cloud, we have to make sure that this occurs.

Geva’s GigaSpaces: Or make it look like our old toys. Use all of the APIs.

Christophe’s Google: It’s important to find a compromise. When we deal with enterprise we can’t tell them to move into the cloud and do it differently. But five years from now its important for people to build apps that can serve millions of users — then people have to think about building apps differently. We need to provide tools for people to build apps for the cloud.

Geva’s GigaSpaces: Vogel said earlier all you need is a credit card, but that’s not what big corporations want. They want help with services.

Lew’s Rackspace: There’s also a big problem with marketing — cloud means something new everyday.

The main value proposition of cloud computing is better economics, that it’s cheaper to rent hardware, software platforms and applications (via a per-usage or subscription model) than it is to buy, build and maintain them in the corporate data center. But if we expect that cloud computing is here to stay –- and not just a passing fad –- it must be feasible for the cloud providers themselves. So how do they do it?

They do it by leverage economies of scale. Put simply, the idea is that one very large organization can more efficiently build and operate its infrastructure than many small firms can on their own. To better understand this, let’s break down some of the financial advantages leveraged in cloud computing:

Specialization: Specialization is also known as division of labor, a term coined by the father of modern economics, Adam Smith. A company for whom running a large-scale data center is a core part of its business will do so much more cost-effectively than a company for whom it’s merely one aspect. The former will hire the best experts in the world, and will have the management attention required to continuously innovate, optimize and improve operations. And the overhead costs associated with doing so will spread thinly across massive usage. Case in point: Since it needed to use hundreds of thousands of servers, it was worthwhile for Google to build its own, homegrown devices to fit its exact power supply and fault-tolerance needs.

Although in software, anyone can build anything with enough people, time and money (as my old boss used to say, “It’s all ones and zeros”), it makes no sense for individual companies to develop capabilities such as dynamic provisioning, linear scalability and in-memory data partitioning when they’re readily available from off-the-shelf products.

Purchasing Power: Large organizations buy in bulk, which they can leverage to negotiate lower prices. So presumably the cloud provider can acquire lower-costing servers and networks, operating systems and virtualization software. Furthermore, they can negotiate better interest rates, insurance premiums and other contracts.

Utilization: This is perhaps the most important one and what I like to call the Kindergarten Principle, or “sharing is good.” In computing, tremendous savings can be achieved by having multiple companies share the same IT infrastructure.

Experts estimate average data center utilization rates range from 15 percent to 20 percent. If you include the processing, memory and storage capacity available on company-owned laptops and desktops as well, utilization rates may be as low as 5 percent. That’s a lot of waste. Imagine if this were the case in the hospitality industry. In most cases, a hotel with even 50 percent average occupancy rates would quickly go out of business.

So why is this happening with corporate IT?

Application loads are volatile; they experience peaks and troughs based on time of day, day of the week or month, seasons and so on. To avoid hitting the “scalability wall,” companies need to overprovision. So if a company expects a certain daily peak volume (for example, the opening of the trading day for an e-trading application), it will provision enough hardware so that utilization rates at the peak reach no more than 70 percent (leaving some room for unexpected loads – hey, Steve Jobs may announce the next iPhone today). But at other times utilization rates could go as low as 10 percent, with the average somewhere in between.

So the difference between peak loads and average loads drives overprovisioning and a high rate of unused computing capacity. But if we aggregate the activities of several companies, we will not face such volatility in application loads. Let’s see why.

Follow the Sun: In many cases, peaks and troughs in application volumes can largely be attributed to the time of day. Human-facing applications are active during daytime and face very low activity during the night. When New York experiences the opening bell trading spike, London is in the midday lull and Tokyo is going to bed. Same goes for e-commerce sites, social networking sites, gaming sites and others, though these types of applications might experience peaks after business hours as well.

If companies around the globe and in different industries share the same resources on the cloud, higher utilization rates will be achieved by the cloud provider, lowering its costs – savings that it can turn around and pass on to its customers. This model of shared resources even addresses the need to overprovision for unexpected peaks, as it is unlikely that all the cloud users, in all geographical regions and all industries will face peaks at the same time. This is similar to the notion of a bank not having all of the cash reserves necessary to handle the cash commitments to all customers at the same time (is there an equivalent to a bank run in cloud computing?).

Follow the Moon: And with so much focus on energy costs, data center power consumption and cooling (not to mention the environment), there’s also a cloud computing approach known as Follow the Moon. It posits that a cloud provider with physical data centers in several different geographical locations can run the applications that are active from the day side of the world in centers on the night side of the world, taking advantage of lower power and cooling costs.

Cloud computing, therefore, is an economically feasible strategy. Over time, the cost savings will be too compelling for all but the very largest companies to ignore.

Geva Perry is the chief marketing officer of GigaSpaces

I’ve been looking at a few different technologies to improve the scalability of one of our applications. We’re scaling pretty ok to be honest, considering that we currently have a traditional database centric solution. The cost for scaling an database bound application running Oracle is crazy to say the least considering they charge $47 500 per two x86 cores for Oracle Enterprise Edition. On top of this it’s 22% for software updates and support per year. As this wasn’t enough, they also increase the support cost with 4% per year.

You might think that the price above is for production environments, but in fact you have to pay for every single installation throughout the organization. There are no discounts for staging, DR, test or development environments.

I have a piece of advice for all you kids out there considering to run Oracle – just don’t do it.

This advice goes for all Oracle products really, as they all have the same pricing model.

Databases are overrated

My strong recommendation is to build an application that doesn’t rely on an underlying RDBMS. The relational database is an overrated, overly complex form of persistent store. They are slow, and are also usually a single point of failure. Does this mean that databases are dead and a thing from the past? No, but the role of the database will probably change going forward. In my opinion we should use the RDBMS as a System of Record that is mostly up to date.

If you ask me, databases are great at mainly two things:

1. They make the data accessible for other systems in a standard way and
2. They have a strong query language that many people know

So, write to databases asynchronously and use it for reporting and extracting data. Store the data in a data grid in the application tier (where it’s used).

What is a Data Grid?

A Data Grid is a horizontally scalable in-memory data management solution. Data grids try to eliminate data source contention by scaling out data management with commodity hardware.

Some underlying philosophies of data grids – according to Oracle (sic!):

• Keep data in the application tier (where it’s used)
• Disks are slow and databases are evil
• Data Grids will solve your application scalability and performance problems

I have been looking at three different data grid vendors; Oracle Coherence, Gigaspaces EDG/XAP and Terracotta DSO.

Oracle Coherence

I really like this product. It focuses solely on being a potent data grid, with abilities to do act as a compute grid as well. Although I haven’t used Coherence for any large projects, its design and concepts are easy to relate to. It supports JTA transactions and consists of a single jar that you drop into your class path. The Coherence configuration doesn’t contain any infrastructural descriptions which means that you can use the same configuration on a your development laptop as in the production environment with multiple servers. The main issue with Coherence is the fact that evil Oracle owns it since a few years back.

Gigaspaces XAP

Gigaspaces mission seem to be to provide a very scalable application server with XAP – “The Scale-Out Application Server”. The EDG – enterprise data grid – packaging seem to provide about the same feature set as Coherence. The main difference to me, is the fact that the Gigaspaces offerings are both application server infrastructure that needs configuration, deployments and all of that. As I see things, the main drawback is the application server approach – it feels overwhelming. On the other hand, Gigaspaces is still a smaller company and eager to do business and provide great implementation support and the product seems to be a really good application server.

Terracotta DSO

Terracotta has a different approach. They provide Networked Attached Memory for the Java heap. If you can write a thread-safe program, you can scale out using Terracotta with no or minor changes to your application. From a technical point of view it’s a beautiful solution: You declare what objects you want to make available using Terracotta, and then Terracotta will makes your data persistent (if you want) and available on all clustered nodes. When you invoke new() on a clustered object, you will get a reference to the cluster object (if one exists). Another important difference between Terracotta and the others is that they only send the part of an object that’s been changed rather than the full serialized object graph.

I’m in love with this product. Its free and open source too and Terracotta Inc provides commercial support. The main concern I have with Terracotta is that its really a paradigm shift to the average java enterprise developer to start to write multi-threaded programs without having JTA transactions. Another concern is the magic – the low-level hooks they do in the JVM:s. At the time of writing, only Sun and IBM JVM:s are supported. It runs fine on OSX though.

The bottom line

So which one is the better? Well, that depends on a lot of things as always. If you decide to move to the grid it’s going to require retraining of your developers regardless of what solution you go for.

Please do keep in mind that products doesn’t usually solve your problems. And that you can go a long way using a less expensive RDBMS by partitioning the data across multiple servers – sharding. This is what a lot of large sites out there do.

Further reading:
The Coming of the Shard
eBay’s Architectural Principles
Oracle Coherence
Gigaspaces EDG
Terracotta DSO

Written by Geva Perry, chief marketing officer at GigaSpace Technologies.

We are witnessing a seismic shift in information technology — the kind that comes around every decade or so. It is so massive that it affects not only business models, but the underlying architecture of how we develop, deploy, run and deliver applications. This shift has given a new relevance to ideas such as cloud computing and utility computing. Not surprisingly, these two different ideas are often lumped together.

What is Utility Computing?

While utility computing often requires a cloud-like infrastructure, its focus is on the business model on which providing the computing services are based. Simply put, a utility computing service is one in which customers receive computing resources from a service provider (hardware and/or software) and “pay by the drink,” much as you do for your electric service at home – an analogy that Nicholas Carr discusses extensively in “The Big Switch.”

Amazon Web Services (AWS), despite a recent outage, is the current poster child for this model as it provides a variety of services, among them the Elastic Compute Cloud (EC2), in which customers pay for compute resources by the hour, and Simple Storage Service (S3), for which customers pay based on storage capacity. Other utility services include Sun’s Network.com, EMC’s recently launched storage cloud service, and those offered by startups such as Joyent and Mosso.

The main benefit of utility computing is better economics. Corporate data centers are notoriously underutilized, with resources such as servers often idle 85 percent of the time. This is due to overprovisioning — buying more hardware than is needed on average in order to handle peaks (such as the opening of the Wall Street trading day or the holiday shopping season), to handle expected future loads and to prepare for unanticipated surges in demand. Utility computing allows companies to only pay for the computing resources they need, when they need them.

What is Cloud Computing?

Cloud computing is a broader concept than utility computing and relates to the underlying architecture in which the services are designed. It may be applied equally to utility services and internal corporate data centers, as George Gilder reported in a story for Wired Magazine titled The Information Factories. Wall Street firms have been implementing internal clouds for years. They call it “grid computing,” but the concepts are the same.

Although it is difficult to come up with a precise and comprehensive definition of cloud computing, at the heart of it is the idea that applications run somewhere on the “cloud” (whether an internal corporate network or the public Internet) – we don’t know or care where. But as end users, that’s not big news: We’ve been using web applications for years without any concern as to where the applications actually run.

The big news is for application developers and IT operations. Done right, cloud computing allows them to develop, deploy and run applications that can easily grow capacity (scalability), work fast (performance), and never — or at least rarely — fail (reliability), all without any concern as to the nature and location of the underlying infrastructure.

Taken to the next step, this implies that cloud computing infrastructures, and specifically their middleware and application platforms, should ideally have these characteristics:

• Self-healing: In case of failure, there will be a hot backup instance of the application ready to take over without disruption (known as failover). It also means that when I set a policy that says everything should always have a backup, when such a fail occurs and my backup becomes the primary, the system launches a new backup, maintaining my reliability policies.
• SLA-driven: The system is dynamically managed by service-level agreements that define policies such as how quickly responses to requests need to be delivered. If the system is experiencing peaks in load, it will create additional instances of the application on more servers in order to comply with the committed service levels — even at the expense of a low-priority application.
• Multi-tenancy: The system is built in a way that allows several customers to share infrastructure, without the customers being aware of it and without compromising the privacy and security of each customer’s data.
• Service-oriented: The system allows composing applications out of discrete services that are loosely coupled (independent of each other). Changes to or failure of one service will not disrupt other services. It also means I can re-use services.
• Virtualized: Applications are decoupled from the underlying hardware. Multiple applications can run on one computer (virtualization a la VMWare) or multiple computers can be used to run one application (grid computing).
• Linearly Scalable: Perhaps the biggest challenge. The system will be predictable and efficient in growing the application. If one server can process 1,000 transactions per second, two servers should be able to process 2,000 transactions per second, and so forth.
• Data, Data, Data: The key to many of these aspects is management of the data: its distribution, partitioning, security and synchronization. New technologies, such as Amazon’s SimpleDB, are part of the answer, not large-scale relational databases. And don’t let the name fool you. As my colleague Nati Shalom rightfully proclaims, SimpleDB is not really a database. Another approach that is gaining momentum is in-memory data grids.

One thing is certain: The way the industry has traditionally built software applications just won’t cut it on the cloud. That’s why companies such as Google, Amazon and eBay have developed their own infrastructure software, opting not to rely on products from the large middleware vendors such as Oracle and BEA, who designed them with a very different approach in mind.

For this reason, we are seeing the emergence of a new generation of application platform vendors. These vendors, which include my own company, GigaSpaces, are building software platforms made for the cloud from the ground up: “cloudware,” if you will.

So although they are often lumped together, the differences between utility computing and cloud computing are crucial. Utility computing relates to the business model in which application infrastructure resources — hardware and/or software — are delivered. While cloud computing relates to the way we design, build, deploy and run applications that operate in an a virtualized environment, sharing resources and boasting the ability to dynamically grow, shrink and self-heal.

I received an excellent question from a reader about his eagerness to use wikis for his product’s doc set, but he came across conflicts and issues when he questioned the practicality of maintaining a wiki for his large set of documentation. Here’s Paul’s well-phrased request for information.

I am considering using a wiki for documentation projects, but have been coming across some showstopper issues. Here is the story:

Our documentation set is large. We only want to maintain one set of files. Therefore, any changes in the wiki would need to be automatically synched with the source files.

The obvious suggestion is “just make the wiki your source files.” However, it is not as simple as that, for a few reasons.

• First of all, we need to generate attractive offline documentation in online help format, viewable across several operating systems. No wiki enables an elegant way of doing that.
• Secondly, we have a bunch of conditional text–our existing documentation comes in six different versions. I have not found a good way to integrate the different conditional tags into a wiki, while maintaining it in both our sources and the offline output files.
• Finally, wikis almost by nature do not support DITA. Wikis are designed to be simple and easy to understand. However, that approach negates many of the advantages of structured writing.

For these reasons, I currently see wikis primarily as a collaboration tool. But they do not have the features necessary for complex technical documentation.

Do you have ideas for how we could get around these issues?

Oddly enough, on this particular day, another reader wrote in about similar issues with wikis, but they have started to overcome them. He listed the issues succinctly, saying:

I’d say that there is quite an art to creating wiki doc from a couple of perspectives:

* conversion
* building out the infrastructure
* look-and-feel issues
* style issues
* review issues
* basic editing issues

Even with all these issues — — however, the immediateness of the experience, the ease associated with making changes and the creation of links and containers, and the modern look and feel really make wikis a fascinating competitor with other, much different technologies. How many other industries move off in such opposite directions (wikis vs. dita)? It’s sort of like trying to figure out whether cars should run on gas or steam!

The CEO of Confluence came through a few weeks ago. He was pointing out to the following as an example of a company that had developed wiki doc:

http://www.gigaspaces.com/wiki/dashboard.action

Here are two more you might find interesting if you don’t already know about them:

http://docs.codehaus.org/display/GROOVY/Documentation

http://www.aptana.com/docs/index.php/Main_Page

And here’s the part that is amazing to me – in a follow up email, Paul answered some of his own questions and said that the gigaspaces.com wiki is one wiki he is investigating further. For example, by talking to one of the writers, he learned that their wiki has 1300 pages, and reuses many pages through the [include] command or transclusion, which is the inclusion of part of a document into another document by reference. My original response to Paul talked about DITA as source files and wiki as an output from those source files. I learned that Robohelp does something like that, with source files and wiki as output, and this blog post mentions round-tripping the content back to Robohelp.

Naturally, I have some ideas about DITA and wikis. My post about DITA Storm built into a custom wiki describes a hybrid approach, with DITA files as the source and editable pages. Paul takes that idea one step further, saying that you could have the internal technical writers see a DITA editor interface to the wiki, but have end-users write doc in a simplified editor with fewer tags. I like that idea.

There’s also the possibility of a transform from DITA to wikitext. A search on the dita-ot-developer list on sourceforge.net revealed that Deborah Pickett was writing such a thing for her employer last April. I emailed her and she generously gave me her XSLT source files, but said that she gave it up when she found that “The whitespace rules for wikimedia meant that anything fancy would end up being better written in wikimedia’s pretend HTML format anyway.” Hm. I haven’t tried the transform yet myself. Bob Doyle has done a lot of DITA to WikiMedia transformation to pre-seed the ditawiki.org with content, and he says “The Perl script for conversion to MediaWiki is publicly available at http://www.jtidy.de/conv. It has a major flaw in that it does not convert URLs to hyperlinks.” Again, I’d need to try it myself to see whether that approach would work and if the technology scripting is worth the effort.

Now, for everyone pondering wikis and DITA, an absolute must read is this great article by Paul Prescod, The Convergence of Structure and Chaos. Not that it offers practical solutions (although he hints at some at the very end), but it maps DITA concepts to wiki concepts.

I’ve also been noticing that people are trying to automate getting content from their support forums into wikis… Check out this poor intern’s daunting task: http://ask.metafilter.com/62679/Automated-Media-Wiki-Page-Creation.

I guess to answer my own question about where wikis fit in tech doc, I currently see wikis as supplemental, not source doc from which to make other things. I probably lean towards seeing a wiki is another output from perhaps DITA source. Sure, there would have to be a loopback mechanism to get the contributed parts of a wiki back to the source files, and I’m not sure how automated that could be. But, I would love it if vendors could convince me otherwise, and frankly, I keep hearing about Confluence and their examples are compelling.

So I share with you these side conversations I’m having in hopes that the information here helps others in their quest to offer wikis to their end-users. Users, write the manuals. But make sure us writers get to meet our objectives as well.

As a final departing thought, I share the machine is us/ing us video, containing the best description of Web 2.0 and new media I’ve seen to date, created by a cultural anthropologist. It’s about five minutes long, and a thought provoking piece.

One of the questions in it that stuck in my mind was the question at about 3:00 minutes, “Who will organize all this data?” And the typed and re-typed answers after a screencast or demo of del.icio.us:

We will.

You will.