标签：#r

Installing a large language model on your personal computer gives you a handy digital assistant that won’t compromise your data privacy.

Cloudflare Workers can now accept inbound TCP connections through a new connect(socket) handler routed via Spectrum, ending an eight-year restriction to HTTP. Containers get full-duplex gRPC in any language, while Workers get unary and server-streaming through automatic gRPC-web translation. Everything is private beta. By Steef-Jan Wiggers

I recently finished building a small suite of puzzle and game solvers that all run entirely in the browser — no backend, no API calls, no machine-learning models. You paste in a Sudoku, a chess position, or a crossword pattern, and the answer comes back instantly, computed on your own device. The fun part wasn't the UI. It was that each puzzle turned out to be a textbook excuse to reach for a different classic algorithm. Nine solvers, and I got to use constraint propagation, adversarial search, heuristic search, brute-force scanning, and plain old pattern matching — the stuff that shows up in an algorithms course and then, in most day jobs, never again. This is a tour of which algorithm fits which puzzle, and a few of the potholes I hit along the way. Everything here is vanilla JavaScript running in a Web Worker. The one design constraint: no server Before the algorithms, the rule that shaped all of them: it has to run client-side. That's a privacy choice (your puzzle never leaves the tab) and a cost choice (no compute bill), but it's also a fun forcing function. You can't lean on a beefy backend or a hosted model — you get one browser thread (well, a Worker thread) and whatever you can compute in a few hundred milliseconds. That budget is exactly why classic algorithms shine here. They're fast, deterministic, and small enough to ship as a script. Let's group the solvers by the technique each one leans on. Family 1: Constraint propagation Sudoku Sudoku is the poster child for constraint propagation. A cell that can only be one value forces that value; that in turn shrinks its neighbours' options, which forces more cells, and so on. Most "easy" and "medium" boards fall over from propagation alone (naked singles + hidden singles), and only the hard ones need a backtracking search on top. The nice property: the same engine that solves the board also powers the hint feature (find the next forced cell and explain why it's forced) and a uniqueness check — count solutions,

Contents Motivation and Purpose Using an Animation to Visualize Key Concepts Working With the Model 1. Get the Files 2. Choose the Dimensions 3. Inspect the Assembly 4. Export the MakerWorld Plates 5. Attach the Hoses Create the Model Animation Reference Links Motivation and Purpose I made a parametric bayonet connector for AC hoses , to attach such hoses to a mobile AC unit and a typical window kit taking the hot air outside. It is part of my Air Conditioning Collection on MakerWorld . And of course, I prefer code over using some GUI CAD application, leading straight to OpenSCAD as the established standard for 3D-models-as-code. It is also one of the few ways MakerWorld models can be made customizable by the end user. The connector allows attaching a hose with a simple push and a short twist, instead of needing a threaded joint or tools every time the hose is removed. The design has three printable parts: A female connector with bayonet slots on the inside. A male connector with matching lugs. A female adapter with a wider fitting section for joining to an existing tube, like the one on an air intake cover. The male lugs fit into the slots in the female connector. Push the parts together, twist them, and the lugs travel along the horizontal parts of the L-shaped slots. This is the same basic idea used by bayonet light fittings, camera mounts, and other quick-release connectors. See the Bayonet mount overview for useful background. The hose itself is held on the printed connector with a worm-drive hose clamp. A screw on the clamp pulls the perforated band tight around the hose. See the Hose clamp reference for an explanation of that mechanism. Using an Animation to Visualize Key Concepts The OpenSCAD file contains code that creates a 10-scene animation. It shows the female connector turning to expose the slots, the hose and male connector moving into position, the male part twisting to lock, and the parts separating again. It also emphasises the parametric nature of

I'm fairly new to SRE/DevOps, and one of the topics I recently spent time studying properly was EKS cluster upgrades . My first instinct, like most people starting out, was: "it's just a version bump, click upgrade in the console, done." That's basically what most beginner blog posts say too. But the more I read and the more I dug into real-world postmortems and discussions, the more I realized — the actual Kubernetes control plane upgrade is the easy part. Almost everything that can go wrong seems to happen around it, not because of it. Sharing what I learned here, mainly for my own notes, but hoping it's useful for anyone else early in their journey too. Learning #1: There's No "Undo" Button This was the first thing that surprised me. I assumed upgrades work like most software — if something breaks, you roll back. But with EKS, you cannot downgrade the control plane version once you upgrade it. So the plan can't be "upgrade, and if it breaks, revert." It has to be "test enough beforehand that breaking isn't really an option," and if something does go wrong, the fix is always moving forward, not backward. That single fact changes how you're supposed to approach the whole thing — testing has to happen before the button is clicked, not after. Learning #2: APIs Get Deprecated, and It's Usually Not Your Own Code That Breaks Kubernetes removes old API versions on a schedule. I already knew this conceptually, but what I didn't realize is that the risk usually isn't your own YAML files — it's the Helm charts and third-party tools you installed a while back and forgot about , which might still be using an older API version internally. There are tools built exactly for catching this before it becomes a problem: pluto detect-helm -owide pluto detect-files -d ./manifests kubent (kube-no-trouble) does something similar. I hadn't heard of either tool before researching this, and it made me realize how much of "being good at Kubernetes" is really just knowing which small tools e

