Francesco Frontera francescofrontera

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

Thread Pools

Thread pools on the JVM should usually be divided into the following three categories:

CPU-bound
Blocking IO
Non-blocking IO polling

Each of these categories has a different optimal configuration and usage pattern.

Fibers

Fibers are an abstraction over sequential computation, similar to threads but at a higher level. There are two ways to think about this model: by example, and abstractly from first principles. We'll start with the example.

(credit here is very much due to Fabio Labella, who's incredible Scala World talk describes these ideas far better than I can)

Callback Sequentialization

Consider the following three functions

	object Low {
	def low = "object Low"
	def shoot = "missed!"
	}

	object High {
	def high = "object High"
	def shoot = "bulls eye!"
	}

	/**
	* D Holbrook
	*
	* Code Club: PO1
	*
	* (*) Define a binary tree data structure and related fundamental operations.
	*
	* Use whichever language features are the best fit (this will depend on the language you have selected). The following operations should be supported:
	*
	* Constructors

	/*
	Parallel processing with ordered output in Go
	(you can use this pattern by importing https://github.com/MarianoGappa/parseq)

	This example implementation is useful when the following 3 conditions are true:
	1) the rate of input is higher than the rate of output on the system (i.e. it queues up)
	2) the processing of input can be parallelised, and overall throughput increases by doing so
	3) the order of output of the system needs to respect order of input

	- if 1 is false, KISS!

	object DockerClientApp extends App {

	import DockerClientOps._

	val client:DockerClient = DefaultDockerClient.fromEnv().build()
	val interpreter = spotifyInterpreter(client)

	val program = for {
	_ <- pull("busybox:latest")
	cntrId <- run("busybox", "sh", "-c", "while :; do sleep 1; done")

	// SPDX-License-Identifier: Unlicensed

	pragma solidity ^0.8.7;

	contract CryptoKids {
	// owner DAD
	address owner;

	event LogKidFundingReceived(address addr, uint amount, uint contractBalance);