Jörn Gersdorf j0xaf

Download the image builder

git clone [email protected]:Robertof/nixos-docker-sd-image-builder.git
cd nixos-docker-sd-image-builder

Configure for Raspi4

modify /config/rpi4/default.nix to increase size of boot partition
- this step is optional but I ran out of space in /boot pretty quickly with the default setting since I'm still learning and rebuilding a lot. Let's leave some room for trial & error.
- sdImage.firmwareSize = 1024;
modify /config/sd-image.nix
./rpi3 becomes ./rpi4

Monads and delimited control are very closely related, so it isn’t too hard to understand them in terms of one another. From a monadic point of view, the big idea is that if you have the computation m >>= f, then f is m’s continuation. It’s the function that is called with m’s result to continue execution after m returns.

If you have a long chain of binds, the continuation is just the composition of all of them. So, for example, if you have

m >>= f >>= g >>= h

then the continuation of m is f >=> g >=> h. Likewise, the continuation of m >>= f is g >=> h.

Query basics

{:db/ident       :meta/tag
 :db/valueType   :db.type/tuple
 :db/tupleAttrs  [:meta/tag-namespace :meta/tag-key :meta/tag-value] ;; all unique strings
 :db/cardinality :db.cardinality/one
 :db/unique      :db.unique/identity}

Then

Purity and pure FP

purity is a syntactical property of programs, more precisely defined as referential transparency: replacing an expression for its bound value doesn't change meaning (precise definition)
side effects are things that break referential transparency (precise definition)
There's no direct connection between the concepts of IO, State and so on, and side effects. Traditionally, these things are side effectful (break referential transparency), but you can have abstractions that are pure (don't break ref.trans.)
Due to the above, the term purely functional programming is not an oxymoron, it makes perfect sense.
In haskell style pure FP, type constructors and algebras are used to represent "things that would otherwise traditionally be side effects (break ref.trans.)". We call these F[_]s effects or computational contexts for brevity. You can see for yourself how this cannot be a precise definition (especially because they could also have kind higher than * -> *, even though most famous a

Peer to Peer Cloud Computing

Current cloud services and traditional Web sites like Amazon or Azure or Google or Facebook all are centralized from the management point of view and thus, they suppose a threat as big as a Super-Mainframe would pose for privacy and security of the data as well as the computing power. Amazon could paralyze the entire world. Facebook can be perfect for political campaigns if the right "leaks" happens when they need them. we know it very well.

The source of concern are:

The centralized databases that consolidate all the data of all users instead of letting the user to control where to store his own data wether locally or in other's nodes and define his own access policies. Although centralized databases are also a consequence of other concerns depicted below, centralization of data is something desired, since it is very profitable for legal and -I´m worried- criminal uses of such data.
The methods for obtaining scalability apparently demand farms of computers, again

I started writing this polemic to answer your question, but I ended up touching on most of my gripes with Haskell in general, not just in a corporate context.

GHC

GHC is a modern compiler with an amazing RTS and tons of features, but I have some issues with it.

	{ pkgs ? import <nixpkgs> {} }:

	let

	# To use this shell.nix on NixOS your user needs to be configured as such:
	# users.extraUsers.adisbladis = {
	# subUidRanges = [{ startUid = 100000; count = 65536; }];
	# subGidRanges = [{ startGid = 100000; count = 65536; }];
	# };

	module Payments where

	data Customer = Customer { name :: String, age :: Int } deriving (Eq, Ord, Show)

	-- I know partial record fields is an anti-pattern, but who's counting?
	data Payment
	= Cash { customer :: Customer, amount :: Double }
	\| Credit { customer :: Customer, amount :: Double, cardNumber :: Int }
	\| Check { customer :: Customer, amount :: Double, routingNumber :: Int, accountNumber :: Int }
	deriving (Eq, Ord, Show)

	#! /usr/bin/env stack
	-- stack --resolver lts-18.8 script

	{-# LANGUAGE OverloadedStrings #-}

	{-
	This is a handy illustration of converting between five of the commonly-used
	string types in Haskell (String, ByteString, lazy ByteString, Text and lazy
	Text).

	# Ubuntu 18.04 and various Docker images such as openjdk:9-jdk throw exceptions when
	# Java applications use SSL and HTTPS, because Java 9 changed a file format, if you
	# create that file from scratch, like Debian / Ubuntu do.
	#
	# Before applying, run your application with the Java command line parameter
	# java -Djavax.net.ssl.trustStorePassword=changeit ...
	# to verify that this workaround is relevant to your particular issue.
	#
	# The parameter by itself can be used as a workaround, as well.