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

	TaskKey[Unit]("source-dep") <<= (fullClasspath in Runtime) map { (cp) =>
	cp map { dir =>
	val analysis = Defaults.extractAnalysis(dir)._2
	analysis.relations.allSources map { file =>
	println(file.getName.toString + " depends on " + analysis.relations.internalSrcDeps(file))
	}
	}
	()
	}

	/*
	Copyright 2012-2021 Viktor Klang

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software

	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] {

	####################################
	# 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

	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

	case class X[A](a: A)

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

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

	// fails

	// 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] =

	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 {