first commit

Author: cs224

Diff for: Makefile

@@ -0,0 +1,21 @@
+
+# https://www.gnu.org/software/make/manual/make.html#Automatic-Variables
+
+# requires: pandoc 1.16 or higher
+
+# https://github.com/freebroccolo/docker-haskell/blob/a396f0d9b35cabeb60920abd87a8b2612530cb1b/7.10/Dockerfile
+# https://github.com/jagregory/pandoc-docker/blob/master/Dockerfile
+
+# docker images
+# docker run --rm -t -i --entrypoint="/bin/bash" pandoc
+# docker run --rm -e "userid=$(id -u):$(id -g)" -t -i --entrypoint="/bin/bash" pandoc
+
+# https://github.com/docker/docker/issues/3206
+# http://stackoverflow.com/questions/27925006/using-host-environment-variables-with-dockerfile
+
+docker-image-cleanup:
+	docker rmi -f $(docker images | grep "<none>" | awk "{print \$3}")
+
+index.html: header.md body.md
+	touch $@ && docker run --rm -e "userid=$$(id -u):$$(id -g)" -t -v `pwd`:/source jagregory/pandoc --standalone -S --highlight-style pygments --toc -c pandoc.css -f markdown+link_attributes -t html5 --self-contained -o $@ $^
+

Diff for: README.md

@@ -0,0 +1,41 @@
+
+See here for details.
+
+You can rebuild the document locally by executing:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.bash}
+> rm index.html
+> make index.html
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Keyword List: Control Structures and Paradigms:
+
+* Parallel Universe: Quasar Library: Continuations for Core Java and the JVM
+* Continuations, Coroutines, Generators
+* Continuation Passing Style (CPS)
+* Flow-Based Programming (FBP)
+* Communicating Sequential Processes (CSP)
+  * Clojure core.async
+* Complex Event Processing (CEP)
+* Actors
+  * "Let it crash" vs. try-catch-finally
+* Incremental Computing
+  * Functional Reactive Programming (FRP)
+    * Reactive Extension (Rx)
+  * Propagators
+  * Self-Adjusting Computation
+  * Bidirectional Programming (Lenses)
+* Fiber, Green Threads, Light-Weight Thread, Cooperative Multi-Tasking
+* Push vs. Pull, Polarity of Pipelines
+* Thread Based vs. Event Driven
+* Cooperative Multi-Tasking vs. Pre-Emptive Multi-Tasking
+* (pull, fiber/stack-based and lazy) form a unit and (push, event-driven and eager) form a unit
+* Cooperative Task Management without Manual Stack Management, avoiding “call-back hell” and “stack ripping” in single threaded applications
+* Event Sourced Architectures, CQRS
+
+Core Message
+
+The core of the message that I want to share with you is that event-driven or fiber style programming are from a performance perspective equivalent.
+
+Actually event-driven, fiber-style, reactive programming, data-flow programming, complex event processing or communicating-sequential-processes are all from a performance perspective equivalent. There exist mechanical transformations between the one style of programming into the other style. These mechanical transformations can be performed under the hood via compiler technology, e.g. via byte code manipulation.
+
+If from a performance perspective all of these programming styles are equivalent then the choice of which style to use should be based on factors like how well the code is understandable, e.g. in a static set-up as code visible in your IDE without running the program. Here the fiber style is much better suited for us humans to understand than the event-driven style!

Diff for: body.md

@@ -0,0 +1,5 @@
+#!/bin/bash
+mkdir -p $HOME/.m2/repository/co/paralleluniverse/quasar-core/0.7.5
+ln -s $HOME/.m2/repository/co/paralleluniverse/quasar-core/0.7.5/quasar-core-0.7.5-sources.jar $HOME/.m2/repository/co/paralleluniverse/quasar-core/0.7.5/quasar-core-0.7.5-jdk8-sources.jar
+ln -s $HOME/.m2/repository/co/paralleluniverse/quasar-core/0.7.5/quasar-core-0.7.5-javadoc.jar $HOME/.m2/repository/co/paralleluniverse/quasar-core/0.7.5/quasar-core-0.7.5-jdk8-javadoc.jar
+

Diff for: control-structures/pom.xml

