<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Flow-Based Programming on A system brought to life</title>
    <link>https://blog.kodigy.com/categories/flow-based-programming/</link>
    <description>Recent content in Flow-Based Programming on A system brought to life</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>© Vladimir Sibirov. Code released under the MIT license.</copyright>
    <lastBuildDate>Sun, 04 Jan 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://blog.kodigy.com/categories/flow-based-programming/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Actor Mesh: Enterprise Architecture for Scalable AI Engineering</title>
      <link>https://blog.kodigy.com/post/actor-mesh-architecture/</link>
      <pubDate>Sun, 04 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.kodigy.com/post/actor-mesh-architecture/</guid>
      <description>Introduction Building intelligent systems at scale is tricky. On the surface, modern AI gives us powerful components (LLMs, Transformers, ML) ready to integrate into our applications. Yet assembling these pieces into a coherent, resilient, and cost-effective whole remains a tough challenge, especially as systems grow beyond simple request-response patterns.
This article presents a comprehensive approach to this problem through the Actor Mesh pattern: a distributed architecture that organizes AI models, machine learning pipelines, and conventional business logic as a network of autonomous, asynchronous actors.</description>
    </item>
    
    <item>
      <title>AI Engineering Goes Visual part 2: Building an LLM RAG with PyFlyde &amp; LangChain</title>
      <link>https://blog.kodigy.com/post/visual-ai-engineering-with-pyflyde-pt2-rag/</link>
      <pubDate>Sun, 03 Aug 2025 00:00:00 +0000</pubDate>
      
      <guid>https://blog.kodigy.com/post/visual-ai-engineering-with-pyflyde-pt2-rag/</guid>
      <description>Introduction and recap of Part 1 Welcome back to our journey into Visual AI Engineering with PyFlyde! In this second part of our tutorial, we&amp;rsquo;ll dive deeper into the fascinating world of AI and data engineering, combining modern tools and libraries with the intuitive power of visual programming.
In Part 1 of this tutorial, we embarked on an exciting journey to build a flexible data extraction flow. We successfully created a web scraper that fetches articles from the Software Leads Weekly newsletter, cleans them up, and saves them as local Markdown files.</description>
    </item>
    
    <item>
      <title>AI Engineering Goes Visual part 1: Web Scraping &amp; Data Prep with PyFlyde</title>
      <link>https://blog.kodigy.com/post/visual-ai-engineering-with-pyflyde-pt1-scraper/</link>
      <pubDate>Sat, 02 Aug 2025 00:00:00 +0000</pubDate>
      
      <guid>https://blog.kodigy.com/post/visual-ai-engineering-with-pyflyde-pt1-scraper/</guid>
      <description>Introduction Building data pipelines often involves integrating multiple tools and services into complex workflows. While traditional programming approaches are effective, visual tools can offer a more intuitive and streamlined way to design and manage these workflows.
In this tutorial, we will explore how to use Flyde, a visual programming tool, to construct a web scraper that feeds into a Retrieval Augmentation Generation (RAG) system. This tutorial aims to go beyond basic examples to demonstrate a more complex application, providing insights into the advantages and trade-offs of visual programming.</description>
    </item>
    
    <item>
      <title>The state of Flow-based Programming</title>
      <link>https://blog.kodigy.com/post/state-of-flow-based-programming/</link>
      <pubDate>Sun, 28 Aug 2022 17:30:12 +0200</pubDate>
      
      <guid>https://blog.kodigy.com/post/state-of-flow-based-programming/</guid>
      <description>In memory of J. Paul Morrison. May he rest in peace, and his work continue to live.
