obji

obji is an implementation of CORBA made in Haskell. It's primary goal is to allow writing CORBA style microservices in Haskell.

The supported languages are:

• Haskell
• C
• Clojure
• Javascript (nodejs)

Current status

Started development. Things done:

• A Haskell client - Haskell implementation spike.
• Add a state to the Haskell implementation spike.
• C client calling the above Haskell implementation.
• Instructions on how to compile C code and link it with Haskell code.

Goals

obji allows creation of software components organized as objects interacting with each other, in the spirit of CORBA. The goals that are followed during obji creation are:

• small and fast implementation
• easy to install and use
• be a good alternative to Apache Thrift
• support Haskell language to develop CORBA microservices
• create a small core that allows objects written in diverse languages to share the same address space
• CORBA interoperability support through bridges external to the core
• efficient support of CORBA bridges
• implement bridges to support IIOP, ZIOP and IIOP over SSL
• provide language mappings for Haskell, Clojure and Javascript
• implement standard mapping for C
• CORBA 3.3 core compliance
• CORBA 3.3 interoperability compliance

Support for other languages

The primary language supported by this ORB is Haskell.

However, the idea behind creating obji was to support Haskell in creation of microservices. And one of the main benefits of microservices architecture is the possibility to use different languages in the development of the services.

Supporting only Haskell would still allow using other languages in the development of a microservices based system, through the use of other interoperable ORB's available for those languages.

It will be actually easier, maybe, to use ORB's that were developed specifically for that language, especially when you think about ORB installation and getting started with that ORB. For example, one could use Java specific build system like Maven or Gradle to resolve dependencies and install the given ORB, making the installation of the ORB a simple dependency declaration. You, also, would not need other build tools installed, except the ones you already use for your Java project.

But, if your main developing language is Haskell and you already have figgured it out the installation and getting started with Haskell and obji, then, maybe, it will be easier to just use obji for the other languages as well, instead of the specific ORB for that language.

So, for installing obji, you will only need stack or Haskell platform, use stack install obji or cabal install obji and use the specific dependency management for your language to install the language dependent libraries.

Support for Haskell

• calls between the objects in the same ORB should be with as little overhead as possible
• the installation of the ORB should be made by just declaring dependency to obji in your Cabal file
• there should be need it no other tools to build obji except Haskell build system it self (cabal or stack)

Planned features

The planned features are features planned to be added later on, but they are not immediate project goals.

• Apache Thrift interoperability bridge - allows calling Apache Thrift services and exposing obji objects as Apache Thrift services (allowing Apache Thrift clients to call services implemented by obji objects).
• REST interoperability bridge - allows calling REST services from obji objects and REST clients to call services implemented by obji objects.
• Python support
• TCL support
• Ruby support
• Go support

Next steps

What is the plan right now? What we need to do next?

• Create some spikes to figure out how the basic obji core system should be:

  • a spike of a Haskell client calling a Haskell implementation;
  • a spike of a C client calling a C implementation;
  • a spike of a C client calling a Haskell implementation;
  • a spike of a Haskell client calling a C implementation;
  • a spike of a Clojure client calling a Haskell implementation;
  • a spike of a Haskell client calling a Clojure implemetation;
  • a spike of a Clojure client calling a Clojure implementation;
  • a spike of a JS client calling a Haskell implementation;
  • a spike of a Haskell client calling a JS implementation;
  • a spike of a JS client calling a JS implementation;