Surinam is a framework for creating 'Hyper-Dynamic Software.' In the world of Surinam, software manifests itself as a loose aggregation of dynamic services. This approach is not all that revolutionary by today's standards, however, Surinam dynamic services and the applications that use them become 'hot-upgradable', allowing for a refreshing level of flexibility. Additionally, Surinam doesn't force you to jump in with both feet, you can begin with simple things and work from there. To that end Surinam is compatible with all existing java frameworks so it will work with what you already have.

This project is a total 'reset' on the concept of software; it challenges our view of the nature of software... how we develop, deploy and support applications throughout its lifecycle. This makes Surinam a mixture of software philosophy, design patterns and a supporting framework that is built on the Java platform. The framework has no appreciable dependencies and plays well with others; therefore it is transparently embeddable in virtually any Java software project. The mantra is that Surinam can go anywhere with anything, while scaling to be as big or as small as you need it to be.

What is Surinam

This project lies in the squarely in the area between highly-decoupled SOAs and localized, statically compiled applications. As such, it introduces a new twist on a somewhat utopian view of software, including the concept of "Hyper-Dynamic Software," based loosely on an SOA model. This view asserts that software should retain the ability to morph and change over time, and in many cases, grow capabilities far beyond its original design... all without stopping the application or sacrificing the formalism that preserves compatibility. Once you change some of the rules about how software is written, deployed and run, you open the door to a cascade of new ideas that is a natural outgrowth of such freedoms. If you delve deeper, you will discover wonders such as Temporal Design disciplines, Service Point Semantics, Blueprints, Service Graphs and Class Versioning.

Something Old, Something New

It should not surprise those of you who have been around software for a while that there is very little that is truly new. People are always running around getting excited about ideas that have been around for a long time, reassured by their own naivety that they have invented something totally new. I make no such claims here as I would rather evangelize that often the best we can do is discover valuable combinations of ideas and concepts that already exist. It is true that Surinam began by trying to throw out most of what we think we know about software in an attempt to start over, the fact that where we ended up is similar to other solutions that currently exist does credit to both them and to us, validating at least some of what Surinam is about.

How can Surinam help my Project?

Surinam could be useful technology if:

  • You want to develop Hyper-Dynamic Software (including runtime Service Graph reshaping)
  • You want to be able to perform runtime upgrades of your software (avoiding rolling upgrades)
  • You want to publish Service Contracts to invite independent implementations
  • You want to simplify the development of dynamic systems through the use of ActionDocuments
  • You are interested in being able to transmit reshaping directives over a network
  • You want to remotely and dynamically alter the software running on node groups on the fly (perhaps to clusters or grids)
  • You want to create software that enjoys a plug-able capability but don't want to write all that code
  • You are familiar with existing meta-data frameworks and want something to extend what you already have.
  • You want to simplify some programming in dynamic systems through ActionDocuments
  • You work with distributed development groups that would benefit from better decoupling and specificity.
  • You outsource
  • Delivering on-demand applications from an unlimited catalog (stored as ActionDocuments); don't change the entire machine in a cloud, just the application
  • You are developing software that modifies its own code (and is self-integrating)
  • You want the agility of ad hoc programming without sacrificing formalism and stability

    I am sure that the list is much longer than this but there certainly is some interesting stuff here. Enjoy.

    - Sam Provencher