Category Archives: Software Development

To the land of plenty.. Moving towards high-performance cluster management


“Jevons Paradox” is the proposition that as technology progresses (invention->innovation->diffusion), the increase in efficiency with which a resource is used tends to increase the rate of consumption of that resource.

As much as cloud operators continue to increase the population of hardware assets, it has become an increasingly difficult problem to efficiently utilize those resources effectively as demand grows. This has huge implications in the longevity of these multi-million dollar cloud warehouses highlighting the need to make better decisions on resource allocation and assignment.

Into the light..

Some promising work comes from Christine Delimitrou described in her paper “Quasar: Resource-Efficient and QoS-Aware Cluster Management

Quasar is a follow-up to the work on Paragon, a system to leverage collaborative filtering to characterize (classify) applications in terms of heterogeneity and potential for interference. Quasar establishes a set of interfaces which expand upon Paragons’ classifier.  These interfaces allow for choices to be made in scaling such as the amount of resources per server or the amount of servers per workload. Both Paragon and Quasar use offline sampling (profiling) instead of relying on some explicit characteristics but Quasar goes further in applying jointly handling resource allocation and assignment. Quasar is part of a broader set of cluster management platforms such as Omega, Borg, Mesos, which are being used in production in some of the largest web properties on the Internet.

Quasar exports a high level interfere to meet different performance constraints such as:

  • Latency critical workloads use a combination of QPS (Queries Per Second) and latency
  • Distributed frameworks use execution time
  • Single and Multi-threaded applications can use IPS (Instructions Per Second)

This work has a lot of promise given the increasing demand for efficient allocation of infrastructure resources. There continues to be an iterative cycle between application developers and infrastructure teams to mitigate the risk of failure while increasing utilization. But how does one decide which variables and how many must be used to decide on which resources to assign?

Large shops like Facebook,Twitter and Google have been experimenting with cluster scheduling for years. Systems like Omega grew out of the complexity of managing flexible scheduling with ever increasing linear complexity spawned from their explosive growth. As reported in the Quasar paper, sophisticated frameworks like Borg and Mesos have a hard time driving more than 20% aggregate CPU utilization and can under estimate resource reservations by 5x and over estimate reservations by as much as 10x. Its important to note that these numbers are at the high-end with a majority of cloud data centers and enterprise customers experiencing only a fraction of the available capacity they have invested in.

As can be seen by the following graphic, Not only are jobs completing faster with the Quasar scheduler but CPU utilization is increasingly higher which could increase the usefulness of a data center by several years having dramatic cost savings for the large web-scale data centers.


It is no secret in todays “application centric economy” that huge benefits can be obtained through application/infrastructure cooperation. Chip designs have followed the path of adding transistors to deal with complex problems such as matrix multiplication, stream processing, virtualization and high-speed I/O. infrastructure vendors have started to focus on the shifting operational models which have manifested in areas such as cloud computing, DevOps, Network Virtualization and Software Defined Networking.

The allocation and assignment of resources becomes a critical decision point which must be reacted to not in human scale but in machine scale.. The dominant force here centers around “Reactive Design” and the need for operational stability.

But who is responsible for coordinating resources, resolving shared resource conflicts in a highly dynamic environment?

Send in the Conductor.. blogging3

Orchestration describes the automated arrangement, coordination, and management of complex computer systems, middleware, and services that are used to align business or operational request with applications, data and infrastructure within a management domain [ref].

Orchestration can be broken into roughly 9 categories including: Allocation, Assignment, Scheduling, Visualization, Monitoring, Modeling,  Discovery, Packaging and Deployment.

These become fundamental building blocks for building distributed systems and allows us to talk about these functions with a clear set of vocabulary.

Allocation: Determining the appropriate resources to satisfy the performance objective at the lowest cost

Assignment: The process of selecting the appropriate resources which satisfy the resource allocation

Scheduling: Enables an allocated resource to be configured automatically for application use, manages the resource(s) for the duration of the task to secure compliance and restores the resource to its original state for future use

Visualization: The process of rendering information related to service availability, performance and security

Monitoring: Provides visibility into the state of resources and notifies applications and infrastructure management serves of changes in state

Discovery: The realization of a resource or service through observation, active probing or enrollment

Modeling: Describes available resources and their capabilities, dependencies, behaviors and relationships as a policy. Can also be used to describe composition of resources and services (i.e. happens-before relationships)

Packaging: The process of collecting all artifacts and dependancies into a portable container which can be transferred across resources. This packaging might also encapsulate existing state for instance in live migrations.

Deployment: Code and data need to be instantiated into a system in order for the scheduler to reserve resources. Delivering the packages mentioned above across resources requires coordination as to not overwhelm the network during updates.

When driving for high-performance for customers and high-efficiency for operators resource allocation and assignment become critical decision processes in the orchestration system. Quasar provides an interface which can directly relate to emerging Promise Theory allowing developers to declare scalability policies which express performance constraints allowing Quasar to search through the available option space to best fit the constraints with the available resources..

But what about the network?

“Your network is in my way..”


Everyone in the network industry is aware of James Hamilton’s observation that network technologies have long become inefficient and overly complex. SDN has driven this conversation to the forefront challenging foundational principals of the Internet such as decentralization and the end-to-end principal. The current protocol stack has a number of problems known as far back as the initial ARPAnet designs over 40 yrs ago. The Internet has become more  complex due to the distributed nature of application design and the need for location independance.

When it comes to network interference we have different opportunities to optimize for resource constraints including:

  • Path selection – Optimized to minimize distance (propagation delay)
  • Congestion and Flow Control – Optimized to maximize bandwidth
  • Error Control – Optimized to minimize loss
  • Scheduling – Optimized to maximize queue fairness amongst competing flows

This would seem to be plenty to deal with network interference except for the problem that not all flows are necessarily equal. For instance a trading application might need market data to take priority over backup replication. VOIP traffic needs to be prioritized over streaming downloads.

Unfortunately as much as we would like to have a way to map priorities across the network, the current environment makes it difficult to achieve in practice. This usually falls within the purview of Traffic Engineering and incorporates different methods for describing, distributing and acting upon flow policies either for admission control or filtering.

In a recent GIGAOM survey operators categorized Network Optimization as the leading use-case for SDN, NFV and OpenSource which might be another way of saying that we need a facility to characterize inter-process communication in a way which can be fed back into our orchestration systems to make proper resource allocation and assignment decisions.


As the industry moves through technological change (S-Curve), a rapid innovation cycle will result in many failures until we reach the point of wide adoption (diffusion). Many have speculated on the timelines but it is still far from proven how well customers will adopt not only the change that comes from technology but also the change in organizational structure, skill sets and policy.

Networking Guy’s, Just don’t understand software