As part of my AI Engineering journey, I recently worked on a project that helped me understand how Retrieval-Augmented Generation (RAG) works in practice. I built a Hybrid RAG system that combines FAISS vector search and BM25 keyword search to retrieve relevant information from a knowledge base and use it to generate grounded answers. In this post, I’ll briefly share what I built, how the system works, and some of the things I learned along the way. Why RAG? Large Language Models are great at generating natural-language responses, but they may not have access to information contained in a specific document or knowledge base. RAG addresses this by first retrieving relevant information from an external knowledge base and then providing that information to the LLM as context. The basic workflow is: User Query ↓ Retrieve Relevant Information ↓ Provide Context to LLM ↓ Generate Answer For my project, I wanted to take this a step further by combining semantic search and keyword search. 🔍 Hybrid Retrieval The system uses two retrieval methods: Vector Search with FAISS Document content is divided into smaller chunks and converted into vector embeddings. These embeddings are stored in a FAISS index, which is used to find documents that are semantically similar to the user’s query. This is useful even when the query and the document use different wording. Keyword Search with BM25 The second retrieval method is BM25. BM25 focuses on the occurrence and importance of terms in the query and documents. This makes it useful for exact terminology, technical terms, names, and identifiers. Instead of depending on only one retrieval method, both approaches are combined. User Query │ ┌──────────┴──────────┐ ↓ ↓ FAISS Search BM25 Search Semantic Search Keyword Search │ │ └──────────┬──────────┘ ↓ Hybrid Ranking ↓ Relevant Context ↓ LLM ↓ Final Answer The FAISS and BM25 scores are normalized and combined using weighted scoring. The results are then ranked, and the highest-ranked chunks ar

🚀 MyZubster Dev Update — Building the Zorgax Monetization Layer We’ve completed another important step toward making Zorgax not only an AI and research layer, but also a service that autonomous agents, applications, and users can interact with economically. This development introduces a new monetization architecture built on top of the MyZubster Payment Layer. What’s now implemented: • Server-side Zorgax product catalog and pricing • Credit accounts for users and services • Append-only credit ledger for auditable transactions • Purchase records bound to Payment Intents • Server-controlled credit grants — clients cannot decide prices or credit amounts • Idempotent credit allocation to prevent duplicate grants • Usage debiting with replay protection • Ownership isolation between users • Authenticated monetization API endpoints • Integration with the MyZubster Payment Intent architecture • Bitcoin payment rail compatibility, disabled by default until production infrastructure is ready The flow we are building is: Zorgax Service → Product & Pricing → Payment Intent → Payment Verification → Credits → Entitlement / Service Access → Usage A key design principle is that payment confirmation alone is not enough to arbitrarily create credits. The server keeps the authoritative relationship between the Zorgax product, its price, the Payment Intent, and the credits that can be granted. This gives us a foundation for future use cases such as: 🤖 AI agent services 🔬 Research and knowledge services ⚙️ Autonomous agent execution 🌐 API usage 🌱 MyZubster LIFE environmental services 🏪 Marketplace services and bounties 📡 IoT and machine-to-machine services ₿ Bitcoin and future machine-payment rails Security and accounting were treated as protocol requirements from the beginning: integer satoshis, transaction idempotency, anti-replay protections, server-side pricing, ownership checks, and auditable credit movements. Current validation: ✅ 8 test suites passing ✅ 69 automated tests passing

