| Episodes | 84 |
| Mentions | 114 |
| Cited here | 36 |
| First — last | #4 — #729 |
| Top guests | Jeri Ellsworth, Bunnie Huang, Mohamed Kassem |
| Related | arm · patent · microcontroller · datasheet · open source hardware |
Intellectual property in engineering practice spans patents, copyright, trade secrets, contractual assignment of ideas, and licensed design blocks, and it conditions decisions at every stage of a hardware career, from the employment contract an engineer signs to the architecture of a chip and the choice of factory.[15][98][113] Its economics are asymmetric in both directions: patents cost far more to enforce than to obtain, while physical designs are often cheaper to copy than to protect, which pushes practical protection toward software, algorithms, and supply-chain control rather than legal instruments alone.[232][113][8] A substantial body of engineering practice also treats openness itself as a strategy, monetising execution speed and accumulated fluency rather than exclusion.[336][232][163]
Employment agreements
Employment contracts in some companies assign every idea an employee has, whether or not it relates to the job, with the company holding first right to it: “Every thought and idea that they have, they own.”[15] The arrangement functions as a genuine trade in some cases—one engineer was paid several times for ideas under such a clause—but it becomes a restriction at its boundary, as when the same engineer could not get permission to enter an outside design contest.[15] Even where an assignment clause would never survive a legal challenge, that only becomes known once a case reaches court, which is why engineers comply with clauses they believe are invalid; a cheap documented workaround beats being right expensively.[203]
One documented workaround is an addendum. On signing an employment contract containing a total-assignment clause, Dave Jones attached an addendum listing every project and idea predating the employment, drawn from old notebooks and including projects never started, and had the employer sign it before the contract took effect; nobody at that company had done it before, and they signed.[203]
Patents
A commonly quoted rule of thumb holds that it costs “100,000 to defend it for the first time,” and that a patent is worth nothing until that first defence has been survived.[232] On this view a patent is a licence to litigate, and the litigation is the expensive part.[232] The corresponding advice to startups is that intellectual property must be protected but should not become the emphasis of the business, and that strong IP should not be expected to keep competitors out by itself.[232]
Disclosure creates patent risk even without any intent to file. Describing an unprotected idea in a company meeting where people are taking notes carries a real risk that the company will patent it, and the exposure exists even when the speaker never intended to pursue the idea.[166]
Ideas and execution
Practitioner estimates of where value sits discount ideas heavily. The value of a thing is held to be the idea multiplied by the execution, so a great idea with poor execution is worth very little, and learning to execute is the critical skill rather than generating ideas.[232] On products going out to real users, roughly ninety percent of the execution effort belongs in the last ten percent of the project, because that is where projects fail; schedules that taper off at the end are mis-planned.[232] Consistent with this, publishing one’s best work and helping people who ask is reported to return more than it costs, with the return arriving as problems solved by others and contacts made rather than as licence income—a return invisible to practitioners trained to patent everything and keep it secret.[232]
Contract development and consulting
Work developed under contract usually becomes the customer’s property and cannot be resold, but the underlying knowledge transfers, and rebuilding the same capability later takes a fraction of the original time; this asymmetry is what makes contract work compound rather than reset.[560] One business structure built on this is to develop general-purpose hardware and libraries between engagements, then license the pre-built part to a client while charging normal non-recurring engineering for the customer-specific adaptation, which answers the client who needs something ready immediately—a bid a from-scratch consultant simply loses.[560] A new consultant faces a ratio of roughly ten hours of self-teaching for every billable hour, which is why building a personal library of tested algorithms and platforms is what eventually makes the business stable.[560]
Consulting clients in practice rarely demand ownership of the designer’s accumulated techniques. Across Mike Harrison’s long contracting career, the closest case was a museum whose policy required enough information to repair or rebuild the hardware itself—a documentation requirement rather than an ownership one.[524] The working rule applied to reusing blocks between client projects is that the novel property lives in the whole solution, not in its pieces; it is a rule of thumb rather than a legal opinion, and the boundary genuinely blurs once a firm starts templating its work.[645] A failure-analysis consultancy can turn the same logic outward: by stamping no drawings and retaining no rights, and scoping its service to exclude design work entirely, it becomes safe for IP-sensitive startups to hand over a problem, so the exclusion of design is an IP strategy as much as a technical one.[399]
Semiconductor intellectual property
Licensed cores
Chip vendors build products by assembling prepackaged licensed cores—a processor, a memory controller, peripheral controllers—so understanding a modern part often means understanding which third-party blocks were dropped into it.[98] The same logic appears in FPGAs, where processors and peripherals are hard-coded into the fabric partly because internal block RAM is usually limited to a few kilobytes, making an on-die DDR controller necessary for any design that behaves like a processor.[98] Licensing a widely available core is a sourcing strategy as much as a technical one: once a design sits on a common architecture, the designer can choose among many vendors for the best peripherals or power consumption, and the architecture survives any single supplier disappearing because the IP exists independently of them.[95] Datasheets often name the licensed block and its exact version, so a peripheral’s behaviour and errata are traceable to the vendor IP rather than to the chip company, which tells an engineer where to look when the peripheral misbehaves.[648]
The buy-versus-build decision is priced against engineer-hours, not against the sticker price: a real-time, deterministic-latency HDL core quoted at 150,000 was still cheaper than building it internally.[536] The governing rule is differentiation—buying the block is not a problem when the buyer’s advantage lies elsewhere, and a block should be written in-house only where that block is the thing the company competes on, with the honest acknowledgement that the from-scratch route is an R&D cost paid now against a payoff years away.[536] A hazard in buying cores is that the vendor may be selling a specification rather than a finished product, and only start writing the core once someone buys it; buyers are advised to ask what silicon or which customers the core has actually run in before committing a schedule to it.[536] A pure IP licensor operates under a structural constraint of its own: it could hire peripheral designers, build its own chips and pay itself no royalty, gaining an immediate price advantage, but doing so would undercut the licensees who fund it, so the business model forbids the obvious move.[106]
A silicon vendor can also differentiate on code in ROM rather than on the die itself. On the motor-control microcontroller family Trey German worked on, the distinguishing feature was a software encoder in ROM that turns current and voltage signals into flux angle, speed and torque, feeding the control algorithms; the premium is charged for the algorithm shipped on the chip.[212]
Process and integration constraints
Chip development starts long before engineering does. On a microcontroller developed by the Raspberry Pi team, roughly six months went into choosing the architecture, deciding which blocks to build versus license, signing NDAs and negotiating IP contracts before any solid engineering began, according to hardware lead James Adams.[529] Integrating flash onto the die is not automatically cheaper: adding flash to a 40 nm process cost roughly 35 percent more, and the flash then consumes the area where SRAM would have gone, so external flash won on cost and also gave the flexibility to fit any memory size.[529] A non-standard process carries a hidden IP cost as well, because third-party blocks are developed and characterised for the standard variant; using an unusual flash process means signing a waiver that the licensed IP may not work, so process choice constrains which blocks can be bought.[529] Memory macros on a shared shuttle run are licensed foundry blocks that cannot be used in an open project, which is why adding meaningful RAM to a small open tapeout is so hard—the licensing boundary, not the silicon area, is the binding constraint.[673] Vendor blocks frequently arrive as an encrypted bitstream with a generated Verilog header rather than as source, so using the block means using the vendor’s tool, and whether the output can be extracted for use with open tools is usually undocumented.[673]
Licensing cost belongs in the per-part cost model alongside die area and I/O count: one configuration might come out at $1.62 per part with zero licensing because the blocks are included in the package, while a third-party block enters the same calculation as cents per part, letting configurations be compared on cost directly.[503] Foundries have an incentive to accumulate validated customer designs, since each retained data converter or block becomes an enablement offered to the next customer; more available blocks mean more business, which is the argument for persuading a foundry to open its process.[503] Making a chip at all requires foundry access, IP blocks, EDA software, complementary knowledge and test capability simultaneously—these combine like an AND gate, so missing any one produces zero, which is the real barrier for small teams rather than any single cost.[503] For FPGA startups, what kills the company is not the first chip but the second: beyond making designs fit, the company must integrate third-party blocks around the chip, build a soft-IP ecosystem and build a sales channel, with investment rising exponentially as capacity grows, so the first product typically consumes all the money.[535] Because bodge wires on an ASIC are close to impossible, observability is built into the silicon itself—internal ADC sensors and current measurement—so a designer can find out why a part failed and iterate rather than treating a tapeout as final.[501]
NDA structure blocks reproducibility in chip-design research: verifying somebody else’s result can require NDAs with three different companies before the raw data can even be approached, which stunts the field’s ability to demonstrate that one approach beats another.[501] On mature architectures, the practical case over a newer open alternative is availability and documentation—licensed cores such as ARM’s are easy to obtain, well tested and well documented, with high-performance options, while the open alternative lacks equivalents and has a long way to go on tool maturity—though competition from the open side has already made the incumbent easier to license from.[648]
Protection in manufacturing
The three subsystems of a product differ sharply in how easily they can be copied. Mechanical design is the easiest thing in the world to replicate—put it in a laser scanner and identify the materials—while electrical design takes more work but is tractable through component identification and reverse engineering.[113] A bare board layout is correspondingly weak protection: strip the components, scan the board, and the design is recovered, so the exposure that matters is the firmware and the algorithms, not the copper.[524] The defensible boundary in an instrument is therefore the algorithm, not the interface: pot the algorithm or run it in an encrypted microcontroller, but the output should still be usable data, since locking the output as well protects nothing extra and cripples the customer.[8]
For offshore manufacture, the recommended software protection is an encrypted bootloader programmed at a secure facility with no internet access and screened workers, with the programmed part then consigned to the factory; this lets firmware travel by email instead of physical media and keeps the plaintext out of the factory entirely.[113] Consigning a security-critical programmed IC also gives supply-chain control: hand the factory a thousand parts and only a thousand products can exist, closing off a ghost shift running the same product out the back door, so the IP protection and the anti-overbuild control are the same mechanism.[113] Factories change over time and a good one can go bad: a twenty-year veteran of manufacturing in China lost his company when the management at a long-trusted factory changed and the new owner stole his design, so vetting the factory once is not enough.[113] Excess caution about IP only becomes a problem if it slows the work down or stops something being done; otherwise it pays to be paranoid, because a single client losing its design would be fatal to the firm that let it happen, and the test to apply is whether the protection blocks the product getting built.[113]
Even the paperwork of fabrication carries IP terms. At least one low-cost assembly service’s terms transfer rights such that the design can be made public, which matters most for work done under a client NDA, so the terms should be read before files are sent.[524] Omitting the top silkscreen saves on the order of ten cents a board and one process step; the obscurity this buys against casual copying is a side effect some manufacturers cite, but cost is the actual driver.[140] At the high end, a genuine market exists for domestic, higher-cost fabrication among customers who cannot let a design leave the building at all, including defence and intelligence work and companies unwilling to send files offshore, alongside customers who simply need very quick turnaround.[462] The extreme version of that requirement is an in-house fab, operated so that the design never leaves the site at any stage of production.[559]
Manufacturers that lock down firmware cite proprietary information and sincerely believe the recipe needs that protection, but the same lockdown also limits exposure if someone finds a vulnerability in a machine with real-world consequences; the stated reason and the operative reason can differ.[318]
Open hardware
Open source hardware imposes no requirement to publish before manufacture: releasing files at the idea stage is a choice, and a design can equally be called open with the files published once the product is manufactured and on sale.[113] Anyone can legally take open source hardware files and compete directly against the originator; the protection is a community norm rather than a legal mechanism, and treating the norm as if it were enforceable is the mistake.[87] Investors consistently ask an open-hardware company how it is protecting itself and where its IP is, and Ian Daniher’s open-hardware startup, which decided not to play that game, had to be prepared for the conversation to end there.[87] The structural tension is funding: medium-volume hardware typically needs between two and ten million dollars, which usually means venture capital, and venture investors expect protected IP as the condition of that money.[113]
The countervailing position rests on execution speed. Bunnie Huang, who has shipped open hardware commercially, argues that even without strong patent or copyright protection an idea can be monetised for long enough to fund the next generation, and that the lack of a monopoly forces the designer to stay competitive rather than resting on one product.[336] The cost of long monopoly rights, on this view, falls on the people who would have moved the field forward and cannot because they have been shut out of the ecosystem.[336] Huang’s own account of building a project with no financial return frames the property generated as intuitive fluency with the whole manufacturing process rather than any copyright or patent—eighty units sold at cost bought understanding of the entire flow.[336] The wider context is that the barrier to producing hardware has fallen very far: knockoff phones represent enormous genuine engineering—someone laid out the circuit board, ported an operating system and made a GSM stack work—and designs came to be treated as freely remixable material only once that barrier had dropped.[336]
Small companies in open niches sometimes reintroduce closure selectively. A closed-source bootloader can be a deliberate way to encapsulate the work put into a product, on the reasoning that a bootloader given away removes the reason to buy the board.[713] An NDA with a silicon vendor can likewise enable a product variant rather than just restrict one: chip security features covered by NDA made a lockable board possible, with encrypted firmware and a secure update process, sold alongside a standard version without those features.[713]
Hosted design tools and shared libraries
Hosted design tools force the ownership question into the open. When users asked who would own designs entered into one hosted tool, the answer that worked was a public page of promises backed by a matching update to the terms of service, so the reassuring page was legally binding rather than marketing; the terms were revised again each time another hosted service had a public incident.[163] What makes hosted design data acceptable is a credible exit: open, documented export formats plus an open source converter to other tools, and servers paid for well in advance, on the vendor’s reasoning that the data has value inside the tool and is dead data outside it, so it is not an asset worth selling.[163] The same service made a deliberate decision not to enforce licences on shared designs—users may declare a licence, but forks are not tracked or policed, because tracking derivation is an impossible complexity problem and becoming an IP enforcement body is not the business.[163]
The economics of reuse are sharply sensitive to friction. Even a small per-block charge kills reuse: as soon as there is a transactional cost on a design block, engineers will not take it, especially when vendors already give away reference designs for free, since the friction of a payment exceeds the cost of redrawing the circuit.[163] On this basis, paid marketplaces for design blocks have been argued to be actively harmful: giving people a way to monetise work they would not otherwise think valuable does damage, because most of that work is not special to them and would be better shared.[163] Publishing schematic symbols and footprints to a shared cloud library is itself a real disclosure decision for a corporation, since footprints and symbols reveal which parts are used; a tool whose default policy is that everything created is public forces each company to decide whether that is acceptable rather than assuming it.[131]
Universities and sponsored research
Universities typically own the IP arising from work they helped fund, and technology transfer can then proceed by selling that IP to a company, so anyone doing sponsored or student work should establish who the owner is before assuming it is themselves.[55] Universities generally do not pre-negotiate IP with corporate research sponsors, because nobody knows in advance how valuable the result will be.[283] One reason companies fund university research is portfolio building: monthly meetings open with whether any new IP was generated, driven by legal departments tracking the pipeline, because the process from filing to grant runs about five years.[283]
Ownership, investment, and disposition
Once a founder takes investment capital, the patents belong to the company and the founder becomes a shareholder like any other; even patents originally gifted to a founder are signed over as part of the financing, and that structure is deliberate.[351] Correspondingly, there are two ways to sell a failing company—on its IP alone, meaning the patents plus any prototypes, systems or code, or on its talent as an acqui-hire, or a combination—and which one applies determines what the founders retain.[351] Whether the output of a tool can be owned also determines whether anyone will fund work built on it: if generated images cannot be copyrighted, a publisher will not invest in the property because it is not defensible and a third party could later force the work down.[621]
Reverse engineering and publication ethics
Practitioner ethics on reverse engineering acknowledge both sides of the boundary. Intellectual property is real and research costs money, but a vendor that sells a device with something hidden inside it has accepted the risk that a buyer will find and exploit it—“well, tough tits to you. That was your risk.”[246] Within that ethic, individual publishers draw their own lines: hardware writer Dave Jones treats hardware modifications and teardowns as fair game even when they void a warranty, but declines to publish license key hacks because those break intellectual property directly—a distinction between understanding a device one owns and circumventing a paywall.[339]