u/FlamingBudder

A very common sentiment amongst theists is that life is too beautiful for God not to exist. It wouldn’t have been this way if it wasn’t for an intelligent creator.

I can agree with this on some level, because it feels like the beauty must be justified by some source. After all if a skyscraper had been built it couldn’t have just appeared out of nowhere, the masterful engineering must have been done by some skilled humans

However then the question is, how do you justify God’s existence? If the universe is like a tall skyscraper, God would be like an entire city full of skyscrapers with a magnificent skyline with ingenious urban planning. Just like with the skyscraper, the city doesn’t just spawn out of nowhere, it is engineered by humans, who are highly intelligent

Positing that there is an intelligent creator just passing the buck. To justify God, there must be an entity that is at least as intelligent as God (God2), enough to spawn itself. Then we would need God3 and God4 …

At some point there must be something beautiful that “just is”. Whether that is an intelligent creator or simply just a set of conditions and structure that give the universe beauty.

Another way things can go is that time is boundless on both sides. The universe never began and will never end, perhaps it goes in cycles. You can also have an infinite God hierarchy where there is a GodN for every natural number N, and gods span for eternity. This is called the big bounce theory because the universe collapses on itself into a singularity, only to big bang into a new beginning. Buddhist Karma also has an infinite cyclic nature.

Honestly the boundless interpretation feels a lot better and more justified. With a bounded universe, something must have spawned out of nothing. However without bounded ness we can pass the buck forever.

You might prefer the God explanation because then there is an intelligent entity who made this stuff. I am not refuting this is not the case, I am just saying that is not necessarily true. God’s intelligence would also need to be justified at least as much as the beauty of physical laws in the universe. The god explanation feels better than “well these laws weren’t synthetically constructed”, but there is an equivalence class in some sense between the naturalistic and God interpretation

I thought about this after revisiting Bob Harper's Practical Foundations of Programming Languages. It seems like every effect is simply just a concurrent process calculi program, where one process is the focal point, an actor which either acts on other processes (effect) or is acted upon by other processes (coeffect).

In particular, fix an arbitrary process calculus program. Within this program, fix a subprocess of the whole system. This one subprocess is the actor and the rest of the program is the environment. Some interactions with the environment or lack of interactions with the environment are considered as effects or coeffects.

In his formulation of "Modernized Algol" and "Concurrent Algol", he uses different syntactic sorts to segregate language constructs. expressions are pure, and may evaluate to a value if they terminate. Commands are impure, involving storage effects, using a monadic structure to implement sequencing of storage effects. Processes are actors which may send messages along channels to other actors.

The proc(m) operator transforms a command m into a process. A command can contain a sequencing of send or receive commands from a channel, which can be thought of as effects because they involve interaction with the outside world. In an entire closed process calculus system though, no effects with the outside world would occur, although if you limited your scope to one process P, its interactions with other processes can be considered as effects that P gives out to its "environment", or the other processes that P sends messages to.

In fact, Harper even mentioned how you can implement "assignables" (pointers to mutable cells), using processes. An assignable is then just a process with an interface of two operations: get and put. The process blocks and waits to receive a command, then executes the command. In the get case, it will send a message back on a return channel with the contents that it currently has. In the put case, it receives a new value and continues as that value to receive more get and put commands.

It has been a while since I've read the book, and just now I thought, hey it seems like you can simply model any effect you can possibly dream of using process calculi... Since all effects are just a program (A process) doing something to its environment (other processes). Coeffects can also be modeled in this sense because they are an environment acting on a program.

Now just because you can model everything with processes and message passing doesn't mean this is anything special. After all you can model all computations with lambda calculus or Turing Machines, or literally any language you can think of. You can also encode any effect you can think of in a language with no message passing concurrency by simply producing a monad that corresponds to that effect.

However I believe there may be a 3 way correspondence between (co)monads, (co)effects, and concurrent system. But I think this correspondence with concurrency and effects makes a lot of intuitive sense and might be more on the level of Curry Howard Correspondences. Below I give some examples of effects and how they can be modeled as concurrency

Examples of effects, modeled with process calculus

Control effects: Control effects work with continuations, which can be thought of as "control stacks" in a computational machine which runs code. This is covered in Harper's control effects section of his book, which essentially models a "machine" similar to the CK/CEK/SECD machines. Each of these machines has a control stack or a (k/c)ontinuation. To model this with concurrency, the continuation/stack is one process, and the actual program doing the control effects is another process. The program sends messages to the continuation to ask about the context and the continuation responds by popping a frame and sending a message back. To model exceptions, the program sends a special stack unwinding message telling the continuation to unwind until it finds a handler, then the continuation sends a message back with the handler's expression used to handle the exception. Essentially the whole picture is a CEK/SECD machine with each of the components being a process. The effect is the main program interacting with the continuation, environment, etc.

Weakening/contraction coeffects: In the SECD machine, the main process interacts with the environment, which then it can send multiple messages to retrieve a variable in the environment multiple times (contraction), or it can not retrieve a variable at all (weakening)

Storage effects: I already talked about this. You can also model shared state concurrency with process calculi. It would be the same as just having normal state except now multiple processes can communicate with the same shared state. Mutexes are easy to implement too a message passing model

Partiality: There would be two processes (which are continuations) representing the end user waiting for the output of the program. A success continuation and a failure continuation. The failure continuation can just receive a unit for when a contract failure or type error happens, or perhaps some debugging info on where the error occurred and for what reason. If the program does not crash and returns a value, it returns to the success continuation. With non termination, the process simply never returns to the success or failure continuation. Partiality then works similarly to control effects

Nondeterminism: Nondeterminism can be modeled by one process being a coinductively generated branching decision tree. Its interface is that you can send over a choice of the multiple choices it provides at the current time, it will run the choice, and give you the result, as well as allowing you to make another choice. The main actor process then is the choice maker, which considered the situation and makes a choice. We can also make the choices random by having a process representing a source of random bits, with an interface to get the next bit. The actor can then pull random bits from the coinflipper process and make random choices and communicate with the coinductive choice tree process. Since the coinductive branching process is lazily coinductively generated, it does not compute any possibility until the possibility is actually chosen.

Fork-Join parallelism: You have a master process and multiple worker parallel processes. The master sends work to the worker as well as a return continuation. The worker does its work and sends work to the return continuation. The master waits on all the return continuations it sent out and continues its work after all processes have returned.

IO: the console is a process, getline and printline are interface functions. Obvious for any other IO effect, after all input and output corresponds to send and receive.

I have never met a competent woman with an ego as large as successful men, and many smart women don't see their own giftedness/undersell themselves