I'm Nadia, and I built HEICtoPDF — it turns iPhone HEIC photos into PDFs without the file ever leaving the browser. I maintain it myself as an indie side project, so read this as a maker post, not a neutral review. The interesting part of building it wasn't the conversion. It was deciding, early, that nothing gets uploaded — and then living with everything that decision took away. Why "no upload" was the starting point, not a feature Look at who actually needs HEIC turned into PDF. An iPhone has shot HEIC by default since iOS 11, and a lot of upload forms still won't take it: government portals, visa and benefit applications, job application systems, insurance and expense claims, print services. So the file someone is converting is usually a photo of a passport, a driver's licence, a signed form, a utility bill with their address on it, a medical receipt. That is the whole population of this tool. "Drop your ID onto our server and we'll send you back a PDF" is a bad shape for that job, even when the server is honest and deletes things on schedule. The user has no way to verify any of it. Doing the work locally is the only version of this where the promise is structural rather than a policy statement. That framing is easy to write on a landing page. What follows is the bill. What the constraint costs A file size ceiling. 10MB per input file. On a server you scale past this by renting a bigger machine; in a browser tab you're spending someone else's device memory, on hardware you know nothing about, and the failure mode isn't a 500 — it's the tab dying while they watch. So the cap is set where it is on purpose, and it does turn some files away. A page ceiling on merging. You can convert a batch and then combine the results into one multi-page PDF, up to 30 pages. Same reason. Thirty pages covers the actual use case — "my landlord wants all of this as one file" — and stops well short of someone dropping a holiday album in. Lossy output, and I have to say so. Each photo

Google Flights has a date grid with a fare for every departure day, and a "track prices" toggle that emails you when its pick of dates moves. Both are fine for one trip. Neither gives you the table: every day, the fare, the airline and stops behind it, in rows you can sort, keep and put a threshold on. If your dates are flexible and you want the cheapest day to fly as data — or airfare price tracking that runs every morning — you need rows. This is how to get one row per departure day from Google Flights as JSON, with no API key (there is no public Google Flights API), and how to turn it into a flight price alert. 1. One request, one row per day The Flight Price Tracker on Apify takes routes, a first departure day and a window length. For each day it searches Google Flights, keeps that day's cheapest itinerary and ranks the days. A 30-day window on one route is at most 30 fare rows plus a free status row. curl -X POST "https://api.apify.com/v2/acts/kestrel~flight-price-tracker/run-sync-get-dataset-items?token= $APIFY_TOKEN " \ -H "Content-Type: application/json" \ -d '{"routes": ["LIS-LHR"], "departDate": "2026-10-05", "days": 30, "adults": 1, "currency": "USD", "market": "us"}' A fare row: { "type" : "fare" , "route" : "LIS-LHR" , "trip" : "one_way" , "depart_date" : "2026-10-05" , "return_date" : null , "seat" : "economy" , "adults" : 1 , "currency" : "USD" , "price" : 127 , "price_display" : "127 US dollars" , "airline" : "Tap Air Portugal" , "stops" : 0 , "depart_time" : "8:00 PM" , "arrive_time" : "10:55 PM" , "duration" : "2 hr 55 min" , "duration_minutes" : 175 , "layovers" : null , "co2_kg" : 123 , "itineraries_seen" : 12 , "cheapest_in_window" : true , "rank_in_window" : 1 , "google_url" : "https://www.google.com/travel/flights?tfs=..." , "fetched_at" : "2026-08-29T06:25:14+00:00" } cheapest_in_window is true on exactly one day per route; rank_in_window orders the rest. The free status row repeats the headline as cheapest and cheapest_date , with days_searc

