Quick Start

 $ gem install utter

install the utter ruby gem on your system

 $ utter classic

generate an utter classic-style project

 $ utter package 

package an utter component as a gem

 $ utter deploy 

deploy an utter container component

Philosophy

Components act as a Pure Functions

clear ordering of what is going to happen, very clear dependencies as they are pure functions (A pure function is a function where the return value is only determined by its input values, without observable side effects.), very easy to test, (Pure Functions are good!) When a function performs any other “action”, apart from calculating its return value, the function is impure. It follows that a function which calls an impure function is impure as well. Impurity is contagious. Referential Transparency: Any invocation of an Utter component(pure function) can always be replaced by its result. (write domain extenstion example) There’s no difference between Math.cos(Math::PI) and -1; we can always replace the first with the second. Localized State: A pure function can only access what you pass it, so it’s easy to see its dependencies. We don’t always write functions like this. When a function accesses some other program state, such as an instance or global variable, it is no longer pure.

Everything is a Component

Utter components keeps a low line count as they are context specific thus approachable by new hires mapping to an overall low cost. Utter projects have high availability via modular, partial deployments of individual microservices. Utter perceives a microservice project as a single service, a single domain, and a number of domain-extenstions. The service could have a number of endpoints that are part of the whole system API in production when mounted. The domain is an isolated bounded-context refined at well-balanced scale with respect to the whole system. The objective of this domain isolation is to limit complexity of a solution, via providing the means for the domain-experts to engage in providing the solution. The domain could have a Domain-specific language (DSL) that aids in attaining experts' aid in tackling the domain challenges. Domain-extenstions are the means for incorportating knowledge from domains(supporting, generic) in a packagable manner. Usually your system will be composed out of a number of microservices. Each of those microservices shall contain a service component, a domain component, and a number of domain extenstion components. Utter components are easily testable, with clear dependencies, and easy to understand as they follow a common functional interface structure. Utter components are independently replaceable and independently upgradable. Every component granularity is dictated via the role it acts, in relevance to the context in which it will be represented.

Sample Apps

Utter classic-style is best-suited to individuals for building whole domain-specific microservcies as single distributable gems, check sample.

Utter modular-style is best-suited to small teams for building independent domain-specific microservice components as multiple distributable gems, check sample.

Classic-style
$ gem install utter 
$ utter classic 
	      

 
# Usage
# Inbounds down the stack A -> B -> C, then 
# Outbounds up the stack C -> B -> A
Utter::Stack.new do
 use A
 use B
 use C
end
	      

 $ utter package 

 $ utter deploy 

Modular-style (Still in Experimental Stage)
$ gem install utter 
# Wizards through multiple utter components
$ utter modular 
# Wizards an individual utter component
$ utter container 
$ utter service
$ utter domain

# Your packged microservice can be installed and used
$ gem install mycomapny::v1::transfers
$ mycomapny::v1::transfers up
$ mycomapny::v1::transfers down 
$ mycomapny::v1::transfers status

# Utter extenstions are middlewares that enables interoperability among core domain-knowledge, supporting domain-knoweldge, and generic domain-knowledge components; via providing the means for exchanging knowledge in a standardrized manner. 
$ utter ext

$ utter auth-provider-service
$ utter auth-consumer-ext
	  

 $ utter classic

 $ utter package 

 $ utter deploy 

Open Source

Can we do better? Utter is opensource, meaning if you like to adjust it for the betterment of your experiance, as well as others, you can simply start engaging via reading the source, forking it, or via submitting a feature request\reporting a bug to improve it, all contributions count!

License

MIT license

Community

Join the discussion at #utter on irc.freenode.net

Consulting\Training

hackspree.com

[add your company here]

Credits

Eric Evans - DDD & Microservices: At Last, Some Boundaries!

Mitchell Hashimoto - Rack Middleware as a General Purpose Abstraction

Rich Hickey - Simplicity Matters

Robert Cecil Martin - Architecture the Lost Years