Alberto agocorona

Asynchronous exceptions and management of resources in transient

NOTE: All this has been superseeded by finalizations

I was looking at the last article of Michael Snoyman about asynchronous exceptions. Proper handling of resources in long term programs such are servers demands very accurate management of resources. In transient where many threads are spawned and sometimes killed asynchronously, this is even more important.

So I first tried to create a version of bracket for the transient monad:

bracket

Do NOT use loops. Loops destroy composition. Use streaming/ non determinism (multithreaded or not):

forM [1..10]  $ \i -> ...   use:   i <- threads 0  $ choose [1..10]    
                                   -- run in the current thread
-- like for i = 1 to 10...

Do NOT use callbacks. De-invert callbacks with react:

onCallback wathever mycallback    use:     event <- react (onCallback wathever) (return())

A lot of problems in haskell development is related with the problem of chaining effects. How do I insert an effect in a chain of computations?

Since the chain operation is bind, and has this signature:

  (>>=) :: m a -> (a -> m b) -> m b

then the two operands: the result of the chain and the rest of the chain should be in the same monad, so they should have the same effects.

To overcome this problem the monad transformer and the free monad use the "runXXX" and the lift pattern with XXX being the effect desired can run for some time:

I have been watching this interesting presentation of distributed computing in Erlang-elixir: https://www.youtube.com/watch?v=AiN4r8E9qKg

I want to mention the remarkable points and compare them with the transient way of distributed computing:

min 1:30 It defines a cookie as a command-line parameter. It is a good idea. Connections would be required to send the same cookie.

min 3:00 Erlang nodes connect all nodes with all by default and maintain a heartbeat between then, probably because the communication protocol is low level in order to be very fast. It uses UDP probably. Transient connect only on demand and a node may route request to other destination nodes. It is made for weakly coupled internet nodes rather than for a closed coupled local area network. For this reason transient uses TCP sockets and websockets. A node behind a firewall can be accessed using the HTTP port as long as websockets are enabled. Once connected the remote node can address nodes internal to the firewall trough the gateway

Services are a standard feature of transient. a service is a transient program with a diferent codebase than the one of the calling program. the services are initiated stand alone or by the monitor service. Although they are transient haskell programs, they can execute internally wathever :they can do FFI or execute a shell. They can also be packaged into docker images.

monitorService:

-is an executable included in transient -it should run in each node of the cloud:

 monitorService -p start/thishost/3000 # first node

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

	--Based on https://gist.github.com/gelisam/be8ff8004cd701a084b6d64204a28bb6
	{-# LANGUAGE DataKinds, DeriveFunctor, FlexibleContexts, GADTs, LambdaCase, RankNTypes, ScopedTypeVariables, TypeApplications, TypeOperators #-}

	module Main (main) where


	import qualified TransientCont as T -- this file: https://gist.github.com/agocorona/2c9149c4d2035f21952fc1d1691b7bde
	import Criterion (bench, bgroup, nf,whnfIO)

	import Criterion.Main (defaultMain)


	-- first attempt (not compiled) of an example simulation of petri net https://twitter.com/semanticbeeng/status/1120662696985268225
	-- assume that the input is stored by a process `receive` not detailed here which store the entries in two transactional variables


	-- read from two typed channels A and B
	-- return three responses of type C

	import Control.Concurrent.STM.TVar
	import Transient.Base

	#!/usr/bin/env execthirdlinedocker.sh

	-- mkdir -p ./static && ghcjs -DDEBUG ${1} -o static/out && echo ${1} && runghc -DDEBUG ${1} ${2} ${3}

	{-
	Programmed following the requirements of a canonical Java project:

	http://www.math-cs.gordon.edu/courses/cs211/ATMExample/

	It demonstates that it is possible to program clearly at the level of the requirements so that the author of the requirements

	import Control.Monad
	import Control.Applicative
	import Control.Concurrent.MVar hiding (takeMVar, putMVar)
	import qualified Control.Concurrent.MVar as MVar
	import Control.Concurrent.Fiber
	import Control.Concurrent.Fiber.MVar
	import System.Environment
	import GHC.Conc.Sync hiding (yield)
	import GHC.Conc.IO
	import Control.Monad.IO.Class