DEV Community: mac172

I Built a Dataflow Engine Where the Graph Is the Program

mac172 — Tue, 15 Sep 2026 06:00:12 +0000

I’m Building a Low-Level Dataflow Environment for Experimenting With Computation

What if you could construct a computational system, change one of its parameters, and immediately see how that change propagates through the system?

That's the idea I'm exploring with Computational World (CW) also called Simwire.

CW is an experimental browser-based environment built around a low-level, topological dataflow substrate.

It isn't intended to be another block-based programming tool or a collection of visual effects.

The goal is much simpler:

Make computation visible, composable, and directly manipulable.

The problem I'm exploring

A lot of visual programming and simulation environments make experimentation easier by hiding the underlying computation.

You might get a node called:

Particle System

or:

Sine Wave

or:

Physics Simulation

That's convenient, but the interesting computational structure is now inside the box.

Traditional programming gives you the opposite tradeoff.

You can see and control the computation, but the interaction loop is usually:

write code
   ↓
run
   ↓
inspect output
   ↓
change code
   ↓
run again

I wanted to explore something in between.

What happens if the computational structure itself becomes the interface?

Computation as a graph

The basic model in CW is a directed graph.

Nodes represent operations.

Edges represent dependencies and data flow.

For example:

Input
  │
  ▼
Multiply
  │
  ▼
Add
  │
  ▼
Output

This isn't just a diagram representing a program.

The graph is the program.

If the output depends on Add, and Add depends on Multiply, those dependencies exist in the actual execution model.

This makes the structure something that can be inspected and manipulated directly.

Topological execution

One of the first problems I had to solve was execution order.

Consider:

A ──→ C
B ──→ C

C can't execute until both A and B have produced their outputs.

With a larger graph, manually deciding execution order obviously doesn't scale.

CW therefore treats the graph as a dependency graph and resolves a valid execution order using topological sorting.

The current implementation uses Kahn's algorithm.

Conceptually:

Find nodes with no unresolved dependencies
            ↓
Execute them
            ↓
Remove their outgoing dependencies
            ↓
Find newly available nodes
            ↓
Repeat

This gives the runtime a deterministic way to propagate computation through the graph.

It also gives me a useful property:

the visual structure and the execution structure remain closely related.

Why primitives?

Another design decision I'm experimenting with is keeping operations relatively primitive.

Instead of immediately creating high-level nodes for every interesting behavior, I want complex systems to be constructed from smaller operations.

For example, instead of treating:

Sine Wave

as a magical black box, I'd rather explore whether useful mathematical behavior can emerge from smaller primitives.

The same idea could eventually apply to:

mathematical models
physics systems
signal processing
algorithms
data transformations
computer architecture

The important question isn't whether this is always more convenient.

It isn't.

The question is whether composition itself can become a useful way of understanding a system.

Live manipulation

This is probably the part of CW that matters most to me.

A computational system shouldn't necessarily require a full edit-run-inspect cycle for every small experiment.

If I change a parameter on the canvas, I want the change to propagate through the graph immediately.

For example:

input = 5

      ↓

multiply × 2

      ↓

output = 10

Change the input:

input = 20

      ↓

multiply × 2

      ↓

output = 40

The important thing isn't the arithmetic.

It's the interaction.

You can change something and immediately observe what the rest of the system does.

That turns the computational graph into an experimental surface.

From computation to visualization

I'm also exploring the relationship between computation and visual output.

The values flowing through the graph don't have to terminate at a text output.

They can drive geometry and interactive visual streams.

Conceptually:

Computation
     ↓
Data
     ↓
Geometry / Visual Output

This makes it possible to construct systems where changing the computational model directly changes what you see.

That's where simulations become particularly interesting.

A mathematical relationship can become motion.

A signal can become geometry.

A parameter can become an interactive control.

The computation becomes something you can observe rather than something that only exists inside source code.

Why build this in the browser?

There are practical reasons.

The browser gives me a relatively accessible environment for experimentation:

no installation for users
immediate visual feedback
interactive canvas
easy sharing
computational output can be rendered directly

More importantly, it lets the computational system and the interface exist in the same environment.

I can change the graph and immediately see the consequences.

What I'm trying to find out

I don't actually know yet whether this interaction model is better.

That's the experiment.

There are several questions I'm currently trying to answer.

How low-level should the primitives be?

Too high-level and the system becomes another collection of black boxes.

Too low-level and constructing anything becomes tedious.

There has to be a useful middle ground.

When does composition become confusing?

A graph is easy to understand when it has ten nodes.

What happens when it has hundreds?

At some point, visibility becomes complexity.

That's a problem I haven't solved.

Can this actually help people understand computation?

This is perhaps the biggest question.

Making something visual doesn't automatically make it understandable.

The visualization has to expose meaningful structure rather than simply decorate it.

What I want to explore next

