Piyush Purang ppurang

Tech companies who have migrated to the JVM

NB: Does not include companies that started with a JVM language. The purpose of this gist is to list the companies that decided to move their stack (or some part of it) to the JVM.

Twitter (Ruby -> Scala) - http://www.readwriteweb.com/hack/2011/07/twitter-java-scala.php
Foursquare (PHP -> Scala) - http://www.scala-lang.org/node/5130
Facebook (PHP/C++ -> PHP on JVM) - http://nerds-central.blogspot.com.au/2012/08/facebook-moving-to-jvm.html
Tumblr (PHP -> Scala) - http://highscalability.com/blog/2012/2/13/tumblr-architecture-15-billion-page-views-a-month-and-harder.html
Square (Ruby -> Java/JRuby) - http://www.quora.com/Square-Inc-1/What-is-the-technology-stack-behind-Square

	import language.experimental.{ macros => scalaMacros }
	import reflect.macros.Context

	package object macros {
	def safe[A](expr: A) = macro safeImpl[A]

	def safeImpl[A](c: Context)(expr: c.Expr[A]): c.Expr[A] = {
	import c.universe._

	def isIgnoredStatement(tree: Tree) = tree match {

	trait Semigroup[A] {
	def op(a1: A, a2: A): A
	}

	trait Monoid[A] extends Semigroup[A] {
	def id: A
	}

	object Monoid {
	implicit def ListMonoid[A]: Monoid[List[A]] =

	package foo.bar

	import spray.routing._
	import spray.http._
	import spray.http.StatusCodes.Forbidden


	// See https://developer.mozilla.org/en-US/docs/HTTP/Access_control_CORS

	case class Origin(origin: String) extends HttpHeader {

	// Missing support libraries
	object MissingLibraries {
	case class State[S, +A](run: S => (A, S)) {
	def map[B](f: A => B): State[S, B] =
	State(s => {
	val (a, t) = run(s)
	(f(a), t)
	})

	def flatMap[B](f: A => State[S, B]): State[S, B] =

	case class X[A](a: A)

	object X {
	// succeeds
	def q: X[String] = X("abc")

	// succeeds
	def r: X[Unit] = X("abc")

	// fails

	object SKI_Applicative {
	/*
	First, let's talk about the SK combinator calculus and how it contributes to solving your problem.

	The SK combinator calculus is made of two functions (aka combinators): S and K. It is sometimes called the SKI combinator calculus,
	however, the I combinator can be derived from S and K. The key observation of SK is that it is a turing-complete system and therefore,
	anything that can be expressed as SK is also turing-complete. Here is a demonstration that Scala's type system is turing-complete
	(and therefore, undecidable) for example[1].

	The K combinator is the most trivial of the two. It is sometimes called "const" (as in Haskell). There is also some discussion about

	####################################
	# BASIC REQUIREMENTS
	# http://graphite.wikidot.com/installation
	# http://geek.michaelgrace.org/2011/09/how-to-install-graphite-on-ubuntu/
	# Last tested & updated 10/13/2011
	####################################

	cd
	sudo apt-get update
	sudo apt-get upgrade

	trait Functor[F[_]] {
	def fmap[A, B](f: A => B): F[A] => F[B]
	}

	trait Extend[F[_]] extends Functor[F] {
	// coflatmap
	def extend[A, B](f: F[A] => B): F[A] => F[B]
	}

	trait Comonad[F[_]] extends Extend[F] {