标签：#r

Hello everyone! In this article, we will take a technical look at Tencent EdgeOne Makers , a Web and Agent development and deployment platform built on Tencent EdgeOne infrastructure. Rather than following a step-by-step tutorial, we will explore how the platform works behind the scenes and how its different technologies work together to support modern web applications. We will look at the journey from source code and build processes to deployment on the EdgeOne network. We will also explore how edge computing and caching deliver content closer to users, how Edge Functions and Cloud Functions handle server-side workloads, and how EdgeOne Makers supports AI Agents, storage, deployment environments, and developer tools . By understanding how these components interact, we can get a clearer picture of what Tencent EdgeOne Makers offers and how its architecture differs from traditional web hosting. Modern web applications are built from more than a frontend. They may combine APIs, serverless computing, storage, deployment automation, and AI services. Tencent EdgeOne Makers is a Web and Agent development and deployment platform built on Tencent EdgeOne infrastructure. It brings these capabilities into one environment, connecting application development with build processes, deployment, edge delivery, serverless execution, and AI development. EdgeOne Makers evolved from EdgeOne Pages, expanding from frontend hosting to full-stack Web and Agent development. Its architecture connects source code, deployment, and EdgeOne's global edge network. 1. From Source Code to Deployment At the center of Makers is its build and deployment workflow. A project can be connected to a Git repository, allowing Makers to detect common frameworks and apply build configurations. Developers can define parameters such as the root directory, installation command, build command, and output directory. Source Code → Git Repository → Build System → Deployment → EdgeOne Infrastructure → Users A push to

If you've ever lost 20 minutes at 2 AM debugging a submask enumeration loop, or drawn a segment tree on paper for the fifth time this month, this post is for you. I want to share a collection of 31 free, browser-based tools built specifically for competitive programming — no signup, no installs, code stays client-side. They're grouped at Utility Tools Lab's Competitive Programming category , and they cover almost every "I wish there was a tool for this" moment from contest practice. Here's a tour of what's inside. Visualizing structures you normally only imagine Half the pain in CP isn't the algorithm — it's seeing what your data structure is actually doing. Graph Visualizer — paste a CP-style edge list and get a force-directed graph you can drag around. Toggle directed/undirected and 0/1-indexing, then copy the adjacency list back out. Segment Tree Builder — feed in an array, pick sum/min/max/gcd, and watch the tree render, plus grab a full C++ class template. Sparse Table Builder — visualizes every level of the O(1) RMQ precomputation, with live queries. Union-Find (DSU) Visualizer — watch path compression and union-by-rank happen live on a forest view. Path Finder — paint walls on a grid and run BFS to see the shortest path animate, then copy the grid as a C++ 2D vector. Sieve Visualizer — step through the Sieve of Eratosthenes on a color-coded grid. Sorting Visualizer and Binary Search Visualizer — step-by-step animations with live comparison counts, or lo/hi/mid tracking on your own array. These aren't just "nice to look at" — watching the not-found path in binary search, or the moment a submask loop wraps around, is often exactly where off-by-one bugs hide. Code generators that skip the boilerplate Some things in CP are conceptually simple but easy to typo under time pressure. These tools generate ready-to-paste C++: Bitmask Planner — set N ≤ 12, visualize all 2^N states and submask iteration order, get a DP skeleton. PBDS Generator — Order Statistics Tree boi

Messy modules rarely break because a pure helper returns the wrong integer on a tidy fixture. They break because three functions share a temporary CSV path, an environment flag, and a cache nobody named. A coding agent then proposes a cleanup that deletes dead branches, renames locals, and still satisfies every existing assertion. The next production export fails because the implicit file layout moved while the return payload stayed identical. That failure mode is the reason this workflow exists, and it is not a style problem. The first commit should freeze a ledger of hidden couplings and store a hash beside it. Only after that hash is in source control should you allow one structural change. The cleanup is legitimate only when the recorded hash remains identical. Cleanup diffs fail differently than feature diffs Feature work usually changes an observable on purpose, so reviewers know which assertions must move. Cleanup work is sold as behavior-preserving, which trains people to trust deletions and rename-only hunks. Coding agents amplify that bias because they optimize for shorter files, conventional names, and green unit tests. Reviewers then accept large deletions that would look suspicious inside a feature pull request. Return-value tests are the wrong gate for that class of change. The public function can still return {"ok": true, "rows": 12} while the working directory quietly shifts. Downstream jobs that glob files or catch a named exception will fail after merge. Those hidden couplings remain part of the contract even when no unit test mentions them. Build a side-effect ledger instead of another unit test Treat the messy module as a black box that emits more than a return value. A ledger is a canonical JSONL file with one record per fixture and fully sorted keys. Side-effect entries need stable ordering so the serialized bytes stay deterministic across reruns. The SHA-256 digest of that file is the only number that must remain constant. Each record should c