I'm interested in pushing the system into increasingly different computational domains.

Mathematics

Construct mathematical relationships and manipulate their parameters interactively.

Physics

Build simple physical systems and observe how their behavior changes.

Signal processing

Represent transformations as dataflow pipelines and visualize signals moving through them.

Algorithms

Explore whether algorithmic processes can become easier to reason about when their execution is directly observable.

Computer architecture

Eventually, I'd like to experiment with representing lower-level concepts such as logic, memory, and computation itself.

That last one is still far away, but it's one of the reasons I'm interested in keeping the underlying system primitive and compositional.

This is still an experiment

CW is nowhere near finished.

I'm not trying to present it as a finished product.

I'm trying to find out whether this way of interacting with computation is actually useful.

The direction I'm exploring is:

construct
    ↓
connect
    ↓
change
    ↓
observe
    ↓
understand

rather than:

write
    ↓
compile
    ↓
run
    ↓
inspect

Maybe this interaction model works.

Maybe it breaks down as systems become more complex.

Maybe the right answer is somewhere between visual composition and traditional code.

That's what I'm trying to discover by building it.

If you're interested in dataflow systems, programming languages, simulation, creative coding, mathematics, or computational education, I'd be interested in hearing where you think this approach breaks — or where you think it could become useful.

Computational World is being built in public.

The current prototype is available here:

Simwire Sandbox

Simple maths behind linear regression model

mac172 — Wed, 30 Mar 2022 09:21:11 +0000

This blog is a little bit long as I want to explain whole linear regression model with error/cost function and gradient descent algorithm

AI this term is making huge interest in peoples mind. But do you know what it is really?, to tell you it is nothing but mathematical equations playing around with large, really large, really really large datasets. Mathematics work is to describe the real world with logic that people want it, it's nothing special and that's why it is created in first place.

Back to topic, machine learning (subfield of AI) is taking most of the concept from mathematics and one of them is "linear regression".

'Linear regression is a linear model which describes linear combination between input variables to output variables'

Linear Regression

Regression means continuous, so output we get from it is also continuous. It is in supervised machine learning type, containing input with output associated with it like

{(X_{1}, y_{1}), (X_{2}, y_{2}), ..., (X_{n}, y_{n})}

or if you are fan of math's

in less messy way.

Main concept in linear regression comes from equation of line
y = mx + b
where, m = slope of line generally determine by

y = \frac{y _{2} - y _{1}}{x _{2} - x _{1}}

and b = y-intercept

That's it the core idea in linear regression. There are lot of horrible mathematical notation used for writing clear and less messy equations, but their function are easy to understand so don't fear.

First let's start with linear regression equation, don't worry I will clear it's function that easy to understand.

Equation

h_{θ} (x) = i = 0 \sum n θ_{i} x_{i}

Now let's break down it little bit. first

h_{θ} (x) = o u tp u t

and

x_{0} = 1

this two things are clear to us now remainings,

x = numbers of features/inputs

θ = p a r am e t ers

if you know little bit about neural network, then you heard about term called "weights". Weights are nothing but vector of numbers which help input value to match it's output value approximately.

for example 2y = 6, now what value of 'y' make this equation balance? Of course 3, that's how weights are work, it calculated again and again until best matching value obtained.

and lastly

n = number of samples or examples

Now we get output from our Linear Regression equation but what next? The output is not what we expected. How we will get our expected output?

To do this we have another two concepts called "Cost Function" and "Gradient Descent". Let's talk about cost function first.

Cost Function

Cost function is method of calculating error done by model when predicting output.

It's simply difference between predicted output and actual output.

One of them Mean Square Error

J (θ) = \frac{\sum _{i = 0 n} ( h ( x ^{i} ) - y ^{i} ) ^{N}}{2}

and to take minimum value

min (J (θ))

Here, $x^{i}$ and $y^{i}$ are $i^{t h}$ value.

Gradient Descent

It is an optimization algorithm usually used to reduce cost function. Core concept is based on differentiation, it is used for finding minima by moving in negative direction.

Before moving to it, first see term called learning rate.

Learning Rate $(α)$

Learning rate are steps taken by gradient descent algorithm for how much area will calculate at a time.

A high learning rate maybe cover large area in less time but it can be overshoot model learning capabilities, means it learn same feature again and again and behave worse in real world situation.

Low learning rate might be useful but it takes lot of time to reach minima.

Let's move to gradient descent algorithm.

θ_{j} = θ_{j} - α i = 0 \sum m (h (x^{i}) - y^{i}) . x_{j}

Above equation is the gradient descent equation. Note that we minus the differential value from our parameter (weights), why we do that? The answer is, suppose if we add them instead of minus then algorithm go in upward or postive direction which search for maxima instead of minima and we get huge error in our model and that is bad thing. Now let's break down it little bit.

