Venelin vmptk

A composable pattern for pure state machines with effects

State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?

There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.

Here I present a composable pattern for pure state machiness with effects,

Workshop Guide - Building Apps on FireFly

Welcome! We're glad you're here! This is the guide that we will be going through during the workshop.

Before the workshop

IMPORTANT: Please make sure you have installed the software listed in this section before the workshop so that we can hit the ground running when the workshop starts.

Install Docker

Read this first!

Hi there! Since this post was originally written, nvm has gained some new tools, and some people have suggested alternative (and potentially better) approaches for modern systems. Make sure to have a look at the comments to this article, before following this guide!

The original article

Trickier than it seems.

MongoDB Cheat Sheet

Show All Databases

show dbs

	FROM yandex/clickhouse-server:${CLICKHOUSE_VERSION:-latest}

	USER root
	ARG UBUNTU_NAME=focal
	ARG UBUNTU_VERSION=20.04

	RUN echo "Begin ODBC install" && \
	#MySQL repo
	wget -qO- "http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xa4a9406876fcbd3c456770c88c718d3b5072e1f5" \| apt-key add - && \
	echo "deb http://repo.mysql.com/apt/ubuntu/ ${UBUNTU_NAME} mysql-8.0" >/etc/apt/sources.list.d/mysql-oracle.list && \

	# Disable the Gradle daemon for Continuous Integration servers as correctness
	# is usually a priority over speed in CI environments. Using a fresh
	# runtime for each build is more reliable since the runtime is completely
	# isolated from any previous builds.
	variables:
	GRADLE_OPTS: "-Dorg.gradle.daemon=false"
	DOCKER_TLS_CERTDIR: ""

	before_script:
	- export GRADLE_USER_HOME=`pwd`/.gradle

	package statemachine

	import debug
	import fail
	import io.reactivex.Observable
	import kotlinx.coroutines.experimental.channels.Channel
	import kotlinx.coroutines.experimental.channels.produce
	import kotlinx.coroutines.experimental.delay
	import kotlinx.coroutines.experimental.launch
	import kotlinx.coroutines.experimental.runBlocking

	package com.domain;

	import com.domain.Module;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.data.domain.Page;
	import org.springframework.data.domain.PageImpl;
	import org.springframework.data.domain.Pageable;
	import org.springframework.jdbc.core.JdbcTemplate;
	import org.springframework.stereotype.Repository;

	export default function useQueryParam<T>(
	key: string,
	push: (path: string) => void,
	defaultValue?: T,
	): [T, (value: T) => void] {
	const { pathname, search } = location

	const query = new URLSearchParams(search)

	const rawValue = query.get(key)

	class Square {
	type = "Square" as const
	constructor(public side: number) {}
	}
	class Circle {
	type = "Circle" as const
	constructor(public radius: number) {}
	}
	class Rectangle {
	type = "Rectangle" as const