ohac

import javax.crypto.spec.SecretKeySpec
import javax.crypto.Mac

object A {
  def main(args: Array[String]): Unit = {
    val secret = new SecretKeySpec("the_secret".getBytes, "HmacSHA1")
    val mac = Mac.getInstance("HmacSHA1")
    mac.init(secret)
    val result: Array[Byte] = mac.doFinal("foo".getBytes)
    println(result.map(_.toString).mkString(","))

mumoshu

name := "DES and AES encryption in Scala"

version := "1.0"

scalaVersion := "2.9.1"

libraryDependencies += "commons-codec" % "commons-codec" % "1.6"

guillaumebort

# --- !Ups

CREATE TABLE users(
  email                     VARCHAR(255) NOT NULL PRIMARY KEY,
  name                      VARCHAR(255)
);

CREATE TABLE subjects(
  id                        INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY,
  title                     LONGTEXT NOT NULL,

gre

package controllers

import play.api._
import play.api.mvc._

object Application extends Controller {
  
  def zip = Action {
    import play.api.libs.iteratee._
    import java.util.zip._

sadache

Asynchronicity is the price to pay, you better know what you're paying for...

Let's share some vocabulary first:

Thread: The primitive responsible of executing code on the processor, you can give an existing (or a new) Thread some code, and it will execute it. Normally you can have a few hundreds on a JVM, arguments that you can tweak your way out to thousands. Worth noting that multitasking is achieved when using multiple Threads. Multiple Threads can exist for a single processor in which case multitasking happens when this processor switches between threads, called context switching, which will give the impression of things happenning in parallel. An example of a direct, and probably naive, use of a new Thread in Java:

public class MyRunnable implements Runnable {
  public void run(){
 System.out.println("MyRunnable running");

oscarrenalias

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd" updateCheck="false">

    <!-- This is a default configuration for 256Mb of cached data using the JVM's heap, but it must be adjusted
         according to specific requirement and heap sizes -->

    <defaultCache
            maxBytesLocalHeap="256000000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"

alexanderjarvis

package daos

import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import play.api.Play.current
import play.modules.reactivemongo._
import reactivemongo.api._
import reactivemongo.api.indexes._
import reactivemongo.bson._
import reactivemongo.bson.handlers.BSONReader

mariussoutier

package json

import reactivemongo.bson._
import reactivemongo.bson.handlers.DefaultBSONHandlers._

import play.api.libs.json._
import play.api.libs.json.Json._
import play.api.libs.json.util._
import play.api.libs.json.Writes._
import play.api.libs.functional.syntax._

gmodarelli

Dark version

wget --no-check-certificate https://raw.github.com/seebi/dircolors-solarized/master/dircolors.ansi-dark
mv dircolors.ansi-dark .dircolors
eval `dircolors ~/.dircolors`

git clone https://github.com/sigurdga/gnome-terminal-colors-solarized.git
cd gnome-terminal-colors-solarized
./set_dark.sh

codetinkerhack

package com.codetinkerhack

import akka.actor.{ ActorRef, Props, Actor, ActorLogging }
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.duration._
import akka.actor.Actor.Receive
import akka.pattern.pipe
import scala.util.Success
import scala.util.Failure