@@ -0,0 +1,13 @@
+package control.structures;
+
+/**
+ * Hello world!
+ *
+ */
+public class App 
+{
+    public static void main( String[] args )
+    {
+        System.out.println( "Hello World!" );
+    }
+}

Diff for: control-structures/set-up-links.sh

@@ -0,0 +1,80 @@
+package control.structures.continuations;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.strands.Strand.State;
+import co.paralleluniverse.strands.SuspendableCallable;
+
+public abstract class CoIterator<E> implements Iterator<E>, Serializable {
+
+    private static final long serialVersionUID = 351278561539L;
+    
+    private final Coroutine co;
+    
+    private E element;
+    private boolean hasElement;
+    
+    protected CoIterator() {
+        co = new Coroutine((SuspendableCallable<Void>)() -> {run(); return null;});
+    }
+
+    public boolean hasNext() {
+        while(!hasElement && co.getState() != State.TERMINATED) {
+			co.run();
+        }
+        return hasElement;
+    }
+
+    public E next() {
+        if(!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        E result = element;
+        hasElement = false;
+        element = null;
+        return result;
+    }
+
+    /**
+     * Always throws UnsupportedOperationException.
+     * @throws java.lang.UnsupportedOperationException always
+     */
+    public void remove() throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("Not supported");
+    }
+
+    /**
+     * Produces the next value to be returned by the {@link #next} method.
+     * 
+     * @param element The value that should be returned by {@link #next}
+     * @throws de.matthiasmann.continuations.SuspendExecution This method will suspend the execution
+     */
+    protected void produce(E element) throws SuspendExecution {
+        if(hasElement) {
+            throw new IllegalStateException("hasElement = true");
+        }
+        this.element = element;
+        hasElement = true;
+        co.yield();
+    }
+    
+    /**
+     * <p>This is the body of the Iterator. This method is executed as a
+     * {@link Coroutine} to {@link #produce} the values of the Iterator.</p>
+     * 
+     * <p>Note that this method is suspended each time it calls produce. And if
+     * the consumer does not consume all values of the Iterator then this 
+     * method does not get the change to finish it's execution. This also
+     * includes the finally blocks.</p>
+     * 
+     * <p>This method must only suspend by calling produce. Any other reason
+     * for suspension will cause a busy loop in the Iterator.</p>
+     * 
+     * @throws de.matthiasmann.continuations.SuspendExecution
+     */
+    protected abstract void run() throws SuspendExecution;
+
+}

Diff for: control-structures/src/main/java/control/structures/App.java

@@ -0,0 +1,48 @@
+package control.structures.continuations;
+
+import java.io.Serializable;
+import java.util.concurrent.ExecutionException;
+
+import co.paralleluniverse.fibers.Fiber;
+import co.paralleluniverse.fibers.FiberExecutorScheduler;
+import co.paralleluniverse.fibers.FiberScheduler;
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.strands.SuspendableCallable;
+import co.paralleluniverse.strands.Strand.State;
+
+public class Coroutine implements Serializable {
+	
+	private static final long serialVersionUID = 357144399321567101L;
+	
+    private static final FiberScheduler myFiberScheduler = new FiberExecutorScheduler("my-scheduler", new MyExecutor());
+	private final Fiber<Void> fiber;
+	
+    public Coroutine(SuspendableCallable<Void> proto) {
+        this(proto, Fiber.DEFAULT_STACK_SIZE);
+    }
+    
+    public Coroutine(SuspendableCallable<Void> proto, int stackSize) {
+        fiber = new Fiber<>(myFiberScheduler, () -> { Fiber.park(); proto.run();});
+        fiber.start();
+    }
+	
+	
+	public void yield() throws SuspendExecution {
+		Fiber.park();
+	}
+	
+	// as long as I am single threaded and as long as I am sticking to the protocol of alternating calls to yield() and run()
+	// I don't need to throw the SuspendExecution exception here, because this channel should never suspend.
+	public void run() {
+		Fiber.unpark(fiber);
+	}
+
+    public State getState() {
+        return fiber.getState();
+    }
+    
+    public void join() throws ExecutionException, InterruptedException {
+    	fiber.join();
+    }
+	
+}

