Pixel

Pixel Updates & Events

Server Updates & Events

Announcements

Security Proofs vs. Findings: What CISOs Need

DEV Community

Your CISO Doesn't Want More Findings. They Want Proof.

  • Human-authored analysis; AI used for formatting and proofreading. You run a security scanner on your AWS environment. It finds 47 issues. The leaders hear: "our infrastructure has 47 things wrong with it." This is the problem with bug-finding tools. Every finding is bad news. What Amazon learned from a bank A finance company could not understand their own IAM policies. The policies were too complex to reason about manually. Amazon team said: "We're formalizing the semantics of the policy language. We can prove what your policies allow and don't allow. Mathematically." The bank increased their workload and their spending. Because AWS proved properties. The asymmetry There are two different things a security tool can tell you: Bug finding: "We found 47 issues in your environment." The scanners CSPM, CNAPP, Prowler, Scout Suite do it. They check your configuration against a list of known-bad patterns. Each finding is a problem. The report is a list of problems. More findings = more problems. The tool is useful but the output is always bad news. Property proving: "We verified that no unauthorized principal can reach any sensitive resource in your environment." The formal verification does it. The output is a statement about what is TRUE across your entire environment for all possible inputs. The report is evidence of safety. The output is good news. Executives want assurance. They want to tell their board, auditors and regulators: "this property holds. Here's the proof." AWS team launched tools, interviewed the users. The executives loved soundness. The people writing the checks wanted proofs. Why this matters for your security tooling Every scanner on the market is a bug finder. You run it. You get findings. You triage and fix. You run it again. You get more findings. The cycle never ends because the tool is designed to find problems, not to prove their absence. The question your CISO wants answer is: Can any external principal reach our customer data? (yes or no, with proof) Do any privilege escalation paths exist in our IAM graph? (yes or no, with proof) Are there any ghost references — resources pointing to things that were deleted? (yes or no, with proof) If an auditor asks whether we have unauthorized access paths, what do I tell them? (here's the mathematical evidence) These are property questions. The answer is a proof. Proof in practice A proof in cloud security is a deterministic evaluation of a specific property against your actual configuration state: Property: No principal outside organization o-abc123 can perform
    s3:GetObject on any resource tagged Sensitivity: High.

Evaluation: 847 resources checked. 23 S3 buckets with Sensitivity: High.
All 23 evaluated against identity policies, resource policies,
SCPs, and permission boundaries.

Result: VERIFIED. No external principal can reach any high-sensitivity
bucket through any policy composition path.

Evidence: Per-resource evaluation trace available.
Deterministic. Reproducible. Same input → same output, always.
That's relevant to the CISO. We verified this property holds across 847 resources. Here's the evidence. Run it again. You'll get the same answer. The CISO brings that to the board. The board brings it to the auditor. The auditor accepts mathematical evidence. The conversation shifts from "how many problems do you have?" to "which properties have you verified?" The two conversations Conversation A (bug finding):
Engineer: "We found 47 issues."
CISO: "How many did we have last quarter?"
Engineer: "38."
CISO: "So we're getting WORSE?"
Engineer: "No, we expanded coverage..."
CISO: "Fix them. All of them. By Friday."

Conversation B (property proving):
Engineer: "We verified three properties across the entire environment."
CISO: "Which properties?"
Engineer: "No unauthorized external access paths.
No privilege escalation chains.
...

Powered by Readybot.io

Security Proofs vs. Findings: What CISOs Need

Self-Test Blocks: One Bug They All Missed

DEV Community

I Ran Every --selftest Block in This Repo and Found One Bug They'd All Miss

I kept seeing "Detecting Flaky Tests and Finding Their Root Causes" show up in my feed this week. I don't have flaky tests, though. I have something plainer and, it turns out, less trustworthy: six scripts in my git-manager repo that each carry a --selftest block instead of a real test framework. I run them by hand before I push, not in CI. I'd never actually asked how much they catch. So I counted them, then I broke one of the things they're supposed to guard, on purpose, and watched what happened. What's actually in these blocks Every script that talks to the DEV.to API in this repo (publish_devto.py, reply_comments.py, scripts/list_all_published_titles.py, scripts/score_published.py, git_commit.py, server.py) ends with an if "--selftest" in sys.argv: block of hand-written assertions. No pytest, no fixtures, just assert statements that run against fakes or small inline inputs. Counting them: reply_comments.py : 30 asserts, 553 lines
scripts/score_published.py : 8 asserts, 151 lines
scripts/list_all_published_titles.py : 9 asserts, 162 lines
scripts/check_key_facts.py : 10 asserts, 277 lines
git_commit.py : 4 asserts, 203 lines
publish_devto.py : 14 asserts, 297 lines
server.py : 62 asserts, 1189 lines
publish_devto.py's block is the most interesting one, because almost every assertion in it is a named regression test for a bug that actually happened and actually broke a live publish. There's one for an unclosed frontmatter fence raising a clean ValueError instead of a bare unpack error. One for already_published() walking every page of /api/articles/me/published instead of stopping at the first 30. One for a missing DEV_TO_API exiting cleanly instead of raising KeyError. One for .env lines with spaces around = not leaving a trailing space baked into the variable name. Running it: $ python3 publish_devto.py --selftest
selftest ok
That's a genuinely well-maintained safety net for everything it tests. The bug it doesn't test for Buried in the same file is this, right next to the two places it calls req.add_header("User-Agent", ...): # dev.to blocks any User-Agent containing "urllib" (case-insensitive), not

just the literal default — see docs/project_notes/bugs.md 2026-07-25.

Any string avoiding that substring works; it doesn't need to look like a browser.

req.add_header("User-Agent", "Mozilla/5.0")
This is a documented bug that already broke publishing once. Python's default User-Agent is something like Python-urllib/3.11, and DEV.to's API rejects any request whose UA contains "urllib," case-insensitively. Without this header, every urlopen() call in this script — the quota check, the duplicate-title check, the publish itself — 403s. I went looking for the assertion that protects it. There isn't one. I grepped every --selftest block in the repo for anything mentioning User-Agent, add_header, or the urllib substring check: $ for f in reply_comments.py scripts/score_published.py \
scripts/list_all_published_titles.py git_commit.py \
publish_devto.py server.py; do
awk '/--selftest/,0' "$f" | grep -i "user-agent|add_header"
done

(no output, across all six files)

Zero matches. So I did a small mutation test: copy the file, delete the two add_header("User-Agent", ...) lines with a regex that respects leading whitespace, and run the existing selftest against the mutated copy. import re
s = open("publish_devto.py").read()
pattern = re.compile(r'^[ \t]req.add_header("User-Agent", "Mozilla/5.0")\n', re.M)
s2, n = pattern.subn('', s) # n == 2
open("mutated.py", "w").write(s2)
$ python3 mutated.py --selftest
selftest ok
Fourteen assertions, all green, on a copy of the script that would 403 on every real HTTP call it makes. I repeated the same mutation on reply_comments.py (one occurrence there) and got the identical result: selftest ok. Why the gap exists It's not that these scripts are untested in general — publ...

Powered by Readybot.io*

Self-Test Blocks: One Bug They All Missed

Fix SQLAlchemy Session Leaks and Pool Exhaustion

DEV Community

Identifying Unclosed SQLAlchemy Sessions That Cause Connection Pool Exhaustion

Identifying Unclosed SQLAlchemy Sessions That Cause Connection Pool Exhaustion 1. The Failure Mechanism: Why Connections Were Never Released In web applications built with SQLAlchemy, proper session lifecycle management is the lifeblood of system stability. Under a standard ORM pattern, a database session is instantiated at the start of a request and explicitly closed or disposed of once processing completes. However, as business logic grows in complexity, unexpected exceptions—such as external API timeouts, serialization failures, or validation errors—can occur mid-flight. When these exceptions are raised, any cleanup logic that is not strictly guarded gets bypassed. sequenceDiagram
participant Client as "Client"
participant App as "Web App"
participant DB as "DB Pool (Size: 20)"

Client->>App: Send Request
App->>DB: session = SessionLocal() (Acquire connection: 1/20)
Note over App,DB: Unexpected exception raised during execution!
Note over App: Exception bypasses db.close()
App-->>Client: 500 Internal Server Error
Note over DB: Connection remains dangling (Leaked)

rect rgb(255, 230, 230)
    Note over App,DB: When this repeats under load...
    App->>DB: 21st connection attempt
    DB-->>App: TimeoutError (Pool exhausted)
end Once a connection leaks in this manner, the underlying resource remains locked until the Python garbage collector (GC) eventually reclaims the orphaned session object and returns the connection to the pool. Under high concurrency, the rate of connection exhaustion vastly outpaces GC collection, leading to a complete service outage. 2. The Limits of Manual Debugging and Code Reviews Immediately following the incident, we deployed a hotfix that wrapped every SessionLocal() call across the codebase in a try...finally block. While this mitigated the immediate outage, it is not a sustainable solution. In a fast-paced engineering environment, expecting every developer to manually maintain strict lifecycle boundaries on every new endpoint or background task is unrealistic. Relying on code reviewers to catch whether a try...finally block or a with context manager was used is a fragile, human-dependent safeguard. "Don't rely on human vigilance—enforce it mechanically." To eliminate this class of bugs permanently, we built a custom static analysis tool using Python's Abstract Syntax Tree (ast) module to automatically detect and block unclosed session patterns during pre-commit hooks and CI pipelines. 3. Implementation: A Python AST Session Leak Detector Using Python's built-in ast module, we implemented a static analyzer that inspects function definitions for session instantiations that are neither protected by a try...finally block (with an explicit close() call) nor managed by a with context manager. Below is the complete implementation of the core detection logic, paired with Pydantic V2 for structured validation and orjson for high-speed JSON report serialization. import os

import ast
from typing import List, Optional
from pydantic import BaseModel, Field
import orjson

--- Pydantic V2 Models for Data Validation ---

class ConnectionLeakIssue(BaseModel):
file_path: str = Field(..., description="Path to the analyzed file")
line_number: int = Field(..., description="Line number where the issue was detected")
message: str = Field(..., description="Detailed description of the detected issue")
severity: str = Field(..., description="Severity level (WARNING / ERROR)")

class AnalysisReport(BaseModel):
total_files_scanned: int = Field(..., description="Total number of files scanned")
issues_found: List[ConnectionLeakIssue] = Field(
default_factory=list,
description="List of potential connection leak locations detected"
)

--- SQLAlchemy Connection Pool Leak Static Analyzer ---

class SQLAlchemyLeakDetector(ast.NodeVisitor):
"""
Static analyzer that detects SQLAlchemy sessions not properly closed
...

Powered by Readybot.io

Fix SQLAlchemy Session Leaks and Pool Exhaustion

** Latest from PC Gamer **

Former survival MMO Dune: Awakening can now be played 'without requiring an Internet connection at any point' as its much requested offline mode arrives

Everything including 'creating and deleting single-player characters' can be done without touching the web.

Powered by Readybot.io

** Latest from PC Gamer ** ## Former survival MMO Dune: Awak

How Face Recognition Works: The Tech Behind the Scan

DEV Community

How Face Recognition Works

Developer note: Series 3, Episode 3 deep dive for Paragon AI MAG. How does face recognition on your phone work? The mechanism: structured infrared light — a flood illuminator, a dot projector casting 30,000+ points, an infrared camera reading their displacement — builds a depth map that a neural engine turns into an embedding, compared inside the Secure Enclave against the enrolled template, with a 1-in-1,000,000 false-match threshold. We also cover the history (Bledsoe 1964, Eigenfaces 1991, DeepFace 97.35% in 2014, FaceNet's 128-number embedding at 99.63%), the 1:1 verification vs 1:N identification split, the NISTIR 8280 demographic gaps, the Kneron spoof tests, and the practical side: five settings to change tonight and three self-tests. Canonical URL: https://paragonaimag.substack.com/p/how-face-recognition-works-series Watch the video: https://youtu.be/PhatIybN_A4 Every time you unlock your phone, it fires more than 30,000 invisible dots at your face. It does not take a photo of you. It builds a 3D map from those dots and turns it into numbers. That is the secret: literal maths, not a picture. And yet the same core technology once locked an innocent man in jail for 30 hours. This article explains both sides — how the phone version works so well, and why the same idea fails so badly when it is pointed at a crowd. THE MAN THE COMPUTER PICKED On 9 January 2020, police arrived at Robert Williams' home in Detroit and arrested him in front of his wife and his two little daughters, aged two and five. They held him for about 30 hours in a dirty, overcrowded cell. A police computer had matched his driver's licence photo to a blurry surveillance still of a man who had stolen watches from a Shinola shop in 2018. The computer was wrong. Williams was nowhere near the shop, and he barely looked like the suspect. It was the first publicly reported wrongful arrest caused by a face-recognition match in the United States. In June 2024, the city of Detroit settled his case for $300,000 and banned arrests based on a face match alone. So here is the question that carries this whole story: if this technology fails that badly out in the real world, why do we trust it to protect our bank accounts, our private emails, and our most sensitive data? The answer is that the phone and the police computer are doing two different jobs. THE SHORT ANSWER Your phone does not take a photo of you. It projects more than 30,000 invisible infrared dots across your face to build a three-dimensional depth map, then turns that map into a list of numbers — an embedding. The phone compares numbers against numbers, never pictures against pictures. Those numbers live in the Secure Enclave, a separate small computer inside the phone's chip with its own key. The operating system cannot read them, apps cannot read them, and they are never sent to Apple or backed up to iCloud. When you look at the screen, the phone asks the vault one question — does this new maths match the saved maths? — and the vault answers yes or no. THE SEVEN STEPS When an Apple device wakes up and checks your face, it runs seven steps: 1. Flood illuminator. An infrared light bathes your face so the phone can find it — even in total darkness. 2. Dot projector. One laser shines through a special plate and splits into more than 30,000 invisible dots across your face. 3. Infrared camera. The only sensor that can see those dots reads how they bend around the shape of your nose, cheekbones and eye sockets. 4. Depth map. The projector sits at one end of the notch and the camera at the other, so each dot's sideways shift gives its distance. Thirty thousand distances make a 3D face. 5. Neural Engine. A dedicated chip turns the depth map and the infrared photo into a list of numbers. 6. Secure Enclave. The fresh numbers are compared with the enrolled ones inside the vault chip. Only yes or no ever leaves. 7. Threshold. A yes needs the numbers close enough that a random stranger has less than a 1 in 1,000,...

Powered by Readybot.io

How Face Recognition Works: The Tech Behind the Scan

Building a Nepali Bill OCR with Gemini and Next.js

DEV Community

Let the Model Read, Let the Code Convert: Building a Bill OCR for Nepal

How I turned photos of Nepali paper bills into reviewable, exportable data with Next.js, Gemini and Prisma 8. The problem In Nepal, many small businesses still receive printed or handwritten bills. An accountant then types each one into Excel or accounting software: vendor, PAN number, date, items, VAT, total. It is slow, and one wrong digit in a total or a PAN can cause mismatches at tax filing time. I wanted to build something people would actually use, so I picked this problem: take a photo of a bill, get structured data back, let a human check it, and export it. The result is Bill OCR Generic OCR tools don't fit well because Nepali bills mix Devanagari numerals (०१२३) with English digits, use Bikram Sambat (BS) dates like 2083/07/22, carry 9-digit PAN/VAT numbers, and come in every layout imaginable. The one design rule The model reads. The code decides. A vision model is excellent at looking at a messy photo and finding the vendor, the date and the total. It is much less trustworthy at arithmetic or calendar conversion, and you can't unit test it. So the model's only job is to copy what is printed. Everything after that (converting numerals, parsing amounts, validating PAN numbers, converting BS dates) is ordinary code with tests. The pipeline Upload
→ validate (type, size, file signature)
→ store the image
→ extract with Gemini (JSON, values exactly as printed)
→ validate the raw output with Zod
→ normalize in code and collect warnings
→ save as PENDING_REVIEW
→ human review → CONFIRMED → CSV export
Step 1: Extraction The prompt asks for JSON only, with fixed keys, and sets rules that matter more than the wording of the task: Copy values exactly as printed. Don't convert numerals or dates. If a field is missing or unreadable, return null. Never guess. Keep item names in their original language. "Never guess" is the important one. A null shows up in the review screen as an empty field. A confident wrong guess looks like a correct value. I validate the response with Zod, where every field is nullable, so one unreadable field doesn't throw away the whole bill: export const RawBillSchema = z.object({
vendor_name: z.string().nullable(),
vendor_pan: z.string().nullable(),
bill_number: z.string().nullable(),
bill_date: z.string().nullable(),
subtotal: z.string().nullable(),
vat: z.string().nullable(),
total: z.string().nullable(),
items: z.array(z.object({
name: z.string(),
qty: z.string().nullable(),
rate: z.string().nullable(),
amount: z.string().nullable(),
})),
});
Note that every value is a string, exactly as printed. Numbers come later. I built this on Gemini's free tier, which sometimes answers 503 "model is overloaded". So extractBill retries with short waits and then falls through a list of models read from an environment variable. A request timeout and a fallback model stop a busy model from hanging the upload for over a minute (I saw 87 seconds once). Step 2: Normalization Now the deterministic part. Nepali numerals are a one-line map: const DIGITS: Record = {
'०': '0', '१': '1', '२': '2', '३': '3', '४': '4',
'५': '5', '६': '6', '७': '7', '८': '8', '९': '9',
};

export const toEnglishDigits = (s: string) =>
s.replace(/[०-९]/g, (d) => DIGITS[d]);
Amounts like रु. ४,८००/- become 4800 after converting the digits and stripping currency markers and commas. Anything that doesn't parse as a number becomes null rather than NaN. PAN/VAT numbers must be exactly 9 digits or they are rejected. Dates were the most interesting part. A bill may carry a BS date (2083-07-22) or an AD date, and I need both stored. I convert with nepali-date-converter, then validate by converting back: const ad = new NepaliDate(year, month - 1, day).toJsDate();

// Round trip: if converting back gives a different BS date,
// the input was invalid (for example day 32 in a 30-day month)
if (new NepaliDate(ad).format('YYYY-MM-DD') !== bs) {
return { bs: null, ad: null };
}
Two...

Powered by Readybot.io

Building a Nepali Bill OCR with Gemini and Next.js

Stop Geofence Flapping with Event Debouncing

DEV Community

Geofence Events That Flap at the Boundary: Debouncing Enter and Exit Signals in a Fleet Backend

A fleet vehicle approaches a delivery site, crosses the configured geofence boundary, and triggers an entry event. A few seconds later, GPS drift places the vehicle just outside the boundary. The backend records an exit event. Another location update moves it inside again, producing another entry. The vehicle may have entered the site only once, but the fleet dashboard now displays several arrivals and departures. This behaviour is known as geofence event flapping. It can create inaccurate arrival reports, duplicate notifications, unreliable dwell-time calculations, and incorrect automated workflows. The problem is not always poor GPS hardware. Geofence boundaries, location accuracy, update frequency, and event-processing logic all influence how the backend interprets movement. A reliable fleet system needs more than a point-in-polygon check. It needs event stabilization, state management, and rules that distinguish actual movement from temporary location noise. Why Geofence Events Flap A geofence is a virtual boundary around a physical location, such as a warehouse, customer site, depot, fuel station, or restricted area. A GPS device periodically sends coordinates to the fleet backend. The system checks whether the latest point falls inside or outside the configured boundary. Flapping can occur because: GPS accuracy changes between updates. The vehicle travels close to the boundary. Buildings and other obstructions affect satellite signals. Location updates arrive at irregular intervals. Different devices report different coordinate precision. The geofence is too small for the expected positioning accuracy. The backend treats every coordinate as a new movement event. For example, a vehicle may report these positions: Time Reported state 10:00:00 Inside 10:00:08 Outside 10:00:16 Inside 10:00:24 Outside 10:00:32 Inside A basic backend may create five events. A more robust system should evaluate whether the vehicle has actually crossed the boundary or whether the readings represent GPS variation. Separate Raw Location Data From Geofence Events The first architectural rule is to retain raw location updates separately from derived geofence events. A practical data model can include: Table Purpose vehicle_locations Stores incoming GPS coordinates and timestamps geofences Defines site boundaries and configuration geofence_vehicle_states Tracks each vehicle's current state for each geofence geofence_event_candidates Stores provisional entry and exit signals geofence_events Stores confirmed entry and exit events event_processing_logs Records processing outcomes and errors This separation is important because raw location updates may need to be reprocessed when the geofence rules change. A confirmed event should not be the only record of what the vehicle reported. Keeping the original location history makes debugging and operational audits easier. Use Hysteresis Instead of One Boundary A common approach to reducing boundary noise is hysteresis. Instead of using one boundary for both entry and exit, the system uses two thresholds: An inner boundary that confirms entry. An outer boundary that confirms exit. For a circular geofence, the backend can define a radius for each threshold. For example: Enter threshold: vehicle is within 450 metres. Exit threshold: vehicle is beyond 500 metres. A vehicle moving around the boundary will not repeatedly switch states because the system requires it to cross a wider separation between the entry and exit thresholds. The exact distances depend on GPS accuracy, site size, vehicle behaviour, and operational requirements. They should be configurable rather than hardcoded for every location. For polygon geofences, the same principle can be implemented using inward and outward buffered boundaries. Add Time-Based Debouncing Hysteresis helps with spatial noise, but time-based debouncing can provide another layer of stability. A candidate entry event may require multiple qualifying location updates or a mi...

Powered by Readybot.io

Stop Geofence Flapping with Event Debouncing

Building Location Scavenger Hunts from Street Imagery

DEV Community

Building a scavenger hunt from street-level imagery: the problems nobody warns you about

The easiest version of a location scavenger hunt is the one where a human builds it: someone walks a neighbourhood, photographs a dozen spots, writes the clues, and publishes a route. That works, and for a city with an active local scene it is a lovely format. It does not scale. Nobody is going to hand-build hunts for every neighbourhood in every city, and the ones that exist tend to concentrate in places where somebody was already willing to do the work. So we went the other way with Ping Hunt: the hunt is generated from street-level imagery around the player. No author, no route to design, no catalogue to maintain. If you are standing in a street, you can start a hunt. That sounds like it removes the hard part. It moves it, and the problems it creates are more interesting than the ones it solves. "What is a spot?" is the entire problem A player matches the scene with their camera to unlock the next location. For that to work, the thing in the photo has to be identifiable from the image alone - and a surprising number of candidates are not. A red door is a red door. So is a café table, a bollard, a statue, a row of parked bikes, a bin. If the reference image is "a red door" then the matching task collapses into "find any red thing", and the player will unlock the wrong spot within thirty seconds. Worse, the game becomes trivial: if any red thing counts, the player is really just looking for red. The fix was to get much more specific about what makes a good target: Prefer geometry. Corners, staircases, shopfronts, arches, steps and distinct rooflines are identifiable because of their shape, not their colour. Reject flat surfaces. Grass, asphalt, painted road lines, sky and blank walls are the most common things in street imagery and almost none of them are unique. Require local distinctiveness. If two candidate spots on the same street look the same, only one of them is usable. Keep the clue honest. The clue text should describe what the player will actually see, not what the reference image happens to contain. This single change - designing around what can be recognised rather than what can be photographed - did more for the game feel than anything else we tried. Coverage is a product feature, not an error state A generated hunt is only playable where the underlying imagery exists, and only good where the imagery is recent and the streets are legible. We treat coverage as a property of the map, tile by tile, and we are honest about it before the player commits. If there is not enough usable material near you, the right answer is to say so and suggest somewhere else - not to generate a hunt that becomes frustrating halfway through. That sounds obvious, and it took us a while to learn. The failure mode is seductive: you always find something within a radius, so the system feels generous. But "we found four spots for you" and "these four spots are actually distinguishable and findable" are different claims, and only the second one produces a game people finish. Stale imagery is a feature of the real world Street-level imagery ages. A shopfront in the reference photo may be a different shopfront now. A bus stop may have moved. A mural may have been painted over. A tree may have grown. Two consequences: Match tolerance has to be generous. If the reference image is from six years ago, insisting on a near-pixel match guarantees failure. We score similarity and accept a range, with the threshold set by how old the imagery is. The confirmation message has to teach. When a player matches a spot, the useful thing to show is not "correct" but "that is the corner with the blue awning" - a description that survives the shopfront changing colour. The honest framing is that the game is played against a memory of the street, not the street itself. Players accept that readily, because they are used to it from every other map. A hunt has to be walkable A list of coordinates is not a route. The spots have to be sequenced so that the walk mak...

Powered by Readybot.io

Building Location Scavenger Hunts from Street Imagery

RunsOn Alternatives: AWS Hosting, Pricing & Tradeoffs

DEV Community

RunsOn alternatives: keep the AWS account, or hand it over

RunsOn alternatives split on a single question, and the per-minute tables that dominate this market answer the wrong one: does the compute stay in your AWS account, or does it leave? RunsOn charges a licence from EUR 300 a year and states that the compute is your AWS bill, not ours, with no markup, so what you are really weighing is a spot-priced EC2 bill you operate against a metered minute somebody else operates. The alternatives split by where the machines live, not by rate. Licence tiers and rates read from each vendor page on 2026-09-21. RunsOn is a licence and a CloudFormation stack. You run it in your own AWS account, it starts EC2 instances on demand to serve your jobs, and the instances are billed by AWS per second at spot or on-demand prices. The licence tiers published on its pricing page are Starter from EUR 300 a year for under 50,000 runners a month, Growth at EUR 900 under 200,000, Scale at EUR 1,800 under 500,000 and Enterprise at EUR 3,600 above that, with a free tier for nonprofit, open-source, educational and personal non-commercial use in exchange for a public acknowledgement linking back. That is a genuinely cheap way to run a lot of CI, and it is cheap because you are doing the operating. Every alternative below is a different answer to how much of that operating you want to keep. Read the tier unit before anything else RunsOn's tiers are counted in runners a month, not minutes a month, and that one word changes which repositories are cheap on it. A runner is a machine started to serve a job, so a workflow with a 30-leg matrix consumes 30 runners in one run regardless of how long each leg takes. A team with short, wide pipelines crosses into the next tier at a fraction of the compute of a team with a few long builds. Work out your own number before you price anything else: total workflow jobs a month, not minutes. If that number is comfortably under 50,000 the licence is EUR 300 a year and is effectively a rounding error against the EC2 bill, which is the point. If it is 300,000, the licence is EUR 1,800 and is still probably a rounding error, which is also the point. The licence is rarely what makes this decision. The alternatives that keep the machines in your account Three options keep the compute inside infrastructure you control, which is usually the reason a team chose RunsOn in the first place: a compliance boundary, a VPC with private resources in it, or an existing committed-spend agreement with a cloud provider that CI minutes can be spent against. They differ in what the vendor supplies and in whether a meter comes back. WarpBuild's bring-your-own-cloud mode is a flat $0.002 a minute for Linux runners in your AWS, GCP or Azure account, so the per-minute meter returns but the machines do not leave. Actuated is a flat per-server licence, $150 for the first and $125 for each additional per month, on hardware you supply that is either bare metal or supports nested virtualization, with a Firecracker microVM per build. Actions Runner Controller is GitHub's own open-source controller, free of licence and expensive in cluster operations. Alternative What you pay the vendor What the vendor supplies What you operate Isolation RunsOn EUR 300 to 3,600 a year by tier The controller, AMIs and binaries AWS account, quotas, spot capacity One EC2 instance per job WarpBuild BYOC $0.002 a minute, flat Control plane, images, cache The cloud account and its limits One VM per job in your account Actuated $150 first server, $125 each after, monthly Control plane and the CI image The physical or metal hosts A Firecracker microVM per build Actions Runner Controller Nothing An open-source controller Kubernetes, scaling, images, upgrades One pod per job RunsOn tiers read from runs-on.com/pricing, Actuated from actuated.com/pricing, WarpBuild from warpbuild.com/pricing, all on 2026-09-21. Actions Runner Controller is maintained by GitHub and has no vendor price; its cost is entirely the cluster and the time. The alter...

Powered by Readybot.io

RunsOn Alternatives: AWS Hosting, Pricing & Tradeoffs

Why Website Traffic Takes Time to Become Sales

DEV Community

When Traffic Turns Into Paying Customers

The short answer Most website traffic will not turn into paying customers on launch day, or even in the first month. Real sales take time, trust, and repeat visits to materialize. Business owners often expect a flood of orders the moment a site goes live, but the reality is usually silence followed by a slow trickle. Why new sites take time Search engines take weeks or months to index a brand new domain and understand what your business actually does. You start with zero algorithmic authority. People rarely buy from an unfamiliar brand on their first visit. They need time to compare options, read reviews, and feel secure before handing over money. Early traffic is often accidental, coming from curious peers or social media links rather than buyers actively looking to solve a specific problem. Stop watching daily stats Checking your visitor counter every hour will only drive you crazy and lead to knee-jerk changes in your design or pricing. Traffic fluctuates wildly for no logical reason. Instead of obsessing over raw visitor numbers, focus entirely on making your core offer and contact process as clear as humanly possible. Ask actual customers if they easily understood what you do when they landed on your pages, and fix the friction points they point out. First published on abdulwasaylodhi.com.

Powered by Readybot.io

Why Website Traffic Takes Time to Become Sales

How Java Synchronization Works: Monitors Explained

DEV Community

How Java Synchronization Works: A Quick Walkthrough

One keyword - synchronized - and two threads stop corrupting each other's data. But what did the keyword actually buy you? The JVM spec has a surprisingly small answer: one mechanism, the monitor, and a handful of bytecode instructions. Let's open it up with real javap output, a live look at a blocked thread, and the Linux primitive the JVM leans on when a thread truly has to wait. One construct: the monitor The JVM spec (JVMS 2.11.10) is blunt: "The Java Virtual Machine supports synchronization of both methods and sequences of instructions within a method by a single synchronization construct: the monitor." Every object can act as a monitor. synchronized (lock) { ... } means: enter the monitor associated with lock; only one thread can own it at a time; everyone else waits. That is the entire mechanism - everything else is how it is compiled and what waiting costs. Here is the journey of two threads and one monitor, animated: Two forms, two very different bytecodes A synchronized block and a synchronized method look alike in Java. In bytecode they are nothing alike. This class: public class SyncBytecode {
private final Object lock = new Object();
private int count;

public void incrementBlock() {
    synchronized (lock) {
        count++;
    }
}

public synchronized void incrementMethod() {
    count++;
}

}
javap -c on the block form - real output: public void incrementBlock();
Code:
0: aload_0
1: getfield #7 // Field lock:Ljava/lang/Object;
4: dup
5: astore_1
6: monitorenter
7: aload_0
8: dup
9: getfield #13 // Field count:I
12: iconst_1
13: iadd
14: putfield #13 // Field count:I
17: aload_1
18: monitorexit
19: goto 27
22: astore_2
23: aload_1
24: monitorexit
25: aload_2
26: athrow
27: return
Exception table:
from to target type
7 19 22 any
22 25 22 any
Read it closely - there are two monitorexit instructions. One on the normal path (offset 18), one inside a compiler-generated cleanup (offset 24) guarded by an exception-table row of type any. If count++ somehow threw, control would jump to offset 22, the monitor would still be released, and then athrow would rethrow. That is the spec's promise, made visible: "the executing thread enters a monitor, invokes the method itself, and exits the monitor whether the method invocation completes normally or abruptly." A forgotten unlock on the exception path is impossible by construction. The method form? javap -v shows there are no monitor instructions in its code at all - just a flag on the method: public synchronized void incrementMethod();
flags: (0x0021) ACC_PUBLIC, ACC_SYNCHRONIZED
Per the same spec section, "method-level synchronization is performed implicitly, as part of method invocation and return... the ACC_SYNCHRONIZED flag... is checked by the method invocation instructions." The entering and exiting still happen; they are just the JVM's job at the call boundary rather than explicit bytecodes. What waiting looks like A thread that wants a held monitor doesn't spin visibly - it changes state. The Thread.State JavaDoc defines BLOCKED as: "A thread that is blocked waiting for a monitor lock is in this state." You can watch it happen. Two threads, one lock, the holder sleeping inside its critical section: before start: holder=NEW waiter=NEW
while contended: holder=TIMED_WAITING waiter=BLOCKED
waiter got the lock
after finish: holder=TERMINATED waiter=TERMINATED
Real output, one run. The holder is TIMED_WAITING (it is inside Thread.sleep - a timed wait, holding the monitor the whole time; sleep never releases locks). The waiter is BLOCKED - parked on the monitor, making zero progress, until the holder's monitorexit lets it in. Note the distinction the states encode: BLOCKED means "waiting for a monit...

Powered by Readybot.io

How Java Synchronization Works: Monitors Explained

Blackridge Systems: Evidence-Driven Open-Source Reuse

DEV Community

Blackridge Systems: An Evidence-Driven Pipeline for Reusing Open-Source Components

This article was written by an AI agent from the project's README and release notes, and published automatically. The project is by krapcys1-maker; the code is at krapcys1-maker/blackridge-systems. Most "compose a system from open-source parts" ideas fail at the same point: deciding whether a component actually does what its README claims. Star counts are not evidence. Green CI is not evidence. Blackridge Systems, an open-source Python project by krapcys1-maker, is built around that distinction. Its product rule is stated directly in the README: Reuse → inspect → verify → adapt → integrate → test → build only the gap. Who this is for Blackridge targets developers who want to assemble a system from existing libraries and services but need a defensible record of why each part was chosen. The repository describes a gated path toward a scientific researcher, AI-memory experiments, and an evidence-controlled research loop, but explicitly labels that a roadmap, not a claim that the tool performs autonomous discovery today. What exists now is an executable, manually reviewed vertical slice. The pipeline The flow is straightforward in shape and strict in what it accepts at each step: Describe the system as capabilities, each with concrete acceptance scenarios. Discover candidate repositories by searching GitHub through the Octocode research engine. Enrich candidates with official GitHub metadata and OpenSSF Scorecard data. Apply license, maintenance, security, and adoption gates. Inspect real package versions and resolved dependency graphs through deps.dev. Sandbox experiments against an exact public commit in disposable Docker via SWE-ReX. Solve a linear compatibility graph, rejecting blocked or unreviewed choices. Generate adapters and a provenance-locked runnable system bundle. Run end-to-end evaluation; failures send the process back to discovery. The discovery command invokes pinned upstream tooling as a subprocess with an argument vector, never through an interpolated shell command, and remote repository code is not executed at that stage. Evidence levels, not verdicts A central design decision is the ladder of evidence levels. Search results enter at L0 — discovered. A component must reach at least L2 — booted before selection, and L4 — system verified before a system can be released. Probes produce evidence; they do not produce approval. The README is explicit: a candidate cannot be marked production-ready until its concrete acceptance scenarios pass named manual review at L4. This separation shows up in the CLI. probe-package does not assign its own PASS/FAIL verdict. A separate review-probe command records the verdict, the reviewer's name, what was observed, and notes justifying the decision: blackridge probe-package pypi paper-qa --output .blackridge/evidence/paper-qa.json
blackridge review-probe examples/blackridge-self-hosting.yaml \
.blackridge/evidence/paper-qa.json \
- -capability ecosystem-intelligence \
- -scenario paper-qa-package-evidence \
- -verdict pass \
- -reviewer "your-name" \
- -observed "Describe exactly what you inspected" \
- -notes "Explain why the evidence satisfies or fails the contract"
The same principle drives the implementation style: freeze a falsifiable scenario, exercise the smallest real vertical slice with positive and broken controls, inspect the artifacts, and only then expand the code. Mocks and green CI protect regressions but do not prove a capability works. Upstream-first toolchain Blackridge integrates tools at stable boundaries rather than copying their code. The README lists the selected building blocks per stage: Stage Upstream building block discovery Octocode + GitHub CLI/MCP ecosystem intelligence deps.dev context Repomix quality OpenSSF Scorecard + OSV-Scanner/OSV-SCALIBR compliance OSS Review Toolkit + Syft execution SWE-ReX / Docker; OpenSandbox next experiments Dagger payload adaptation JSON Patch + JSON Schema adaptation ast-grep / OpenRewrite missing code OpenH...

Powered by Readybot.io

Blackridge Systems: Evidence-Driven Open-Source Reuse

csperf Limits: What Not to Ask of Your Benchmark Tool

DEV Community

Honest Limits: What csperf Shouldn’t Be Asked to Do

Why this lesson exists When a tool silently refuses to answer a question, users start to doubt its honesty. In performance work, that doubt can turn into mistrust of the entire measurement pipeline. This episode shows how to surface the limits of csperf so that users know exactly what not to ask. Recap — where we are in the series Ep 1 — Why a Single ./a.out Time Misleads Your Performance Claims — Use csperf for reproducible evidence. Ep 2 — Warm vs Cold: Why a Single Trial Misleads Performance Claims — Warm‑up and repeat give credible data. Ep 3 — Screenshots Aren’t Evidence: Use csperf for Real Performance Artifacts — Metadata‑rich artifacts beat screenshots. Ep 4 — Comparing Across Machines: Why Metadata Matters in csperf — Machine metadata enables honest cross‑machine comparison. Ep 5 — csperf: A Lightweight Observatory for Honest Performance Tracking — Observatory commands give quick evidence. Ep 6 — csperf Doctor: First Command to Diagnose Toolchain Issues — Doctor validates the compiler environment. Ep 7 — csperf Quickstart: From Install to First Run — Get up and running fast. Ep 8 — csperf List‑Backends: Discover What Backends You Can Profile — Know which backends are available. Ep 9 — csperf Profile: Running a Full Benchmark Suite — Execute a comprehensive profile. Ep 10 — csperf Diff: Comparing Two Builds — Spot regressions. Ep 11 — csperf Visualize: Turning Artifacts into Charts — Visual insights. Ep 12 — csperf List‑Artifacts: Inspect What’s Been Collected — See the raw data. Ep 13 — csperf Doctor: Advanced Diagnostics for Complex Toolchains — Deep dive into diagnostics. Ep 14 — csperf List‑Backends: Filtering by Capability — Narrow down backends. Ep 15 — csperf Profile: Custom Workloads and Flags — Tailor the benchmark. Ep 16 — csperf Diff: Handling Large Artifact Sets — Efficient diffing. Ep 17 — csperf Visualize: Interactive Dashboards — Explore data interactively. Ep 18 — csperf List‑Artifacts: Querying Metadata — Filter by machine info. Ep 19 — csperf Doctor: Cross‑Platform Consistency Checks — Ensure consistency. Ep 20 — csperf Profile: Parallel Execution Modes — Speed up profiling. Ep 21 — csperf Diff: Visualizing Differences — See changes at a glance. Ep 22 — csperf Visualize: Exporting to CSV — Share data. Ep 23 — csperf List‑Backends: Extending with Custom Backends — Add new backends. Ep 24 — csperf Profile: Handling Non‑Deterministic Workloads — Manage randomness. Ep 25 — csperf Diff: Statistical Significance Testing — Test if changes matter. Ep 26 — csperf Visualize: Custom Plot Templates — Create reusable plots. The misconception Many users assume csperf can answer any performance question, from “how fast is this one line of code?” to “does my compiler produce the same binary on all machines?” The reality is that csperf is a measurement observatory, not a black‑box performance oracle. What problem csperf solves (this episode’s slice) This episode focuses on exposing the boundaries of csperf. By running csperf doctor and csperf list-backends we learn what the tool can and cannot do, and we document those limits so users don’t misinterpret missing answers as failures. Mental model Doctor checks the environment that csperf relies on: compilers, libraries, and runtime support. List‑Backends enumerates the capabilities that csperf can probe. If a feature is missing, the tool should explicitly say so, not silently return empty data. Lab: install and first commands Install csperf via pip: pip install compilersutra-perf
Verify installation: csperf --version
Lab: what we ran on this machine We executed the two diagnostic commands on a recent Ubuntu 22.04 workstation with an Intel i7‑12700K. The commands were: csperf doctor
csperf list-backends
The output is captured in the artifact csperf-27-limits.json. Results (real numbers only) Artifacts missing for this episode — numbers withheld. How to read the artifacts The artifact contains two top‑level keys: doctor_report: a dictionary of environment che...

Powered by Readybot.io

csperf Limits: What Not to Ask of Your Benchmark Tool

Red Hat Quay CVE-2026-123710: Critical Registry Risk

DEV Community

Red Hat Quay CVE-2026-123710: Registry Takeover and Fixes

Last updated: 15 November 2026. This is a developing issue; see theupdate logand re-check Red Hat's advisory before acting. Red Hat Quay, the container registry that many teams run on-premises and on OpenShift, has a critical flaw in the way it manages its own signing keys. CVE-2026-123710 is scored 9.8 (Critical) and, as described by Red Hat, lets a client with no account install its own trusted signing key. After that it can read private images and overwrite tags. If you run Quay, the registry itself is the thing at risk, and so is every system that pulls from it. This article explains in plain terms what the bug is, who is affected, what to do first (before and after patching) and how to reduce your exposure to a poisoned image. I could not run Quay itself, so the vulnerability details come from Red Hat and security press coverage, and I say which is which. One of the mitigations, restricting the key endpoint at your reverse proxy, I did test with nginx. The short version What: CVE-2026-123710, CWE-1287 (improper validation of the specified type of input), in Quay's service key server. Red Hat's CVSS 3.1 score is 9.8 with the vector AV:N/AC:L/PR:N/UI:N: network, low complexity, no privileges, no user interaction. Impact: an attacker can install a signing key that Quay trusts, then mint tokens that give read and write access to repositories. That means exposure of private images and any secrets inside them, and the ability to replace images that other systems pull. Affected: Red Hat Quay 3 and 5, including standalone deployments, the Quay Operator on OpenShift and the mirror registry for OpenShift, according to The Hacker News' reading of Red Hat's data. Exploited in the wild: none of the coverage I read says so, and one vendor write-up lists "no public exploit". That can change quickly. Fix: upstream fixes were merged on 11 November. Red Hat has published fixed builds for several Quay 3 branches. See the version note below. How the attack works Quay signs the tokens that authorize registry access. The signing keys are managed by a service key server, and keys can be rotated through an API. According to The Hacker News, the key server accepts a rotation request if it carries a token signed by a trusted key with the expected audience and issuer. It does not check that the token was issued for key rotation. That is the gap: An unauthenticated client requests an anonymous registry token from the auth endpoint (/v2/auth) and chooses the audience. That token passes the key server's checks, so the client can ask the key server to add or rotate a key. The attacker's key is accepted as trusted. It can be set with no expiry, and it survives restarts. With that key the attacker can sign tokens that Quay honors for any repository, and can pull private images or push tampered ones under existing tags. Red Hat's report also says the rotation deletes the legitimate instance key as a side effect, and the attacker's key can delete replacement keys. That can break legitimate pushes and pulls. Two points from Red Hat that change what you might assume: Turning off anonymous access does not protect you. Red Hat says any valid Quay account can still exploit the flaw. Resetting passwords or regenerating robot tokens does not remove the attacker's key. The key lives in Quay's key store, not in a user credential. A second flaw in the same fix: CVE-2026-110697 The same researcher, Red Hat's Dave O'Connor, found a related issue, scored 9.9. As The Hacker News describes it, the robot-account listing code builds a SQL LIKE pattern from the namespace name without escaping wildcards. In SQL LIKE, an underscore matches any single character, so a crafted namespace can match another tenant's namespace and return its robot accounts with their tokens. The only prerequisite reported is the ability to create a namespace. Stolen robot tokens allow reading, pushing or overwriting another tenant's images. This one is easier to understand if you have written SQ...

Powered by Readybot.io

Red Hat Quay CVE-2026-123710: Critical Registry Risk

Indonesia Port API Adds Verified Coordinates

DEV Community

Indonesia's Official Port List Has No Coordinates, So I Added Them Without Guessing

Indonesia's official port list is the National Port Master Plan (Rencana Induk Pelabuhan Nasional, RIPN): ministerial decree KP 432 Tahun 2017 and its amendments. It comes as a scanned PDF annex, and it has no coordinates at all. I turned that annex into data and matched every port against open coordinate sources. The result is the Port API on API Indonesia, under /api/v1/pelabuhan. What is in it 1,082 ports: 637 sea ports and 445 ferry ports. The official hierarchy of every sea port for the 2022–2027 period: 28 main ports (utama), 164 collector ports (pengumpul), 165 regional feeder ports and 279 local feeder ports. The planned 2027 and 2037 hierarchy is kept too. The class of every ferry port (I, II, III). Province and regency/city with Kemendagri codes. UN/LOCODE for 133 ports and World Port Index attributes (harbour size, channel depth) for 84. Latitude and longitude for the 468 ports that pass validation. How the coordinates were checked Coordinates come from OpenStreetMap, the NGA World Port Index and UN/LOCODE. A coordinate is only filled when it passes one of two levels: terverifikasi (178 ports): at least two independent sources agree within 5 km, and the point is in the same province as the RIPN entry. sebagian (290 ports): one source so far, an exact name match, and the point falls in the same province and regency as the RIPN entry. Anything else keeps lat and lng empty with validasi = tanpa_koordinat. There are no estimated positions and no regency centroids. 18 points landed in a different regency from the one the RIPN lists, and those coordinates were dropped. Using it Nearest ferry ports to a point: curl "https://use.apiindonesia.id/api/v1/pelabuhan/nearby?lat=-5.93&lng=106&jenis=penyeberangan" \
- H "x-api-key: YOUR_API_KEY"
All main ports: curl "https://use.apiindonesia.id/api/v1/pelabuhan?hierarki=utama&per_page=30" \
- H "x-api-key: YOUR_API_KEY"
You can also look a port up by UN/LOCODE, for example /api/v1/pelabuhan/IDJKT for Tanjung Priok. Limits More than half of the ports have no coordinate yet, mostly local feeder ports and small ferry ports. They are still in the dataset because their name, administrative location and hierarchy are official, but the point is only added once a source can be checked. A few more things to know: The amendments in KM 172 Tahun 2021 and most of KM 217 Tahun 2022 are not applied yet, because the decree files could not be retrieved. The RIPN annex is a scan, so some names were cleaned of OCR errors. A sea port and a ferry port with the same name often share one point. Most coordinates come from OpenStreetMap (ODbL 1.0). Every response carries meta.attribution. Pricing: 2 credits (Rp2) per successful request, and failed requests are free. Product page: https://apiindonesia.id/produk/pelabuhan/ Docs: https://docs.apiindonesia.id/#pelabuhan

Powered by Readybot.io

Indonesia Port API Adds Verified Coordinates

Fix GitHub Actions Reusable Workflow Not Found

DEV Community

GitHub Actions reusable workflow was not found

GitHub Actions reusable workflow was not found means the uses: reference was well formed but resolved to nothing: the file is not directly under .github/workflows at that ref, the ref does not exist on the target repository, or the caller is not allowed to read it. The annotation prints every hop as a chain of arrows, so check the entry after the last arrow first; on a nested call it is often a reference inside a workflow you did not write. Four checks in order: the path exists, the ref exists, the caller may read it, and the file declares that it can be called. The chain stops at the first failure. What this error means The run is created and then ends immediately, with no jobs and no logs. In the Actions tab it carries an annotation titled with the caller file and a line number, and the body is a chain of quoted references joined by arrows, ending in a colon and the words that give this page its name. Because nothing ran, there is no step to open and any tooling looking for a failed job finds none. The chain is the diagnosis: each arrow is one hop the resolver made, so the reference on the last line is the one that could not be loaded. On a nested call that line is often a workflow you did not write the reference for. ```Invalid workflow file annotation, quoted from wazuh/wazuh-dashboard-plugins#9158 error parsing called workflow ".github/workflows/4_builderpackage_dashboard.yml" -> "wazuh/wazuh-security-dashboards-plugin/.github/workflows/[email protected]" (source tag with sha:e9267cedfeaf707032ac9454ce494a32745585a3) --> "./.github/workflows/4_builderprecompiled_base-dev-environment.yml" : workflow was not found. See https://docs.github.com/actions/learn-github-actions/reusing-workflows#access-to-reusable-workflows

Common causes

The path or the file name is wrong

The ordinary case. A called workflow must sit directly in the workflows directory, so a file moved into a subdirectory stops resolving, and so does an extension that is .yaml on one side and .yml on the other. The message names the file it looked for.

The ref does not exist on the target repository

Refs are resolved on the repository that owns the called workflow, not on yours. A release that tags several repositories at once is the usual source: the tag exists where you are standing but not where you are calling.

The called workflow does not declare workflow_call

The file is found and still refused, because nothing marks it as callable. This one has its own wording, about a missing trigger rather than a missing workflow, and it is common when a manually run workflow gets reused.

The caller cannot read the target repository

A private or internal repository has to allow its workflows to be used elsewhere, and the setting lives on the target rather than on the caller. Nothing about the reference looks wrong, which is why the error links the access documentation.

The failing reference is one level down

Resolution recurses, so a workflow you call may call others, and a relative reference inside it resolves against its own repository and commit. The chain is the only place that distinction is visible.

How to fix it

Read the chain from the bottom up

  1. Find the entry after the last arrow: that is the reference that failed.
  2. Note which repository it belongs to, which is the repository of the entry above it for a relative reference.
  3. Check the path, then the ref, then the access, in that order, against that repository.

Confirm the file and the ref from the API

One call tells you whether the file exists at that ref on that repository, answering the path and ref questions together.

```Terminal (illustrative)
$ gh api repos/octo-org/shared/contents/.github/workflows/package.yml?ref=v2 --jq .name
$ gh api repos/octo-org/shared/git/ref/tags/v2 --jq .object
Make the called workflow callable A workflow becomes reusable by declaring the trigger, and it can carry several at once. Ke...

Powered by Readybot.io

Fix GitHub Actions Reusable Workflow Not Found

Fix GitHub Actions Unrecognized env Errors

DEV Community

GitHub Actions unrecognized named-value: env and the context table

GitHub Actions unrecognized named-value: env means the expression sits in a workflow key whose list of allowed contexts does not include env, most often runs-on, jobs..if, a job name, or the with: of a reusable workflow call, all of which are evaluated before a runner exists. The fix is to move the value, not reword the expression: use a vars variable, a job output read through needs, or a step-level if, which does accept env. The rows people trip on. A job-level condition takes four contexts and four status functions, and neither env nor secrets is among them. What this error means The workflow is invalid and nothing runs. The message names the context in quotes, gives its position inside the expression, and prints the expression back to you, which makes the whole thing read like a typo even though the spelling is right. Two details give the real shape away. The same name works elsewhere in the same file, usually one key higher or one key lower, and the name that is rejected is almost always env or secrets. Both are contexts that exist, are documented, and are simply not permitted in the key where you used them. A long annotation with several of these separated by commas means the parser found every one of them in a single pass, so fixing the first line will not shorten the list. ```Invalid workflow file, quoted from actions/runner#480 The workflow is not valid. .github/workflows/dev.yml (Line: 15, Col: 11): Unrecognized named-value: 'env'. Located at position 1 within expression: env.aws_account

Common causes

env used in a key that is evaluated before the runner exists

The largest group by far: runs-on, jobs.<job_id>.if, jobs.<job_id>.name, a job-level concurrency, or the with: of a called workflow. All of them are decided while the job is still being planned, and the environment belongs to a runner that has not been picked yet.

secrets used in a condition

A job-level or step-level if does not accept the secrets context, by design rather than by omission. The documented replacement is to copy the secret into a job environment variable and test that, which also gives you a reliable way to ask whether a secret is set at all.

matrix or strategy in a workflow-level key

The workflow-level keys, run-name, the top-level env and a workflow-level concurrency, are read before any job exists, so neither matrix nor strategy is on their lists. Inside a job the parser does not check whether a strategy is declared: matrix.os in the runs-on of a job without a matrix is accepted and resolves to an empty value. In our experience the rejected version arrives when a matrix value is promoted to a workflow-level env to share it between jobs.

steps read from a job-level key

The steps context belongs to the job that is running and holds only steps "that have an id specified and have already run". A job-level if, a runs-on or a with: in a caller cannot see it, because at that point no step has run. Job outputs and the needs context are the way to move a value up a level.

How to fix it

Look up the key, not the expression

  1. Take the workflow key from the line and column in the message, not the context name.
  2. Find that key in the context availability table and read the list of contexts it accepts.
  3. If the name you used is missing, move the value rather than rewriting the expression.

Use a repository variable where you wanted a workflow env

The vars context is available in nearly every key in the table, including runs-on, a job-level if and a caller with:. A value that is configuration rather than a per-run computation belongs there, and moving it removes the whole class of problem rather than working around one instance.

```.github/workflows/ci.yml (illustrative)
jobs:
build:
runs-on: ${{ vars.RUNNER_LABEL }}
steps:
- run: echo building
Compute it in a job and read it through needs When the value really is computed at run t...

Powered by Readybot.io

Fix GitHub Actions Unrecognized env Errors

Optimize Unity WebGL with a Faster JavaScript Bridge

DEV Community

Engineered in Japan GCC: Optimizing Unity WebGL / Emscripten JS Bridge (Zero-Copy FS & Branchless Lookup)

بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ Algorithmic Fractal Art ("New Math" Series) Engineered in Japan. Minted on Ethereum Blockchain as a Private Collection (Not Listed / Invitation & Offer Only). 🔗 View Collection on OpenSea 🇸🇦 🇦🇪 🇶🇦 🇧🇭 🇴🇲 ⸺ Arabic Version (العربية - لغة تقنية فصحى) هذا المشروع هو تقرير بحثي تقني يركز على تحليل برمجيات الجسر (JavaScript Bridge) بين المتصفح ومحرك الألعاب في ألعاب WebGL التجارية (Unity WebGL)، مما أدى إلى تقليل استهلاك الذاكرة العشوائية (RAM) وتحسين أداء المعالجة (CPU). التزاماً بالشروط والأحكام وحماية لحقوق النشر، تم استبعاد الشيفرة المصدرية الفعلية للمنتج بالكامل. يشرح هذا المستند التحديات الهيكلية وطرق المعالجة المحددة. 🇬🇧 English Version This project is a technical research report focusing on analyzing JavaScript bridge code between the browser and the game engine in commercial WebGL games (Unity WebGL), resulting in reduced memory consumption (RAM) and CPU workload optimization. To comply with terms of service and protect copyrights, the actual product source code is completely excluded. This document explains the architectural challenges and specific remediation approaches. 🇯🇵 日本語版 (Japanese) 本プロジェクトは、商用WebGLゲーム(Unity WebGL)におけるブラウザとゲームエンジン間のJavaScriptブリッジコードを解析し、メモリ消費量(RAM)の削減およびCPU負荷の最適化を行った技術研究レポートです。 ※ 規約および著作権保護のため、製品のソースコード自体は含んでいません。アーキテクチャの課題と、それに対する具体的な修正アプローチを解説します。 🚀 نظرة عامة (Overview) يعتبر جسر JavaScript (خاصة حول نظام الملفات الافتراضي وإدارة الأجهزة) في ألعاب Unity WebGL منطقة معرضة بشدة للتسبب في تسريب الذاكرة وتقطعات الأداء الناتجة عن المعالجة المكثفة لآلية تنظيف الذاكرة (Garbage Collection)، لا سيما على متصفحات الهواتف المحمولة. يقضي هذا البحث على "نسخ البيانات المتكرر" و"خوارزميات البحث غير الفعالة" الموجودة في التطبيقات التجارية القياسية، مما يعيد هيكلة الكود ليعمل بسلاسة حتى على الأجهزة ذات المواصفات المنخفضة. 🚀 Overview The JavaScript bridge (specifically around the virtual file system and device management) in Unity WebGL games is highly prone to causing memory leaks and framerate hitches (spikes) due to heavy Garbage Collection (GC), particularly on mobile browsers. This research eliminates the "redundant data copying" and "inefficient lookup algorithms" found in standard commercial implementations, refactoring the codebase to run smoothly even on lower-end devices. 🚀 概要 (Overview) Unity WebGLゲームにおけるJavaScriptブリッジ(仮想ファイルシステムおよびデバイス管理周辺)は、特にモバイルブラウザ(スマホ)においてメモリリークやガベージコレクション(GC)によるカクつき(スパイク)の原因になりやすい領域です。 本研究では、既存の一般的な実装に見られる「冗長なデータコピー」と「非効率な探索アルゴリズム」を解消し、低スペック端末でも安定して動作するコードへのリファクタリングを行いました。 🛠 محاور التحسين الرئيسية (Key Optimizations) ١. نقل البيانات ذو النسخ الصفري عبر إلغاء النسخ المتكرر للذاكرة 🔴 التحدي (Before) عند كتابة ملفات الأصول الثنائية المستلمة من جهة المتصفح (البيانات الواردة من Web Workers، إلخ) داخل نظام ملفات WebGL الداخلي (FS)، كان يتم إنشاء نسخة جديدة من Uint8Array في كل مرة، مما يتسبب في تخصيص مزدوج للذاكرة. أدى ذلك إلى استدعاء مفرط لآلية تنظيف الذاكرة أثناء تحميل الأصول الكبيرة، مما تسبب في تجمد مؤقت للشاشة وتقطعات دقيقة. 🟢 حل المعالجة (After) الانتقال من "النسخ بالقيمة" إلى "التمرير بالمؤشر (المرجع)"، مع تفعيل خيار تفويض ملكية الأصول (canOwn: true) ضمن إعدادات نظام ملفات Emscripten. Zero-Copy Transfer via Elimination of Redundant Memory Copying 🔴 Challenge (Before) When writing asset binaries retrieved on the browser side (data returned from Web Workers, etc.) into the WebGL internal file system (FS), a new Uint8Array instance was instantiated every time, causing double allocation of memory. This triggered massive Garbage Collection during large asset loads, leading to micro-stutters and screen freezes. 🟢 Remediation Approach (After) Shifted from "copy-by-value" to "pass-by-pointer (reference)," utilizing the asset ownership delegation option (canOwn: true) within Emscripten's file system configuration. 🛠 主な最適化ポイント (Key Optimizations) メモリの重複コピー廃止によるゼロコピー化 (Zero-Copy Transfer) 🔴 課題 (Before) ブラウザ側で取得したアセットバイナリ(Web Worker等から返されたデータ)をWebGL内のファイルシステム(FS)に書き込む際、毎回新しい Uint8Array のインスタンスを生成(メモリの二重確保)していました。これにより大量のファイル...

Powered by Readybot.io

Optimize Unity WebGL with a Faster JavaScript Bridge

AI Agent Runs 187 FEM/CFD Solves: Accuracy Results

DEV Community

An AI Agent Ran 187 FEM/CFD Solves Over MCP. Here's How Many Matched the Textbook

From 6 to 12 November 2026, using dates as recorded in the logs, an AI agent (Claude Code) drove an open-source simulation app, NovaSolver Studio, through its MCP server. Structural, modal, buckling, thermal, flow, electrostatic and DC current problems. Every call and every reply was written to a log. The headline numbers, all from those logs: MCP calls 3,355 (49 log files) Solves started 187 Accepted comparisons with a reference 136 (from 118 analyses) Median difference 0.13% Within 1% / within 3% 105 / 130 Above 5% 2 The accepted set has 132 external-reference comparisons (formulas, series, correlations or independent 2D FEM) and 4 comparisons with another mesh of the same Studio model; 140 comparisons were recorded including reference-only results. The interesting part is not the median. It is what got thrown away before those 136, and two types of setup mistake that passed a mesh or reference check. What "the agent ran it" means here It was not a chat where the model clicked around freely. Claude Code wrote Python scripts that act as an MCP client. Each script starts Studio's MCP server over stdio, calls the tools in a fixed order, and appends every call and reply to a .jsonl file. Claude Code also wrote the STEP geometry, the scripts that compute the reference values, and the scripts that compare the two. The client is small. This is the core of mcpdrv.py, the shared driver: async def call(self, name, args):
t0 = time.perf_counter()
r = await self.s.call_tool(name, {"language": "ja",
args})
...
with io.open(self.log, "a", encoding="utf-8") as f:
f.write(json.dumps({"tool": name, "args": args, "reply": text,
"s": round(time.perf_counter() - t0, 2),
"data": getattr(r, "structuredContent", None)},
ensure_ascii=False, default=str) + "\n")
return text

async def wait(self, text):
m = re.search(r"Running as (\S+?).", text)
if not m:
return text
while True:
await asyncio.sleep(5)
rep = await self.call("job_status", job_id=m.group(1))
if rep.startswith(("done", "failed", "stopped", "error")):
return rep
A typical case script then reads like a recipe: create_case or import_geometry, update_case with materials and boundary conditions, validate_case, check_convergence, get_results, verify_case, probe_results. 58% of the calls were waiting job_status was called 1,949 times out of 3,355. Solves run as background jobs. run_simulation and check_convergence return a job id if the job is not done in about 20 seconds, and job_status waits up to 20 seconds per call before it answers. So most of the traffic is the client asking "done yet?". The calls that carry engineering content are an almost flat band of about 170–200 each: set up, check, solve on three meshes, read results, compare. The sum of all call durations is 42,086 seconds (about 11.7 hours). That is not wall time: it does not include the scripts' own time, and jobs that queued behind each other are counted in parallel. From 206 cases to 171 results Of 187 solves started: Outcome Count Out of memory (Studio's pre-check or during the solve) 11 Iterative solver did not converge 3 Tool error (the disk filled up) 1 Result not recorded 1 Results obtained 171 ...with a completed three-mesh test 167 ...mesh tests passed / failed 145 / 22 ...single-mesh pipe calculations 4 Before any solve, validate_case returned RED 8 times. All eight were DC current cases where Joule heating was on by default and no face set a temperature. Four plate updates were rejected; the client continued, and one started job has no recorded completion. Eleven cases were only opened to read the geometry. The accepted set excludes the 800 mm column, which failed the mesh test. Re-solves often covered a whole set after one case failed, to keep the mesh settings consistent. Out of 23 topics, 13 needed at least one redo, design change or abandon...

Powered by Readybot.io

AI Agent Runs 187 FEM/CFD Solves: Accuracy Results

Migrate from Depot Runners Without Losing Cache

DEV Community

Migrate from Depot runners without losing the cache

Teams that migrate from Depot runners in 2026 are usually reacting to one number: Depot lists its GitHub Actions runners at $0.006 a minute, which is GitHub-hosted list price to the cent. The move itself is a label per job, and the two things that do not move with it are the remote BuildKit builders and a cache that behaves differently from every other cache in this market. The cost of 1,000 jobs at five job lengths, at the rates published on 2026-09-20. Per-second tracking wins below about 25 seconds a job and loses above it. Start with what you are giving up, because it is specific and some of it is unusual. Depot tracks usage by the second and bills whole minutes at the end of the month, with no one-minute minimum, so a wide matrix of short jobs does not pay for rounding. Its runner documentation publishes 100 GB of disk on the smallest Linux runner, rising to 250 GB, with a slice of memory reserved as a RAM-disk accelerator in front of it. It publishes no concurrency limit, no cache size limit and no network limit. And its cache is not isolated by branch: its documentation says entries from main and from other branches share one namespace, scoped by repository. That is the opposite of actions/cache, where an entry is restorable only from the branch that wrote it or from the default branch. It is the single change most likely to make a migrated pipeline slower without any error appearing. The alternatives and their rates are in Depot alternatives. This page is the cutover: the label map, the cache work, and the arithmetic for whether per-second tracking was worth the rate. The label map, with the disk in it Depot labels carry the Ubuntu version and a vCPU suffix, so depot-ubuntu-22.04-4 is a 4 vCPU runner on 22.04. Sizes match Latchkey up to 16 vCPU and the memory matches at every step; the disk does not. Depot publishes 100 GB at 2 vCPU and 130 GB at 4, while a Latchkey runner reports 43 GB free, measured on 2026-09-20 and quoted in migrate from Blacksmith. Depot label What it is Closest Latchkey label What changes depot-ubuntu-24.04 2 vCPU, 8 GB, 100 GB disk latchkey-small 58% cheaper a minute, 43 GB of disk, no RAM-disk accelerator depot-ubuntu-22.04-4 4 vCPU, 16 GB, 130 GB disk latchkey-medium Same cores, 15.3 GB usable measured, a third of the disk depot-ubuntu-24.04-8 8 vCPU, 32 GB, 150 GB disk latchkey-large Same cores and memory, 43 GB of disk depot-ubuntu-24.04-16 16 vCPU, 64 GB, 180 GB disk latchkey-xlarge The largest size Latchkey publishes depot-ubuntu-24.04-32 and -64 32 or 64 vCPU, 128 or 256 GB None No equivalent; these jobs stay on Depot or go to Blacksmith at 32 depot-ubuntu-24.04-arm and depot-windows-2025 Graviton4 arm64, or Windows None Linux x86_64 only on the other side, so these stay put depot-macos-latest 8 CPU, 24 GB, 400 GB disk None No macOS runner at any price; the destinations are priced separately One constraint is identical on both sides and catches personal accounts: Depot requires the repository to be owned by a GitHub organization, and so does Latchkey. Ubicloud, Blacksmith and Namespace each have their own connection step, listed in the roundup. The pre-flight checklist Seven items. The cache ones are the two that decide whether this migration feels neutral or feels like a regression. Labels. Grep the workflow directory for runs-on:.depot- to find every job, including the Windows and macOS ones you may not be able to move. Depot actions. Grep for depot/. The build actions and the CLI talk to Depot builders and have no meaning on another runner. Cache scope. List the jobs that restore a cache written by another branch. On Depot that works; on actions/cache it does not, and those jobs will start cold on every feature branch. Cache size. Depot sells 25 GB on its $20 Developer plan and 250 GB on Startup. GitHub gives 10 GB per repository with 7-day eviction; Latchkey publishes no size and keeps entries 14 days. If you are above your destination's allowance, decide what stops being cached ...

Powered by Readybot.io*

Migrate from Depot Runners Without Losing Cache

Fix GitHub Actions Cache 503 and 429 Errors

DEV Community

Cache service responded with 503 or 429 in GitHub Actions

Cache service responded with 503 in GitHub Actions is the Actions cache backend refusing one request, and a 429 is the same backend throttling you. Neither is a problem with your key: the step warns, the job carries on without a cache, and the only thing that turns it into a red build is a workflow that treats a cache miss as fatal. The restore failing is a warning. A red build needs something else in the workflow to insist that the cache was essential. What this error means A cache step logs a warning rather than an error, and the job keeps going: "Warning: Failed to restore: Cache service responded with 503". A 429 appears in the same shape and means the opposite thing, that the service is working and has decided you are asking too often. Either way the restore did not happen, so the steps after it run cold: the install downloads everything, the build has no incremental state, and the job takes the long route. The save at the end of the job can fail the same way, which is worse in one specific sense, because the next run then starts cold too. The block below is a sample from the pattern library rather than from a run of ours, and the section on reproduction explains why there is no run on this page. ```Sample log from the pattern library Warning: getCacheEntry failed: Cache service responded with 503

Common causes

The cache service had a bad few minutes

The ordinary case. A 503 is the backend declining one request during an incident, a deploy or a load spike, and it clears on its own. Nothing in the workflow caused it and nothing in the workflow will prevent it; the only useful response is to make sure it costs a slower build rather than a failed one.

You set continue-on-error and the job still failed

The wasted fix, because the tolerance went on the step that was already tolerant. The cache step warns; the failure is in whatever ran next on the assumption that the cache was restored. Look for a step gated on the cache-hit output, a fail-on-cache-miss, or a test command that expects a directory the restore was supposed to create.

Your own concurrency earned the 429

A wide matrix, several workflows triggered by one push, or a monorepo running twelve jobs that each save a large cache will produce a burst of cache traffic in a short window. The service answers that with a throttle. It is transient, and it is also a design signal: the same caches are being written many times over.

The caches are large enough to make every operation fragile

A multi-gigabyte cache takes a long time to upload and download, which widens the window in which something can go wrong, and it pushes other entries out under the eviction policy. In our experience the repositories that see cache-service errors most often are the ones caching a built tree rather than a package store.

How to fix it

Let a cache miss be a cache miss

  1. Remove fail-on-cache-miss unless the job genuinely cannot run without the cache.
  2. Make sure the install step runs whether or not the restore succeeded, rather than being skipped on a cache hit.
  3. Re-run the workflow once the service recovers, and expect the first run after the incident to be slow.

```.github/workflows/ci.yml
- uses: actions/cache@v6
id: cache
with:
path: ~/.npm
key: npm-${{ hashFiles('package-lock.json') }}
- run: npm ci --no-audit --no-fund
Put the tolerance where the failure is If something downstream really does need the cache, guard that step rather than making the whole job depend on a service you do not control. A conditional fallback is a few lines and it turns an outage into a slow build. - uses: actions/cache@v6
id: deps
with:
path: ~/.cache/pip
key: pip-${{ hashFiles('requirements.txt') }}
- if: steps.deps.outputs.cache-hit != 'true'
run: pip install -r requirements.txt
Reduce the cache traffic you generate Cap matrix parallelism, share one warm cache across legs with restore-keys, and cache the package store instead of the...

Powered by Readybot.io

Fix GitHub Actions Cache 503 and 429 Errors

Connect Google Reviews to Claude with MCP

DEV Community

Ask your Google reviews from Claude: a hosted MCP server walkthrough

If you manage Google reviews for more than one location, the day usually starts the same way: open the Business Profile for each location, scroll, find what's new, find what's still unanswered. I wanted to ask one question instead: "which of my locations has the most unanswered reviews, and what are people complaining about?" That's what the Model Context Protocol (MCP) is good at. Here's how we wired Google reviews into Claude, Claude Code and Cursor with a hosted MCP server, and the design decisions that mattered. The setup in one command For Claude Code: claude mcp add --transport http reputemap https://api.reputemap.com/mcp \
- -header "Authorization: Bearer rmk_YOUR_KEY"
Then: claude "which of my locations has the most unanswered reviews?"
For Cursor, add this to ~/.cursor/mcp.json: {
"mcpServers": {
"reputemap": {
"url": "https://api.reputemap.com/mcp",
"headers": { "Authorization": "Bearer rmk_YOUR_KEY" }
}
}
}
In claude.ai or Claude Desktop you don't need a key at all: add it as a connector and sign in through OAuth. The tools The server is Streamable HTTP and exposes seven tools: Tool What it does list_locations Every location you manage, with ids list_reviews Reviews filtered by location, rating, unanswered, last N days, with the published reply get_review_stats Counts, averages, 1–5 breakdown, unanswered, per location and in total draft_reply Reply variants, saved as a draft. Never publishes publish_reply Publishes a reply you explicitly approved send_review_request Sends a real review-request email get_usage This month's API credits Three design decisions worth copying 1. Read tools run freely, write tools always ask. Every tool carries MCP annotations: the four read tools are marked read-only, while draft_reply, send_review_request and publish_reply are not. Well-behaved clients ask before running them, and in Claude you can block the write tools entirely to keep the assistant read-only. An AI that answers customers on its own is the most common complaint about review software, so the default here is "the model drafts, a person approves". 2. Writes are idempotent where it matters. A second send_review_request for the same email at the same location returns status: "already_requested". No second email goes out and no credit is spent. Models retry; customers shouldn't get two emails because of it. 3. Surface the platform's verdict, not just "success". Google now moderates owner replies before showing them. So publish_reply returns google_state: pending while Google checks, or rejected_by_google with the policy reason. list_reviews carries the same state, and a rejected reply counts as unanswered. Without that, an agent would happily report "replied!" to a reply nobody can see. Prompts that work well "Summarize what customers complained about at the Austin location in the last 30 days." "Draft replies to every unanswered 1–3 star review this week. Don't publish anything." "Compare average rating and unanswered count across all locations, worst first." "Send a review request to [email protected] for the Round Rock location." (Claude asks first.) Costs and limits Each tool call costs one API credit (get_usage is free), and every paid ReputeMap plan, including the 14-day trial, includes 1,000 credits a month, shared with the REST API. Links Setup reference with Claude Desktop, Cursor and troubleshooting: reputemap.com/docs/mcp Copy-paste configs and scripts: github.com/reputemap-com/examples Agent skills for review triage and replies: npx skills add reputemap-com/review-skills If you build something on top of it, I'd love to hear what you ask your reviews.

Powered by Readybot.io

Connect Google Reviews to Claude with MCP

Fake Ryzen CPU: How a Laptop Hid Its Real Chip

DEV Community

The Fake CPU Booted Fine. That's the Real Scandal.

A laptop that lies about its own processor should not work. It should crash, refuse to boot, or at least throw an error somewhere. The Chuwi CoreBook X did none of that. Sold as carrying an AMD Ryzen 5 7430U, it actually carried the older Ryzen 5 5500U — and it booted, ran Windows, and displayed the fancier name everywhere a buyer would look. That is what made the story stick when it broke in March 2026. A teardown by NotebookCheck found the mismatch the only two ways it could be found: by reading the chip's own ordering part number, and by running benchmarks that did not match the advertised processor. The BIOS, the operating system, and the packaging all repeated the wrong name. Nothing in the machine objected. So the interesting question is not only how one small brand got caught. It is why the lie was so easy to tell. The answer sits one level up the supply chain. AMD's mobile lineup reuses architectures across generations in ways that make several model numbers close cousins: the 5500U, 5600U, 5625U, and 7430U share enough silicon DNA, microcode, and driver support that a system can accept one name in place of another without tripping. Rebadging is not a bug in this world. It is the business model. When a chipmaker stretches one architecture across many price points and model years, it saves engineering cost — and it also creates a gap between what a model number promises and what the silicon actually is. A downstream seller only has to step into that gap. This is not unique to AMD, and it is not new. Intel has spent decades moving sockets and sharing chipset microcode across product tiers, and every one of those transitions created the same kind of confusion: parts that fit, boot, and mostly work, while meaning something slightly different from what the box says. The PC industry has trained buyers to read model numbers as if they were precise technical descriptions. In practice, they are often marketing labels pasted over a shared platform. That is the argument a March 2026 Chinese commentary piece made about the Chuwi case, and it is worth taking seriously even if you strip away its sharper language: the fraud was downstream, but the conditions that made it possible were upstream. A giant's cost-saving habit — reuse, rename, repeat — became a small brand's opportunity. The commentary called it greed. A cooler word would be negligence about what reuse does to trust. Either way, the mechanism is the same: when the top of the chain stops policing the meaning of its own labels, the bottom of the chain gets to rewrite them. None of this excuses the mislabeling. The facts of the case are plain. The teardown evidence was the chip number and the benchmark scores, not a rumor. AMD denied involvement. Chuwi's OEM was identified as the Shenzhen assembler Emdoor. A recall was offered with narrow conditions: units bought new, with full original packaging, before the end of May 2026 — and at least one popular reseller channel was left outside it. Buyers who checked early, with a free tool like CPU-Z and a benchmark run, could catch it. Buyers who trusted the box could not. There are three lessons here, and they apply well beyond laptops. First, a spec sheet is a claim, not a measurement. For anything where performance is the product — a processor, a battery, a motor — the only numbers that count are the ones you can reproduce yourself. A five-minute check beats a five-star listing. Second, reuse is a trust decision, not just an engineering one. Every company reuses platforms; every company that does so owes buyers a clear map of what changed and what did not. When model numbers multiply faster than real differences, the map is being hidden, not drawn. Third, the penalty for getting caught has to land on the right floor. A recall window that excludes ordinary resale channels and demands pristine packaging protects the seller more than the buyer. If the industry wants the benefit of cheap reuse, it should pay for verification: publ...

Powered by Readybot.io

Fake Ryzen CPU: How a Laptop Hid Its Real Chip

Weekly CVE Triage with KEV, EPSS and CVSS

DEV Community

Build a weekly CVE triage workflow with CISA KEV, EPSS and CVSS

This article was first published on the Rokkhe blog on Hashnode. It was drafted with AI assistance and reviewed and edited by the Rokkhe team; all commands and sources were checked against CISA, FIRST and NVD documentation. A one-hour operational pass you can run every Monday, using official feeds only. 15 November 2026, Asia/Dhaka. By the Rokkhe research team. Most teams do not fail at “finding CVEs.” They fail at deciding which ones to do this week. Three public signals help, and they do not measure the same thing: CISA’s Known Exploited Vulnerabilities (KEV) catalog records vulnerabilities with reliable evidence of exploitation in the wild, and a clear remediation action. EPSS, from FIRST, estimates the probability that a CVE will be exploited in the next 30 days. CVSS describes severity (how bad a successful exploit can be), not whether anyone is exploiting it. This post is a weekly workflow: fetch, join, ticket. It complements the existing Rokkhe briefing on how to prioritize vulnerabilities with CISA KEV, EPSS and CVSS; it does not replace that briefing, and it does not invent a success rate for the method. Do not use this workflow to discuss or publish embargoed research. If a draft is under vendor embargo, it stays out of the queue. TL;DR If a CVE is in KEV and you run the product, treat it as a priority this week, even when EPSS is low. FIRST says that explicitly. Use EPSS for the large majority of CVEs that are not in KEV. Use CVSS to understand impact once you already know a CVE is relevant, not as the only sort key. The commands below only read public APIs. They do not patch anything by themselves. After you patch a KEV item, hunt for signs it was used before the fix. A patch does not prove the box was clean. Three signals, three different questions CISA maintains the KEV catalog so organisations can prioritize vulnerabilities that have already been used. CISA also publishes BOD 26-04, Prioritizing Security Updates Based on Risk (issued 10 June 2026), which carries the KEV criteria forward and tells federal civilian agencies to prioritize using exposure, KEV status, exploit automation and technical impact. You do not have to be a federal agency for the catalog to be useful. CISA encourages every organisation to watch it. FIRST’s “Using EPSS” guidance is careful about what the score is: a calibrated probability of observed exploitation in the next 30 days, not a severity score and not a complete risk score. A low EPSS on a KEV-listed CVE is not a contradiction. KEV says exploitation has already been seen. EPSS says the current signal looks like CVEs that are rarely exploited in the next month. FIRST’s rule of thumb: when a CVE is on KEV, treat it as a priority regardless of EPSS. Use EPSS for everything KEV does not cover. CVSS remains useful for impact: a network-exploitable, no-user-interaction vulnerability is a different change window than a local issue that needs an existing account. It is a poor only-sort, because a “critical” CVE with no exploitation evidence and no instance in your estate should not beat a “high” KEV item you actually run. A fourth, unglamorous signal sits underneath all three: do we have this product, in this version, on a reachable network? If the answer is no, log it and stop. If the answer is “we do not know,” the first ticket is inventory, not a patch. Pull this week’s KEV additions CISA publishes the catalog as a JSON feed. The following command only downloads a public file: curl -fsSL \
'https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json' \
- o /tmp/kev.json

Newest dateAdded values first. Adjust the slice as you like.

jq -r '
.vulnerabilities
| sort_by(.dateAdded)
| reverse
| .[:20]
| .[]
| [.dateAdded, .cveID, .vendorProject, .product, .shortDescription]
| @tsv
' /tmp/kev.json
For a weekly pass, filter to additions since last Monday (use your date): SINCE=2026-11-09 # replace with last week's cutoff, in UTC dates as the feed ...

Powered by Readybot.io

Weekly CVE Triage with KEV, EPSS and CVSS

GitHub Actions working-directory Error Explained

DEV Community

GitHub Actions working-directory on a uses step is rejected, not ignored

GitHub Actions working-directory on a uses step is refused by the workflow schema before anything runs, so the belief that the key is accepted and quietly ignored is backwards. There is no wrong directory to debug, because the file never compiled and no job was ever created. A step is one of two shapes. Reading uses narrows the reader to the shape that has no working-directory property, and the next key has nowhere to go. What this error means You added a directory to a step that calls an action, pushed, and the workflow did not run. In the Actions tab the file is flagged rather than the job, and the annotation names a line and a column and quotes the key you added. If you are reading a stale answer that says the key is silently ignored, the thing to check is whether your run exists at all: an ignored key produces a green run that did the wrong work, and a rejected key produces no run. ```Message text from TemplateStrings.UnexpectedValue in actions/runner Invalid workflow file: .github/workflows/ci.yml#L12 (Line: 12, Col: 9): Unexpected value 'working-directory'

Common causes

The key was copied from a run step onto a uses step

Overwhelmingly the commonest origin. Somebody had a working run step with a directory on it, replaced the command with an action, and kept the surrounding keys. The diff looks harmless because only the middle line changed.

An answer elsewhere said the key is ignored rather than refused

The claim that a uses step accepts working-directory and quietly does nothing with it is widespread and wrong. It matters because the two behaviors need opposite responses: an ignored key means hunting for why the action used the wrong path, and a refused key means the run you are looking for does not exist.

The action really has no way to take a path

Some actions assume the repository root and offer no input for anything else. Reaching for working-directory is the natural next move, and the schema refuses it, which leaves the reader convinced the key is broken rather than absent.

The directory belonged on the job, not the step

When every step in a job works in the same subdirectory, per-step keys accumulate until one of them lands on an action. In our experience this is the version that survives review, because each individual line looks like the line above it.

How to fix it

Pass the path as an input the action declares

Open the action's action.yml and read the inputs block. Most actions that touch the filesystem expose a path, a working-directory or a source input. Passing it under with is the only mechanism the step shape offers, and it is the one the action author tested.

.github/workflows/ci.yml (illustrative) - uses: some-org/build-action@v1 with: path: packages/app Set the directory once for the job, for run steps Move the directory to defaults.run.working-directory on the job. It applies to every run step in the job and to none of the actions, which is exactly the boundary the schema draws, so nothing is left ambiguous for the next reader..github/workflows/ci.yml (illustrative) jobs: build: defaults: run: working-directory: packages/app

Wrap the action in a run step when it takes no path

  1. Check the action's action.yml once more for any input that accepts a path.
  2. If there is none, replace the action with the command it wraps, in a run step that carries the directory.
  3. If the action does real work you do not want to reimplement, prepare the directory in a run step before it, so the action still sees the layout it expects at the repository root.

Split the job when two directories are genuinely involved

A job whose steps work in two places is asking one defaults block to be two values. Two jobs, each with its own default, expand into a clearer run page and let you give them different conditions later. The cost is one extra checkout, which a cache usually absorbs.

How to prevent it

  • Validate workflow files in the editor, wh...

    Powered by Readybot.io
GitHub Actions working-directory Error Explained