BLUF / Executive Summary: Target: Model Context Protocol (MCP) HTTP/SSE Server endpoints. Discovery: Audit of 5,308 public MCP endpoints revealed 65% lack transport authentication . Solution: Introducing MCPGrade ( mcpgrade-1.4.0 ) , a 39-check rating algorithm. The Model Context Protocol (MCP) is now the standard for connecting AI models to tools and data. But as developers deploy MCP servers, security has lagged. In our audit of 5,308 public MCP servers under SentinelReign research, over 3,450 servers (65%) exposed tool execution capabilities without authentication. MCPGrade ( mcpgrade-1.4.0 ) Matrix Assessment Domain Checks Impact Weight 1. Transport Authentication 10 Checks 35% 2. Tool Scope & Authorization 12 Checks 30% 3. Input Validation & Injection 9 Checks 20% 4. Rate Limiting & Audit Logging 8 Checks 15% Check out the full teardown and live A-F scanner at Andrax Pentester . Written by Syed Zada Abrar — Founder & CEO of SentinelReign ( https://sentinelreign.com ).

If you've ever built a site for a client, a friend, or your own side project, you've had this conversation: "So... how much would a website cost?" And you've answered with "it depends" — which is true, but useless without context. So here's the breakdown I wish I could just link people to instead of explaining from scratch every time. First: "Website" Is Not One Thing If you've ever built a site for a client, a friend, or your own side project, you've had this conversation: "So... how much would a website cost?" And you've answered with "it depends" — which is true, but useless without context. So here's the breakdown I wish I could just link people to instead of explaining from scratch every time. A landing page and a custom marketplace platform are both "websites" the same way a bicycle and a truck are both "vehicles." Different build process, different skillset, different price tag. Once you separate by type, the numbers actually make sense: Type Typical Range Landing Page / One-Pager $500 – $3,000 Multi-Page Business Site $1,500 – $8,000 E-Commerce Store $2,000 – $20,000+ Custom Web App / Platform $10,000 – $100,000+ The Build-Method Question (This Is the Part Devs Actually Care About) No-code builders (Wix, Squarespace): $15–$50/month. Fast to ship, fine for a hypothesis test. The tradeoff is architectural debt you don't see until you hit it — custom logic, advanced SEO control, and scaling all get harder or impossible without a full platform switch. WordPress / CMS: $50–$500/year for platform + plugins, plus dev time. Flexible, huge plugin ecosystem, no vendor lock-in — but every convenience plugin is also a maintenance and security surface you now own. Custom-coded: starts around $1,000, no real ceiling. This is the only route when requirements exceed what a template or plugin can do — unusual functionality, real performance constraints, or a design that isn't achievable off-the-shelf. The trap: a $20/month builder that gets outgrown in 18 months and rebuilt

AI agents are getting very good at doing things . They can search databases, call APIs, modify tickets, draft code, update records, trigger workflows, and interact with production systems. And that changes the engineering problem. When an LLM only generates text, a bad answer is usually just that: a bad answer. When an LLM can take an action, a bad answer can become a bad state change . So the most important question in agent architecture is no longer: Can the model figure out what to do? It is: Who decides whether the model should actually be allowed to do it? Those are two very different responsibilities. And I think one of the most useful principles for production AI agents is surprisingly simple: Use the model to reason. Don’t automatically give it authority to execute. The architecture that works beautifully in demos A lot of agent demos reduce to something like this: User → LLM → Tool → Action The model receives a request. It reasons about what should happen. It selects a tool. It generates the parameters. The tool executes. That is an incredibly productive abstraction. It is also a risky one when the tool can affect something real. The same probabilistic system is effectively doing two jobs: deciding what it believes should happen; authorizing that thing to happen. You can try to fix this with prompting: Always ask for confirmation before making important changes. But that is still an instruction. It is not a security boundary. The difference becomes clearer when you compare the two architectures. %%{init: {'theme':'base','themeVariables': { 'primaryTextColor':'#111827', 'secondaryTextColor':'#111827', 'tertiaryTextColor':'#111827', 'textColor':'#111827', 'edgeLabelBackground':'#FFFFFF', 'lineColor':'#4B5563' }}}%% flowchart LR subgraph BAD["❌ Demo-Style Agent"] direction LR A["User"] --> B["🧠 LLM"] B --> C["🔧 Tool"] C --> D["💥 Real-World Action"] end subgraph GOOD["✅ Production-Oriented Agent"] direction LR E["User"] --> F["🔎 Evidence"] F --> G["🧠 LLM"] G --

Remember when spotting a phishing email was as easy as scanning for broken English, a generic "Dear Customer" greeting, and a weird sender address that looked like a random string of numbers and letters? For years, cybersecurity awareness training focused heavily on those exact red flags. We taught teams to look for misspellings, awkward phrasing, and mismatched URLs. We built a collective intuition around digital bad hygiene. That playbook is officially obsolete. Generative artificial intelligence and large language models (LLMs) have completely rewritten the rules of social engineering. Bad grammar is gone, hyper-personalization has been automated at scale, and threat actors are no longer just typing—they’re cloning voices, automating OSINT, and orchestrating multi-channel attacks that look breathtakingly real. The Great Equalizer: How LLMs Murdered the Obvious Clue In the pre-AI era, threat actors faced a frustrating bottleneck. High-volume attacks meant blasting out cheap, poorly worded emails, while high-value spear-phishing campaigns required hours of manual research into a specific executive's writing style and background. AI completely eliminated that friction. While a human analyst might take over half a day to craft a hyper-realistic targeted lure, an LLM can generate dozens of contextually flawless variants in seconds. This shift has introduced several dangerous characteristics to modern social engineering: Native-Language Fluency: Language barriers have vanished. Scammers can use LLMs to generate native, localized content in English, French, Japanese, or any other language without a single syntactic slip-up. Automated OSINT: Attackers use automated scripts to scrape LinkedIn profiles, corporate websites, and social footprints, weaving real colleagues, ongoing projects, and corporate milestones directly into the lure. Behavioral A/B Testing: Cybercriminals treat phishing like digital growth hacking, using AI to churn out multiple narrative variations (e.g

Psychedelics are often associated with disconnecting from reality, but a recent neuroimaging study found that psilocybin can actually make our brain activity more connected to the world around us.

Many engineers believe Common Table Expressions (CTEs) are always faster than subqueries. In modern SQL Server (and PostgreSQL), that is a myth . Here is what actually happens under the hood: 1. Inlining & The Query Optimizer By default, the SQL optimizer treats standard CTEs and derived tables (subqueries) almost identically: The engine expands both into the same relational tree. They generate the exact same execution plan and I/O cost . -- Pattern A: Derived Table (Subquery) SELECT DeptID , EmpName , Salary FROM ( SELECT DeptID , EmpName , Salary , DENSE_RANK () OVER ( PARTITION BY DeptID ORDER BY Salary DESC ) AS rnk FROM Employees ) RankedData WHERE rnk <= 2 ; -- Pattern B: Common Table Expression (CTE) WITH RankedData AS ( SELECT DeptID , EmpName , Salary , DENSE_RANK () OVER ( PARTITION BY DeptID ORDER BY Salary DESC ) AS rnk FROM Employees ) SELECT DeptID , EmpName , Salary FROM RankedData WHERE rnk <= 2 ; 2. When CTEs Truly Win: Readability & Pipeline Stacking: You can chain 5 CTEs sequentially without deeply nested pyramid brackets. In-Place Deduplication: In SQL Server, you can run DELETE directly on a CTE, and it deletes duplicate rows straight from the real underlying table! WITH DuplicateCleaner AS ( SELECT CustomerID , Email , ROW_NUMBER () OVER ( PARTITION BY Email ORDER BY RegistrationDate ASC ) AS rn FROM Customers WHERE Email IS NOT NULL ) DELETE FROM DuplicateCleaner WHERE rn > 1 ; -- ✅ Clean in-place deletion! 3. The Big Trap (Spooling Overhead): If you reference the same CTE multiple times in a query (e.g. CTE_A JOIN CTE_A ), SQL Server may execute the underlying CTE query multiple times or create a Lazy Spool in tempdb . -> Fix: For heavy multi-million row reuse, use a Temporary Table ( #TempTable ) with an explicit Clustered Index instead! 💡 How do you choose between CTEs, Temp Tables, and Subqueries in your pipelines? 💼 Connect on LinkedIn: linkedin.com/in/arpitmbangre

Hey DEV community! 👋 When debugging network streams, parsing custom file formats, or inspecting database buffers, we often extract data as raw arrays of numbers rather than human-readable text. This data typically presents itself as raw byte sequences formatted in either decimal or hexadecimal notation. While there are online decoders available, pasting raw byte sequences into third-party sites that process data on their backend databases introduces an unnecessary data privacy risk. To solve this, I designed a lightweight, entirely browser-based Byte to String Converter that decodes raw byte sequences locally using standard JavaScript APIs. In this post, we will look at how bytes map to character encodings and implement a client-side JavaScript utility to decode them safely. The Structure of a Byte In modern computing, a byte is the basic unit of digital information, consisting of an 8-bit sequence: 1 byte = 8 bits Because each bit represents a binary state (0 or 1), a single byte can represent: 2 8 = 256 states This translates to numeric values spanning from: Decimal (Base 10): Range of [ 0 , 255 ] Hexadecimal (Base 16): Range of [ 00 , FF ] When we render characters on a screen, we rely on character encoding tables (such as ASCII or UTF-8) to map these numerical byte values back to their original symbolic representations. Navigating Encodings: ASCII vs. UTF-8 The reconstruction process depends entirely on the encoding format used: ASCII: A basic 7-bit standard where each character maps to exactly one byte. It covers basic English letters, numbers, and core control characters. For example, the decimal value 72 maps to the uppercase letter 'H' . UTF-8: A variable-length encoding format that utilizes between 1 and 4 bytes per character. This structure allows UTF-8 to represent emojis, mathematical notations, and diverse language scripts. Our browser utility parses byte sequences using UTF-8 to maintain compatibility with modern web standards. JavaScript Implementatio