Before I begin my rant, let me just say my first router was a WellFleet CN with a VME Bus and my first Cisco router was an AGS+.. I have been around long enough to see DecNet, IPX, IP, SNA, Vines and a few others running across my enterprise network while troubleshooting 8228 MAU’s beaconing in the wiring closets and watching NETBEUI “Name in Conflict” packets take down a 10’000 node RSRB network.

Its 2012 and gone are the days when network engineers need to juggle multiple protocol behaviors such as IPX GetNearestServer, IP PMTU bugs in Windows NT 3.5.. or trying to find enough room in your UMB to fit all your network ODI drivers without crashing Windows.

Its a new age, and as we look back at almost 40 years since the inception of the Internet and almost 20 years since TCP/IP was created, we are at the inflection point of unprecedented change fueled by the need to share data, anytime, anywhere on any device.

The motivation for my writing this entry comes from some very interesting points of view from my distinguished ex-colleague Brad Hedlund entitled “Dodging Open Protocols with open software“. In his post he tries to dissect both the intentions and impact of a new breed of networking players such as Nicira on the world of standardized protocols.

The point here isn’t to blow a standards dodger whistle, but rather to observe that, perhaps, a significant shift is underway when it comes to the relevance and role of “protocols” in building next generation virtual data center networks.  Yes, we will always need protocols to define the underlying link level and data path properties of the physical network — and those haven’t changed much and are pretty well understood today.

The “shift in relevance and role of protocols”  is attributed not necessarily at what we know as the IETF/IEEE based networking stack and all the wonderful protocols which make up our communications framework, but in a new breed of protocols necessary to support SDN.

Sidebar: Lets just go back a second and clarify the definition of SDN. Some define Software Defined Networking in terms of control plane, data plane separation, which clearly has been influenced by the work on OpenFlow.

So the shift that we see in networking which is towards more programmability and the fact that we need new ways to invoke actions and carry state is at the crux of this shift..

However, with the possibility of open source software facilitating the data path not only in hypervisor virtual switches, but many other network devices, what then will be the role of the “protocol”? And what role will a standards body have in such case when the pace of software development far exceeds that of protocol standardization.”

Ok so this is the heart of it.. “what then will be the role of the “protocol”? And what role will a standards body have in such case when the pace of software development far exceeds that of protocol standardization.”

I think the problem here is not necessarily the semantics of the word “protocol” (for this is just a contract which two parties agree upon), but the fact that there is a loosely defined role in how this “contract” will be standardized to promote an open networking ecosystem.

Generally standardization only comes when there is sufficiently understood and tested software which provide the specific implementation of that standard. Its very hard to get a protocol specification completely right without testing it in some way..

Sidebar: If you actually go back in history you will find that TCP/IP was not a standard.. The INWG was the governing standards body of the day in defining the international standard which was supposed to be INWG 96 but because the team at Berkley got TCP up into BSD Unix, well now its history..I wrote a bit about it here:

With that in mind, take a closer look at the Open vSwitch documentation, dig deep, and what you’ll find is that there are other means of controlling the configuration of the Open vSwitch, other than the OpenFlow protocol.

When it comes to OVS its very important not to confuse interface and implementation. Since OVS in a classical form just a switch, you operate it through helper routines to manipulate the state management layer in the internal datastore called OVSDB and interact with the OS. This is no different than say a CLI on a Cisco router. Most of the manipulation in the management plane will probably be exposed through JSON-RPC (Guessing here) through a high-level REST interface.

What you must understand about OVS when related to control plane/data plane separation or  “flow-based network control” is you are essentially changing the behavior from a standardized switch based on local state to a distributed forwarding engine coordinated with global state.

From OVS:

The Open vSwitch kernel module allows flexible userspace control over flow-level packet processing on selected network devices. It can be used to implement a plain Ethernet switch, network device bonding, VLAN processing, network access control, flow-based network control, and so on.

Clearly since we are in the realm of control plane/data-plane separation we need to have a protocol (i.e. contract) which is agreed upon when communicating intent. This is where OpenFlow comes in..

Now unfortunately OpenFlow is still a very nascent technology and is continuing to evolve but Nicira wants to solve a problem. They want to abstract the physical network address structure in the same way that we abstract the memory address space with VMM’s (see Networking doesn’t need VMWARE but it does need better abstractions). In order to do this they needed to jump ahead of the standards bodies (in this case the ONF) and adopt some workable solutions.

For instance, OVS is not 100% compliant with OpenFlow 1.0 but has contributed to better models which will appear soon in the 1.2 specification. OVS uses an augmented PACKET_IN format and matching rules