I started this article in 2018 as a collection of observations and ideas that I wanted to share with the Flow-based Programming community. It didn&amp;rsquo;t go beyond a quick draft that never got published. During the next 4 years I barely thought about Flow-based Programming. My focus was on figuring out how software is built in large companies.</description>
    </item>
    
    <item>
      <title>Forcing a specific NoFlo version for all dependencies</title>
      <link>https://blog.kodigy.com/post/noflo_08_npm_shrinkwrap/</link>
      <pubDate>Mon, 13 Mar 2017 18:25:04 +0300</pubDate>
      
      <guid>https://blog.kodigy.com/post/noflo_08_npm_shrinkwrap/</guid>
      <description>Using NPM Shrinkwrap to force NoFlo 0.8 Recently released 0.8 branch of NoFlo introduces several fundamental changes as well as a backwards compatibility layer for long-existing applications. However, the backwards compatibility layer is only capable of doing its job if all NPM dependencies in a project use noflo@0.8.*. Which means that if a project uses an old library that depends on something like noflo@0.5.22, the compatibility layer may work incorrectly.</description>
    </item>
    
    <item>
      <title>Development efficiency challenges in NoFlo</title>
      <link>https://blog.kodigy.com/post/noflo_development_efficiency/</link>
      <pubDate>Mon, 07 Nov 2016 17:39:26 +0100</pubDate>
      
      <guid>https://blog.kodigy.com/post/noflo_development_efficiency/</guid>
      <description>Development efficiency challenges in NoFlo Programming with NoFlo is getting more and more smooth with every release. However, if maintaining a NoFlo application is your day-to-day job you may notice some inconveniences.
Defining new components is slow Every time you add a new component you have to define a pretty massive hash map of its ports, their data types and preferably at least descriptions. This is cool as it encourages you to declare as many details as possible but it’s not very friendly to rapid prototyping where you want just to list the ports and get your hands on the code and add details later.</description>
    </item>
    
    <item>
      <title>On NoFlo database applications</title>
      <link>https://blog.kodigy.com/post/on_noflo_db_apps/</link>
      <pubDate>Wed, 27 Jul 2016 14:25:04 +0100</pubDate>
      
      <guid>https://blog.kodigy.com/post/on_noflo_db_apps/</guid>
      <description>On NoFlo Database Applications Thinking over common parts of database applications&amp;hellip;
… I came to some conclusions below
Common application architecture Steps common to all route graphs The only processing step that is often present and easy to decompose is Validate (fig. I and II). String of pearls or Pipeline or Request backbone Request flow should be serial, it simplifies synchronization and understanding of the flow. Each bone in the spine of the graph or step on the pipeline can process some data in parallel.</description>
    </item>
    
    <item>
      <title>Running web services as NoFlo graphs</title>
      <link>https://blog.kodigy.com/post/noflo_webservices/</link>
      <pubDate>Fri, 23 Jan 2015 14:38:41 +0100</pubDate>
      
      <guid>https://blog.kodigy.com/post/noflo_webservices/</guid>
      <description>Getting All Things NoFlo This article describes things which are yet TODO to get the entire server architecture running on NoFlo (and in Flowhub), problems related to them and potential solutions.
Request Isolation By default there is no isolation between IPs belonging to different user requests in NoFlo networks.
Solution 1 (current): a new Network instance per request Express does its job conventionally, while request handlers instantiate NoFlo networks on demand.</description>
    </item>
    
    <item>
      <title>Comparison of dataflow models</title>
      <link>https://blog.kodigy.com/post/dataflow-model-comparison/</link>
      <pubDate>Sun, 03 Jun 2012 15:56:29 +0100</pubDate>
      
      <guid>https://blog.kodigy.com/post/dataflow-model-comparison/</guid>
      <description>Comparison of dataflow models Mathematical model of choice Comparison criteria and analysis methods should be chosen before performing actual analysis.
We will solve the task of parallel computation model evaluation as a multiple criteria choice. In order to do this, a set of particular criteria is outlined and for each of them a mapping to the real numbers set is defined:
k(x):i(x)→R(1) where x - is alternative choice (model); i(x) - is a particular factor value; R - is the set of real numbers; k - is the particular criterion number, k∈[1,K]; K - total number of particular criteria.</description>
    </item>
    
  </channel>
</rss>
