John lgastako

WebSockets - An Introduction

WebSockets is a modern HTML5 standard which makes communication between client and server a lot more simpler than ever. We are all familiar with the technology of sockets. Sockets have been fundamental to network communication for a long time but usually the communication over the browser has been restricted. The general restrictions

The server used to have a permanent listener while the client (aka browser) was not designated any fixed listener for a more long term connection. Hence, every communication was restricted to the client demanding and the server responding.
This meant that unless the client requested for a particular resource, the server was unable to push such a resource to the client.
This was detrimental since the client is then forced to check with the server at regular intervals. This meant a lot of libraries focused on optimizing asynchronous calls and identifying the response of asynchronous calls. Notably t

Recent improvements to the ClojureScript compiler have greatly simplified setting up development versus production outputs.

This example uses Figwheel as something that you want to exclude for production, but the pattern is general.

With this simple setup you only need one html file/view and it will work for developement and production.

Elm best practices

Style guide

Functional, Reactive, and Distributed Systems Bibliography

Books

CQRS Journey: Free ebook from Microsoft (Print book available for purchase)
Functional and Reactive Domain Modeling: A high level overview of how to build up domain models using free monads and interpreters.
Reactive Microservices Architecture: Free booklet from Lagom and O'Reilly
Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka
Domain-Driven Design: Tackling Complexity in the Heart of Software

The Problem

Defining records in Haskell causes accessor functions for the record's fields to be defined. There is no seperate namespace for these accessor functions.

The Goal

Be able to

use records in Haskell, which share field names.
use lenses for accessing these fields

	data WidgetConfig t a
	= WidgetConfig { _widgetConfig_setValue :: Event t a
	, _widgetConfig_initialValue :: a
	, _widgetConfig_attributes :: Dynamic t (Map String String)
	}

	makeLenses ''WidgetConfig

	instance (Reflex t, Default a) => Default (WidgetConfig t a) where
	def = WidgetConfig { _widgetConfig_setValue = never

	module Main where

	import Signal


	type alias Message =
	{ operation : String
	, message : String
	}

	{-# language KindSignatures #-}
	{-# language PolyKinds #-}
	{-# language DataKinds #-}
	{-# language TypeFamilies #-}
	{-# language RankNTypes #-}
	{-# language NoImplicitPrelude #-}
	{-# language FlexibleContexts #-}
	{-# language MultiParamTypeClasses #-}
	{-# language GADTs #-}
	{-# language ConstraintKinds #-}

	This example comes from the Wikipedia article:

	https://en.wikipedia.org/wiki/Visitor_pattern

	Our first indication of complexity is the fact that the MyInterface[] array requires rank 2 types:

	> {-# LANGUAGE Rank2Types, MultiParamTypeClasses, FunctionalDependencies #-}

	The multiparam type class and functional dependency is not part of the Wikipedia article proper,
	and instead come because I saw myself writing an expression like:

	module Main

	import Data.Vect

	-- %hide transpose

	dot : Num a => Vect n a -> Vect n a -> a
	dot va vb = foldr (+) 0 $ zipWith (*) va vb

	Matrix : (rows : Nat) -> (cols : Nat) -> Type -> Type