iomonad iomonad

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

General Background and Overview

Probabilistic Data Structures for Web Analytics and Data Mining : A great overview of the space of probabilistic data structures and how they are used in approximation algorithm implementation.
Models and Issues in Data Stream Systems
Philippe Flajolet’s contribution to streaming algorithms : A presentation by Jérémie Lumbroso that visits some of the hostorical perspectives and how it all began with Flajolet
Approximate Frequency Counts over Data Streams by Gurmeet Singh Manku & Rajeev Motwani : One of the early papers on the subject.
[Methods for Finding Frequent Items in Data Streams](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.187.9800&rep

Common

export OPT=/opt
export BUILDS=/some/where/mini_linux
mkdir -p $BUILDS


	" _ _ "
	" _ /\|\| . . \|\|\ _ "
	" ( } \\|\|D ' ' ' C\|\|/ { % "
	" \| /\__,=_[_] ' . . ' [_]_=,__/\ \|"
	" \|_\_ \|----\| \|----\| _/_\|"
	" \| \|/ \| \| \| \| \\| \|"
	" \| /_ \| \| \| \| _\ \|"

	It is all fun and games until someone gets hacked!

	Binge
	=====

	Another curses client for transmission-daemon. Not fully featured,
	but sufficient for my daily torrents. Minimal and experimental.

	Screenshot: http://i.imgur.com/2X82oyS.png

	Dependencies
	============

	{-# LANGUAGE OverloadedStrings #-}
	{-# LANGUAGE DeriveDataTypeable #-}

	import Data.Aeson
	import qualified Data.ByteString.Char8 as BS
	import qualified Data.ByteString.Lazy.Char8 as BSL
	import Data.ByteString.Lazy (toChunks)
	import Data.List
	import Data.Maybe
	import Data.Typeable (Typeable)

	import akka.actor.ActorSystem
	import akka.stream._
	import akka.stream.scaladsl._

	import scala.io.StdIn
	import scala.util.Random

	object SimplePartitionSample extends App {

	implicit val system = ActorSystem()

	/*
	https://scalafiddle.io/sf/sniohcZ/1

	Use PassThroughFlow when you have a message that should be used in a
	flow that trasform it but you want to maintain the original message for
	another following flow.
	For example if you consume messages from Kafka (CommittableMessage).
	You process the message (transform, save it inside a database, ...) and then you need again the original message
	to commit the offset.

	package alwyzon.irc

	/*
	<message> ::= [':' <prefix> <SPACE> ] <command> <params> <crlf>
	<prefix> ::= <servername> \| <nick> [ '!' <user> ] [ '@' <host> ]
	<command> ::= <letter> { <letter> } \| <number> <number> <number>
	<SPACE> ::= ' ' { ' ' }
	<params> ::= <SPACE> [ ':' <trailing> \| <middle> <params> ]
	<middle> ::= <Any non-empty sequence of octets not including SPACE or NUL or CR or LF, the first of which may not be ':'>
	<trailing> ::= <Any, possibly empty, sequence of octets not including NUL or CR or LF>

	(ns happyeyeballs
	(:require [missionary.core :as m])
	(:import (java.net InetAddress InetSocketAddress)
	(java.nio.channels AsynchronousSocketChannel CompletionHandler)
	(java.util.concurrent.atomic AtomicBoolean)))

	(defn happyeyeballs
	"Tries to establish a connection to a host associated with multiple endpoints, following the Happy Eyeballs protocol.

	Given a sequence of tasks performing the connection to each endpoint, returns a task sequentially performing connection

iomonad iomonad

Applied Functional Programming with Scala - Notes

1. Mastering Functions

Common

Linux kernel