Armando Ramirez ramirez7

#SOA Manifesto

In 2002, Jeff Bezos (CEO of Amazon), issued a mandate requiring all teams to expose their data and functionality through services interfaces. Jeff Bezos understood that in order for his company to be successful, he had to switch focus from creating a "perfect product" to creating a perfect platform for that product.

He mandated that:

All teams will henceforth expose their data and functionality through service interfaces
Teams must communicate with each other through these interfaces
There will be no other form of interprocess communication allowed: no direct linking, no direct reads of another team's data store, no shared-memory model, no back-doors whatsoever. The only communication is via service interface calls over the network.
It doesn't matter what [API protocol] technology you use

	module FizzBuzzC

	%default total

	-- Dependently typed FizzBuzz, constructively

	-- A number is fizzy if it is evenly divisible by 3
	data Fizzy : Nat -> Type where
	ZeroFizzy : Fizzy 0
	Fizz : Fizzy n -> Fizzy (3 + n)

	// JVM sizing options
	-server -Xms40g -Xmx40g -XX:MaxDirectMemorySize=4096m -XX:PermSize=256m -XX:MaxPermSize=256m
	// Young generation options
	-XX:NewSize=6g -XX:MaxNewSize=6g -XX:+UseParNewGC -XX:MaxTenuringThreshold=2 -XX:SurvivorRatio=8 -XX:+UnlockDiagnosticVMOptions -XX:ParGCCardsPerStrideChunk=32768
	// Old generation options
	-XX:+UseConcMarkSweepGC -XX:CMSParallelRemarkEnabled -XX:+ParallelRefProcEnabled -XX:+CMSClassUnloadingEnabled -XX:CMSInitiatingOccupancyFraction=80 -XX:+UseCMSInitiatingOccupancyOnly
	// Other options
	-XX:+AlwaysPreTouch -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintTenuringDistribution -XX:+PrintGCApplicationStoppedTime -XX:-OmitStackTraceInFastThrow

	import scalaz.Applicative
	import scalaz.concurrent.Task

	/**
	* This `Applicative[Task]` runs tasks in parallel, by defining
	* `ap` and `apply2` in terms of `mapBoth`. This differs from the
	* default `Applicative[Task]`, where effects are sequenced
	* deterministically, in left to right order.
	*/
	val T = new Applicative[Task] {

	package quantity

	// like Nat, but for integers
	trait Z

	// Pos means positive-or-zero, and Neg means negative-or-zero
	trait Pos extends Z { type P <: Pos }
	trait Neg extends Z { type N <: Neg }

	class Zero extends Pos with Neg { type N = Zero }

	import concurrent.{ExecutionContext, Future => SFuture, Promise}
	import util.Try

	import _root_.scalaz.\/
	import _root_.scalaz.concurrent.{Task => ZTask}


	object Task {

	def fromScala[A]