utaal

webserver: webserver.c libuv/uv.a http-parser/http_parser.o
	gcc -I libuv/include \
    -lrt -lm -lpthread -o \
    webserver webserver.c \
    libuv/uv.a http-parser/http_parser.o

libuv/uv.a:
	$(MAKE) -C libuv

http-parser/http_parser.o:

stonegao

class Respond extends Service[Request, Response] with Logger {
  def apply(request: Request) = {
    try {
      request.method -> Path(request.path) match {
        case GET -> Root / "todos" => Future.value {
          val data = Todos.allAsJson
          debug("data: %s" format data)
          Responses.json(data, acceptsGzip(request))
        }
        case GET -> Root / "todos" / id => Future.value {

aloiscochard

import Stream._

  /** A possibly finite stream that repeatedly applies a given function to a start value.
   *
   *  @param start the start value of the stream
   *  @param f     the function that's repeatedly applied
   *  @return      the stream returning the possibly finite sequence of values `start, f(start), f(f(start)), ...`
   */

  def iterate[A](f: A => A, a: A): Stream[A] = unfold((x: A) => Some((x, f(x))), a)

gseitz

scala> val pair = for {
     | _ <- token(char('{'))
     | id <- token(ident)
     | _ <- token(char(':'))
     | v <- integer
     | _ <- token(char('}'))
     | } yield id -> v
obj: scalaz.parse.huttonmeijer.Parser[(List[Char], Int)] = scalaz.parse.huttonmeijer.Parser$$anon$2@234e7730

scala> pair("{ foo : 17 }".toList)

stonegao

import com.twitter.finagle.http.path._
import com.twitter.finagle.http.service.RoutingService
import com.twitter.finagle.http.{Request, Response, RichHttp, Http}
import com.twitter.finagle.{Service, SimpleFilter}
import org.jboss.netty.handler.codec.http._
import org.jboss.netty.handler.codec.http.HttpResponseStatus._
import org.jboss.netty.handler.codec.http.HttpVersion.HTTP_1_1
import org.jboss.netty.buffer.ChannelBuffers.copiedBuffer
import org.jboss.netty.util.CharsetUtil.UTF_8
import com.twitter.util.Future

imeredith

  implicit val PromiseInstance = new Monad[Promise] {
    def point[A](a: => A) = Promise.pure(a)
    def bind[A, B](fa: Promise[A])(f: A => Promise[B]) = fa.flatMap(f)
  }

tonymorris

sealed trait KeyValueStore[+A] {
  def map[B](f: A => B): KeyValueStore[B] =
    this match {
      case Put(k, v, q) => Put(k, v, f compose q)
      case Get(k, q) => Get(k, f compose q)
      case Del(k, q) => Del(k, f compose q) 
    }
}
case class Put[A](k: String, v: String, q: Option[String] => A) extends KeyValueStore[A]
case class Get[A](k: String, q: Option[String] => A) extends KeyValueStore[A]

savonarola

#!/usr/bin/env ruby
#
# Proof-of-Concept exploit for Rails Remote Code Execution (CVE-2013-0156)
#
# ## Advisory
#
#   https://groups.google.com/forum/#!topic/rubyonrails-security/61bkgvnSGTQ/discussion
#
# ## Caveats
#

tonymorris

object PdxleifMonoid {
  trait Monoid[A] {
    def op(a1: A, a2: A): A
    def id: A
  }

  def XorMonoid[A]: Monoid[Option[A]] =
    new Monoid[Option[A]] {
      def op(a1: Option[A], a2: Option[A]) =
        (a1, a2) match {

aloiscochard

#!/usr/bin/env bash

############
# QuickSBT #
############

# Launch SBT with support for generating /tmp/sbt.quickfix file for Vim
# http://github.com/aloiscochard / https://gist.github.com/4698501

# Error format for SBT, and shortcut to open SBT quickfix file :