I have no idea what I'm f*cking doing. Something I keep questioning: Why the hell am I building an operating system for this? Seriously. Every couple of weeks I look at ShrekOS, look at the amount of work involved in building an actual Linux distribution, and have basically the same reaction. This is f*cking ridiculous. I wanted a safer way to run AI agents on my computer. Somehow that turned into an immutable Debian system with isolated workloads, capability grants, controlled egress, verified updates, a desktop policy layer, an installer, and enough architecture documents to make me question every decision that led me here. There has to be an easier answer. There has to be some tool I missed. Run the agents in Docker. Use Podman. Use a VM. Use a better agent harness. Install some security middleware. Find a desktop application that manages all of this. Anything other than: Build a f*cking operating system. So I keep trying to prove that ShrekOS does not need to exist. And the annoying part is that every time I do, I eventually end up back at the same problem. I already know containers exist I already wrote the technical version of this question in Why I'm Building ShrekOS When Containers Already Exist . I am not going to repeat that whole argument here. Containers are useful. I use them. The Bench system in ShrekOS literally runs on rootless container technology. I did not invent a magical new isolation primitive because AI showed up. Namespaces exist. Seccomp exists. Landlock exists. Containers exist. Virtual machines exist. Linux already has an absurd number of ways to restrict a process. That is not the thing I keep getting stuck on. The thing I cannot seem to find is the user space around all of it . Not userspace in the kernel terminology sense. I mean the actual space where the human uses the computer. The desktop. The workflow. The place where I can run several autonomous things on my machine and understand, at a glance, what each one is allowed to do. I wa

Somewhere in the DataLens build, my teammate and I hit the wall every "zero-dependency" project eventually hits: the anomaly detector needed a neural net, and the rulebook said no third-party packages. No NumPy. No pandas. No scikit-learn. Just Python 3.14's standard library. Our first reaction was denial. You cannot build an ANN without a matrix library — everyone knows that. numpy.dot() is basically load-bearing infrastructure for machine learning in Python. We spent an embarrassing amount of time trying to convince ourselves some obscure math submodule secretly did vectorized linear algebra. It doesn't. There is no shortcut. If you want matrix multiplication in pure stdlib Python, you write nested for loops and you like it. What we normally would have installed In any other project, this is a two-second decision: pip install numpy , import it, move on with your life. Matrix ops, broadcasting, vectorized activation functions — all free. Neither of us had ever really had to think about how A @ B works under the hood, because neither of us had ever had to write it ourselves. What it actually took to replace it An autoencoder needs: matrix multiplication, transpose, element-wise activation functions (sigmoid, ReLU), and gradient computation for backprop. Without NumPy, every one of those is a hand-rolled function operating on nested Python lists. Matrix multiply becomes three nested loops instead of one line. A forward pass that would be a single .dot() call turns into a small file of helper functions: matmul() , transpose() , add_bias() , sigmoid() , sigmoid_derivative() . We split it — one of us built the forward pass and activation functions, the other took backprop and the training loop — and then spent a good while debugging the seam where the two met. The genuinely hard part wasn't the math — it was performance. Pure Python loops over lists of lists are slow, and profiling a dataset with a few thousand rows through even a small autoencoder made that obvious fas

You don't necessarily need more traffic. I know that's not what most growth advice tells you. Every ad platform and every "get more eyes" thread says the opposite. But after reviewing dozens of business websites across real estate, construction, hospitality, and retail, the uncomfortable truth is usually the same: the site isn't leaking customers because too few people show up. It's leaking them because the people who do show up leave within seconds, and nobody is asking why. If you've opened Google Analytics, seen respectable traffic numbers, and then looked at a disappointing lead count, this article is for you. Traffic Is Not the Same as Conversion Traffic measures attention. Conversion measures whether that attention trusts you enough to act. The gap between the two is where most of your lost leads live. A useful way to think about it is the conversion rate: the percentage of visitors who take your intended action (a form submission, a booking, a call, a purchase). If your conversion rate is 1% and you double your traffic, you now have 2% of a bigger number, but you're still losing 99% of everyone who lands on your site. Pouring more traffic into a website that fails the basics doesn't fix anything. It just means more visitors leaving faster, at a higher cost per click. The 10-Second Test Your Website Is Failing A new visitor isn't reading your site; they're scanning it. In the first few seconds, they're subconsciously asking three questions: What is this? Can I trust it? What do I do next? If your homepage doesn't answer all three quickly, they're gone. Not because they weren't interested, but because nothing gave them a reason to stay. That's not a traffic problem. That's a trust problem. Why This Keeps Getting Missed Here's the trap: trust doesn't show up as a line item in Google Analytics. There's no "trust score" sitting next to your sessions and impressions. So business owners chase what's measurable (clicks, reach, ad spend) because it feels like progress

Longshot is a Firefox screenshot extension I wrote to replace FireShot: full page, visible area, drag region and element capture, an editor with eleven annotation tools, export to PNG, JPEG, WebP and PDF, and local OCR that produces a searchable text layer. It has no runtime dependencies. The code is not public, so this is a description rather than an invitation to read it. At one point it had 130 passing Node assertions across six suites, zero failing. Printing could not open a dialog at all. Not "printed the wrong thing". The print command hung indefinitely and no dialog ever appeared. The suites did not go amber, or flake, or report a warning. They reported 130 passed, 0 failed, which is what they had reported the day before and what they would have gone on reporting. Why nothing caught it printCanvas encoded each slice of the image to a blob URL and awaited img.decode() . That call does not resolve for an image inside a display:none subtree, and the print stylesheet creates exactly such a subtree by design, since the container has to be hidden on screen. So the await never returned, and the dialog never opened. Every part of that failure is a meeting point between my code and the browser: the decode promise's behaviour, the stylesheet's effect on the subtree, and the ordering between them. None of it is reachable by a function you can call from Node. The six suites test band arithmetic, canvas dimension limits, filename sanitising, the background module graph under stubbed extension APIs, PDF structure and scan geometry. All of that is worth testing and none of it goes near a real DOM. The second bug in the same batch has the same shape one level in. Choosing PDF broke "Open in editor", because deliver() handed the editor the PDF blob and createImageBitmap cannot decode one. That is not a browser boundary; it is one internal stage handing another something it cannot accept. Both stages were tested; the seam between them was not. That is the pattern worth naming.