2026-01-25 15:11:06
How are you, hacker?
🪐Want to know what's trending right now?:
The Techbeat by HackerNoon has got you covered with fresh content from our trending stories of the day! Set email preference here.
## AI Doesn’t Mean the End of Work for Us 
By @bernard [ 4 Min read ]
I believe that AI’s impact and future pathways are overstated because human nature is ignored in such statements. Read More.
By @proflead [ 4 Min read ] Read More.
By @davidiyanu [ 11 Min read ] Traditional CI/CD pipelines are buckling under scale. Agentic DevOps promises less toil—but introduces new risks teams must understand. Read More.
By @melissaindia [ 4 Min read ] Bad data secretly slows development. Learn why data quality APIs are becoming core DX infrastructure in API-first systems and how they accelerate teams. Read More.
By @opensourcetheworld [ 3 Min read ] Solo Satoshi is Start9’s first US distributor, shipping the 2026 Server One from Houston so you can run open-source StartOS, apps, and Bitcoin nodes at home. Read More.
By @scylladb [ 5 Min read ] ScyllaDB Vector Search reaches 1B vectors with 2ms p99 latency and 250K QPS, unifying structured data and embeddings at scale. Read More.
By @dharmateja [ 12 Min read ] Why average ROI fails. Learn how distributional and tail-risk modeling protects marketing campaigns from catastrophic losses using Bayesian methods. Read More.
By @stevebeyatte [ 4 Min read ] Miniswap, a Warhammer marketplace founded by Cambridge students, is betting on taste, curation, and community over AI automation. Learn how they raised $3.5M. Read More.
By @davidiyanu [ 6 Min read ] That's the mark of a modern senior engineer: not just writing code that works when everything goes right, but designing resilience into every line Read More.
By @mend [ 9 Min read ] As an opportunity to "kick the tyres" of what agents are and how they work, I set aside a couple of hours to see build one - and it blew me away. Read More.
By @dharmateja [ 11 Min read ] Learn how counterfactual forecasting helps data scientists measure true revenue impact by simulating causal scenarios beyond traditional time series models. Read More.
By @vigneshwaran [ 5 Min read ] Learn how to uninstall problematic Windows 11 updates using Settings, Control Panel, Command Prompt, PowerShell, and Microsoft tools. Read More.
By @btcwire [ 2 Min read ] The platform is capable of producing video with realistic physics, lighting, and motion, making it suitable for marketing content. Read More.
By @williamguo [ 7 Min read ] The core design philosophy of SeaTunnel CDC is to find the perfect balance between "Fast" (parallel snapshots) and "Stable" (data consistency). Read More.
By @hck3remmyp3ncil [ 11 Min read ] RAG optimizes language model outputs by having them reference external knowledge bases before generating responses. Read More.
By @stevebeyatte [ 12 Min read ] Modern midsize companies need platforms that balance sophistication with agility, offering powerful features without overwhelming complexity. Read More.
By @vigneshwaran [ 5 Min read ] Learn how to create a Windows 11 bootable USB using Rufus for installation, upgrades, or system recovery in this step-by-step guide. Read More.
By @nathanbsmith729 [ 5 Min read ] The week immediately started with deep equity losses Monday and Tuesday. Read More.
By @farida [ 4 Min read ] The rise of Agentic AI has fueled predictions of improved company performance and stronger stock returns. Read More.
By @techexplorer42 [ 8 Min read ]
Learn how DAOs work by building a governance token with Solidity, OpenZeppelin, and Foundry, from deployment to testing on a local blockchain. Read More.
🧑💻 What happened in your world this week? It's been said that writing can help consolidate technical knowledge, establish credibility, and contribute to emerging community standards. Feeling stuck? We got you covered ⬇️⬇️⬇️
ANSWER THESE GREATEST INTERVIEW QUESTIONS OF ALL TIME
We hope you enjoy this worth of free reading material. Feel free to forward this email to a nerdy friend who'll love you for it.
See you on Planet Internet! With love,
The HackerNoon Team ✌️
.gif)
2026-01-25 09:59:59
Why wider neural networks usually break—and how a simple mathematical constraint lets deep models grow smarter without collapsing.
2026-01-25 03:00:19
Some recent trends in theoretical ML
2.1 Deep Learning via continuous-time controlled dynamical system
2.2 Probabilistic modeling and inference in DL
3.1 Kuramoto models from the geometric point of view
3.2 Hyperbolic geometry of Kuramoto ensembles
3.3 Kuramoto models with several globally coupled sub-ensembles
Kuramoto models on higher-dimensional manifolds
4.1 Non-Abelian Kuramoto models on Lie groups
4.2 Kuramoto models on spheres
4.3 Kuramoto models on spheres with several globally coupled sub-ensembles
5.1 Statistical models over circles and tori
5.2 Statistical models over spheres
5.3 Statistical models over hyperbolic spaces
5.4 Statistical models over orthogonal groups, Grassmannians, homogeneous spaces
6.1 Training swarms on manifolds for supervised ML
6.2 Swarms on manifolds and directional statistics in RL
6.3 Swarms on manifolds and directional statistics for unsupervised ML
6.4 Statistical models for the latent space
6.5 Kuramoto models for learning (coupled) actions of Lie groups
6.6 Grassmannian shallow and deep learning
6.7 Ensembles of coupled oscillators in ML: Beyond Kuramoto models
Examples
7.2 Linked robot’s arm (planar rotations)
7.3 Linked robot’s arm (spatial rotations)
7.4 Embedding multilayer complex networks (Learning coupled actions of Lorentz groups)
In 1994. Watanabe and Strogatz [69] demonstrated that the simple Kuramoto ensemble with globally coupled identical oscillators exhibits 3-dimensional dynamics. They have shown that dynamics of a large ensemble can be reduced to the system of ODE’s for three global variables. This implies that an ensemble consisting of N oscillators admits N − 3 constants of motion. This result initiated the new research direction which deals with symmetries and invariant submanifolds in simple Kuramoto networks.
\ The underlying symmetries have been exposed in 2009. by Marvel, Mirrolo and Strogatz [70].
\
\ Proposition 1. [70]
\
\ Further insights into the relation between hyperbolic geometry and Kuramoto models have been reported in [71]. It has been demonstrated that (under certain conditions on the coupling function f) Kuramoto dynamics of the form (6) are gradient flows in the unit disc with respect to hyperbolic metric. Potential function for dynamics (7) has particularly transparent geometric interpretation. It turns out that dynamics of Kuramoto ensembles with repulsive interactions uncover a point inside the unit disc that has the minimal sum of hyperbolic distances to the initial points on S1. In complex analysis this point is conformal barycenter [72] of the initial configuration.
\
:::info Author:
(1) Vladimir Jacimovic, Faculty of Natural Sciences and Mathematics, University of Montenegro Cetinjski put bb., 81000 Podgorica Montenegro ([email protected]).
:::
:::info This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license.
:::
\
2026-01-25 03:00:12
Today the Go team is pleased to release Go 1.25. You can find its binary archives and installers on the download page.
\
Go 1.25 comes with improvements over Go 1.24 across its tools, the runtime, compiler, linker, and the standard library, including the addition of one new package. There are port-specific changes and GODEBUG settings updates.
\
Some of the additions in Go 1.25 are in an experimental stage and become exposed only when you explicitly opt in. Notably, a new experimental garbage collector, and a new experimental encoding/json/v2 package are available for you to try ahead of time and provide your feedback. It really helps if you’re able to do that!
\ Please refer to the Go 1.25 Release Notes for the complete list of additions, changes and improvements in Go 1.25.
\ Over the next few weeks, follow-up blog posts will cover some of the topics relevant to Go 1.25 in more detail. Check back in later to read those posts.
\ Thanks to everyone who contributed to this release by writing code, filing bugs, trying out experimental additions, sharing feedback, and testing the release candidates. Your efforts helped make Go 1.25 as stable as possible. As always, if you notice any problems, please file an issue.
\ We hope you enjoy using the new release!
Dmitri Shuralyov, on behalf of the Go team
\ This article is available on The Go Blog under a CC BY 4.0 DEED license.
\ Photo by Francesco Gallarotti on Unsplash
2026-01-25 02:00:03
How a JSON or JSON-like language enables the next generation of safe human and AI-generated UIs
In The Future of AI-Generated UI, I pointed out that the raw JavaScript generated by AI-generated code is a security problem, and the flexibility of JavaScript without a framework can result in hard-to-manage code. I argued that we need declarative, sandboxed formats like A2UI or a Computational DOM (cDOM) with JSON Pointer Regular Expressions (JPRX if), if we want to trust an LLM to build our interfaces.
\ It also helps if the approach is based on industry standards for which there is lots of documentation and examples that have probably been consumed by LLMs during training. cCOM and JPRX do this; they incorporate concepts and syntax from JSON Pointers, JSON Schema, and XPath.
\ In my previous article, to show how a cDOM and JPRX work, I used a reactive counter, but let's be real: reactive counters and to-do lists are easy. Any framework looks elegant when the logic fits on a napkin. To prove a JSON-based approach actually holds up, you need a problem with messy state, edge cases, and distinct modes of operation. You need a calculator.
\ Calculators are inherently tricky:
\
So, I asked Claude Opus to build a fully functional, iOS-style calculator using zero custom JavaScript functions - just declarative cDOM and JPRX expressions. The fact that AI could produce a declarative calculator with little prompting purely from documentation demonstrates another point I made in my earlier article: cDOM and JPRX aren't just new syntax. They can be a protocol for human-machine collaboration. \n
\n The CodeTo reduce characters and quotation noise while allowing inline explanation, I am using cDOMC, a compressed version of a cDOM. A regular cDOM does not support comments and requires quotes around attributes and JPRX expressions. When represented with quotes and without comments, cDOM can be treated as regular JSON.
\
{
div: {
class: "calculator",
// A calculator feels stateless, but it's actually a strict state machine.
// You're never just "typing a number"; you're either entering the first operand,
// waiting for an operator, or entering the next operand.
onmount: =state({
display: "0", // What you see on the screen
expr: "", // History string, (e.g. "8 + 5 =")
prev: "", // value stored before an operation
op: "", // the active operator
waiting: false // true when expecting a new number vs operator
},{
name: "c", // the root name of our state, so we can express things like: /c/display
schema: "polymorphic", // allow type changes, e.g. "0" or 0
scope: $this // scope the path to the current element
}),
children: [
// Display area
{
div: {
class: "display",
children: [
{ div: { class: "expression",children[=/c/expr] }},
{ div: { class: "result",children[=/c/display] }}
]
}
},
// Button grid
{
div: {
class: "buttons",
children: [
// Row 1: AC, ±, %, ÷
{
button: {
class: "btn btn-clear",
onclick: =/c = { display: "0", expr: "", prev: "", op: "", waiting: false },
children: ["AC"]
}
},
{
button: {
class: "btn btn-function",
onclick: =/c = { display: negate(/c/display), waiting: true, expr: "" },
children: ["±"]
}
},
{
button: {
class: "btn btn-function",
onclick: =/c = { display: toPercent(/c/display), waiting: true, expr: "" },
children: ["%"]
}
},
// Divison is our first operator. This is where it gets tricky.
// When you click `+`, you can't just link `prev` to `display`.
// If you did, `prev` would update every time you selected a new digit for the**second**number,
// breaking the math. We need a snapshot of the value at that exact moment.
// Excel solves this with INDIRECT, effectively dereferencing a cell. JPRX borrows the same concept:
{
button: {
class: "btn btn-operator",
onclick: =/c = {
prev: indirect(/c/display), // Capture the value right now
expr: concat(/c/display, " ÷"),
op: "/", waiting: true
},
children: ["÷"]
}
},
// Row 2: 7, 8, 9, ×
// I have 10 number buttons. Do I write 10 handlers? Do I write a loop? In React or Vue,
// you'd probably map over an array. With JPRX, the DOM is the data key and although map is available,
// I represent the calculator using literals in this example. In a future article I will cover map.
// By giving each button an `id` (e.g., `id: "7"`), we write a uniform logic expression that adapts
// to whichever element triggered it. We just reference $this.id in JPRX and use an xpath to get the text
// content for the child node, #../@id. In cDOM (not JPRX) '#' delimits the start of an xpath expression
{
button: {
id: "7",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id] // use xpath (starting char #) to get the text for the button from parent id
}
},
// Here's what is happening:
// Waiting for input? (e.g., just hit `+`) → Replace the display with the button's ID.
// Displaying "0"? → Replace it (avoids "07").
// Otherwise: → Append the button's ID.
// This is replicated identically for every number button. No loops, no external helper functions.
{
button: {
id: "8",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0), $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
id: "9",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
class: "btn btn-operator",
onclick: =/c = {
prev: indirect(/c/display), expr: concat(/c/display, " ×"), op: "*", waiting: true
},
children: ["×"]
}
},
// Row 3: 4, 5, 6, −
{
button: {
id: "4",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
id: "5",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
id: "6",
class: "btn btn-number",
onclick: =/c = {
display: if(/c/waiting, $this.id, if(/c/display==0, $this.id, concat(/c/display, $this.id))), waiting: false
},
children: [#../@id]
}
},
{
button: {
class: "btn btn-operator",
onclick: =/c = {
prev: indirect(/c/display), expr: concat(/c/display, " −"), op: "-", waiting: true
},
children: ["−"]
}
},
// Row 4: 1, 2, 3, +, use set and eq just to demonstrate equivalence with = and ==
// the buttons below use 'set' in place of the infix operator '=', just to show a different way of doing things
{
button: {
id: "1",
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), $this.id, concat(/c/display, $this.id))),
waiting: false
}),
children: [#../@id]
}
},
{
button: {
id: "2",
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), $this.id, concat(/c/display, $this.id))),
waiting: false
}),
children: [#../@id]
}
},
{
button: {
id: "3",
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), $this.id, concat(/c/display, $this.id))),
waiting: false
}),
children: [#../@id]
}
},
{
button: {
class: "btn btn-operator",
onclick: =set(/c, {
prev: indirect(/c/display),
expr: concat(/c/display, " +"),
op: "+", waiting: true }),
children: ["+"]
}
},
// Row 5: 0, ., =
{
button: {
id: "0",
class: "btn btn-number btn-wide",
onclick: =set(/c, {
display: if(/c/waiting, $this.id,
if(eq(/c/display, "0"), "0", concat(/c/display, $this.id))),
waiting: false }),
children: [#../@id]
}
},
{
button:
{
class: "btn btn-number",
onclick: =set(/c, {
display: if(/c/waiting, "0.",
if(contains(/c/display, "."), /c/display, concat(/c/display, "."))),
waiting: false }),
children: ["."]
}
},
// Finally, the math. We need to say:
// 1. Take the snapshot we stored
// 2. Apply the current operator
// 3. combine it with what's on screen now
// This is the job of calc(). If prev == 8 and op == * and display = 5, then calc would be evaluated as calc("8 * 5")
// To keep the syntax a little cleaner we also use $(<path>) as a shorthand for indirect.
{
button:
{
class: "btn btn-equals",
onclick: =set(/c, {
display: if(eq(/c/op, ""), /c/display, calc(concat("$('/c/prev') ", /c/op, " $('/c/display')"))),
expr: concat(/c/expr, " ", /c/display, " ="),
prev: "", op: "",
waiting: true }),
children: ["="]
}
}
]
}
},
// Branding
{
div: {
class: "branding",
children: [
{
span: {
children: [
"Built with ",
{
a: {
href: "https://github.com/anywhichway/lightview", target: "_blank",
children: ["Lightview"]
}
},
" cDOM • No custom JS!"
]
}
}
]
}
}
]
}
}
\
Lightview supports hypermedia capability similar to HTMX by allowing the use of the src attribute on almost any element.
\
Simply reference a cDOM file using src:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description"
content="A beautiful calculator built with Lightview cDOM and JPRX reactive expressions - no custom JavaScript!">
<title>Calculator | Lightview cDOM</title>
<link rel="stylesheet" href="calculator.css">
<!-- Load Lightview scripts -->
<script src="/lightview.js"></script> <!-- DOM as JSON and reactivity support -->
<script src="/lightview-x.js"></script> <!-- hypermedia support -->
<script src="/lightview-cdom.js"></script> <-- cDOM/JPRX support -->
</head>
<body>
<!-- The calculator cDOM is loaded via Lightview's hypermedia src attribute -->
<div id="app" src="./calculator.cdomc"></div>
</body>
</html>
\
The src attribute works like an HTML <img> or <script> tag - Lightview automatically fetches the .cdomc file, parses it, and renders the reactive content into the target element. This approach:
You might look at concat("$('/c/prev') ...") and ask: Why in the world wouldn't you just write parseFloat(prev) + parseFloat(curr)?
\ If you are a human writing code for yourself? You probably would. Lightview supports standard JS handlers for exactly that reason.
\ But if you are building infrastructure for AI Agents, the calculus changes. Sticking to a declarative, JSON-based path offers things raw code can't:
\
Sandboxing: It executes in a controlled environment. The logic can't access `window`, make global fetch requests, or execute arbitrary secondary code. This makes it safe to "hot swap" UI logic generated by an LLM in real-time.
Portability: This entire UI—logic and all—is just data. It can be sent from a server, stored in a database, or streamed from an AI model.
Mental Model: It forces a clear separation between state transformations and view structure, which is exactly how LLMs reason best.
\n This calculator proves that "declarative" doesn't have to mean "dumb." With the right primitives - state, conditionals, and path-based referencing—you can build rich, complex interactions without ever leaving the data structure.
This series isn't just about a new library. It's about finding the right abstraction layer for the AI age.
\ In The Future of AI-Generated UI, we looked at the risks of letting LLMs write raw scripts and introduced the "Data as UI" philosophy.
\n In this article, we showed that "Data as UI" doesn't mean "dumb UI." We handled state, context, data snapshots, math, and DOM navigation with ‘xpath’ without executing a single line of custom JavaScript.
\n cDOM defines structure. JPRX defines behavior. It’s reactivity without the compilation and UI without the security risks.
The complete calculator is available at:
\
2026-01-25 01:30:04
The Rust team has published a new point release of Rust, 1.77.2. Rust is a programming language that is empowering everyone to build reliable and efficient software.
\ If you have a previous version of Rust installed via rustup, getting Rust 1.77.2 is as easy as:
rustup update stable
\
If you don't have it already, you can get rustup from the appropriate page on our website.
This release includes a fix for CVE-2024-24576.
\
Before this release, the Rust standard library did not properly escape arguments when invoking batch files (with the bat and cmd extensions) on Windows using the Command API. An attacker able to control the arguments passed to the spawned process could execute arbitrary shell commands by bypassing the escaping.
\ This vulnerability is CRITICAL if you are invoking batch files on Windows with untrusted arguments. No other platform or use is affected.
\ You can learn more about the vulnerability in the dedicated advisory.
Many people came together to create Rust 1.77.2. We couldn't have done it without all of you. Thanks!
The Rust Security Response WG
\ Also published here
\ Photo by holigil 27 on Unsplash
\
