Spiros Tzavellas sptz45

Principles of Adult Behavior

Be patient. No matter what.
Don’t badmouth: Assign responsibility, not blame. Say nothing of another you wouldn’t say to him.
Never assume the motives of others are, to them, less noble than yours are to you.
Expand your sense of the possible.
Don’t trouble yourself with matters you truly cannot change.
Expect no more of anyone than you can deliver yourself.
Tolerate ambiguity.
Laugh at yourself frequently.

Explaining Miles's Magic

Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.

But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.

For starters, here is the sort of thing that SI-2712 affects:

def foo[F[_], A](fa: F[A]): String = fa.toString

These links no longer work. Springer have pulled the free plug.

Graduate texts in mathematics

duplicates = multiple editions

A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen

Hi Nicholas,

I saw you tweet about JSX yesterday. It seemed like the discussion devolved pretty quickly but I wanted to share our experience over the last year. I understand your concerns. I've made similar remarks about JSX. When we started using it Planning Center, I led the charge to write React without it. I don't imagine I'd have much to say that you haven't considered but, if it's helpful, here's a pattern that changed my opinion:

The idea that "React is the V in MVC" is disingenuous. It's a good pitch but, for many of us, it feels like in invitation to repeat our history of coupled views. In practice, React is the V and the C. Dan Abramov describes the division as Smart and Dumb Components. At our office, we call them stateless and container components (view-controllers if we're Flux). The idea is pretty simple: components can't

Git DMZ Flow

I've been asked a few times over the last few months to put together a full write-up of the Git workflow we use at RichRelevance (and at Precog before), since I have referenced it in passing quite a few times in tweets and in person. The workflow is appreciably different from GitFlow and its derivatives, and thus it brings with it a different set of tradeoffs and optimizations. To that end, it would probably be helpful to go over exactly what workflow benefits I find to be beneficial or even necessary.

Two developers working on independent features must never be blocked by each other
- No code freeze! Ever! For any reason!
A developer must be able to base derivative work on another developer's work, without waiting for any third party
Two developers working on inter-dependent features (or even the same feature) must be able to do so without interference from (or interfering with) any other parties
Developers must be able to work on multiple features simultaneously, or at lea

indylambda: Putting invokedynamic to work for Scala

Java 8 introduced lambdas to the Java language. While the design choices differ in many regards from Scala's functions, the underlying mechanics used to represent Java lambdas is flexible enough to be used as a target for the Scala compiler.

Lambdas in Java

Java does not have canonical heirarchy of generic function types (ala scala.FunctionN), but instead allows a lambda to be used as a shorthand for an anonymous implementation of an Functional Interface

Here's an example of creating a predicate that closes over one value:

	import slick.lifted.TupleShape
	import slick.driver.H2Driver.api._
	import scala.concurrent.Await
	import scala.concurrent.duration.DurationInt
	import scala.concurrent.ExecutionContext.Implicits.global

	object Example {

	val db = Database.forConfig("db")


	/**
	* Loosely Based on info gleaned from this article: https://victorops.com/blog/capturing-raw-requests-play/
	* Play really makes this harder than it should be (with some good reasons)
	*/
	trait ParseLoggerTrait {
	val logger: LoggerLike = Logger(this.getClass)

	def log[A](parser: BodyParser[A], maxLength: Int, enableBadRequestLogging: Boolean): BodyParser[A] = BodyParser("LoggingParser") { request =>
	import play.api.libs.iteratee.Execution.Implicits.trampoline

	scala> import scala.reflect.runtime.universe._
	import scala.reflect.runtime.universe._

	scala> showCode(reify {
	\| for{
	\| x <- 1 to 5
	\| _ = print("hi")
	\| } print(x)
	\| }.tree)
	res1: String =

	/** This is in reference to @tploecat's blog http://tpolecat.github.io/2015/04/29/f-bounds.html
	* where he compares F-bounded polymorphism and type classes for implementing "MyType".
	*
	* Curiously, the in my mind obvious solution is missing: Use abstract types.
	*
	* A lot of this material, including an argument against F-bounded for the use-case
	* is discussed in:
	*
	* Kim B. Bruce, Martin Odersky, Philip Wadler:
	* A Statically Safe Alternative to Virtual Types. ECOOP 1998: 523-549