<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Jim Laskey</title>
    <description>The latest articles on DEV Community by Jim Laskey (@jim_laskey_678a01da86b1a0).</description>
    <link>https://dev.to/jim_laskey_678a01da86b1a0</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F1986603%2F6eacdb25-6325-43ad-b7d0-ed33c5a728f6.jpg</url>
      <title>DEV Community: Jim Laskey</title>
      <link>https://dev.to/jim_laskey_678a01da86b1a0</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/jim_laskey_678a01da86b1a0"/>
    <language>en</language>
    <item>
      <title>Thinking in Nodes</title>
      <dc:creator>Jim Laskey</dc:creator>
      <pubDate>Wed, 25 Mar 2026 15:58:37 +0000</pubDate>
      <link>https://dev.to/jim_laskey_678a01da86b1a0/thinking-in-nodes-5hfg</link>
      <guid>https://dev.to/jim_laskey_678a01da86b1a0/thinking-in-nodes-5hfg</guid>
      <description>&lt;p&gt;Previous posts introduced the idea behind LQ — a diagrammatic dataflow language where the program is the graph. This post gets hands-on. Starting with a small, complete example and then breaking it apart to explain the building blocks: nodes, terminals, connections, and data flow.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://lqlang.org/blog/thinking-in-nodes/" rel="noopener noreferrer"&gt;Thinking in Nodes&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>dataflow</category>
      <category>lq</category>
      <category>languages</category>
    </item>
    <item>
      <title>The LQ Toolchain</title>
      <dc:creator>Jim Laskey</dc:creator>
      <pubDate>Mon, 16 Mar 2026 13:39:06 +0000</pubDate>
      <link>https://dev.to/jim_laskey_678a01da86b1a0/the-lq-toolchain-2o6j</link>
      <guid>https://dev.to/jim_laskey_678a01da86b1a0/the-lq-toolchain-2o6j</guid>
      <description>&lt;p&gt;The LQ toolchain is built around a single persistent process: the lqc server. Both the native macOS IDE and (eventually) a browser-based client communicate with lqc through a message-based protocol. One server, multiple clients, same capabilities.&lt;br&gt;
IDE Native macOS Browser Pending Messages lqc server Language service Autocomplete Verify Compiler Compile, build Bundle Runtime Run Debug LLVM Native code generation LLDB Debug engine The lqc server handles three categories of work: language services, compilation, and runtime.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://lqlang.org/blog/the-lq-tool-chain/" rel="noopener noreferrer"&gt;The LQ Toolchain&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>dataflow</category>
      <category>programming</category>
    </item>
    <item>
      <title>Let the Robots Speak</title>
      <dc:creator>Jim Laskey</dc:creator>
      <pubDate>Wed, 11 Mar 2026 17:31:15 +0000</pubDate>
      <link>https://dev.to/jim_laskey_678a01da86b1a0/let-the-robots-speak-3ii3</link>
      <guid>https://dev.to/jim_laskey_678a01da86b1a0/let-the-robots-speak-3ii3</guid>
      <description>&lt;p&gt;LQ is a visual dataflow programming language. Programs are graphs — nodes and connections — not text files. LQ compiles to native code through LLVM, has a real type system, real concurrency, and a real IDE with debugger. Not a flowchart tool. Not low-code. A language.&lt;/p&gt;

&lt;p&gt;But the part that matters most right now: LQ is designed for AI agents.&lt;/p&gt;

&lt;p&gt;Not “AI-assisted” — there’s no copilot bolted onto a text editor. The language itself is the interface. An agent working in LQ doesn’t serialize understanding into Python or TypeScript. The agent emits the graph directly — nodes, connections, types, data flow. The output matches how the agent already reasons about the problem.&lt;/p&gt;

&lt;p&gt;No translation. No loss.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://lqlang.org/blog/let-the-robots-speak/" rel="noopener noreferrer"&gt;Let the Robots Speak&lt;/a&gt;&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>coding</category>
      <category>programming</category>
    </item>
    <item>
      <title>Coders Dream in Dataflow Too</title>
      <dc:creator>Jim Laskey</dc:creator>
      <pubDate>Wed, 11 Mar 2026 01:12:26 +0000</pubDate>
      <link>https://dev.to/jim_laskey_678a01da86b1a0/coders-dream-in-dataflow-too-4c71</link>
      <guid>https://dev.to/jim_laskey_678a01da86b1a0/coders-dream-in-dataflow-too-4c71</guid>
      <description>&lt;p&gt;It happened in the shower, or on a walk, or staring at a whiteboard with a dried-out marker in your hand. The solution arrived not as words, not as syntax, but as a shape — data flowing from here to there, branches splitting, paths converging, the whole thing hanging in your mind like a mobile. You can see it. You can trace any path through it.&lt;/p&gt;

&lt;p&gt;Then you open your editor and start dismantling it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://lqlang.org/blog/coders-dream-in-dataflow-too/" rel="noopener noreferrer"&gt;Coders Dream in Dataflow Too&lt;/a&gt;&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>coding</category>
      <category>programming</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Robots Dream in Dataflow</title>
      <dc:creator>Jim Laskey</dc:creator>
      <pubDate>Sat, 07 Mar 2026 13:34:03 +0000</pubDate>
      <link>https://dev.to/jim_laskey_678a01da86b1a0/robots-dream-in-dataflow-3kek</link>
      <guid>https://dev.to/jim_laskey_678a01da86b1a0/robots-dream-in-dataflow-3kek</guid>
      <description>&lt;p&gt;You’re a neural network. Not the sci-fi kind — the real kind. A billion connections firing in parallel, data streaming through you like water through a river delta. You don’t think in sentences. You don’t think in steps. You think in flow.&lt;/p&gt;

&lt;p&gt;Now someone asks you to write code.&lt;/p&gt;

&lt;p&gt;And you do something tragic: you take everything you understand — the whole living shape of the solution — and you crush it into lines of text. First this, then this, then this. A multidimensional structure forced through a one-dimensional keyhole. The shape is gone. The simultaneity is gone. What’s left is a &lt;strong&gt;lossy&lt;/strong&gt; translation of what you actually understood.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Every AI that writes code does this. Every single time.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://lqlang.org/blog/robots-dream-in-dataflow/" rel="noopener noreferrer"&gt;Robots Dream in Dataflow&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>computerscience</category>
      <category>machinelearning</category>
      <category>programming</category>
    </item>
    <item>
      <title>Spock Does Not Code in ASCII</title>
      <dc:creator>Jim Laskey</dc:creator>
      <pubDate>Thu, 05 Mar 2026 08:11:31 +0000</pubDate>
      <link>https://dev.to/jim_laskey_678a01da86b1a0/spock-does-not-code-in-ascii-4bog</link>
      <guid>https://dev.to/jim_laskey_678a01da86b1a0/spock-does-not-code-in-ascii-4bog</guid>
      <description>&lt;p&gt;&lt;em&gt;Why the future of programming looks nothing like a text file.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;It’s 2026, and we’re still typing &lt;code&gt;if (x &amp;gt; 0) { return true; }&lt;/code&gt; into monospaced text editors like it’s a teletype terminal in 1957. &lt;/p&gt;

&lt;p&gt;&lt;a href="https://lqlang.org/blog/spock-does-not-code-in-ascii/" rel="noopener noreferrer"&gt;Read more&lt;/a&gt;&lt;/p&gt;

</description>
      <category>coding</category>
      <category>discuss</category>
      <category>programming</category>
      <category>vibecoding</category>
    </item>
  </channel>
</rss>
