betandr

object Lists {
  val emptyList = List()
  val otherEmptyList = Nil

  val items = List("foo", "bar", "baz")
  val consStyleItems = "foo" :: "bar" :: "baz" :: Nil // cons prepend to front of Nil list
  val concatStyleItems = List("foo", "bar") ::: List("baz")

  items(2) // returns 'baz'
  items.count(s => s.length == 3) // counts number of items with length of three chars

betandr

object Loops {

  val items = Array("Hello", ", ", "World!")
  val moreitems = Array.apply("Hello", ", ", "World!")

  items.foreach(arg => println(arg))
  items.foreach((arg: String) => println(arg))

  val greetStrings = new Array[String](3)

betandr

object Functional {

  def printItemsImperative(items: Array[String]): Unit = {
    var i = 0

    while (i < items.length) {
      println(items(i))
      i += 1
    }

betandr

Although you may have great version control in place, sometimes stuff gets inadvertently overwritten or messed up…in this case it's always good to do a quick backup before you do anything potentially serious. I've written a little Bash shell hack which I thought might be useful:

In your ~/.bash_profile (or ~/.bashrc if you load that in your .bash_profile) file, add the line:

alias bag='b=$(basename `pwd`);cd ..;tar -cvf  $b"_"$(date +'%Y-%m-%d_%H-%M-%S')".tar.gz" "./"$b"/";cd $b'

...then re-load your bashrc by running 'source ~/.bash_profile' or 'source ~/.bashrc'.

When you're then in your working directory, simply run 'bag' which will create a time-stamped, gzipped tar file in the directory above the one you're in, containing the contents of the directory you're currently in. Such as:

betandr

#!/usr/bin/env ruby

require "tco"
require "rmagick"
require "json"

include Magick

class PickledImage
  attr_accessor :rows

betandr

package bbc

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class RadioHomepageServicesSimulation extends Simulation {

  val httpConf = http
    .baseURL("http://www.bbc.co.uk")

betandr

public class Roulette {
	/* program n_select=1000 times selects one of n=4 elements with weights weight[i].
	 * Selections are summed up in counter[i]. For the weights as given in the example 
	 * below one expects that elements 0,1,2 and 3 will be selected (on average) 
	 * 200, 150, 600 and 50 times, respectively.  In good agreement with exemplary run.
	 */
public static void main(String [] args) {
	int n=4;
	
	double weight[] = new double [n];

betandr

// basic recursion; will not handle large Lists
def sum(nums: List[Int]): Int = ints match { 
  case Nil => 0
  case x :: tail => x + sum(tail)
}

// tail recursion
def sum2(nums: List[Int]): Int = {

betandr

object Imperative {

  def run(x: Int): Int = {
    var n = x

    while(n < 20){
      n = n + 1
    }

    n

betandr

def find(key: String, in: String): scala.util.Try[Int] = {
  scala.util.Try {
    def findValue(items: Array[String]): String = {
      val item = items.head
      if (item.contains(key)) { item.split("=").last }
      else { findValue(items.drop(1)) }
    }
    findValue(in.split(", ")).toInt
  }
}