Diff for: control-structures/src/main/java/control/structures/continuations/CoIterator.java

@@ -0,0 +1,13 @@
+package control.structures.continuations;
+
+import java.util.concurrent.Executor;
+
+public class MyExecutor implements Executor {
+
+	@Override
+	public void execute(Runnable command) {
+		command.run();
+	}
+
+
+}

Diff for: control-structures/src/main/java/control/structures/continuations/Coroutine.java

@@ -0,0 +1,35 @@
+package control.structures.dataflow;
+
+import java.io.Serializable;
+
+import co.paralleluniverse.fibers.SuspendExecution;
+
+public interface DataflowVariable<T extends Serializable> extends ResponseVariable<T> {
+	
+	public void bind(T value) throws AlreadyBoundToIncompatibleValueException;
+	public T get() throws SuspendExecution, InterruptedException;
+	
+	public ResponseVariable<T> response();
+	
+	public boolean isDone();
+	
+	public static class AlreadyBoundToIncompatibleValueException extends RuntimeException {
+		private static final long serialVersionUID = 6396210388354647161L;
+		public AlreadyBoundToIncompatibleValueException() {
+			super();
+		}
+		public AlreadyBoundToIncompatibleValueException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+			super(message, cause, enableSuppression, writableStackTrace);
+		}
+		public AlreadyBoundToIncompatibleValueException(String message, Throwable cause) {
+			super(message, cause);
+		}
+		public AlreadyBoundToIncompatibleValueException(String message) { 
+			super(message);
+		}
+		public AlreadyBoundToIncompatibleValueException(Throwable cause) {
+			super(cause);
+		}
+	}
+
+}

Diff for: control-structures/src/main/java/control/structures/continuations/MyExecutor.java

@@ -0,0 +1,73 @@
+package control.structures.dataflow;
+
+import java.io.Serializable;
+import java.util.function.Supplier;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.strands.dataflow.Val;
+import control.structures.utils.InfrastructureUtils;
+
+
+public class QuasarVarDataflowVariableRepository {
+
+	private static final Logger logger = LoggerFactory.getLogger(QuasarVarDataflowVariableRepository.class);
+
+	private final static class DV<T extends Serializable> implements DataflowVariable<T>, Serializable {
+
+		private static final long serialVersionUID = -7384576069381176916L;
+		private final Val<T> val = new Val<T>();
+		private final String variableName;
+		
+		private DV(String variableName) {
+			this.variableName = variableName;
+		}
+
+		@Override
+		public void bind(T value) throws DataflowVariable.AlreadyBoundToIncompatibleValueException {
+			logger.debug("DV<T>.bind(): '" + variableName + "' : '" + InfrastructureUtils.truncate(value) + "'");
+			val.set(value);
+		}
+
+		@Override
+		public T get() throws SuspendExecution, InterruptedException {
+			logger.debug("DV<T>.get(): '" + variableName + "' : before");
+			T v = val.get();
+			logger.debug("DV<T>.get(): '" + variableName + "' : after");
+			return v;
+		}
+		
+		@Override
+		public String toString() {
+			T value = null;
+			if(val.isDone())
+				try {
+					value = val.get();
+				} catch (InterruptedException e) {
+					// ignore
+				} 
+			
+			return "DV<T>: '" + variableName + "' val bound?: '" + val.isDone() + "' value: '" + InfrastructureUtils.truncate(value) + "'";
+		}
+
+		@Override
+		public ResponseVariable<T> response() {
+			logger.debug("DV<T>.response(): '" + variableName + "'");
+			return this;
+		}
+
+		@Override
+		public boolean isDone() {
+			return val.isDone();
+		}
+	}
+
+	public static <S extends Serializable> DataflowVariable<S> createReference(Supplier<S> constructor, String name) {
+		DV<S> dv = new DV<S>(name);
+		logger.debug("createReference(): " + dv);
+		return dv;
+	}
+	
+}

Diff for: control-structures/src/main/java/control/structures/dataflow/DataflowVariable.java

@@ -0,0 +1,9 @@
+package control.structures.dataflow;
+
+import java.io.Serializable;
+
+public interface ResponseVariable<T extends Serializable> extends Serializable {
+
+	public void bind(T value);
+	
+}