We know $θ_{j}$ as $j^{t h}$ parameter.

$α$ is learning rate, how much step we want to take at a time.

$h (x^{i}) - y^{i}$ difference between $i^{t h}$ predicted output and $i^{t h}$ actual output.

$x_{j}$ is $j^{t h}$ input value.

This algorithm act on all input datasets, means the time consuming for training is directly proportional to input size of datasets. If datasets is lage, time required is also large. For this we have it's another brother called "Stochastic gradient descent".

θ_{j} = θ_{j} + α i = 0 \sum m (h (x^{i}) - y^{i}) . x_{j}

This equation will iterates over definite number of samples, i.e. we can specify how much input data we want to train.

pseudo code for stochastic gradient descent.

Understanding Bell Inequality of Quantum Computing

mac172 — Sun, 27 Mar 2022 16:27:26 +0000

Quantum Mechanics/Physics is rising and intersting field, right?. When learning it you come across topic called Bell Inequality. This is little guide for it.

It is a test which depends on Quantum Mechanics to describe real world experiment.

So let's know what is it and how do we calculate it.

Bell Inequality

John Stewart Bell is a Irish physicist. He devised an amazing test which distinguish between Bohr and Einstein models. Most amazing feature of this test is not only it is philosophies but also testable. So, let's take a look at it.

Before we start learning Bell Inequality, we have to learn it's basic ideas on which it depends. I hope you have basic knowledge about matrices and it's operations.

Basic

Column vector represent as "ket" $∣ ψ ⟩$

Row vector represent as "bra"
$⟨ ψ ∣$

You can look at it like this

Hadamard gate

Also known as H gate. It is single qubit operation that map qubit into equal superposition.

Simply it convert basis state into equally superposition states like this

∣ 0 ⟩ = \frac{∣ 0 ⟩ + ∣ 1 ⟩}{2}

∣ 1 ⟩ = \frac{∣ 0 ⟩ - ∣ 1 ⟩}{2}

Matrix for this is

Simply every element is 1 with scalar multiple of $\frac{1}{2}$

example let's calculate hadamard matrix for $∣ 0 ⟩$

At top we write matrix for $∣ 0 ⟩$ , take look at it because it contains 1 at top and 0 and bottom describing it is at $∣ 0 ⟩$ state. Side of it is Hadamard matrix (H). Below is simply multiplication of 2x2 matrix and 2x1 matrix. After calculating we get 2x1 matrix containing 1 at each position indicating it has both $∣ 0 ⟩ ∣ 1 ⟩$ states
and at the end we can write it in simple form

∣ 0 ⟩ = \frac{∣ 0 ⟩ + ∣ 1 ⟩}{2}

Symbol

CNOT Gate

It is two qubit operation. So it take two qubit as input, label it as first is "control" qubit and second is "target" qubit. Main point to remember is,

If control qubit is 1 then it perform Pauli-X gate on target qubit means convert 0 to 1 or vice-versa.
If control qubit is 0, then target qubit remain unchanged.

You can consider this as classical NOT gate.
Example

∣ 00 ⟩ = ∣ 00 ⟩

∣ 01 ⟩ = ∣ 01 ⟩

∣ 10 ⟩ = ∣ 11 ⟩

∣ 11 ⟩ = ∣ 10 ⟩

Symbol

That's it we need to understand Bell Inequality, although you read EPR and Bell's story as additional resources to your knowledge.

Bell Inequality

Before getting output from Bell circuit (similar to classical logic circuit) it first undergo Hadamard transformation and then CNOT gate act on it and give us output.

Process

Now we have hadamard gates and CNOT gate with us the circuit of Bell state is

So first hadamard gate act on it like

∣ 0 ⟩ = \frac{∣ 0 ⟩ + ∣ 1 ⟩}{2}

And after converting $∣ 0 ⟩$ to it's equally superposition states we apply CNOT gate. As CNOT gate require two qubits as input.

∣ 00 ⟩ = \frac{( ∣ 0 ⟩ + ∣ 1 ⟩ ) ∣ 0 ⟩}{2}

∣ 00 ⟩ = \frac{∣ 00 ⟩ + ∣ 10 ⟩}{2}

We know CNOT gate will change target qubit if control qubit is 1 else it remains unchanged.

∣ 00 ⟩ = \frac{∣ 00 ⟩ + ∣ 11 ⟩}{2}

Similarly we get another 3 states.

for $∣ 01 ⟩$

∣ 01 ⟩ = \frac{∣ 01 ⟩ + ∣ 10 ⟩}{2}

for $∣ 10 ⟩$

∣ 10 ⟩ = \frac{∣ 00 ⟩ - ∣ 11 ⟩}{2}

for $∣ 11 ⟩$

∣ 11 ⟩ = \frac{∣ 01 ⟩ - ∣ 10 ⟩}{2}

And above are Bell's states/pairs