ornicar

/**
 * Ensure asynchronous functions are run sequentially.
 * This implementation is for Future[Unit],
 * so the work is sent in fire-and-forget style,
 * and we don't care about the function result.
 *
 * Usage:
 * val sequencer = new Sequencer
 * sequencer ! Sequencer.work(updateDatabaseAsynchronously)
 * sequencer ! Sequencer.work(moreUpdate)

dgageot

# Scope
#
class Scope
  constructor: ->
    @$$watchers = []

  $watch: (watcherFn, listener, byValue = false) ->
    @$$watchers.push
      fn: watcherFn
      listener: listener

viktorklang

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import akka.pattern.after
import akka.actor.Scheduler

/**
 * Given an operation that produces a T, returns a Future containing the result of T, unless an exception is thrown,
 * in which case the operation will be retried after _delay_ time, if there are more possible retries, which is configured through
 * the _retries_ parameter. If the operation does not succeed and there is no retries left, the resulting Future will contain the last failure.

ornicar

package models.store.prismicDB

import scala.util.{ Try, Success, Failure }
import scala.concurrent.{ Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global

import akka.actor._

// This actor will perform asynchronous side effects sequentially.
// It ensures two effects are not performed at the same time, without blocking.

fjavieralba

import java.io.IOException;
import java.util.Properties;
import kafka.server.KafkaConfig;
import kafka.server.KafkaServerStartable;
 
 
public class KafkaLocal {
 
	public KafkaServerStartable kafka;
	public ZooKeeperLocal zookeeper;

poc.scala

object CLI {
  def apply(cmd: String): Enumeratee[Array[Byte], Array[Byte]] = ...
}

object Application extends Controller {

  val videoSrc = "http://ftp.nluug.nl/pub/graphics/blender/demo/movies/Sintel.2010.720p.mkv"

  def stream = Action {

tonymorris

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

mandubian

"copy file" in {
  var i = 0
  val fileGenerator = Enumerator.fromCallback( () => 
    if(i<1000){ i+=1; Future.successful(Some((new java.util.Date).getTime.toString + "\n")) } else Future(None) 
  )

  val f = FileChannel("/tmp/testwrite.txt").delete.writing.create
  val f2 = FileChannel("/tmp/testwrite2.txt").delete.writing.create

  fileGenerator                                     // generates data

sadache

Is socket.push(bytes) all you need to program Realtime Web apps?

One of the goals of Play2 architecture is to provide a programming model for what is called Realtime Web Applications.

Realtime Web Applications

Realtime Web Applications are applications that make use of Websockets, Server Sent Events, Comet or other protocols offering/simulating an open socket between the browser and the server for continuous communication. Basically, these applications let users work with information as it is published - without having to periodically ping the service.

There are quite a few web frameworks that target the development of this type of application: but usually the solution is to simply provide an API that allows developers to push/receive messages from/to an open channel, something like:

jonleung

#Don't forget to do a 'chmod +x iterm.sh'
#Also, obviously I don't really know how to use AppleScript so this is really really crappy AppleScript code lol...

osascript <<ENDSCRIPT

	tell application "iTerm"
		activate
	
		--terminate the first session of the first terminal