mbrace is a .NET based software stack which addresses the challenges of developing, deploying, debugging, maintaining and extending applications either running on cloud environments such as Microsoft Azure, Amazon EC2, etc or private data centers. mbrace is based on the F# language and leverages F#’s power by giving it cloud based computational semantics.
mbrace is both a framework, comprised of libraries, tools and patterns, for developing cloud applications and a platform – runtime for deploying, running and managing cloud applications. As a framework, mbrace provides very simple conceptual models and semantics for developing cloud applications while, as a platform, it is capable of executing any kind of computations expressed by using the framework. Essentially, the framework provides a language for developing applications and the platform provides a runtime that executes them, much in the sense of a distributed CLR or JVM.
Programming issues
mbrace abstracts the underlying computer infrastructure and deals with a series of cloud programming issues.
Concurrency
Concurrency is dealt with threads when at a shared memory computer infrastructure. However, threads are error prone (dead locks, race conditions, etc), difficult to debug and have lots of overhead to program. During the years a variety of frameworks have emerged (OpenMP, TPL, etc) in order to facilitate concurrency which feature less code overhead but are still error prone while the automations offered might not scale.
Message passing
Message passing is the leading paradigm when data interchange is needed in a distributed environment. However message passing is not native in programming languages but are offered as APIs. Message passing APIs are usually low-level in nature with minimal abstractions which mix synchronous and asynchronous programming models. They also have lots of overhead to program with and exhibit a certain difficulty in maintenance. Moreover refactoring might affect message passing routines as there might be changes in data structures which, in turn, affect messages passed.
Machine failure
Machine failure affects program execution; nodes might fail in the middle of processing but the program must continue flawlessly. This is also the case with time critical applications that need vast amounts of processing power (eg. fund transfers, ForEx, etc) which of course, must not fail when individual machines fail. In order to achive this a program must constantly monitor its state and have the ability to restart on another node and continue its execution from where it stopped.
Platform heterogeneity
In a data center, machine hardware might not be homogeneous. This means that every machine might have different performance which in turn means that load balancing has to be taken into account while the program is executing.
Code maintenance and versioning
Debugging a program that spans hundreds or thousands of machines is difficult since it is virtually impossible to replicate the state of failure in a local machine. Moreover, parallel programs are concurrent in nature which makes things even worse. On the other hand, a program is like a living organism which evolves over time. New features are needed and hotfixes that solve critical problems might need to be made and the program has to be upgraded without stopping
Why mbrace?
mbrace has a series of virtues which make it very appealing to use.
- Distribution and orchestration has compositional properties (reusable modules)
- Offers a simple, streamlined programming paradigm
- Lightweight and transparent
- Abstracts underlying cloud services
- Built using managed code
- Based on F# concepts and architecture