Mallory M. malzzz

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

Simple automated GIT Deployment using GIT Hooks

Here are the simple steps needed to create a deployment from your local GIT repository to a server based on this in-depth tutorial.

How it works

You are developing in a working-copy on your local machine, lets say on the master branch. Most of the time, people would push code to a remote server like github.com or gitlab.com and pull or export it to a production server. Or you use a service like deepl.io to act upon a Web-Hook that's triggered that service.

How to setup Let's Encrypt for Nginx on Ubuntu 18.04 (including IPv6, HTTP/2 and A+ SLL rating)

Virtual hosts

Let's say you want to host domains first.com and second.com.

Create folders for their files:

Deep Learning for Face Recognition (May 2016)

Popular architectures

FaceNet (Google)
- They use a triplet loss with the goal of keeping the L2 intra-class distances low and inter-class distances high
DeepID (Hong Kong University)
- They use verification and identification signals to train the network. Afer each convolutional layer there is an identity layer connected to the supervisory signals in order to train each layer closely (on top of normal backprop)
DeepFace (Facebook)
- Convs followed by locally connected, followed by fully connected

	// WebSocket Client Example for Scala 2.11 with Netty 4
	// http://netty.io/4.0/xref/io/netty/example/http/websocketx/client/WebSocketClient.html
	package org.koiroha.websocket

	import io.netty.bootstrap.Bootstrap
	import io.netty.buffer.Unpooled
	import io.netty.channel.{Channel,ChannelFuture,ChannelHandlerContext,ChannelInitializer,ChannelPipeline,ChannelPromise,EventLoopGroup,SimpleChannelInboundHandler}
	import io.netty.channel.nio.NioEventLoopGroup
	import io.netty.channel.socket.SocketChannel
	import io.netty.channel.socket.nio.NioSocketChannel

	package examples
	import cats._, data._
	import org.atnos.eff._, all._
	import org.atnos.eff.syntax.all._
	import cats.implicits._

	object ExampleLocalReader {

	def exampleInterpreter = {
	type Env = Map[String,Int]

	package ca

	import scalaz.{Comonad, NonEmptyList, Zipper}
	import Zipper._

	case class Board[A](p: Zipper[Zipper[A]]) {
	def up = Board(p.previous.get)
	def down = Board(p.next.get)
	def left = Board(p.map(_.previous.get))
	def right = Board(p.map(_.next.get))

	// quick translation from http://www.geeksforgeeks.org/inplace-m-x-n-size-matrix-transpose/

	def matrixInplaceTranspose[A](a: Array[A], rows: Int, columns: Int): Unit = {
	val size = rows * columns - 1
	// bitset<HASH_SIZE> b; // hash to mark moved elements
	val b = new collection.mutable.BitSet(size)
	b.add(0)
	b.add(size)
	var i = 1; // Note that A[0] and A[size-1] won't move
	while (i < size) {

	import java.io.{File, FileInputStream}
	import java.util
	import monix.execution.Cancelable
	import monix.reactive.Observable
	import scala.util.control.NonFatal

	def fromInputStream(in: java.io.InputStream, chunkSize: Int = 256): Observable[Array[Byte]] = {
	val iterator = new Iterator[Array[Byte]] {
	private[this] val buffer = new Array[Byte](chunkSize)
	private[this] var lastCount = 0

	/**
	* Base contract that all upgradeable contracts should use.
	*
	* Contracts implementing this interface are all called using delegatecall from
	* a dispatcher. As a result, the _sizes and _dest variables are shared with the
	* dispatcher contract, which allows the called contract to update these at will.
	*
	* _sizes is a map of function signatures to return value sizes. Due to EVM
	* limitations, these need to be populated by the target contract, so the
	* dispatcher knows how many bytes of data to return from called functions.