/* NXT_PACKET_IN (analogous to OFPT_PACKET_IN).
* The NXT_PACKET_IN format is intended to model the OpenFlow-1.2 PACKET_IN
* with some minor tweaks. Most notably NXT_PACKET_IN includes the cookie of
* the rule which triggered the NXT_PACKET_IN message, and the match fields are
* in NXM format.


Open Source networking is nothing new, you have XORP, Zebra, Quagga,, Vyatta and standard bridging services built into Linux.

Just like with TCP/IP if there is value in OpenFlow or whatever its derivatives are we will see some form of standardization. OVS is licensed under Apache 2, so if you want to fork it go ahead thats the beauty of software. In the mean time I wouldn’t worry so much about these control protocols, they will change over time no doubt and good software developers will encapsulate the implementations and publish easy to use interfaces.

What I think people should be asking is not so much about the protocols (they all suck in their own way because distributed computing is really, really hard) but what can we do once we have exposed the dataplane in all its bits to solve some very nasty and complex challenges with the Internet?.

Cisco UCS “Cloud In A Box”: Terabyte Processing In RealTime

Now I hate using the term “Cloud” for anything these days but in the latest blog entry from Shay Hassidim, Deputy CTO of Gigaspaces Terabyte Elastic Cache clusters on Cisco UCS and Amazon EC2 the Cisco UCS 260 took the place of 16 Amazon High-Memory Quadruple Extra Large Instance. With 16:1 scaling imagine what you can do with a rack of these, in other words forget about Hadoop, lets go real-time data grid enabled networking!

With 40 Intel cores and 1TB of memory available to Gigaspaces XAP high performance In Memory Data Grid the system achieved an astounding 500,000 Ops/sec on 1024B POJO, the system could load 1 Billion objects in just under 36 minutes.

Now this might not sound extraordinary, but when you consider how to build an application where the bottleneck on a 40 core, 1TB system is CPU and Memory bound, properly deal with failures and have automation and instrumentation, you can’t beat this kind of system. Gigaspaces is also integrated into Cisco UCS XML-API for dynamic scaling of hardware resources.

Eventually people will catch on that memory is critical for dealing with “Big Data” and it’s no longer an issue of reliability or cost. Without disk rotational latency in the way and poor random access we can push the limits of our compute assets while leveraging the network for scale. Eventually we might see a fusion of in-memory data grids with network in a way, which allows us to deal with permutation traffic patterns by changing the dynamics of networking, processing and storage.

A View from the Developer Nation


By: Gary Berger

Every year the folks at Trifork and InfoQ put on a conference in San Francisco (expanding to other geographies) for enterprise software developers. The conference is geared towards team leads, architects, product managers and developers of all skill sets. This conference is different than most because the constituents are all practitioners (i.e. software developers) not academics, and the agenda spans from Architecture to Agile and Cloud. Many of the leading players in the industry attend, including Twitter, NetFlix, Amazon and Facebook. The discussions are usually very intriguing and provide glimpse into the complex ecosystems of these successful companies.

After being involved in this community for several years I can say that the level of maturity continues to accelerate as developers become experienced with new toolkits, new languages and are encouraged to fail fast through agile techniques like Lean Development, Kanban and Agile. Open Source continues to cross pollinate software developers allowing them to iterate through solutions find what works and keep producing minimal viable products on schedule. The fast innovation in this industry is the culmination of many geniuses over time, paying forward with their hard work and dedication so others can benefit and you can see the influences across architectures starting to emerge.

This paper does not intend to be a comprehensive text on software development practices, tools and techniques. I will however try and distill common themes and highlight specifics, which I find and where others might want to dig deeper to investigate on their own behalf.

JAVA as a Platform

It’s been several years now since I have been advocating the use of JAVA as the abstraction layer for modern applications. I have been exposed to JAVA for many years including designing an infrastructure for one of the world’s first equity matching kernels built in Java. At the time we leveraged Solid Data (DRAM) based storage and one of the first Object Databases to store our transactions, We leveraged CORBA for inter-process messaging and Netscape HTTP server for our front-end. It was a complicated set of interacting components that needed to work together flawlessly to be successful. The system itself was completely over engineered, a standard design philosophy in those days, and performed perfectly for several years before the business could not be sustained any longer. Turned out the “Mom and Pop” investor wasn’t interested in trading after-hours and there just wasn’t enough liquidity to sustain a marketplace.

Needless to say JAVA is everywhere and has recently become poster child for the nascent Platform as a Service model.  Even companies like Yammer or falling back to JAVA from Scala because of the inconsistent build tools and developer education. To be fair, its also the complexities that come from PolyGlot programming so take it or leave it. A great view on the practicality of JAVA from Erik Onnen here: Don’t forget to check out Oracle’s Public Cloud offering here:

Why JAVA? Why Now?

About a year ago now, Rod Johnson proclaimed, “Spring is the new cloud operating system”.  Even though the term “cloud” has been overloaded to the extent it’s almost superfluous, it was a profound statement when centered on the JVM and the JAVA language. For more information see Alex Buckley’s presentation on JAVA futures here:

Sidebar: Rod’s Key Note

Rod Johnson is the General Manager of SpringSource, a company acquired by VMWare to expand their footprint into the core of application development. Rod usually speaks about the evolution of the Spring Framework his gadgets such as Spring Roo and Aspect Oriented programming, but this time he was somewhat reflective on his career and his life. From the beginning, his industry acclaimed book on Java development practices turned into a massively successful Open Source project called the Spring Framework from which the first real threat to the JEE ecosystem was felt. Spring, and its philosophy around dependency injection are mainstream and his teams have a catalog of products under the SpringSource banner. Rod has had an astonishing career and talks enthusiastically about the potential for entrepreneurs to change the world through software. See Rod’s presentation here:

Oracle acquired Sun Microsystems in early 2009 and the Java community was rocked. Hints of legal battles over Java with Google left people to assess the impact on the Java ecosystem. Even the OpenJDK project the open source incarnation of the JAVA platforms survival was put in question.

Luckily, Oracle has caught on that JAVA is the way forward, and is now marketing the JEE as a “Platform as a Service”. Clearly it is the breadth and depth of the JAVA platform, which makes it successful, with a large set of toolkits, frameworks and libraries a highly educated developer community, the JAVA platform is everywhere. From Google to NetFlix and Twitter, JAVA can be found running some of the worlds most successful systems.

JAVA is now Oracles future. From Fusion to Exalogic and the JEE platform itself taking on a full service model, JAVA continues to have a profound impact on the industry.

Sidebar: The “Application Memory Wall” and its impact on JAVA

When trying to understand the scalability limits of a system we sometimes have to look under the covers at the intent of the application and how the design leverages the core resources of a system. Gil Tene from Azul Systems boils down the problem this way. We all know that the memory wall exists and is determined by the memory bandwidth and latency which evolves at a much slower pace than CPU’s. However we have yet to breach this wall thanks to the phenomenal engineering of modern chips such as Intel Nehalem instead we have been constrained by how applications are designed. This actually creates several issues, as infrastructure designers may “architect” the right solution to the wrong problem.

In the Java world the most restrictive function is Garbage Collection, the process of removing dead objects, recouping memory and compacting the fragmented heap. This process impacts all major applications and teams spend man years tweaking the available parameters on their collectors to push the problem as far into the future as they can, but alas it is unavoidable, the dreaded Stop-the-world-pause. Developers are must be very conscious of their code, how they organize their object models in order to limit the overhead, which every object has on the heap.  (See Attila Szegedi from Twitters presentation

Azul Systems has some of the brightest minds in systems design, memory management and garbage collection and have built a business to solve this specific problem. Currently the most widely used Garbage Collector (GC) is the Concurrent Mark Sweep (CMS) collector in the HotSpot JVM. CMS is classified as a Monolithic Stop-the-World collector, which must provide a full-lock to catch up with mutations (i.e. changes started during GC) and compaction.

The C4 collector from Zing has recently been upgraded to version 5, which no longer requires a hypervisor for its page-flipping techniques and instead has boiled down the necessary Linux kernel changes to a kernel loadable module (trying to be pushed into upstream kernel through Managed Runtime Initiative). This frees up wasted memory and removes the overhead of a hypervisor while still providing pause-less GC for applications. Zing has many more benefits, which can be investigated offline. See Gil’s presentation here:

The JAVA ecosystem is thriving, both the improvements in the runtime and the language are becoming better at dealing with concurrency, expressiveness and performance. Despite the fact that the current incarnation of Objects has not lived up to their promise (see below), developers seem to always find away around that continuing the evolution of this platform.


For several years now the developer community has been entrenched in debate over Object Oriented Programming (OOP) vs. Functional Programming, but more specifically over the implementation of OOP methodology in Object Oriented Languages (OOL) such as JAVA.  In part, code reuse, componentization and frameworks have not lived up to their promises. Readability has for the most part been sacrificed, as encapsulation and inheritance have been somewhat abused thanks to the creativity of developers and high-pressure timelines. QCON’s “Objects on Trial” was an interesting debate over the use of Objects. Sorry to say the jury voted “guilty”. Regardless of the verdict Poly Paradigm Computing (i.e. mix of object oriented, procedural, functional, etc..) will play a big role in application development for the same reason why different languages are better for different purposes. This means that app developers need to transparently work across these styles, picking up on the strengths such as reusable software patterns while minimizing the weaknesses such as concurrency support.

Sidebar: Ruby, Groovy, Scala, Erlang, Javascript, DART

Anyone who says language doesn’t matter when designing a system either doesn’t have a system, which cares about flexibility, performance and agility or simply doesn’t have a large enough problem to care.  All things being equal, developers will gravitate to what they are most familiar with regardless of readability, agility or the complexity it adds. Language development continues to evolve, from adding simple annotations replacing lines of boiler plate code, aspect oriented programming to syntactic sugar which makes the readability of code much better. Languages are the face of the development process, the more expressive and easier to use the faster applications can be created and the easier to maintain and extend.

Over the past several years new languages have taken hold such as Ruby, Groovy, Scala, older languages have been given a second life with growing adoption of Erlang and JavaScript and experimental languages have popped up to challenge the others such as Go and DART.

The need for “Finding the right tool for the job” gives rise to the idea of PloyGlot programming, where many different languages are utilized based on their suit for purpose. Mostly you will find JAVA+ in every shop playing a critical role of the system with a sprinkle of JavaScript for client-side coding, some Erlang for middleware maybe, Python, Groovy, C, C++, PERL, etc.. Typically you have a high-performance core written in a statically linked language like C++ responsible for all of the critically performing code, you have a plugin or module architecture to extend the core and a scripting or higher-level language which provides familiar storage primitives, collections, etc..

Frameworks such as Ruby on Rails have been a blessing to those who could leverage its rich dynamic language and templating tools for building quick web-based applications but cursed when trying to do something at a level of scale beyond the Ruby runtime. (Twitter got burned by this and moved to Scala)

For more complex scenarios such as running distributed gossip protocols with 99.999999% reliability, Erlang might be the right choice at the sacrifice of a more complex coding (See Steve Vinoski’s talk on WebMachine, an HTTP server written in Erlang).

There were a number of conversations throughout the conference regarding the importance of a type system. “A type system associates a type with each computed value[1]“. Basically a type system ensures that the value provided or returned from a function is of the expected type. This has several benefits: It allows for code readers to explicitly see what variable types are being passed around (if they don’t obscure the reference), By providing a static type the compiler can allocate the proper size memory and lastly it allows the compiler to check the validity of the variable before getting a runtime error.

Unfortunately this isn’t a panacea, the type system may get in the way especially when the primitive types are hidden making it very difficult to read the code. More on this when we talk about DART.

One of the most popular languages in software development today is JavaScript. JavaScript has gotten a bad wrap and there are many things to be weary of when it comes to writing good JavaScript. Readers should consult Douglas Crockford books on JavaScript for more information

This tiny little language is a pure Object Oriented Language (everything is an object). It provides for anonymous functions, dynamic typing, and functional reactive programming and has a host of examples from which developers can learn. Oh, and its embedded in every browser running on almost every device you can imagine. Originally JavaScript was designed as a programmatic interface for manipulating the DOM in web browsers but has found its way into server-side implementations through Node.JS and Rhino, which detach the language from the incredibly complex Document Object Model.

Sidebar: JavaScript and Node.JS

The popularity of Node cannot be understated. There is a rich set of new libraries created daily, from LDAP to Riak and all kinds of middleware to solve interesting problems. Node is merely a shim on top of JavaScript and the V8 VM which insulates some of the bad parts of the JavaScript language and confines the developer to a single-threaded model with local scoping, simplifying the design by only allowing sharing state through an IPC barrier similar to the Erlang. Node is exceptional at dealing with network-based applications supporting a variety of services such as HTTP, REST and WebSockets. Node.JS has become one of the most watched projects on GitHub and is gaining in popularity due to its rich but sometimes dangerous base language JavaScript.

As an example, here is how simple it is to create a Web server in Node.

var http = require('http');

http.createServer(function (req,rsp){
rsp.writeHead(200, {‘Content-Type’ : ‘text/plain’});
rsp.end(‘Hello World\n’);
}).listen(8080, “”);
console.log(‘Server running at’);

I will reiterate the mantra of  “having the right tool for the job” and certainly Node, V8 and JavaScript have their place centered on I/O demanding applications. The eventing model and single-threaded model is not for everyone, but it does provide a powerful tool kit and expressive language to be useful for a number of different use-cases.

Structured Web Programming, Intro to DART

While JavaScript is gaining in popularity, primarily because of the dominance of web based applications and the now future success of HTML5, CSS3 thanks to Adobe dumping flash for mobile programming, but JavaScript may not have all the answers which is why Google is investing in DART.

Google may have realized that the divergence between native applications (i.e. ones that have to be coded for iOS and Android) and web based applications, were not going to be solved by JavaScript or the ECMA community the stewards of the specification so Google created DART.

DART is being created by a number of people within Google most notably are Gilad Bracha who gave the keynote and session on DART and Lars Bak lead developer of Google V8 virtual machine.

Gilad has a long history in language development including his work on StrongTalk and co-authored of the Java Language Specification.

DART is being built as a pure object oriented language with familiar syntax such as Classes and Interfaces with a type system that doesn’t interfere with developer productivity. In its current pre-release DART script is compiled into JavaScript to be run on the V8 virtual machine. Eventually there will be a standalone DartVM (maybe part of Chromium), which will allow DART scripts to avoid this code generation step.

New languages take time to be nurtured and accepted into mainstream, but what makes DART so powerful is the rampant change in client-side development and device refreshes which might give it a great leap forward if the OSS community adopts it.

Data Management

In the field of application science (if there was such a thing), data management would be the foundational pillar to writing applications, which are reliable, flexible and engaging. In the post client/server era we are bombarded with new ways of storing, retrieving, protecting and manipulating data. The 451 Group has put together a very comprehensive look at this space, which incorporates the traditional relational database stores, the emerging NoSQL stores and the second incarnation relational stores called NewSQL. Accompanying them is also the growing and important Datagrid and Caching tier.

Lets look a moment at NoSQL since it is the hottest field in data management today.

In 1998 Carlo Strozzi uses the term NoSQL to describe his new relational database system. In 2004 at USENIX OSDI conference, Jeff Dean and Sanjay Ghemawat published their paper “MapReduce: Simplified Data Processing on Large Clusters”. It was the start of the industries changing viewpoint on data persistence and query processing. By 2007, database guru Michael Stonebraker published his paper entitled “The End of an Architectural Era (It’s Time for a Complete Rewrite). In this paper he exposes the issues around relational database models, the SQL language and challenges the industry to build highly engineered systems that will provide a 50X improvement over current products. He does however ignore the impact of commodity scale-out distributed systems. And in 2009, Eric Evans uses the term “NoSQL” in a conference in describing the emerging “non-relational, distributed data stores”.

These systems have grown from bespoke highly guarded proprietary implementations to now general use and commercially backed products such as Hadoop. While the impact of implementations such as Hadoop, Cassandra, HBase, Voldemort, etc. has yet to be fully understood, every player from EMC to Arista Networks have banked on participating in this growing field and “Big Data” has become the new buzzword in the industry.

SQL and Not Only SQL

Many large-scale shops are using and/or experimenting with a multitude of DME’s including traditional databases such as MySQL, PostGres, BerkleyDB and are starting to experiment with NoSQL implementations. MySQL, PostGres and BDB are still very much in active use and are being used in new ways, i.e. MySQL as a graph database and BDB as a Key/Value store.

Sidebar: Facebook and MySQL

Facebook uses MySQL as a graph database. The data model represents the graph by associating each row with either a vertex or an edge. This data model is abstracted into their API so that the application developer’s just deal with data in those terms, there are no indexes or joins in the data layer. In order to deal with disk bottlenecks they use a block device cache on the database servers to improve I/O especially for random reads.

Hadoop, Cassandra, MongoDB, Riak

Each of these systems has benefits and tradeoffs depending on the use-case. Application designers need to understand how their application behaves, how write oriented they are, how read oriented, how dependent on transactions or sensitivity to bandwidth and latency there application is. The reality there is “no one solution to all problems” and there is a lot of experimentation going on out there.

Hadoop has been a very successful project despite its downfalls. The issue I will highlight with Hadoop relates to the memory management and impact of garbage collection discussed a priori.

Instead I would like to focus on Cassandra. Cassandra combines the eventually consistent model of Dynamo with the data model of Google BigTable. It was created by FaceBook and transferred to the Apache Foundation where it continues to thrive with active participation and new customer adoption. At its core Cassandra is a four to five dimensional key-value store with eventual consistency. You can choose to model it as:

  • Keyspace − > Column Family − > Row − > Column − > Value
  • Keyspace − > Super Column Family − > Row − > Super Column − > Column − > Value

Cassandra provides a number of benefits including its flexible schema, multi-datacenter awareness, its ability to retrieve ordered ranges and high performance distributed writes. Several years ago sites like Twitter were discussing Cassandra it appears that there is plenty of adoption including a major push by NetFlix. See Sid Anand presentation from NetFlix here

Sidebar: Netflix

Most people know that NetFlix discontinued building in datacenters instead chose to adopt full production support on Amazon EC2. Through their partnership, NetFlix has been instrumental in shaping Amazon services and improving their design to support high performance multi-tenant infrastructure services. There is however a downside. Given the high I/O demand for some of NetFlix processes (i..e video codecs) they have to very diligent about understanding the performance envelope of their system. Because Amazon is allowed to choose where VM reside, there is a statistically significant chance that two high-demand users will wind up on the same physical gear. This has lead some to do a burn-in process to indirectly determine if there is another high-demand customer sharing the system, which could cause instability, or breach service levels. See Adrian Cockcroft presentation for more information on NetFlix and Amazon

Sidebar: A note on Riak

Riak is a distributed Key/Value store somewhat based on Amazon Dynamo. Just as Cassandra, Dynamo uses an eventual consistency model but one which allows the developer to make more discreet choices in the consistency/availably tradeoff i.e. you can choose to accept writes even under partitioning events where you may not have quorum [AP], or you can enforce consistency by making quorum mandatory [CP]). Riak handles complex processes such as, Vector clocks, Merkle trees, consistent hashing, read repair, hinted handoff, gossiping, etc., these infrastructure services are highly complex and are hidden from the application developer through a flexible API.

Riak is written in Erlang, which provides a highly reliable system for building distributed services. Erlang is designed to be highly robust in the face of failure and leverages a number of techniques to maintain reliability. But there is a price for writing in Erlang’s functional event driven style. It is either loved or hated, but the functional model and actor patterns that it embraces has also become a reference point for how new languages (see DART Isolates). Riak’s presentation can be read here:

NewSql, A blast from the past

So what in the world is NewSQL? NewSQL is the second incarnation of relational datastores, which may have more in common with the original use of the term NoSQL by Strozzi. Essentially these database engines provide the same DB semantics such as indexes, foreign keys, stored procedures and are geared towards OLTP workloads that require ACID based consistency. They borrow from a number of techniques found in NoSQL datastores such as sharding and reconciliation but are designed to be compatible with traditional DDL and SQL based language constructs. NewSQL implementations such as VoltDB and Drizzle and will play an increasing role as these types of datastores will continue to live on.  See Ryan Betts presentation here:

Reliability at Scale

Complex systems can trigger bottlenecks and exhibit near linear falloff as side effects dominate interactions. . Facebook’s Robert Johnson gave a great talk on how they use their fail-fast development process to reduce failures at scale. See Roberts presentation here: .

FaceBook has a unique position on dealing with scale with over 800M subscribers they process more requests in an hour than most Fortune 500 do in a month. For FaceBook scalability is intrinsically linked to reliability (i.e. dealing with failures). “The goal isn’t to avoid mistakes, it’s to make the costs of mistakes low”. With an aggressive approach to moving things fast, they reduce the convergence time for failure allowing them to be more consistent (sort of a high-pass filter).  By making frequent small changes, they reduce the surface area allowing them to quickly skirt around problems without having a large impact. They have honed this methodology to a craft allowing them to not only fail-fast but also encourage developers to try new things. Their goal is to run a new experiment every day, which allows them to continue to make the site engaging.

Measurement and Monitoring

Critical to all well run services is the proper use of instrumentation and monitoring. In the Internet and more specifically with Cloud, it is even more important as systems typically consist of hundreds if not thousands of independent services tied together to deliver a user facing service.  A theme emerged throughout most of the talks which center around application architectures, which was to instrument the heck out of everything. printf like logging (where the developer inserts log statements into the codebase), GC logging, application logs (i.e. webserver) are all part of a necessity to traceback the system at the time of the failure. In these systems coordinated failures (failures which coincide across many services) become more prominent and latency issues can be hidden in the inter-service calls requiring a mass amount of information. Some have hundreds of machines dedicated to instrumentation, logging and monitoring.

Sidebar: Disaster Porn and Joyent

One of the most interesting talks was by Bryan Cantrill from Joyent. Bryan is one of the original developers of DTrace at Sun Microsystems and now runs one of the largest competitors to Amazon EC2. DTrace is an expressive debugging tool built in Solaris it is also incorporated in the Open Source version of Solaris called Illumos and is a core component in MacOS. DTrace allows you to do some very sophisticated things including filtering the call stack running across every core and embedding references in dynamic languages such as JavaScript to reconcile address pointers to libraries and even to source code. Bryan demonstrated some wizardry of analyzing a core dump of a crashed Node.js application, which was simply unbelievable. It means that the pains of troubleshooting stack traces of managed languages such as Python, Ruby and JavaScript are within reach (as long as you use Illumos). See Bryan’s presentation here:

The Simian Army

So how do you deal with a business that is tied together with hundreds if not thousands of services? Each having some combinatorial effect on the other but distributed which makes understanding what is happening at any point in time almost impossible? Call in the monkeys!!

Chaos Monkey

 “The Chaos Monkey’s job is to randomly kill instances and services within our architecture. If we aren’t constantly testing our ability to succeed despite failure, then it isn’t likely to work when it matters most – in the event of an unexpected outage.”[2]

What started as a methodology to literally create chaos or the worst-case situation for operations has turned into a methodology for coping with the unknown? Keeping customers happy requires a range of understanding complex interactions from the impact of a simple server failure to more exotic memory corruption errors and race conditions.

As noted earlier, modern applications are designed to be both modularized and resilient in the face of catastrophe. In a similar vane to the way packet networks were designed to continue operation on the loss of a packet, modern application services are isolated from one another so as to avoid a mass cascaded failure which would impact the entire service. In a technique similar to the way security researches Fuzz applications in search of memory corruption vulnerabilities, the Simian Army is put to work to challenge the best developers to keep their systems running in the face of utter chaos.

Latency Monkey

Hard failures are one thing but soft failures such as service degradation are harder to spot before users start to feel something is wrong. These monkeys inject random delays in client-side and server-side processing to test the ability for applications to detect and recover in a graceful way. These tests might expose more complex issues such as thundering herd and timeouts.

The Role of the Network

 The network is a critical component especially as designers gravitate towards distributed services. Whether or not you are dealing with two-phase commit or quorum based consistency models the network plays a major role in application design. Application architects must make clear tradeoffs when it comes to consistency and availability under network partitioning events and must pay clear attention to how the network flow and error control are impacting the application.

During Facebook’s presentation they were clear to post the slide to the right to the community when talking about dealing with scalability.

Incast[3][4] is a well-documented phenomenon but solutions vary from engineering larger buffers to high-resolution TCP timers. The impact for applications with coordinated “synchronization” is a complete falloff in network throughput for 100s of milliseconds. There is also another phenomenon called “port blackout” or “outcast”[5] where switches with tail-drop queues exhibit unfairness due to RTT bias. The effect is that short-flows with small RTT can be starved by longer-flows with larger RTT. Given the sacrifices that have to be made under these conditions and others. Application developers struggle with dealing with prioritizing communications. For critical writes the network must have capacity to commit in a consistent way, non crucial services such as bookkeeping writes should be relegated to a best-effort service. Today application architects solve these problems a number of ways, from moving to UDP and building error and flow control in the application layer to providing rate limiters within the application API itself.

Network designers try and solve the problems with larger buffers (which can cause instabilities itself because the error control channel is caught up in data transfer PDUs), leverage active queue management such as RED (although algorithmically flawed) and even stochastic based drop queues (i.e. random instead of tail-drop).


Application development continues to go threw a massive amount of change. We have not discusses some of the practices around Agile, Lean software development, technical debt and all of the work going into the client-side such as HTML5 and CSS. We are seeing an increasing role in dealing with infrastructures at scale and redefining the proper models and patterns for continuously reengineering to grow the business. We all know that Moore’s Law does not track the improvements in performance and our view of time shared systems doesn’t reflect the combinatorial effects if O(N^2) application interactions. Hypervisor based clouds are also becoming problematic for some. A great talk by Erik Onnen from Urban Airship talked about the difficulties in maintaining their business on EC2 including:

  • Erratic network latency
  • Strange network behavior
  • Kernel hypervisor issue
  • Undocumented limitations
  • Database scaling

This should not be a big surprised, after all Hypervisor based systems are based on multi-tiered time sharing which can be highly volatile especially for data intensive applications. Erik’s presentation can be seen here:

As application developers learn to improve their use of memory, and are given better interfaces to manage communications and quality of service it may be possible to solve some of these challenges. Certainly there is no turning back, these problems need to be fully understood and plans need to be in place so businesses can continue to use the Internet to grow their businesses, put people to work to strengthen world economies and allow innovation to transcend individual expectations to make a better world for tomorrow.


Forrester Views Cloud/Web is Outmoded and App-Internet is the new model

LeWeb 2011 George Colony, Forrester Research “Three Social Thunderstorms”

Over the past several years the word ‘Cloud’ has been used and to some extent abused  almost to the point of being superfluous. Every technology company, provider and enterprise is immersed in some sort of “cloud” project although the exact descriptions of these projects may fall short of the NIST formal definitions.  I think as technologists we tend to rebel against the status quo in attempt not just to redefine the marketplace but also to claim for our own a new path as we iterate over the current challenges for delivering new applications and services.

Just as we have overused and bludgeoned the hell out of terms like internet, virtualization and web (the prior name cloud), we are bound to move into a new set of vernacular definitions such as intercloudinterweb, fog computing  or in the case of Forrester CEO George Colony APP-Internet.

“Web and cloud are .. outmoded” concludes Mr. Colony as he goes on to explain the App-Internet as the next model offering a “faster, simpler, more immersive and a better experience”.

The thesis for this conclusion is based on the figure above where the y-axis is defined as “utilities per dollar” and the x-axis is time. P is representative of “Moores Law” and speaks to the scalability of processing power. In reality the beauty behind Moores law is lost in translation. What Moore really said was “transistors on a chip would double every year” and subsequently David House, an Intel executive at the time, noted that the changes would cause computer performance to double every 18 months [1].

If you plot transistors per chip against actual computer performance you might see a different picture due to the thermodynamic properties and manufacturing complexity of CMOS based technology not to mention the complexity in actually utilizing that hardware with todays languages, application methodologies, libraries and compilers.

S is for the growth in storage which Colony calls the “Hitachi’s Law”. This predicts that storage will double approximately every 12 months. This also is somewhat contrived as the limits of scaling magnetic medium on disk are becoming extremely difficult as we approach the limits of perpendicular recording although maybe there is some promise with the discovery of adding NaCl to the recoding process[2]. Yes we can build bigger houses with disks packed to the ceiling, but the logistics in managing such a facility is increasingly hitting the upper limits. (imagine shuffling through a facility over 100,000sqft and replacing all those failed hard drives)

N is related to the network where Colony goes on to describe the adoption rates of 3G vs 4G. First and foremost nailing down exactly what 4G is and means is an exercise in itself, as most vendors are implementing various technologies under this umbrella[3]. With an estimated 655Million people adopting 4G in its various forms by 2010[4] and the quick adoption of new mobile devices, I think this is a bit short sighted..

But there is another aspect to this which is missing which is all of the towers that collect those 3G and 4G signals need to be back-hauled into the Internet backbone. With 40GE/100GE ratified in the IEEE, I suspect the first wave of 100GE deployments to be put into production in 2012 [5]

Colony goes on to say “If your architecture was based on network you are wasting all of these improvements in processing and storage.. the center (meaning the warehouse scale datacenters such as Google, Amazon and Microsoft) is becoming more powerful and the periphery is becoming ever more powerful…

His point is valid to an extent but not because of the P, S, N curves but because now that the devices are so powerful AND we have such a robust network infrastructure we can take advantage of all of this processing power and storage available to us. Afterall if transport pricing had continue to rise as the late great Jim Gray predicted in his paper on Distributed Computing Economics [7] we would not even be having this discussion because without the distribution of data capability in the network, all we would have were some very smart expensive devices that would essentially be a fancy calculator.

To that point Colony compares todays devices with their predecessors but as stated earlier its not a fair comparison. “In 1993 the iPad 2 would have been considered one of the 30 fastest computers in the world”. Unfortunately the problem space has changed from 1993 and if we follow Parkinsons Corollary called “Jevons Paradox” or the proposition that technological progress that increases the efficiency with which a resource is used, tends to increase (rather than decrease) the rate of consumption of that resource[6] it would be hard to compare these two accurately.

So the reality is that all of these iterations, from the early ARPANET viewpoint of access to expensive time-sharing computer centers to the highly distributed and interconnected services we have today are just a succession of changes necessary to keep up with the demand for more information. Who knows what interesting changes will happen in the future but time and time again we have seen amazing strides taken to build communities and share our lives through technology.

 So lets take a closer look at the App-Internet model.

Hmm. So how is this different from todays “Web-Centric” application architecture? After all isn’t a web browser like Chrome and Safari an “application”?.

Jim Gray defined the ideal mobile task to be stateless (no database or data access), has a tiny network input and output and has a huge computational demand[7]. To be clear, his assumptions of course were that transport pricing would be rising to make the economics infeasible, but as we know the opposite effect happened as transport pricing has fallen


“Most web and data processing applications are network or state intensive and are not economically viable as mobile applications” Again the assumptions he had about telecom pricing made this prediction incorrect. He also contended that “Data loading and data scanning are cpu-intensive; but they are also data intensive and therefore are not economically viable as mobile applications. The root of is conjecture was that “the break-even point is 10,000 instructions per byte of network traffic or about a minute of computation per MB of network traffic”.

Clearly the economics and computing power has changed significantly in only a few short years. No wonder we see such paradigm shifts and restructuring of architectures and philosophies.

The fundamental characteristic which supports a “better experience” is defined as latency. We perceive latency as the responsiveness of an application to our interactions. So is he talking about the ability to process more information on intelligent edge devices? Does he not realize that a good portion of applications written for web are built with JavaScript, and that the advances in Virtual Machine technology like Google V8 is what enables all of that highly immersive and fast responding interactions? Even data loading and data scanning has improved through advances in AJAX programming and the emerging WebSockets protocol allowing for full duplex communications between the browser and the server in a common serialization format such as JSON.

There will always be a tradeoff however especially as the data we consume is not our own but other peoples. For instance, the beloved photo app in Facebook would never be possible utilizing an edge centric approach as the data actually being consumed is from someone else. There is no way to store n^2 information with all your friends from an edge device it must be centralized to an extent.

For some applications like gaming we have a high-sensitivity to latency as the interactions are very time-dependent both for the actions necessary to play the game but also how we take input for those actions through visual queues in the game itself. But if we look at examples such as OnLive which allows for lightweight endpoints to be used in highly immersive first-person gaming, clearly there is a huge dependency on the network. This is also the prescriptive approach behind Silk, although Colony talks about this in his context of App-Internet. The reality is that the Silk browser is merely a renderer. All of the heavy lifting is done on the Amazon servers and delivered over a lightweight communications framework called SPDY.

Apple has clearly dominated pushing all focus today on mobile device development. The App-Internet model is nothing more than the realization that “Applications” must be in the context of the model something which the prior “cloud” and “web” didn’t clearly articulate.

The Flash wars are over.. or are they?

 So what is the point of all of this App-Internet anyway? Well, the adoption of HTML5, CSS3, JavaScript and advanced libraries, code generations, etc.. have clearly unified web development and propelled the interface into a close to native environment. There are however some inconsistencies in the model which allows Apple to stay just one-step ahead with the look and feel of native applications. The reality is we have already been in this App-Internet model for sometime now, ever since the first XHR (XMLHttpRequest) was embedded in a page with access to a high performance JavaScript engine like V8.

So don’t be fooled, without the network we would have no ability to distribute work and handle the massive amount of data being created and shared around the world. Locality is important until its not.. at least until someone build a quantum computer network.

over and out…

  8. (Note: This is more representative as a trend rather than wholly accurate assessment of pricing)

Emmergence of DataGrids to solve scaling problems

There is a great post at BigDataMatters discussing the emergence of Open Source Data Grids and the introduction of Infinispan 4.0.0 Beta 1.

The Infinispan site defines data grids as:

Data grids are highly concurrent distributed data structures. They typically allow you to address a large amount of memory and store data in a way that it is quick to access. They also tend to feature low latency retrieval, and maintain adequate copies across a network to provide resilience to server failure.

In the article Chris Wilk explains some of the challenges in data grid technologies around dynamic routing.

The reason that GigaSpaces suffers from this limitation is that it has a fixed space routing table at deployment time. The above scenario was described to Manik who said that Infinispan does not suffer from this restriction as it uses dynamic routing tables. Infinispan allows you to add any number of machines without incurring any down-time.

The spreading of data across many hosts is accomplished using different techniques but the point to take here is that altering the partition routing logic in mid-stream is very destructive to supporting distributed transactions. There are also many system level aspects which create inconsistencies including garbage collection and network overhead which could jeapordize the movement of dynamic objects between partitions.

Increasing the capacity of a data-grid to provide deterministic performance , robustness and consistency should be done by running a fixed amount of partitions and “moving” partition from one JVM to another newly started JVM. With GigaSpaces you can have 10 , 50 or 200 partitions used when starting the data-grid and have these running within a small amount of JVMs, later you can increase the amount when needed (manually or dynamically). You can re-balance the system and spread the partitions across all the existing JVMs. It is up to you to determine how far you want to scale the system which means you have total control on system behavior.

The routing mechanism with GigaSpaces will function without any problems and spread data across all  partitions as long as you have more unique keys than the amount of partitions. This should not be a problem with 99.99% of the cases.

The comparison ignores many other GigaSpaces features such as Mule integration , Event handling and data processing high-level building blocks , Web container and dynamic HTTP configuration , Service management , system management tools , performance (especially for single object operations , batch operations and local cache) , text search integration , massive amount of client support , large data support (up to several Tera data ) , large object support , Map-Reduce API , Scripting languages support (Java, .NET, C, Scala , Groovy…) , Cloud API support , schema evolution , etc….

Having new players is great and verifies that there is room for new vendors in this huge market for In-Memory-Data-Grid technologies on the cloud (private/public) – But it is important also to do the right comparison.

See more here:

What Should Be VMWares Next Move

I wanted to point out an interesting article posted here on

Here is an excerpt,

“The most glaring omission [in VMware’s portfolio] is [the] need for Java object distributed caching to provide yet another alternative to scalability,” Ovum analyst Tony Baer said in a post to his personal blog on Tuesday. “If you only rely on spinning out more [virtual machines], you get a highly rigid, one-dimensional cloud that will not provide the economies of scale and flexibility that clouds are supposed to provide. So we wouldn’t be surprised if GigaSpaces or Terracotta might be next in VMware’s acquisition plans.”

Now I couldn’t be more happy that someone besides myself recognizes that in order for services to be uncoupled from the persistence layer you must have a distributed caching system. There are several players not all created equal but all with value in this field. They include  Gigaspaces, Terracotta, Oracle (Tangasol) Coherence and Gemstone.

Distributed caching is nothing new and most of the large internet companies like FaceBook, Twitter etc are utilzing open source tools like memcache to get a very rudimentry distributed cache.

Gartner analyst Massimo Pezini is right on with his comment “I think one of the reasons why VMware is buying SpringSource is to be able to move up the food chain and sell cloud-enabled application infrastructure on top of their virtualization infrastructure,” Pezzini said. “It wouldn’t take much to make it possible to deploy Spring on top of the bare VMware — i.e., with no Linux or Windows in the middle

If VMWARE changes focus onto the JAVA stack they can be well on their way to building a complete service virtualization platform.

The JAVA platform has an opportunity to sit on the bare metal and provide a ubiquitous abstraction layer between the infrastructure and the application stack. If we look at Oracle JRocket, IBM Libra and Sun Maxine there is already much research in a baremetal JVM. Sun has also been working on a pure JAVA OS called Guest VM which eliminates Windows and Linux from the guest altogether and is wriiten in pure JAVA.

The realization that instance scaling (Virtual Machine Proliferation) which requires moving the complete server state from machine to machine is a very difficult and a dirty process. If we have abstracted the underlying operating system as a pure JAVA runtime we can migrate our JAVA applications very simply in fact it is the main usecase I demonstrated in my multi-part series which utiizes Gigaspaces as an In-Memory Data Grid.

Part 2: Using Groovy, Grails and Gigaspaces “3G”

Part 2: Utilize a dynamic language, one that really anyone can learn.

I chose to use Groovy and Grails for this project.. why?

Because of Groovys natural support for the JAVA language anyone with a background in the language can be productive. In fact since Groovy is a dynamic language which means it supports first class functions, closures, etc… It saves a lot of the developers time. Groovy is not a statically typed language which means you don’t have to declare the “storage” type before you use the variable.. You can actually recast a variable depending on the problem you are working on making the langage very fluid. Groovy supports about 98% (i think) of native JAVA

Groovy benefits (

  • Is an agile and dynamic language for the Java Virtual Machine
  • Builds upon the strengths of Java but has additional power features inspired by languages like Python, Ruby and Smalltalk
  • Makes modern programming features available to Java developers with almost-zero learning curve
  • Supports Domain-Specific Languages and other compact syntax so your code becomes easy to read and maintain
  • Makes writing shell and build scripts easy with its powerful processing primitives, OO abilities and an Ant DSL
  • Increases developer productivity by reducing scaffolding code when developing web, GUI, database or console applications
  • Simplifies testing by supporting unit testing and mocking out-of-the-box
  • Seamlessly integrates with all existing Java objects and libraries
  • Compiles straight to Java bytecode so you can use it anywhere you can use Java

Grails ( is an advanced and innovative open source web application platform that delivers new levels of developer productivity by applying principles like Convention over Configuration. Grails helps development teams embrace agile methodologies, deliver quality applications in reduced amounts of time, and focus on what really matters: creating high quality, easy to use applications that delight users.

Grails is built around SpringMVC. Groovy and GraIls behave like another web framework and dynamic language called Ruby on Rails…
Continue reading Part 2: Using Groovy, Grails and Gigaspaces “3G”

Gigaspaces powered Service Virtualization and the Cloud Part 1:

So i promised my pal Shay Hassidim over at Gigaspaces when I had time I would post the use case I demonstrated to some Cisco folks on the power of “Service Virtualization”.

To start off, “Service Virtualization” is nothing new.. Its merely another abstraction level on top of the ones that have existed in many forms throughout the decades of modern computing. You can look deep down in the edges of the Linux C-Library where there is a low level API called SYSCALL. This  interface  provides practically the lowest level of interaction from the OS to the CPU and provides the foundation for new services to be built on top..

So why should I care about this? Well as is written in the article The Free Lunch is Over: A Fundamental Turn towards Concurrency in Software. Single threaded applications will gain little improvement over the next decade as clock rates are stalled to reduce power. These applications eventually may get slower as we pack hundreds even thousands of cores on a socket. Scale-Out and utilizing proper concurrency methods allow us to break the problem into many smaller chunks and put thousands of little workers to attack the problem.

With the thermodynamic barriers in chip design driving us wide instead of tall (horizontal instead of vertical, scale-out instead of scale-up..) Okay enough analogies…,

New architectural patterns are emerging including space based architectures and event driven architectures to address the developers obstacles, a lot of the work is rooted in a more simplistic look at the application stack built on top of the well understood JVM or CLR.

The new resurgence of functional languages like Erlang, Clojure are getting more interest as well as new languages like Ruby, Groovy and Scala.

The feature rich and pithy implementation of the language offering things like no need for semicolons or parens. In a lot of cases this reduces the noise and allows the code to be read more like plain English.

This more “readable” code allows the developers to communicate with the domain experts in an easier way. Speeding up the dev/test cycle to get “good enough” code out the door for consumption.

In essence the business interface gathers around a new DSL (Domain Specific Language) which is written in the semantic language of the business. Inter-dimensional relationships are easily described through method libraries.

So what was the demo about?

This entire demo was used to show how you could build a working JEE (like) application, instaniate it over a grid which is provided by an L3 encrypted overlay and allow the application to migrate around the cloud, in and out at will. My thesis is that you can create a movable matrix of hosts around a graph of cloud resources regardless of the source… We don’t take into case any global load balancing scenarios, that’s a problem for another day.

So how do we do that…

My demonstraton had several parts:

Part 1: Figure out how to configure systems in a stateless Amazon EC2 world…

Part 2: Utilize a dynamic language, one that really anyone can learn the semantics to and be productive as a programmer with the correct style guide and well documented API..

Part 3: Connect multiple hosts across autonomous cloud entities utilizing a SSL VPN overlay network. This provides the illusion of being on the same L2 network… Oh and it has to support multicast forwarding so I can have dynamic service discovery…

Part 4: Establish the VPN, Key assignment using CohesiveFT VPNCubed and OpenVPN

Part 5: Batch the images on Elastic Server.. threw some at Seattle some at Dublin other was me in NY.

Part 6: Customer writes into the application and the data is instanty synchronized across the world

Continue reading Gigaspaces powered Service Virtualization and the Cloud Part 1: