<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Alexander Luria on Medium]]></title>
        <description><![CDATA[Stories by Alexander Luria on Medium]]></description>
        <link>https://medium.com/@alexanderluria?source=rss-ec3934e49e41------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*5W5oMa5sxEptXgvI.</url>
            <title>Stories by Alexander Luria on Medium</title>
            <link>https://medium.com/@alexanderluria?source=rss-ec3934e49e41------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:46:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alexanderluria/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why Stealing a GPU Design Is Practically Impossible]]></title>
            <link>https://alexanderluria.medium.com/why-stealing-a-gpu-design-is-practically-impossible-ef20c915af82?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef20c915af82</guid>
            <category><![CDATA[foundry]]></category>
            <category><![CDATA[manufacturing]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[espionage]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 23:23:04 GMT</pubDate>
            <atom:updated>2026-11-09T23:23:04.298Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8kXv1pRi-vQgtNGET9UePA.png" /><figcaption>Find the mulfunctioning cpu on this wafer.</figcaption></figure><h3>The blueprint fallacy</h3><p>The design files are the cheapest part of a modern GPU. Every spy thriller, every headline about stolen secrets, and every congressional hearing on chip espionage rests on the same intuition: that the design <em>is</em> the product, and whoever holds the files holds the prize. In semiconductors, that intuition is simply wrong. A leading-edge GPU is not a document; it is the output of an industrial system so deep, so constrained, and so dependent on accumulated craft that possessing a perfect copy of the design moves a would-be thief almost nowhere.</p><p>This is not a comforting slogan. It is an engineering claim with specific, checkable parts: the design itself cannot be fully read, the machines cannot be bought, the manufacturing recipe cannot be transferred, the learning loops cannot be compressed, and the industrial civilization around a fab cannot be improvised. Each wall is independent. A thief must breach all of them, in sequence, while the target moves. The sections below walk each wall in turn.</p><h3>Wall zero: the blueprint you cannot read</h3><p>Before any factory problem, the stolen files present a reading problem — because a modern GPU is not one design but a sediment of twenty years of designs, and large parts of it are opaque even to the company that owns them.</p><p>Start with the software continent fused to the silicon. A GPU ships as hardware plus microcode, firmware, compilers, drivers, and libraries — in NVIDIA’s case the CUDA stack, hundreds of millions of lines of code co-evolved with the chips for two decades. The hardware is designed around what the software can schedule; the software is tuned around what the hardware actually does, including its undocumented quirks. Steal the silicon design without that software inheritance and the product is a brick; steal both and you now maintain a codebase whose institutional memory stayed behind.</p><p>The hardware description itself is the same story at a lower level. An instruction pipeline, an out-of-order scheduler, a cache hierarchy with its coherency protocol — these look like textbook diagrams from outside, but the shipping versions are thousands of accumulated fixes, workarounds, and counterintuitive tunings, each encoding some bug a validation team hit years ago. The <em>why</em> behind each oddity lives in old bug trackers, hallway lore, and heads that have since moved on. The files say what; they do not say why; and in chip design, changing a <em>what</em> without its <em>why</em> is how you create the next respin.</p><p>And then there are the haunted blocks. Every mature design carries regions marked, in practice if not in writing, “don’t touch it if it works”: an analog corner, the power-delivery network of some ancient sub-block, a clock-distribution structure — circuitry carried forward verbatim generation after generation because it passed validation on billions of shipped units, while the engineers who designed it have retired, forgotten the details, or died. Inside the owning company, nobody fully understands these blocks anymore; they are trusted on their track record, not their documentation. A thief inherits the same opacity with none of the validation history, none of the oral tradition about which warnings matter, and no one to call. The blueprint, it turns out, is not self-describing — even its legitimate owner reads parts of it on faith earned over decades. A copy carries the faith nowhere.</p><h3>Wall zero: the design cannot even read itself</h3><p>Before any wall of machinery, there is a quieter problem: the stolen files themselves are not understandable, not even — fully — by their owner. A modern GPU or CPU design is tens of millions of lines of hardware description code, microcode, and verification collateral, layered over decades. Inside it live the instruction pipeline — fetch, decode, schedule, dispatch, retire — with its branch predictors, out-of-order machinery, and speculative paths tuned by thousands of engineer-years of benchmark warfare; and the cache hierarchy — L1, L2, shared L3, coherence protocols, prefetchers, replacement policies — where a single mistuned heuristic can erase a generation’s performance gain. None of these subsystems is documented to the depth at which it actually works. The documentation is the team that built it.</p><p>And every mature design carries its haunted quarters: the “don’t touch it if it works” blocks. Logic written twenty or thirty years ago, patched around rather than rewritten, validated by the fact of its survival rather than by anyone’s living understanding. The engineers who designed these blocks have retired, moved on, forgotten, or died — and the companies themselves treat the code as archaeology: new features are built <em>around</em> it, because reopening it risks breaking behaviors nobody can enumerate. x86’s decades of backward compatibility are the canonical example, but GPU driver stacks and fixed-function units carry the same sediment. A thief inheriting these files inherits the mystery without the oral tradition: millions of lines where the original intent exists nowhere on paper, where the comments lie, and where the only people who could explain a timing hack from 2003 are unreachable in the most permanent sense.</p><p>This is why even <em>legitimate</em> acquirers struggle to absorb a design team’s codebase, and why hardware companies pay fortunes to retain gray-haired engineers who hold the map in their heads. The blueprint is not self-describing. Stealing it is stealing a library written in a private dialect, indexed by memories you cannot subpoena.</p><h3>Wall one: the machines you cannot buy</h3><p>A leading-edge GPU can only be printed by extreme ultraviolet (EUV) lithography, and every EUV machine on Earth comes from one company: ASML of the Netherlands. There is no second source, no clone, no gray market. Each machine is the size of a bus, costs $150–400 million depending on generation, contains mirrors polished by Zeiss to tolerances measured in atoms, and ships in parts aboard multiple cargo planes before a months-long installation and calibration by ASML’s own engineers. Production runs at a few dozen units per year, allocated years in advance to a handful of customers.</p><p>EUV machines are also export-controlled. The Dutch government, under a framework agreed with the United States, has never licensed a single EUV system for sale to China — the restriction predates the current chip war and has only tightened. A stolen design file therefore meets its first wall immediately: the thief cannot legally, or practically, acquire the one category of machine required to print it. China’s best domestic fabs push older deep-ultraviolet (DUV) tools through heroic multi-patterning to approximate 7nm-class features, at yields and costs that make the output strategically interesting and commercially uncompetitive. The tool gap alone is a decade wide, and it is enforced at the level of national export law, not corporate secrecy.</p><h3>Wall two: the recipe that does not transfer</h3><p>Suppose the thief somehow has the machines. The next discovery is that a semiconductor process is not a recipe in any transferable sense — it is closer to an alchemy practiced by a specific group of people on specific tools in a specific building. A leading-edge flow runs 400 to over 1,000 steps: deposition, lithography, etch, implant, polish, clean, repeat — each step tuned to the individual fingerprint of the tool performing it, the chemistry batch feeding it, and the steps before and after it. Move the “same” recipe to a different tool in different air with different incoming chemistry, and it yields differently. Process transfer between a company’s own fabs — same firm, same documents, same engineers flying between sites — routinely takes a year or more. Between adversaries, with stolen paper and no people, it barely means anything.</p><p>The numbers from inside the industry make the point brutally. On a new process node, reaching even 10% yield within the first year has been described by fab veterans as a miracle — ninety-plus percent of early wafers, each worth roughly $25,000 at advanced nodes, go to the bin while the process is learned. Economic production needs 70–90% yield, and the climb between those numbers is years of iteration, not a document anyone can hand over.</p><p>And the process is fragile in ways no blueprint captures. Cleanrooms run at particle counts thousands of times below ordinary air because a single micron-scale speck is a boulder at nanometer geometry. Fab lore is full of ruined batches traced to astonishingly human causes: coins rinsed in an etch bath, cosmetics worn past the gowning line, a momentary lapse in a chemical sequence — each capable of destroying a month of work-in-progress. The real intellectual property is ten thousand operators and process engineers <em>not</em> having a bad day, simultaneously, for years. That knowledge lives in people and institutional scar tissue. It cannot be photographed.</p><h3>Wall three: time, and the target that moves</h3><p>Every learning loop in a fab is gated by physics, not willpower. A wafer takes roughly 30 days or more to travel the full process before any test automation can even touch the chips and report whether they live. Every experiment — tweak a step, run a lot, measure, adjust — costs a month of calendar time, and a mistake made in week one is discovered in week five, buried somewhere behind hundreds of subsequent steps. Yield learning is a sequence of these loops, dozens of them, and they cannot run faster than the wafers move. Money buys parallel experiments; it does not buy shorter loops.</p><p>Now grant the thief everything at once: the blueprints, the poached engineers, installed EUV tools, a certified cleanroom, the supply chain, and unlimited funding. The remaining, irreducible path — tool installation and qualification, recipe re-derivation, the yield ramp from miracle-grade 10% to economic 70%+ — still consumes roughly two to three years of process time. The honest real-world benchmark is TSMC’s own Arizona expansion: the same company, moving its own proven process with its own people onto friendly soil, took about four years to first production silicon and still runs at a cost premium to Taiwan. That is the <em>best case</em>, with nothing stolen and everything shared.</p><p>Meanwhile the target moves. GPU architectures now ship on a roughly annual cadence. By the time a cloned line produces its first sellable chip, the stolen design is two to three generations obsolete — a museum piece manufactured at a loss. The thief is not chasing a position; the thief is chasing a velocity, with a loop-time handicap that physics will not waive.</p><h3>Wall four: the civilization around the fab</h3><p>A leading-edge fab is less a factory than a small city-state. It demands gigawatt-class electrical service on utility contracts negotiated years ahead; ultrapure water by the millions of gallons per day; a resident population of thousands of specialized engineers, technicians, and operators who must be housed, transported, fed, and — above all — retained, because the yield knowledge walks out the door with them. Around the fab sits a supply web of hundreds of firms: photoresist and specialty gases with their own single-source chokepoints, mask shops, metrology vendors, chemical-mechanical polish slurries, each qualified to the specific line. None of this is secret, and none of it can be stolen, because it is not information — it is logistics, labor markets, and decades of vendor relationships. A $30 billion building full of stolen knowledge, without its civilization, produces nothing.</p><p>History has already run the “clone the leader” experiment, in a far easier era, and catalogued the bodies. In the 1990s, Cyrix, NexGen, Transmeta, IDT/Centaur, and Rise all built working x86 processors — real designs, real talent, shipping products. All are gone. Cyrix in particular bled out in the fab gap: lacking its own foundry, it rented capacity from IBM and SGS-Thomson and ran perpetually a process node behind Intel — clever architecture executed on slower transistors still loses. And that was at micron-scale lithography, when a fab cost a billion dollars. The sole survivor of the clone wars, AMD, lived not by out-manufacturing Intel but by legal armature: the second-source agreements of 1976 and 1982, IBM’s insistence on dual suppliers, and decades of antitrust pressure that forced the cross-licenses keeping it alive. The market, left alone, produced a graveyard and a near-monopoly. Even survival turned out to be a matter of law, not larceny.</p><h3>What is actually stealable — and why it does not matter</h3><p>Espionage is real, and some things do move: architectural ideas, roadmap hints, software tricks, the general direction of travel. These leak constantly through papers, patents, teardowns, poached hires, and ordinary industrial spying — and the industry prices that leakage in. What cannot move is the thing that makes the product exist: the millions of lines of design code that only its authors — some retired, some dead — could ever fully explain, the sole-source machines guarded by export law, the tool-specific recipes that die in translation, the yield knowledge distributed across thousands of heads, the month-long learning loops no budget can shorten, and the industrial civilization that feeds a fab its power, chemistry, and people.</p><p>Stack the walls and the verdict writes itself. A stolen blueprint alone leaves the thief five-plus years from competitive silicon. A stolen blueprint <em>plus</em> machines, people, cleanrooms, and will still leaves two to three years of irreducible process time — against a target that redesigns itself annually. The clone arrives, if it arrives, as an obsolete chip at a hopeless cost, which is exactly how every previous attempt in semiconductor history ended.</p><p>The deepest intellectual property in the chip industry was never written down, which is why it has never been stolen. It is the accumulated, embodied, perishable skill of making atoms behave at miracle-grade difficulty, at scale, every day — and the only known way to acquire it remains the way the incumbents did: build it yourself, wafer by ruined wafer, for decades.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef20c915af82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A peace treaty with Product: you bring the vision, we bring the polish]]></title>
            <link>https://alexanderluria.medium.com/a-peace-treaty-with-product-you-bring-the-vision-we-bring-the-polish-9ad771b9032d?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ad771b9032d</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 22:57:56 GMT</pubDate>
            <atom:updated>2026-11-09T22:57:56.005Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UFGad1qTMkC4C9GL_ZLadA.png" /></figure><h3>TL;DR</h3><ul><li><strong>The treaty:</strong> Product owns the <em>what</em>: requirements as a POC, a Jira epic, or a Claude Design mockup. Engineering owns the <em>how</em>: we drive it to polish, test, ship and support it.</li><li>Vibe-coded prototypes are a gift: keep making them. Treat each one as an <strong>executable requirement, not a release candidate.</strong></li><li>A demo is half a feature. The other half (edge cases, tests, architecture, security, upgrades, support) is what makes it a product.</li><li>Requirements go to dev <strong>and</strong> QA at the same time. QA validates requirements; finding bugs is a side effect.</li><li>On-prem customers pay yearly for responsibility, not code, and every upgrade costs them downtime and staging time. Small, predictable releases beat fast ones.</li><li>AI-generated code raises legal, IP, supply-chain and privacy questions, especially features that open an LLM window into the system.</li><li>We’re not racing to be first. We’re the ones who carry the heavy lifting when things break, and engineering is using AI too, to make that faster.</li></ul><p>Something genuinely exciting is happening. Product managers who used to describe features in slides can now build working prototypes in an afternoon. You can click through an idea before anyone writes a ticket. That’s a real superpower.</p><p>So this isn’t a “slow down” message. It’s a proposal for a peace treaty between product and engineering. Product keeps doing what it’s now better at than ever: defining and showing what to build, as a working POC, a Jira epic, or a Claude Design mockup. Engineering takes it from there and drives it to polish, so it’s something customers can rely on for years.</p><p>The rest of this document explains why that split works, and the treaty itself spells out what each side commits to.</p><h3>A prototype answers “what.” Shipping answers “how, forever.”</h3><p>A vibe-coded POC is the best answer we’ve ever had to the question <em>“what should we build?”</em> It makes ideas concrete, surfaces bad assumptions early, and gets everyone aligned in minutes instead of meetings.</p><p>Shipping asks a different question: <em>“How do we run this on a customer’s on-prem system, keep it secure, fix it at 2 AM, and upgrade it for the next five years?”</em> That’s where the dev and QA teams live. It’s a different kind of work, not a slower version of the same work.</p><h3>The 3D printer and the mould</h3><p>Manufacturing went through this exact shift. 3D printing collapsed the long prototyping stage: an engineer can hold a new part in their hands the same afternoon, test it, change it, and print it again. That was a revolution.</p><p>But 3D printing didn’t replace injection moulding. When you need ten thousand identical parts that fit every time, survive years of use, and come off the line fast and cheap, you still build a mould. Designing that mould is slow, exacting work, and it’s what makes mass production fast and reliable.</p><p>Vibe-coded apps are our 3D printer. They’re brilliant for prototyping: quick to make, easy to change, perfect for learning what works. Shipping to hundreds of on-prem customers is mass production, and that still needs the mould: reviewed code, tests, architecture, security, and an upgrade path. Both belong in the process. They’re just different stages of it.</p><h3>The whack-a-mole game</h3><p>Here’s what happens when the print goes straight to production. The first release looks great. Then the next feature has to be built on top of it, and that’s when the foundation starts talking back.</p><p>Fix a bug in one screen, and another pops up somewhere else. Add a field to an API, and two unrelated views break. Nobody designed the boundaries, so everything is quietly coupled to everything else: logic duplicated in three places, data contracts that differ slightly between the backend and the frontend, and no tests to tell you what you just broke. Every patch, often generated just as fast, adds another layer on a base that was never meant to carry weight. The game never ends; the moles just get faster.</p><p>And once real customers depend on it, the way out gets expensive. A rewrite now means migrating their data and configurations and re-earning their trust, all while still supporting the brittle version in the field.</p><p>The lesson is simple: the mould is far cheaper to build before the first customer than after the hundredth. Hardening before release isn’t the slow path. It’s what keeps every release after it fast.</p><h3>The invisible half of every feature</h3><p>By the time a feature reaches the dev team, the visible part is roughly half the job. The other half is what makes it a product: user experience, edge cases, error handling, test automation, code quality, modularity, sound principles like SOLID, DRY and YAGNI, architecture, compatibility with the existing codebase, infra upgrades, scalability, performance, and a look and feel that matches the rest of the product.</p><p>Data contracts between backend and frontend take honest trial and error to get right. UI components take several rounds before they’re truly usable and understandable. None of that shows up in a demo, and that’s fine. It’s not supposed to.</p><p>It’s just good to know it’s there, so that “the POC already works, why is this taking two sprints?” becomes “oh, <em>that’s</em> what those two sprints are for.”</p><h3>Why requirements matter more than ever</h3><p>Here’s a way to think about it. Every possible piece of software is, in a sense, a very large natural number. Somewhere out there is the exact number that is the product everyone dreamed of.</p><blockquote><strong><em>Side note: why software is “just a number.”</em></strong><em> Any program, source code or compiled binary, is a finite sequence of bytes, and every byte is 8 bits. String all those bits together and you get one long binary number. So every program that exists, or could ever exist, corresponds to exactly one natural number, and counting 0, 1, 2, 3… would eventually pass through all of them: every app ever written, every bug fix, and the perfect product too. The catch is that almost all of those numbers are garbage, and the useful ones are astronomically rare. Finding the right one isn’t a typing problem. It’s a search problem, and requirements are the map.</em></blockquote><p>AI is an incredibly fast guessing machine for that number. But a guess needs parameters. With the right ones, you get close to the dream. With the wrong ones, you get a beautifully working elevator controller when you needed a pool temperature management system.</p><p>There’s a scene in <em>I, Robot</em> where Dr. Lanning’s hologram keeps saying: <em>“You must ask the right questions.”</em> That’s the job now, and it’s a job product people are uniquely good at.</p><p>AI writes code fast and mostly reliably, but left alone it produces <em>different</em> software every time. To get a predictable result, it needs something persistent to aim at: written requirements, user flows, data contracts, acceptance criteria. The better those are, the better everything downstream becomes, whether a human or an AI is writing the code.</p><h3>QA validates requirements. Bugs are a side effect.</h3><p>There’s a common misunderstanding about what QA does. It’s easy to think of QA as “the team that finds bugs.” But finding bugs isn’t the goal. It’s a side effect.</p><p>The real job of QA is <strong>validating that the requirements are met.</strong> Does the feature do what we said it would do, for the users we said it was for, in the situations we said it would handle? Bugs show up naturally along the way, because a bug is simply a place where the software doesn’t match what was intended.</p><p>Which means QA can only be as good as the requirements they receive, and as early as they receive them.</p><p>Too often, QA first sees what a feature is supposed to do <em>after</em> it’s been implemented. At that point, they’re reverse-engineering intent from the code, and code can only say what it does, not what it <em>should</em> do. A vibe-coded POC makes this trickier still: it’s a convincing picture of one possible answer, but it doesn’t say which behaviours are deliberate and which are accidents of generation.</p><p>When QA gets the requirements at the same time as the dev team, everything improves. Test plans and automation get written in parallel with the code. Gaps and contradictions surface before anyone builds the wrong thing. And “is this a bug or a feature?” becomes a quick lookup instead of a debate.</p><p>Bringing QA in early isn’t extra process. It’s the cheapest quality we’ll ever buy.</p><h3>Software lives a long life</h3><p>Every artefact starts ageing the moment it’s created. New requirements arrive, bugs appear, feedback comes in. If each change means regenerating the app from scratch, every iteration drifts a little further from the last, and the cost adds up. Tokens are cheap today; they may not be tomorrow, and some customers may restrict AI tooling on their networks altogether.</p><p>That’s why ownership matters. Code a team understands, reviews and maintains can evolve steadily instead of being reinvented.</p><h3>What our customers are really paying for</h3><p>On-prem customers typically pay for long-term support every year, often around a quarter of the original purchase price. Every year, for as long as they run the product.</p><p>They don’t pay that for lines of code. They pay for <strong>responsibility</strong>: someone who understands the system, answers the call when something goes wrong, ships the fix, keeps it secure, and keeps it working through upgrades for years to come.</p><p>Now imagine that customer’s procurement team looking at a feature that was generated, lightly tested, and shipped without anyone truly owning it. Their question would be fair: <em>“If this is vibe-coded, why are we paying thousands of dollars a year for it? We have AI tools too. We could build something similar in-house, with the same lack of accountability and the same risk, and keep the money.”</em></p><p>And they’d have a point. AI has made code itself cheaper for everyone, including our customers. What it hasn’t made cheaper is trust. The value we offer is no longer just that we <em>can</em> build it. It’s that we stand behind it.</p><h3>Every upgrade costs the customer too</h3><p>For many on-prem customers, an upgrade isn’t a download. It’s a project: a change request, a maintenance window, a staging run on their own rigs, sign-off from someone accountable, and a rollback plan. In a 24/7 operation, there may be no real window at all, just a quiet hour negotiated weeks ahead.</p><p>That’s true even for the lightest change. “It’s just a UI container, no configuration, totally safe” is a claim the customer can’t verify cheaply, so they test it as if it touches everything. Trust in “lite” releases is earned over years of releases that really were lite, and lost with one that wasn’t.</p><p>When our pace outruns theirs, customers start skipping versions. The field fills with many versions at once, the support matrix grows, and every skipped version makes the eventual jump bigger and riskier. Shipping faster can literally produce slower adoption.</p><p>Regenerated code makes this harder. When code is regenerated rather than carefully changed, the diff between versions is often far larger than the feature itself, so the real risk of each upgrade rises, and release notes can’t honestly say what changed.</p><p>For on-prem, the winning pattern is small, predictable, well-described changes; strong backward compatibility; a clear risk label per release; fast, safe rollback; and a cadence customers can plan around. Every one of those is engineering discipline, not code generation.</p><h3>We’re not racing to be first</h3><p>Building software just got its “upload button” moment. When video production stopped requiring a studio, millions of creators appeared, and the established players moved toward what only they could provide. Software is following the same path. Generating code is becoming nearly free, and a wave of independent vendors and solo builders will solve small, specific problems that were never worth a major vendor’s time.</p><p>That’s good news for customers and for us alike. Those small tools will fill gaps we’d never prioritise ourselves, and some of them will run right alongside our product, making it more useful.</p><p>But it also makes plain what game we’re in. We’re not competing on who ships a feature first. If speed of generation were the contest, anyone with an AI subscription could win it in a weekend.</p><p>Customers don’t call the fastest prototype; they call the vendor that owns the system end to end and knows how to bring it back. Our game is a different one: <strong>who carries the heavy lifting when things go wrong.</strong> When a broadcast is on the line, when a configuration nobody tested breaks in the middle of the night, when an upgrade has to land safely across hundreds of installs, that is who they turn to.</p><h3>We show up, even for the scenarios nobody planned</h3><p>Real customers don’t run our software the way the lab does. Some combine features in unusual ways, push configurations far beyond anything we tested, or run their own in-house tools alongside ours. Our official position is that we have never supported those setups, and we have never prevented them either. Every on-prem vendor lives with this.</p><p>And when a one-of-a-kind scenario breaks for a customer, we don’t point at the fine print. We pick up the phone, dig in, and fix it. That’s what support means, and it’s what we’re paid to do.</p><p>Code ownership matters because, when an issue appears in a scenario no one ever tested, the only way to respond quickly is with a team that understands the code deeply: how it was designed, why it behaves the way it does, and what a change will affect. Every feature that enters the product without that understanding makes those calls harder, slower and riskier, for us and for the customer waiting on the fix.</p><h3>Commitment, not caution</h3><p>It’s worth saying clearly: when the dev team asks for time to review, test and integrate, it isn’t hesitation, and it certainly isn’t laziness. The software lifecycle has never excused us from delivering, and no one on the team sees it that way.</p><p>We’re committed to release schedules that are set by product and marketing. We don’t invent those dates. We plan around them, adjust where we can, and give our best effort to meet them, every release.</p><p>What we’re asking for is simply the room to deliver the quality those releases promise. “Just merge it to production and see what happens” has never been a recipe for success, at any company, with or without AI. A reviewed, validated release is how we keep our commitments to the schedule and to the customer at the same time.</p><h3>AI on both sides of the handoff</h3><p>This isn’t product using AI while engineering holds the line. The dev and QA teams are putting AI to work on the invisible half too: tests generated from requirements, AI-assisted code review, automated checks on dependencies and data flows, and specs precise enough for machines to verify against.</p><p>That’s where the real speedup is. AI multiplied how fast code can be written, but review, testing and security checks were sized for human output. Verification is the new bottleneck, and the teams that win will be the ones that make it as fast as generation, not the ones that skip it.</p><p>It also means AI can run freely wherever the stakes allow. Prototypes, internal tools, test scaffolding and one-off scripts are cheap to undo and touch no customer, so let AI rip there. As the cost of a mistake rises, toward production code on a customer’s on-prem rig, the level of review rises with it. Autonomy matched to risk, not one rule for everything.</p><p>So the deal is two-sided: product brings sharper requirements and working prototypes, engineering brings faster, AI-assisted hardening. Both of us go faster, and the customer doesn’t pay for it.</p><h3>Keeping the company and our customers safe</h3><p>A few things are easy to miss in the excitement of a working prototype, so it’s worth naming them.</p><ul><li><strong>Responsibility.</strong> When something breaks in a customer environment, our contracts and SLAs apply regardless of who or what wrote the code. Review is how we stand behind what we ship.</li><li><strong>Intellectual property.</strong> The legal status of purely AI-generated code is still unsettled in many places, and models can reproduce fragments of code under licenses we can’t comply with. Publishing a POC to a public repo can also expose product logic or secrets we’d rather keep. A quick review protects our IP.</li><li><strong>Supply chain.</strong> AI tools sometimes suggest packages that don’t exist, and attackers register those names to plant malicious code. Vetting dependencies keeps spyware and backdoors off our customers’ systems.</li><li><strong>Privacy.</strong> Many customers chose on-prem precisely so their data stays in the building. A prototype that calls an external AI service or sends telemetry could unintentionally break that promise.</li><li><strong>The open window.</strong> Features that embed an LLM, a box where users type “configure this, replace that,” deserve special care. Inputs can be manipulated through prompt injection, and an AI with broad permissions can be talked into the wrong change, with results that vary from one run to the next. With clear permissions, validation, logging and a narrow scope, these features can be safe and powerful. That design work is exactly what the dev team is there for.</li></ul><h3>Part of a long, good story</h3><p>Vibe coding is real progress, and the latest link in a proud chain: punch cards → assembly → high-level languages → libraries and frameworks → generated code → AI-generated code. Every step made us faster, and every step was the right move.</p><p>And every step left the same things in human hands: <strong>vision, requirements, user flows, user feedback, and long-term maintenance.</strong> That’s not a limitation of AI. It’s where the interesting work has always been.</p><h3>The treaty</h3><p>Product owns the <em>what</em>. Engineering owns the <em>how</em>. Both of us own the outcome.</p><h3>Product brings the vision</h3><p>Requirements come in whichever form fits the idea best, and often all three together. Working POC, Jira Epic and/or Claude Design mock.</p><p>Product also commits to:</p><ul><li>Sharing requirements with dev <strong>and</strong> QA at the same time.</li><li>Staying available for questions while the feature is built.</li><li>Owning priorities and the release-date conversation.</li><li>Treating the POC as the reference, never as the release.</li></ul><h3>Engineering drives it to polish</h3><ul><li>Turn the requirements into production-grade code we own: architecture, tests, security, performance and upgrade paths.</li><li>Give fast, honest feedback early: gaps, risks and estimates up front, not at the end.</li><li>Ask, don’t guess: when the POC, the epic and the mockup disagree, we come back to product.</li><li>Use AI to speed up hardening, so polish doesn’t mean slow.</li><li>Plan around the release schedule, and flag early when scope and date don’t fit.</li><li>QA validates against the requirements from day one.</li></ul><h3>Together</h3><ul><li><strong>Definition of ready:</strong> a feature enters a sprint with a POC or mockup, an epic with acceptance criteria, and QA has seen both.</li><li><strong>Definition of done:</strong> acceptance criteria met, code reviewed, tests automated, dependencies and data flows checked, release notes and a risk label written.</li><li><strong>Handoff session:</strong> a short walkthrough per epic, where product demos the POC or mockup and dev and QA ask their questions.</li><li><strong>Scope vs. date:</strong> when they collide, we resolve it together, early and in the open.</li></ul><h3>Making it stick</h3><p>Keep vibe coding. Please. Prototypes make our conversations sharper and our products better.</p><p>Let’s just treat the POC as what it truly is: <strong>an executable requirement, not a release candidate.</strong></p><p>Product builds the POC, epic or mockup to explore and validate the idea. Those requirements, covering flows, data contracts and acceptance criteria, goes to the dev team <strong>and the QA team at the same time</strong>, along with a security review of its dependencies and data flows, and legal sign-off before anything touches a customer environment. The dev team turns it into something we can own, support and upgrade for years, while QA prepares to validate it against the requirements from day one.</p><p>That handoff is where the magic happens. Your prototype gives the dev and QA teams a head start they’ve never had before, and they give your idea a future. Same team, same goal, just different halves of the job.</p><p><strong>Anyone can generate code now. What our customers buy from us is the confidence that someone stands behind it.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ad771b9032d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[YouTube Already Showed Us What AI Is About to Do to Software]]></title>
            <link>https://alexanderluria.medium.com/youtube-already-showed-us-what-ai-is-about-to-do-to-software-8791ec6bfc41?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/8791ec6bfc41</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[entrepreneurship]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future-of-work]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Sat, 13 Jun 2026 22:05:54 GMT</pubDate>
            <atom:updated>2026-06-13T22:05:54.301Z</atom:updated>
            <content:encoded><![CDATA[<h3>The tech giants won’t shrink, and the thing they actually monopolised is coming apart — and it was never the code.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wi_AdVVcKvBZjjOLxVBnZw.png" /><figcaption>TV giants were gate keeping the producers not the product.</figcaption></figure><p>I build software for a living — lately, more of it sitting beside an AI that writes code faster than I can read it. I also help run a small business on another continent I’ve never set foot on, managed entirely through a screen. Fifteen years ago, each of those would have required a company with a payroll. I do both on a laptop in three languages before lunch.</p><p>So when people ask whether AI is going to “replace developers,” I think they’re staring at the wrong screen. I’ve already seen this film. It came out in 2005, and it was about television.</p><h3>The upload button</h3><p>Before 2005, making television was a capital problem. You needed studios, crews, an editing suite, a distribution deal, and a network executive willing to hand you a slot. The barrier was never talent. It was infrastructure and permission. A few hundred companies decided what billions of people watched.</p><p>Then YouTube added an upload button, and the cost of producing and distributing video fell toward zero.</p><p>What appeared next was not a flat field of equal creators. It was a power law with an enormous tail: today, more than 200 million people who call themselves creators, inside an economy worth roughly $250 billion that grew up <em>beside</em> television rather than inside it. Most earn very little. A real middle makes a living. A few became bigger than the networks ever were.</p><p>And two things conspicuously did not happen — the two things almost everyone predicts and gets wrong. The studios did not die; more professional video is made now than at any point in history. And the platform did not shrink. YouTube alone earns over $60 billion a year, and Google, which owns it, became one of the largest media companies on Earth.</p><blockquote><em>What died wasn’t the incumbent. It was the necessity of being one in order to produce.</em></blockquote><h3>Software in 2026 is standing exactly where television stood in 2005</h3><p>Building a real product used to require a team, a runway, infrastructure expertise, and usually someone’s permission — a funding round, a hiring plan, a year of stealth. The barrier was never the idea. It was the cost of turning an idea into a running, billable thing.</p><p>AI coding tools are the upload button.</p><p>The moment the cost of producing the artifact collapses, an ocean of markets appears that were always there and never worth serving. A product that earns a thousand dollars a month is invisible to a large company — it sits below the minimum size that can justify a roadmap slot, a design review, an on-call rotation. But the demand is real, and there are millions of these: narrow, specific, mildly painful problems in industries too small or too strange for anyone big to bother with. Drop the cost to build and run the tool far enough, and that entire substratum of demand becomes a business. Solo operators already run portfolios of these products; the most-cited of them turns over around three million dollars a year, alone.</p><h3>The thing the giants were actually selling</h3><p>Here is the part worth slowing down for, because it explains everything else.</p><p>Why did thousand-person companies make software in the first place? In 1937, the economist Ronald Coase asked the same question about firms in general: if markets are so efficient, why does so much activity happen <em>inside</em> companies instead of through them? He answered that using the market is itself expensive — finding the right people, negotiating, coordinating, contracting each piece of work separately. A firm exists to swallow those costs. It bundles many activities under one roof because coordinating them internally is cheaper than buying each one on the open market.</p><p>The software lifecycle is one of the largest bundles there is — discovery, design, build, review, security, infrastructure, billing, support, marketing, sales, compliance. Coordinating all of that through a market of strangers was wildly expensive, so it got swallowed whole into companies. And that — not talent, not tooling — was the giants’ real moat.</p><blockquote><em>They never gatekept the work. They gatekept the coordination. Which means they gatekept the payment.</em></blockquote><p>You could be brilliant at design, or security, or operations, but the only way to get paid for it at scale was to get hired for an organisation that already owned every other link in the chain.</p><p>AI does two things to this at once. It collapses the cost of producing each artifact, and it collapses the cost of coordinating the work. By Coase’s own logic, when coordination gets cheap, the rational firm gets <em>smaller</em>, and the work that used to live inside it spills back into the market. The bundle comes apart. Each link can now be priced and sold on its own.</p><h3>“But won’t AI eat the small players too?”</h3><p>It’s the obvious objection. If the model writes the code, surely it also does the design, the SEO, the support — so won’t the whole crew get automated as fast as it appears?</p><p>This is where the distinction that matters most, lives. AI automates the <em>artifact</em>, not the <em>judgment</em>. It will generate twenty mockups; a human still has to know which one lands with <em>this</em> audience, sit through all twenty to find it, get on the call, read the room, and own the outcome. And beneath all of it is a fact about people no model changes: capability was never the scarce input. Plenty of makers <strong><em>could</em> </strong>do their own editing or their own books — <strong>they just don’t want to</strong>. What survives automation is taste, approval, accountability, and relationship — the parts of the job that were never about producing the artifact in the first place.</p><p>YouTube didn’t only create creators. It created editors, colorists, thumbnail designers, channel managers, agencies, analytics tools, and a brisk market for buying and selling channels outright. Software is already growing the identical crew: a picks-and-shovels layer nobody builds themselves anymore, a services economy aimed squarely at solo builders, and marketplaces whose entire purpose is to value, finance, and trade these small products.</p><h3>What the next decade actually looks like</h3><p>Not a world with fewer software companies. A world with vastly more of them — most with one or two people, most running portfolios rather than chasing a single hit, because once the next product is nearly free to build, you ship another, and another.</p><p>The bar for “worth it” drops through the floor. A product that nets fifteen thousand dollars a year for an hour of maintenance a week is not a failed startup; it’s a rational unit of work, and a second one beside it is better. Around these makers sits the unbundled crew, sold by the task. And above them all sit the giants — larger than ever, not as the makers, but as the rails. They are pouring something on the order of seven hundred billion dollars into compute and models, building the infrastructure the entire long tail will rent by the token. A great deal of what the tiny shops earn will flow straight back up to them.</p><p>That isn’t a contradiction. It’s the deal.</p><p>So the right way to read what’s coming is not as a hunt for the next Google. The giants are not being replaced. The <em>firm</em> is being resized. Production has been democratised, coordination has been cheapened, and the boundary that used to enclose a thousand people inside one logo is receding toward two. What expands into the space it leaves behind is a market — of makers, of specialists, of the tools and brokers that serve them.</p><p>The studios survived YouTube. The creators arrived anyway, by the hundreds of millions, and an entire economy grew up in the gap between them and the platform. Software is about to run the same experiment one layer up.</p><p>The question for anyone working in it is no longer whether you can build something enormous. It’s which link in the chain you want to own — now that the chain has finally come apart.</p><p><em>What’s the $1,000-a-month product in your corner of the world that nobody big will ever build? I read every response — tell me yours.</em></p><p>#AI #software_development #future_of_work</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8791ec6bfc41" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How patch-package --error-on-fail Can Save Your Jenkins CI from Silent Failures]]></title>
            <link>https://alexanderluria.medium.com/how-patch-package-error-on-fail-can-save-your-jenkins-ci-from-silent-failures-84bbac851fa7?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/84bbac851fa7</guid>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[npm]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Sat, 07 Jun 2025 19:19:58 GMT</pubDate>
            <atom:updated>2025-06-07T19:19:58.366Z</atom:updated>
            <content:encoded><![CDATA[<p>Maintaining stability in CI/CD pipelines is tricky, especially when you start introducing patch-package to hotfix dependencies without waiting for upstream releases. One subtle gotcha many teams encounter is the silent failure of patch-package when used with version ranges like &quot;^2.2.2&quot; in package.json. This issue becomes critical in multi-stage Docker builds, where node_modules is cached aggressively across environments.</p><p>Let’s break it down.<br>The Problem: When Patches Silently Fail</p><p>Let’s say you patch a third-party dependency like this in your patches/ folder:</p><pre>patches/<br>  some-lib+2.2.2.patch</pre><p>But your package.json contains</p><pre>&quot;dependencies&quot;: {<br>  &quot;some-lib&quot;: &quot;^2.2.2&quot;<br>}</pre><p>Everything seems fine locally — you’ve tested it, it’s solid. But then one day, Jenkins installs version 2.2.3, the patch doesn’t apply, and worst of all, <strong>your build silently continues</strong>.</p><p><strong>Why?</strong><br> Because patch-package by default, it <strong>doesn’t fail</strong> when patches aren’t applied. It may just log a warning and move on.</p><p>In a CI environment, this can be catastrophic.<br>Docker + Jenkins = Triple Cache Trouble</p><p>Let’s complicate it further with a multi-stage Docker build and Jenkins:</p><ol><li><strong>Your local machine</strong>: Docker build uses your local machine node_modules or .npm cache, and everything “just works.”</li><li><strong>Jenkins</strong>: Uses its own Docker image and node cache — a different version of the lib might be installed.</li><li><strong>Docker build cache</strong>: If your RUN npm ci layer is cached, it may skip reinstallation altogether.</li></ol><p>If any of these caches introduce a new version (like 2.2.3 instead of 2.2.2), your patch won&#39;t apply, but the pipeline won&#39;t break—unless you force it to.<br>Solution: Enforce Patch Failures</p><p>There are two solid ways to enforce patch validity and fail the build if patches don’t apply.</p><h3>1. Add to package.json postinstall hook</h3><pre>&quot;scripts&quot;: {<br>  &quot;postinstall&quot;: &quot;patch-package --error-on-fail&quot;<br>}</pre><p>Pros:</p><ul><li>Runs after every npm install or npm ci.</li><li>Easy to maintain in a monorepo or shared script environment.</li></ul><p>Cons:</p><ul><li>Doesn’t run if someone installs it with --ignore-scripts.</li><li>You need to be sure postinstall isn’t disabled in CI.</li></ul><h3>2. Add an explicit step in Dockerfile</h3><pre>RUN npx patch-package --error-on-fail</pre><p>Pros:</p><ul><li>Works even if postinstall is skipped.</li><li>Explicit, visible in the Dockerfile pipeline.</li></ul><p>Cons:</p><ul><li>Slightly redundant if already covered in postinstall.</li></ul><p>✅ <strong>Best Practice</strong>: Do <strong>both</strong>. Add it to postinstall and your Dockerfile. The redundancy protects you from changes in defaults, future npm flags, and human error.</p><h3>Bonus Tip: Lock Your Dependencies</h3><p>To reduce the likelihood of patch drift:</p><ul><li>Use exact versions (e.g., &quot;some-lib&quot;: &quot;2.2.2&quot;) instead of ^.</li><li>Use a lockfile (package-lock.json or yarn.lock) and <strong>enforce lockfile integrity</strong> in CI.</li></ul><pre>npm ci</pre><p>This ensures everyone, from devs to Jenkins to Docker, is installing the same versions.</p><h3>Summary</h3><p>When using patch-package, <strong>don’t trust warnings—treat patch failures as errors</strong>.</p><p>By using --error-on-fail in your build process, you avoid the silent landmine of patch mismatch and keep your CI/CD tight and reliable.</p><h3>Checklist for CI Safety:</h3><ul><li>Lock versions, avoid ^ in patched deps.</li><li>Use npm ci, not npm install in CI.</li><li>Add &quot;postinstall&quot;: &quot;patch-package --error-on-fail&quot; to package.json.</li><li>Explicitly run npx patch-package --error-on-fail in your Dockerfile.</li></ul><p>If you’re patching, you’re already in risky territory. Don’t make it worse by allowing the patch to silently fail.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84bbac851fa7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Best gaming and productivity peripherals: keyboard mouse headset 2023]]></title>
            <link>https://alexanderluria.medium.com/best-gaming-and-productivity-peripherals-keyboard-mouse-headset-2023-5f5cb8e1d097?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f5cb8e1d097</guid>
            <category><![CDATA[gaming-articles]]></category>
            <category><![CDATA[keyboard]]></category>
            <category><![CDATA[gaming-laptop]]></category>
            <category><![CDATA[gaming]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Wed, 18 Jan 2023 13:41:15 GMT</pubDate>
            <atom:updated>2023-01-21T07:46:15.400Z</atom:updated>
            <content:encoded><![CDATA[<p>I posted at the end of 2019 the <a href="https://alexanderluria.medium.com/best-2020-gaming-peripherals-727b03f72bf8">review</a> of my hunt for gaming peripherals.</p><p>Time has passed and I have gifted my Corsair HS70s to my gaming dad. and had an opportunity to look for new gaming equipment for 2022.</p><p>I looked again for all the best headset and mouse and keyboard combos and could not match a good fit.</p><p>First, I looked for an excellent ergonomic mouse that would be esthetically pleasing: no high rise, side buttons, or weird looking like [some ergo mouse]. I was on the lookout for the slickest mouse on the market. So I found my wonder in the Logitech MX Keys series.</p><p><a href="https://amzn.to/3CWPzXd"><strong>MX Master 3 mouse</strong></a></p><figure><img alt="MX Master 3 mouse" src="https://cdn-images-1.medium.com/max/1024/0*LsgHU64Tf92JJdw5.jpg" /></figure><p>Let me tell you this thing is amazing, and I do not say it lightly. It is dual wireless, with up to 3 programmable devices with an easy button switch or Logitech software switch between devices. It has a built-in battery that is working for at least 2 months with no charge. A USB type c port to charge or work directly as a wired mouse. It has an aluminium “magspeed” dual-speed scroll wheel. Very satisfying to use. 5 button layout and a horizontal second wheel. In the thumb rest, there is an additional button to define gestures for productivity.<br>Works on any surface, even glass, with a 4000 DPI dark field sensor. <br>Multi-Device and Multi-OS — connect up to 3 devices via Bluetooth or the included USB receiver to Windows, Mac or Linux, whichever you prefer.</p><p>All in all best purchase ever. You can also get the “<a href="https://amzn.to/3iHIS4H">mac</a>” version which comes without the UniLink USB-A dongle.</p><p><a href="https://amzn.to/3XI8LjD"><strong>Logitech K780 keyboard</strong></a></p><figure><img alt="Logitech K780 keyboard" src="https://cdn-images-1.medium.com/max/1024/0*zPhSBlX--9L2d6tw.jpg" /></figure><p>I choose it for the coolest feature ever in a keyboard, a place to put my phone in while I work on my computer.</p><p>It has the same technology as the MX Master mouse, meaning it can connect to 3 devices via BT or UniLink, and switch between them with a press of a physical button.</p><p>The first thing you notice about this keyboard is that it is heavy. The polyurethane frame makes it stick to the surface you are working on, whether it is the tabletop or your lap. This keyboard was intended as a tablet holder while you&#39;re working on the couch or in bed, and that is why it has that heavy vibe. The keys are very pleasant and got a “typewriter” feel to them, aka they are round and very low, both in actuation and profile. I work as a software developer and enjoy FPS gaming and the feel is great for both. The keyboard works on 2 AAA batteries which can run for as many as 2 years. Yes, I have had this keyboard for over a year now and the power indicator is “Full”, and I rarely remember to turn it off.</p><p>This keyboard does have a <strong><em>bug on Windows</em></strong>, the volume up/down keys become programmatically stuck and will blast or turn off the volume accordingly. You would have to hard reset the keyboard for it to go back to normal. I also work with the same keyboard on macOS and no such issue was seen.</p><p>It is also great for typing in you phone messages because it can connect to it via BT and would free your thumbs.</p><p><a href="https://amzn.to/3He4y1J"><strong>MX Keys the better alternative</strong></a></p><figure><img alt="MX Keys full length rechargable keyboard" src="https://cdn-images-1.medium.com/max/1024/0*cUrZaLI-UQTxkaVM.jpg" /></figure><p>Now I would probably go with the newer version of the K780 which is the <a href="https://amzn.to/3kqMAQl">MX Keys keyboard</a> that has the same feature but has a standard 101 keyboard length. Illuminated keys, USB-type C built-in rechargeable battery and a hi-tech look to it.</p><figure><img alt="MX Keys mini with MX Anywhere mouse" src="https://cdn-images-1.medium.com/max/1024/0*hbxKveDYYBq3Eunj.jpg" /></figure><p>The is also a short version called <a href="https://amzn.to/3QKVu7z">MX Keys mini</a> for your traveller&#39;s lightweight, and it comes in three colours: <a href="https://amzn.to/3CVPPWz">white</a>, <a href="https://amzn.to/3CVRknE">graphite</a>, and <a href="https://amzn.to/3QQImOs">rose</a>. Although the MX Keys itself is much lighter than the K780.</p><p>The mini comes in a bundle option also in three colours: <a href="https://amzn.to/3CUW3Gd">white</a>, <a href="https://amzn.to/3ZHoDVf">graphite</a>, and <a href="https://amzn.to/3XzXYZf">rose</a>. It comes with an <a href="https://amzn.to/3QNnqYs">MX Anywhere mouse</a> which is the small version of the MX Master mouse.</p><p><a href="https://amzn.to/3Xg38cu"><strong>CORSAIR VIRTUOSO RGB WIRELESS XT</strong></a></p><figure><img alt="Corsair virtuoso XTpackage content" src="https://cdn-images-1.medium.com/max/1024/0*zWQbdIUzbFwd4Zpk.jpg" /></figure><p>Through my research, and I do mean research that took almost a month. I went thru some high-end gear since I had a $200 purchase in mind.</p><p>I looked at <a href="https://amzn.to/3kjLwOh">SteelSeries Arctis 9 Dual Wireless</a></p><p>Then at <a href="https://amzn.to/3XlDKC9">HS70 BT edition</a>.</p><p>And even <a href="https://amzn.to/3QKqaG4">Audeze Penrose Dual wireless</a></p><p>Eventually, since I have both a mac and a PC, I work hybrid, so these things need to be portable and versatile. I get to connect via BT to my mac and use the dedicated LightLink to my gaming pc, which later was changed to <a href="https://amzn.to/3wdQa30">ASUS TUF Dash 15 (2022) Gaming Laptop</a> to save space under my desk. The light show in form of the Corsair sail logo support full RGB and is synced with mic RGD lighting. It is also synchronized over several devices that support iCue software. They are mostly metal and therefore heavy and big. What is important is that the BT setup is very easy just a regular “3-second” click will get you going. You can game in one connection and be conferencing with another connection or be on your phone pausing the game and putting thru important calls. The headset also operates via 3.5 jack and USB direct connection so you could charge and use the headphones.</p><p><strong>What I liked about these</strong></p><p>Accurate gaming positioning audio with Dolby Atmos (needs configuration in windows). This is a very different experience from 7.1 in the Corsair HS70s. The audio is very crisp, and the vertical positioning is something you cannot achieve in a regular 7.1 headset setup. The bass is subtle and accurate. The mids and the highs are accurate and do not oversaturate the hearing. Voice lines and music and sound effect are completely separated and distinct. I play Apex Legends in which all that audio data is critical and these headphones give exact positioning every time. The mic is superb and clear. It has a big button to mute at the base and a light indicator that glows red when the mic is muted. After an idle time, the phones will go to standby mode and can remain in it for a couple of days. Once you pick them up they will reconnect to the platform and continue to work after 2 beeps. The charge will hold for several gaming sessions or several days of conferencing at work. Frequent firmware updates and software iCue 5 improved a lot.</p><p><strong>What might be improved in the next generation</strong></p><p>The mic can be adjusted but it is in view most of the time. Does not filter the breathing noise. The ear cup material is PU leather and started to disintegrate after several months. The wall penetration is bad, 10ft will lose the signal. Standing next to the microwave or electric motor will interfere with the light link connection.</p><p><strong>Conclusion</strong></p><p>Big thumbs up. You would have to buy backup ear cushions like these <a href="https://amzn.to/3IXNgXR">Gel Earcups </a>or these <a href="https://amzn.to/3CRQo3J">Fabric earpads</a> when the factory ones would start to disintegrate. (Logitech supplies additional fabric ear cups in its <a href="https://amzn.to/3QR8Xeg">G Pro</a> headset). The headsets are the best I owned and work amazingly over several platforms. They are jam-packed with features and the cons are minimal. Be well!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f5cb8e1d097" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[23 benefits of playing video games — finance]]></title>
            <link>https://alexanderluria.medium.com/23-benefits-of-playing-video-games-finance-6ea121089ae3?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ea121089ae3</guid>
            <category><![CDATA[finance]]></category>
            <category><![CDATA[resource-management]]></category>
            <category><![CDATA[gaming]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Sun, 15 Jan 2023 10:12:15 GMT</pubDate>
            <atom:updated>2023-01-15T11:30:58.797Z</atom:updated>
            <content:encoded><![CDATA[<h3>23 benefits of playing video games — finance</h3><figure><img alt="Good finance habbits — piggy bank https://youtu.be/8Fxp_wQ-IIE" src="https://cdn-images-1.medium.com/max/1024/1*DdivJN5whewCTOU3KkCMGQ.jpeg" /></figure><p>Video games have become increasingly realistic and provide players with a wide range of experiences, including the ability to <a href="https://amzn.to/3w3sZZd">learn about finance</a> and manage virtual money and resources. Not only do they provide a safe and controlled environment to practice, but they also help players develop efficient ways to acquire resources, keep track of virtual finances, and even make strategic decisions.</p><p>One of the most significant advantages of using video games to learn about finance is that they provide players with a safe and controlled environment to practice managing money and resources. Many video games feature virtual economies and require players to manage their virtual finances, such as by earning and spending in-game currency, trading resources, and making investments. This can help players learn about basic financial concepts, such as budgeting, saving, and investing.</p><p>Another advantage of using video games to learn about finance is that they can help players develop efficient ways to acquire resources. Many video games require players to acquire resources, such as money, equipment, and materials, to progress through the game. This can help players learn about different ways to acquire resources, such as trading, farming, and investing. Additionally, video games often require players to make strategic decisions about how to acquire resources, which can help players develop critical thinking skills.</p><p>Video games can also help players keep track of their virtual finances. Many video games feature in-game menus or interfaces that allow players to view their virtual finances and track their progress. This can help players learn how to keep track of their finances and monitor their spending. Additionally, many video games feature leaderboards or other social features that allow players to compare their virtual finances with others, which can help players learn about budgeting and saving.</p><p>Another benefit of using video games to learn about finance is that they provide players with a fun and engaging way to learn. Unlike traditional methods, such as reading books or watching videos, video games provide players with an interactive experience that can make learning about finance more enjoyable.</p><p>In conclusion, video games can be an excellent tool for learning about finance and managing virtual money and resources. They provide players with a safe and controlled environment to practice managing money and resources and help players develop efficient ways to acquire resources. Video games can also help players keep track of their virtual finances and provide a fun and engaging way to learn. Additionally, video games can also help players develop critical thinking skills and make strategic decisions, which are important for managing finances in real life.</p><p>Watch in video form at <a href="https://youtu.be/8Fxp_wQ-IIE">https://youtu.be/8Fxp_wQ-IIE</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ea121089ae3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[23 benefits of playing video games — computer operation]]></title>
            <link>https://alexanderluria.medium.com/23-benefits-of-playing-video-games-computer-operation-f25162e9b802?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/f25162e9b802</guid>
            <category><![CDATA[hardware]]></category>
            <category><![CDATA[gaming]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Sun, 15 Jan 2023 10:02:00 GMT</pubDate>
            <atom:updated>2023-01-15T10:02:00.016Z</atom:updated>
            <content:encoded><![CDATA[<h3>23 benefits of playing video games — computer operation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hBYAjYxZy8MMjedAAVUEoQ.jpeg" /></figure><p>Video games have come a long way since the days of Pong and Space Invaders. Today’s video games are incredibly realistic and provide players with a wide range of experiences, including the ability to learn about computer hardware, software, and drivers. Video games can also help players keep up to date with the latest tech news and broaden their interest in technology.</p><p>One of the most significant advantages of using video games to learn about computer hardware, software, and drivers is that they provide players with hands-on experience. Many video games require players to optimize their computer’s hardware, software, and drivers to improve performance and experience the game’s full potential. This can help players learn about the different components of a computer, such as the CPU, GPU, and RAM, as well as how to install and update drivers.</p><p>Another advantage of using video games to learn about technology is that they can help players keep up to date with the latest tech news. Many video games require players to have the latest hardware and software to run properly, which can encourage players to stay informed about the latest technology trends. Additionally, many video games feature cutting-edge technology, such as virtual reality and artificial intelligence, which can help players learn about the latest advancements in technology.</p><p>Video games can also help players broaden their interest in technology. Many video games feature different genres and themes, such as science fiction, fantasy, and historical settings. These games can introduce players to new technologies and ideas and can inspire them to learn more about these subjects. Additionally, video games can also inspire players to explore new areas of technology, such as game development, programming, or even Artificial Intelligence.</p><p>Another benefit of using video games to learn about technology is that they provide players with a fun and engaging way to learn. Unlike traditional methods, such as reading books or watching videos, video games provide players with an interactive experience that can make learning about technology more enjoyable.</p><p>In conclusion, video games can be an excellent tool for learning about computer hardware, software, and drivers, as well as keeping up to date with the latest tech news and broadening your interest in technology. They provide players with hands-on experience and can inspire players to learn more about different areas of technology. Additionally, video games can be a fun and engaging way to learn and can make the process of learning about technology more enjoyable.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f25162e9b802" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[23 benefits of playing video games — Driving Lessons]]></title>
            <link>https://alexanderluria.medium.com/23-benefits-of-playing-video-games-driving-lessons-dd713f673505?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd713f673505</guid>
            <category><![CDATA[driving]]></category>
            <category><![CDATA[learing]]></category>
            <category><![CDATA[video-games-industry]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Sun, 15 Jan 2023 09:53:25 GMT</pubDate>
            <atom:updated>2023-01-15T09:53:25.354Z</atom:updated>
            <content:encoded><![CDATA[<h3>23 benefits of playing video games — Driving Lessons</h3><figure><img alt="Driving in videos games" src="https://cdn-images-1.medium.com/max/862/1*gLstasCuBt7AXRZrG3PNRg.jpeg" /></figure><p>Video games have come a long way since the days of Pong and Space Invaders. Today’s video games are incredibly realistic and provide players with a wide range of experiences, including the ability to learn how to drive. While driving in real life is a dangerous and expensive endeavour, video games provide a safe and cost-effective way to learn how to drive.</p><p>One of the most significant advantages of using video games to learn how to drive is the ability to practice in a safe environment. Unlike real-life driving, video games allow players to make mistakes without the risk of injury or damage to property. This is particularly important when learning to drive, as it allows players to gain confidence and experience without the fear of making mistakes.</p><p>Another advantage of using video games to learn how to drive is the ability to practice various driving scenarios. Many video games feature a wide range of driving environments, including city streets, rural roads, and highway driving. This allows players to experience different types of driving conditions and learn how to handle them. Additionally, many video games offer different weather conditions, such as rain and snow, which can be difficult to practice in real life.</p><p>Another benefit of using video games to learn how to drive is the ability to practice at your own pace. Unlike traditional driving lessons, video games allow players to practice as much or as little as they want. This is especially helpful for players who may be nervous about driving or who may need extra practice to master certain driving skills.</p><p>Additionally, video games offer a variety of driving experiences, from racing games to simulation games, which can help players learn how to drive in different styles and situations. These games can help players develop the necessary skills to drive in real life. Racing games, for instance, can help players understand how to handle high-speed driving while simulation games can teach players how to drive in a realistic environment.</p><p>In conclusion, video games are a great way to learn how to drive safely and cost-effectively. They provide players with a safe and controlled environment to practice, offer a wide range of driving scenarios and experiences, and allow players to practice at their own pace. Additionally, video games can help players learn how to drive in different styles and situations, and develop the necessary skills to drive in real life.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd713f673505" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React memory leaks]]></title>
            <link>https://alexanderluria.medium.com/react-memory-leaks-76ebb1399a1b?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/76ebb1399a1b</guid>
            <category><![CDATA[memory-leak]]></category>
            <category><![CDATA[react-hook]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Thu, 14 Oct 2021 09:20:14 GMT</pubDate>
            <atom:updated>2021-10-14T09:21:26.091Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/463/1*gcKhM8W2iSZcG9c-dGB4IQ.png" /><figcaption>Memory leak</figcaption></figure><p>You are in charge of writing a component that updates something periodically, sleep, and then check if it has to update something again.</p><p>Problem:</p><p>Once the flag to update becomes negative, but you have the component still mounted, useEffect still holds the last update timer open and will trigger the update even when it has no permission to do so.</p><p>Result:</p><p>Memory leak in form of updating unmounted component and the browsers is not happy.</p><p>Solution:</p><p>When setting interval or timeout clear functions make sure you:<br>A: Trigger the interval only when the update flag is positive.<br>B: Store the cancel function or the interval ID available to the local component scope.</p><p>Reasons:</p><p>When triggering a new setInterval you will get a new interval id. When the update is cancelled you will still hold the old ID and will try to cancel the new ID. That is why you must store the ID outside the useEffect, to effectively cancel the correct timeout trigger and not the stale one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76ebb1399a1b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fix Jenkins kubernetis parallelization issues in jest react test using fetchMock and react testing…]]></title>
            <link>https://alexanderluria.medium.com/fix-jenkins-kubernetis-parallelization-issues-in-jest-react-test-using-fetchmock-and-react-testing-9f48af2b0f7a?source=rss-ec3934e49e41------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f48af2b0f7a</guid>
            <category><![CDATA[jest]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Alexander Luria]]></dc:creator>
            <pubDate>Tue, 20 Apr 2021 21:05:58 GMT</pubDate>
            <atom:updated>2021-04-20T21:05:58.624Z</atom:updated>
            <content:encoded><![CDATA[<h3>Fix Jenkins kubernetis parallelization issues in jest react test using fetchMock and react testing library</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*OuOAVxDiH4C6UE8AW0Uk2w.png" /><figcaption>Testing can be tricky if you combine multiple disciplines together</figcaption></figure><p>TLDR: When working in multi worker insane of test runner. Chain events!</p><blockquote>mockApiFetch<br> .mockResolvedValueOnce({ ok: true, body: jobPendingBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobSuccessBody });</blockquote><p>PROBLEM: I started to develop in new devops environment. This one is using Jenkins Helm kubernetes and gitswarm to spin up test execution instances on each code delivery.</p><p>I developed a simple component using React and typescript (yes I know… roll your eyes and click your tongs). All in al a descent peace of code that is monitoring RestAPI task progress by scheduling a poll interval and invoking browser “fetch” to call the server.<br>All the test were passing at my local environment, but when delivered to the DevOps pipeline, failed consistently on not fulfilled fetch calls.</p><p>It was driving me crazy, I tried all kinds of trick but no avail. I even tried to debug the test delivering small changes to pipeline but nothing seemed to work.</p><p>SOLUTION: I found that I can actually mock whole functional component using `jest.mock(‘yourlibrary’)` and actually importing the library but using it for mock calls.</p><p>The basic code was about to be</p><blockquote>import { ApiFetch } from ‘data-access-api’;<br>jest.mock(‘data-access-api’);</blockquote><blockquote>beforeEach(() =&gt; {<br> jest.useFakeTimers();<br> jest.clearAllMocks();<br> });</blockquote><blockquote>afterAll(() =&gt; {<br> jest.clearAllTimers();<br> });</blockquote><blockquote>test(‘Task fetches, calls onUpdate with each fetch result, and ends on successful job’, async () =&gt; {<br> const mockApiFetch = ApiFetch as jest.Mock;<br> const apiFetchSpy = jest.spyOn(mockApiFetch, ‘mockResolvedValueOnce’);<br><br> mockApiFetch .mockResolvedValueOnce({ ok: true, body: jobPendingBody })<br> mockApiFetch .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> mockApiFetch .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> mockApiFetch .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> mockApiFetch .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> mockApiFetch .mockResolvedValueOnce({ ok: true, body: jobSuccessBody });</blockquote><blockquote>const onComplete = jest.fn();<br> const onUpdate = jest.fn();<br> const onFailure = jest.fn();<br> TaskPoller({<br> taskCreated: taskCreatedMock,<br> onComplete,<br> onFailure,<br> onUpdate,<br> });</blockquote><blockquote>await waitFor(() =&gt; {<br> expect(onComplete).toHaveBeenCalledTimes(1);<br> });</blockquote><blockquote>expect(onComplete).toHaveBeenLastCalledWith(jobSuccessBody);<br> expect(onUpdate).toHaveBeenCalledTimes(5);<br> expect(onUpdate).toHaveBeenLastCalledWith(jobRunningBody);<br> expect(onFailure).not.toHaveBeenCalled();<br> expect(apiFetchSpy).toHaveBeenCalledTimes(6);</blockquote><blockquote>jest.advanceTimersByTime(DEFAULT_POLL_RATE_MS);<br> expect(apiFetchSpy).toHaveBeenCalledTimes(6);<br> });</blockquote><p>The thing is though it improved the test passage in the DevOps pipeline it still had tests failing even thought “it worked on my computer”.</p><p>So the next thing came painfully after several days of trying every trick in the book. Lets chain the execution of the mocks that way we can make sure they happen and fire and mock fetch in order. Since the pipeline runs on multiple workers the test were colliding mocks, sometimes overcounting mock calls and some time over counting. It was a clear synchronization issue. So chaining the calls solved the issue terminally.</p><blockquote>mockApiFetch<br> .mockResolvedValueOnce({ ok: true, body: jobPendingBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobRunningBody })<br> .mockResolvedValueOnce({ ok: true, body: jobSuccessBody });</blockquote><p>Happy testing dear friends, hope I save several years of you life trying to solve this issue!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f48af2b0f7a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>