Start With These If You Are New

• Why This Instrument Exists - why a programmable fabric needs readable structure, local ownership, timing, bounded replacement, and continuity while it runs.
• Tinkerer-Scale Control Circuitry - short local build/test loops for sensing, switching, gain, restoration, timing, actuation, and test.
• The Missing Maker Fab - why open hardware still needs locally reproducible fast active devices.
• One-Pin FPGA FM Receiver - the receiver path from thresholded RF to audio.
• AI-Assisted Drafting and Published Technical Work - assisted drafting and responsibility for published pages.
• Correctness Emerges by Acting - a short note on closed feedback loops: scan, observe, choose, correct, and turn real behavior into tests or safer paths.
• Disseminated Thought Can Be Improved - why public notes become more useful when they can be re-read, challenged, revised, and linked to later work.
• The End of the Hackers Era - why distributed, reactive, multi-device programs need usable structure instead of one-off cleverness at every boundary.

Theme Paths

Use these as entry points, then return to the chronological list when dates matter.

• Visible computation and Cartilage: start with Cartilage Core and the public source repository, then read Modular PCB Logic Tiles: A Physical MUX and Wire Alphabet, What Cartilage Is and Is Not, and Boolean Logic Is Everything.
• Maker-scale active devices: The Missing Maker Fab, The Closed Photolithography Compute Cycle, Let Me Make a Chip at Home.
• Radio and stack stripping: One-Pin FPGA FM Receiver, An FM Receiver With One FPGA Input Pin.
• Graphics, programmable shaders, and AI hardware: A History of Programmable Shaders, then Cheap Pixelless Textures With 2D SDFs.
• Chip arithmetic and open ASIC implementation: FMA From RTL to GDSII, Bit-Serial Bubbles-Free Multiplier, and AI Arithmetic on Chips.
• Programmable matter and fabrication: Wafer-Diced Chiplets for Programmable Matter, Distributed Reactive Programming for Claytronics, and Movie Inspirations for Programmable Matter.
• Small learning machinery: Training a Tiny LLaMA From Scratch, The Long Mathematical Path to Transformers, Cross-Entropy Intuition.
• Speculative theory kept in bounds: Discrete Photon Reconnection Graphs, Many-Worlds and the Discrete Photon Field Fabric, Quantum Darwinism and the Dust Grain.

Chronological Archive

The rest of this page keeps the original dated order because the sequence of thought matters.

2026

• June 2, 2026 Merchant Values and Honest Exchange

  A practical note on exchange: the other person receives useful work, clear terms, reliable delivery, and enough care that trust survives the transaction.

• May 10, 2026 Discrete Photon Reconnection Graphs

  A bounded computational-physics hypothesis about discrete photon reconnection graphs, mass-rate ratios, branch balancing, and validation targets against gravity, quantum experiments, chemistry, Casimir effects, and neural timescales.

• April 27, 2026 The Missing Maker Fab

  Open hardware can own boards, firmware, enclosures, fixtures, and tests, but still needs a locally reproducible path to fast active devices.

• April 24, 2026 Writing Assistance and Published Work

  Assisted drafting can help turn rough notes into readable public text, but responsibility stays with the finished page and its source material.

• April 24, 2026 How Much Radio Do You Actually Need?

  Launch note for the one-pin FPGA FM receiver: RF enters a digital input threshold, becomes a transition stream, and is recovered as FM audio in the full article and Verilog follow-up.

• April 24, 2026 An FM Receiver With One FPGA Input Pin

  One digital input pin receives RF, the FPGA threshold produces transitions, and the receiver recovers FM audio through logic, CIC filtering, and sigma-delta output.

• April 15, 2026 Magnetic Paramp and Second-Harmonic Saturable-Core Downconverter

  A diode-free magnetic front-end research thread: magnetic paramp or mag-amp input, two-core second-harmonic saturable-core downconverter, printable magnetics, windings, anneal schedules, and source requests.

• March 6, 2026 Correctness Emerges by Acting

  Correctness as a closed-loop engineering problem: scan, observe, choose, correct, and turn real behavior into tests, migrations, and safer paths.

• February 25, 2026 Why This Instrument Exists

  A Cartilage requirements article: a programmable fabric should keep structure, ownership, timing, runtime change, and continuity readable while it runs.

• January 31, 2026 Modular PCB Logic Tiles: A Physical MUX and Wire Alphabet

  Physical MUX tiles turn the Boolean fabric alphabet into connectable circuit pieces: MUX, wire, constants, intersections, one-sided orientation, and edge-to-edge patches.

2025

• December 31, 2025 Chain-of-Thought Reasoning May Be a Mistake

  A model-evaluation note about chain-of-thought prompting, hidden computation, single-shot answers, benchmark incentives, and why more text is not always better reasoning.

• October 30, 2025 AI Does Not Repeal No Free Lunch

  A software-engineering note: AI tools can accelerate parts of development, but No Free Lunch, No Silver Bullet, and The Mythical Man-Month still apply.

• August 19, 2025 Cheap Pixelless Textures With 2D SDFs

  A self-contained Python scanline renderer for cheap pixelless procedural textures: UV-space 2D SDF material tests, point-cloud foliage speckles, triangle trunks and branches, and a UV-SDF deer sprite...

• June 29, 2025 Floating-Point Hardware From Pixar to AI Chips

  A graphics and compute-history note connecting RenderMan-era floating-point needs, SGI/DEC workstations, custom ASIC suppliers, programmable shaders, and GPU-heavy model training through scalable FMA.

• June 5, 2025 Nano-Core Logic at the kT Limit

  A post-CMOS magnetic-logic proposal: cobalt, iron, or nickel nano-core elements near the kT switching limit, differential magnetic-amplifier fabric, cascadability, gain, and process requirements.

2024

• January 17, 2024 Teach Microelectronics in Maker Spaces

  A microelectronics education note: maker spaces can teach PCB process, measurement, lithography basics, devices, failure analysis, and active-circuit fabrication literacy.

• January 17, 2024 DINOv2, SALAD, SuperGlue, and the Dustbin Question

  A vision-model note comparing DINOv2/SALAD, SuperGlue, LightGlue, optimal transport, and the dustbin mechanism used for unmatched image features.

• January 13, 2024 The Closed Photolithography Compute Cycle

  Advanced chipmaking increasingly depends on computation made by the chips it produces: process models, mask correction, scanners, foundries, and GPU hardware in one manufacturing loop.

• January 10, 2024 Loss Functions in LLMs and Embedding Models

  The choice of loss function is a significant difference between training a generative language model (LLM - Language Model) and training a vector search...

• January 10, 2024 Training a Tiny LLaMA From Scratch

  A small-model training note: a 500k-parameter LLaMA-style model trained overnight on CPU with TinyStories, architecture parameters, and sample output preserved.

• January 2, 2024 RAG as a Rewrite-or-Repeat Discipline

  A retrieval-augmented generation note: rewrite an answer when retrieved context changes it, or repeat the answer when the context adds no useful information.

2023

• December 8, 2023 Remembering Carl Hewitt

  A remembrance of Carl Hewitt focused on the Actor Model, object capabilities, edge computation, message passing, and incompleteness robustness.

• November 29, 2023 AI Arithmetic on Chips

  A chip-arithmetic note about CSA, PPA, one-hot FSM control, H-trees, FIFO, CDC, IEEE 754 FMA, bfloat16, and pipelined backpropagation on large chips.

• November 9, 2023 Learn How Chips Multiply and Add

  A chip-arithmetic note about learning multiplier and adder structures directly: Wallace trees, Han-Carlson adders, FMA datapaths, Newton-Raphson approximation, and arithmetic blocks behind AI chips.

• November 2, 2023 Why Open-Source ASIC IP Is Hard: FMA From RTL to GDSII

  A chip-design note about why FPU FMA IP is hard to open-source: RTL-to-GDSII reasoning, tool cost, proprietary implementation know-how, and the gap between software openness and ASIC openness.

• October 25, 2023 The Long Mathematical Path to Transformers

  A compact map of the mathematical background behind transformers: probability, optimization, sequence models, tensor operations, normalization, tokenization, and hardware arithmetic.

• October 24, 2023 Hessian-Free Methods Did Not Vanish

  An optimizer-history note about Hessian-free methods, recurrent-network training, and why second-order ideas remain relevant beside AdamW and transformer-era training.

• October 24, 2023 Many-Worlds and the Discrete Photon Field Fabric

  A speculative physics-model note about path integrals, absorber ideas, discrete graph models, photons, causality, and what such a model would need to explain.

• October 20, 2023 Binarized Weights and Efficient Model Hardware

  A machine-learning hardware note about binarized neural networks, BitNet-style scaling, and why model arithmetic matters for specialized accelerators.

• September 19, 2023 Cross-Entropy Intuition

  A short mathematical note connecting cross-entropy, negative log-likelihood, matrix exponentials, expectation, and why the target distribution enters the loss.

• August 30, 2023 Autoregression, Nonlinear Processes, and Embedding

  A mathematical note connecting autoregression, nonlinear dynamics, embedding theorems, and why transformer embeddings belong in a longer history of state representation.

• August 30, 2023 Functions, Prediction, and Autoregression

  A computation note connecting functions, finite-state machines, autoregression, and transformer output: prediction is shaped by representation and state.

• August 24, 2023 Optimizer History Around Attention and AdamW

  A model-training note about why transformer history should include optimizer choices: SGD with momentum, Adam, AdamW, RMSProp, schedules, and attention.

• August 18, 2023 Probit, Argmax, Logit, and Neural Networks

  A statistical-modeling note separating probit, logit, sigmoid, softmax, argmax, Gaussian CDFs, and neural-network output layers.

• August 11, 2023 NVIDIA GPUs Are Not Universal Computers

  A GPU-architecture note about why GPUs are excellent throughput machines for some parallel workloads but not universal replacements for CPUs or custom hardware.

• August 1, 2023 Hilbert-Space Operators as Statistical Models

  A mathematical modeling note connecting data vectors, correlation structure, linear operators, eigenvalues, and Hilbert-space language.

• July 28, 2023 Lattice Regularization and Measurement Tensors

  Lattice regularization. Operators are just continuous version of measurement tensors. Spacetime probability amplitudes of your favorite fields and the field...

• July 24, 2023 A Draft Theory of Discrete Photons

  A bounded draft-theory note about discrete photons, emergent probability-density fields, observer state, entropy production, and what a physical model would have to answer.

• July 21, 2023 Attention, Dynamic Weights, and Mutual Information

  A machine-learning note: attention as dynamic weighting, with historical links to soft windows, density networks, mixture models, and mutual-information questions.

• July 3, 2023 Predictive Patterns Are Not Meaning

  A model-boundary note about Transformers, predictive patterns, generated text, mathematical modeling, and why prediction should not be confused with meaning.

• June 29, 2023 A Second Law After Moore

  A technology-access note about active devices beyond conventional CMOS: switching behavior, process scale, educational prototypes, and fabrication constraints.

• June 26, 2023 Rights for AI and Hardware Democratization

  A hardware-access note about local AI compute, open hardware, Soft IP versus Hard IP, and active-device fabrication beyond board-level maker work.

• June 23, 2023 ShaderToy as an ASIC Simulator Path

  A browser/GPU computation note: GLSL, SDFs, and ShaderToy made circuit-like visual simulation and massively parallel kernels directly inspectable in the browser.

• June 21, 2023 Reversible Computation and Biological Efficiency

  A computation-energy note about reversible logic, biological efficiency, and why power dissipation matters when parallel systems scale.

• April 30, 2023 SerDes, Topology, and Compute Locality

  A compute-topology note: SerDes links, latency, energy, memory movement, and island-style accelerator layouts matter as much as raw core throughput.

• April 18, 2023 Intrinsic Metrics and Mutual Information

  A machine-learning outline connecting intrinsic metrics, mutual information, nonlinear feature spaces, kernel methods, and measurements that reveal structure.

• April 10, 2023 LLMs, Reinforcement Learning, and Physical World Models

  A model-architecture note about LLMs, reinforcement learning, physical-world models, grounding, state estimation, and why prediction alone is not enough.

• April 5, 2023 Application Startup and Dataflow Architecture

  An application-architecture note: startup code, object construction, state ownership, event handlers, dataflow, and feedback paths define the program users actually run.

• March 26, 2023 Transformers as Mathematical Optimization

  A mathematical-optimization note about Transformers as trained function approximators, objective functions, variational analogies, and hardware for efficient model execution.

• March 25, 2023 Explaining Cartilage by Comparison With Hadoop

  A Cartilage architecture note comparing distributed data systems with a spatial, reactive fabric: locality, ownership, routing, isolation, and bounded resources.

• March 22, 2023 FPGAs, Claytronics, and Reactive Programming

  A parallel-computing note: FPGA teaching, reactive programming, and programmable matter meet at timing, locality, ownership, and many small resources running together.

• March 20, 2023 Public Technology Work and Openness

  An open-technology note: public technical work earns trust when source, interfaces, hardware assumptions, and collaboration paths are visible enough to build on.

• March 18, 2023 AI Is Mathematics

  A machine-learning math note about autoencoders, autoregression, mixture models, noise bases, ICA, control theory, and recovering structure from measured data.

• March 11, 2023 Predictive Models Are Control Theory

  A modeling note about the overlap between prediction and control: actions, observations, controllable variables, physical models, and desired future state.

• January 31, 2023 Entanglement, Pure States, Mixed States, and Superposition

  A quantum-terminology note separating entanglement, pure states, mixed states, superposition, mutual information, nonlocal correlations, and teleportation.

• January 5, 2023 Let Me Make a Chip at Home

  Chip-making is an ownership problem: useful machines depend on active devices that most builders can design around but not fabricate, inspect, or reproduce locally.

2022

• December 22, 2022 Software Developers Are the Cybersecurity Frontline

  A software-security note about why secure systems depend on engineering decisions in code, architecture, data flow, configuration, and operational boundaries.

• October 8, 2022 VLSI Questions for Reactive Programming

  A reactive-programming note framed through VLSI concerns: multi-bit completeness, comparators, pipelines, propagation delay, feedback, and oscillation.

• July 20, 2022 Rocks, Photons, and Spacetime Motion

  A physics-modeling note about inertial motion, falling bodies, spacetime paths, and why the same law can describe straight-line and curved trajectories.

• July 6, 2022 Tinkerer-Scale Control Circuitry

  Tinkerer-scale control circuitry means short local build/test loops for active machine behavior: sensing, switching, gain, restoration, timing, actuation, and test.

• July 6, 2022 Searching for a Tinkerer Replacement for Silicon

  What active element family could let builders make useful logic and control circuitry without depending entirely on silicon fabs?

• May 13, 2022 OpenCL Kernels and the Final Chip

  An accelerator-placement note about OpenCL-style kernels, device allocation, configuration, security boundaries, and what changes when kernels approach final hardware.

• May 12, 2022 Verilog, Allocation, and Dynamic Languages

  A hardware/software allocation note: Verilog reserves resources before runtime, while dynamic languages allocate objects, fields, and references while the program runs.

• May 12, 2022 Who Is Solving Parallel Source Code?

  Parallel source code as a fundamental computing problem: preserving causality, timing, locality, ownership, and failure when execution spreads across workers, devices, and machines.

• May 11, 2022 When One FPGA Is Not Enough

  What changes when an FPGA design crosses one device: partitioning, SerDes, clocks, protocols, latency, pipelines, placement, routing, and readable physical boundaries.

• May 5, 2022 Cartilage, Transputers, and CellMatrix

  A reconfigurable-fabric note comparing Cartilage with Transputer and CellMatrix ideas: local links, cell-scale configuration, packaging, power, and routing discipline.

• May 5, 2022 FPGAs as Reactive Parallel Structure

  An FPGA education note: Verilog exposes parallel structure, timing, local state, routing, and reactive behavior that conventional software often hides.

• May 1, 2022 A Shader for Nano-FPGA Fabric

  A WebGL/GLSL fabric-rendering note: a nano-FPGA surface drawn as a shader so cell roles, tiling, and local connections can be inspected visually.

• April 28, 2022 Movie Inspirations for Programmable Matter

  A programmable-matter note: film references used as visual problem statements for repair, replication, shape change, swarms, and local machine behavior.

• April 27, 2022 Elementary Computation Is a Switching Operation

  A Boolean-logic note: elementary computation can be read as switching, selection, and if-then-else structure rather than starting from the CPU as the primitive.

• April 27, 2022 Cartilage Project Structure, 2022

  A Cartilage project-structure note from 2022: fabric emulator, FPGA prototype path, Cartilage VM/runtime, Sinew control plane, and parallel-language surface.

• April 27, 2022 What Cartilage Is and Is Not

  Cartilage is a reconfigurable computing-fabric direction built around local regions, ports, routing, ordinary digital logic, and readable runtime structure.

• April 27, 2022 Reactive Programming Implies Distributed Systems

  Reactive variables become a distributed-systems problem when state changes over time, crosses boundaries, triggers other work, and needs ordering, ownership, fanout, and failure behavior.

• April 26, 2022 Migrating From DSL Languages to Erlang-Like Parallelism

  DSLs help express a domain; Erlang-like systems show what changes when timing, messaging, supervision, hot reload, and failure become runtime requirements.

• April 26, 2022 Adopting a New Massively Parallel Language

  A 2022 note about what a new massively parallel language has to make adoptable: emulator, syntax, examples, concurrency semantics, debugging, and runtime boundaries.

• April 21, 2022 Legacy Cloud Infrastructure and Reprogrammable FPGAs

  A migration note about moving legacy backend infrastructure toward reprogrammable fabric without losing names, data shape, state, ordering, configuration, and operational behavior.

• April 21, 2022 Compiling Backend Code to a Colder Chip

  A backend execution note about moving selected hot paths toward colder, more parallel hardware while preserving data models, state, configuration, observability, and security boundaries.

• April 18, 2022 Verilog as a Programming Language

  A hardware-language note about Verilog as a programming model for structure, timing, allocation, registers, parallel data paths, and reconfigurable fabric.

• April 18, 2022 Hilbert 13 and Neural Networks

  A machine-learning note: multivariate approximation, neural networks, sum-of-products structure, Q-learning, Monte Carlo methods, and why empirical scaling still needs mechanism.

• April 13, 2022 Focus on People, Models, and Thought

  A model-centered AI note about why human thought, world models, reasoning limits, and physical interpretation matter more than treating language output as intelligence.

• April 13, 2022 Machine Learning Plus Quantum

  A speculative modeling note about machine learning, quantum measurement, noise, Hilbert-style representation questions, and perception as structured inference.

• April 6, 2022 Three Levels of a New Programming System

  A programming-system note about three layers: hardware substrate, self-reprogramming object model, and high-level language syntax for distributed reactive computation.

• March 30, 2022 The Von Neumann Bottleneck Is Still Here

  A parallel-computing note about the von Neumann bottleneck, many-core contention, object-capability ownership, and one program spanning cores and devices.

• March 23, 2022 Fail Fast and Building Large Systems

  A systems-engineering note separating useful small experiments from the mistake of treating fail-fast as a complete strategy for large systems.

• March 13, 2022 Quantum Darwinism and the Dust Grain

  "A grain of dust one micrometer across, after being illuminated by the sun for just one microsecond, will have its location imprinted about 100 million times...

• March 11, 2022 Disseminated Thought Can Be Improved

  Public notes improve when they leave the private notebook: sharing, re-reading, and correction turn rough thought into something other people can build on.

• January 23, 2022 A TSMC-ASML Consortium for Distributed Fabs

  A semiconductor-capacity note: central process knowledge, distributed older-node local fabs, and the split between research coordination and order fulfillment.

• January 18, 2022 Induction, Deduction, Abduction, and ML

  A machine-learning note separating pattern induction, logical deduction, and abductive hypothesis formation, with Erik Larson's AI critique as source context.

• January 18, 2022 Anesthetics, Cells, and Consciousness

  A cell-biology note prompted by anesthesia literature, focused on molecular mechanisms, intracellular transport, and limits on broad consciousness claims.

• January 4, 2022 Superdeterminism, Many-Worlds, and Quantum Luck

  A quantum-foundations reading note comparing superdeterminism, many-worlds, relational interpretation, observer relations, and what each model must explain.

2021

• December 8, 2021 Chip Capacity as DDoS-Style Distribution

  A mature-node capacity note: treating chip supply as distributed infrastructure means useful regional process capability, not only more leading-edge fabs.

• December 7, 2021 Three Polarizers and Acausal Reality

  This experiment is one of the best demonstrations of the acausal and quantum nature of reality. Look, when you look at something which is black, there's no...

• December 3, 2021 Grow the Silicon Ingot for Trust

  A supply-chain trust note: chip security depends on the physical process, materials, wafer source, masks, equipment, metrology, and reproducible fabrication, not only IP design.

• November 15, 2021 Technology Education Instead of Technology Secrecy

  A technology-education note about teaching practical fabrication, instrumentation, materials, design, and process knowledge instead of leaving capability behind secrecy.

• November 13, 2021 Technology Secrecy and Manufacturing Concentration

  A technology-access note: public technical knowledge, semiconductor concentration, open-source business models, and what should remain secret versus teachable.

• October 27, 2021 Web 3.0 Already Happened

  A web-platform naming note separating AJAX-era Web 2.0, HTML5/WebSocket/localStorage client applications, and the later blockchain use of web3.

• June 30, 2021 Turing, Von Neumann, Boole, and Faggin

  Notes on a computing lineage from Boolean algebra and sequential logic to VLSI, FPGAs, and statistical workloads, with Federico Faggin's Silicon as source context.

• June 22, 2021 An FPGA Cloud for Shared Designs

  A shared-FPGA infrastructure note: running reusable designs while preserving isolation, scheduling, dynamic reconfiguration, and open/proprietary boundaries.

• June 18, 2021 The ISA as an API You Cannot Extend

  A machine-interface note: an ISA is a fixed contract between software and hardware, useful for portability but limiting when a program needs a new datapath.

• June 18, 2021 CPUs Solve a Narrow Class of Problems

  A compute-architecture note: sequential CPUs are general tools, but locality, concurrency, timing, and reconfigurable datapaths matter when software must scale.

• June 18, 2021 Mini-FPGAs Inside FPGAs

  A reconfigurable-fabric note: small programmable regions inside a larger FPGA can carry local configuration, control, and custom datapaths without CPU cores.

• June 18, 2021 Boolean Logic Is Everything

  Boolean logic as machine material: switching, state, layout, interconnect, MUXes, parallelism, and reactive structure rather than a classroom endpoint.

• June 4, 2021 Cellular Automata Across FPGA Chains

  A cellular-automata hardware note: a fully pipelined FPGA mesh can trade global wires for local timing, but placement, links, and latency become the design.

• May 27, 2021 Sequential Code and Hidden Runtime State

  A software-architecture note: sequential source code can hide state, time, ownership, and locality when the real system behaves like many interacting machines.

• April 26, 2021 Binary Decision Diagrams and MUX Networks

  A Boolean-representation note: binary decision diagrams can be read as MUX / if-then-else networks connecting EDA representation with programming conditionals.

• April 26, 2021 Geometric Algebra as Strict Types

  A geometric-algebra note about typed quantities, grades, multivectors, rotations, complex numbers, quaternions, tensors, and matrix multiplication.

• April 19, 2021 The End of the Hackers Era

  A programming-systems note on moving beyond clever one-off tricks: distributed, reactive, multi-device programs need structure people can run, understand, and extend.

• April 18, 2021 Open Hardware IP Cores Are Coming

  An open-hardware note: reusable IP cores for Wi-Fi, 5G, USB, and accelerators could give hardware some of the scale benefits of open-source software.

• April 18, 2021 Moore Law Grand Finale

  A compute-scaling note: as Moore's Law slows, growth pressure moves toward parallelism, distributed computation, hardware reuse, and new programming models.

• April 18, 2021 A Physical-Constraints-Aware Programming Language

  A programming-language note: distributed programs need to express physical constraints such as placement, links, latency, clock domains, ownership, and device boundaries.

• March 12, 2021 Energy Paths Beyond Gasoline

  An energy-carrier note comparing hydrogen, turbines, fuel cells, solar, geothermal, molten-salt nuclear, and fusion against the behavior gasoline currently provides.

• March 12, 2021 Portable Power and Transportation Energy

  A transportation-energy note about the gap between useful vehicle power and portable energy storage: replacing liquid fuel means replacing delivered behavior.

• March 11, 2021 The Non-Electric Energy Market

  An energy-system note about the hard non-electric replacement cases: portable continuous vehicle power and local heat without relying only on grid expansion.

• January 4, 2021 Research Engineers Need Roles

  A research-engineering note on separating learning, scientific modeling, invention, and client-facing engineering so each phase has the right output and audience.

2020

• November 6, 2020 FTL Communications as a Research Program

  A speculative research-program note connecting computation, optimization, field models, photonics, and hardware as tools for asking hard questions about communication and physics.

• November 1, 2020 Closed Circuit Designs Are Binary Blobs

  The common thing between AMD and Intel is that the products they make has a very extensive use of IP: the proprietary circuit designs which small vendors...

• October 23, 2020 DIY BGA and Solderless Multilayer PCB Tests

  A process note on 0.4 mm pitch solderless multilayer PCB/BGA tests using laser-drilled Avery masks and conductive ink, with measured via isolation.

• October 18, 2020 The Difficulty of Tiny PCBs at Home

  A PCB-process note on why tiny at-home boards are hard: 6 mil traces, 0.35 mm BGAs, repeatability, alignment, etch spread, glue spread, and realistic feature size.

• October 12, 2020 Code and Circuits in 4D Spacetime

  A computation-structure note about treating time, state, Boolean algebra, circuit volume, and physical realization as part of code and hardware reasoning.

• September 1, 2020 A Warning About Constructive Foundations

  A foundations note about classical logic, intuitionistic logic, axiom of choice, Univalent Foundations, Category Theory, and what changes when classicality is rejected.

• September 1, 2020 Lie Algebras From Algebraic Structures

  A math-structure note tracing Lie algebras through modules, rings, groups, bilinear maps, ideals, generators, matroids, and vector spaces.

• July 19, 2020 Single-Argument Functions and Abstraction

  A programming-language note about single-argument functions, multi-input abstractions, tuples, records, and why useful interfaces need explicit shape.

• June 15, 2020 Quaternions and Completeness

  A very important paper on the theory of numbers with broad applications (and implications) in quantum mechanics, machine learning, big data analysis, complex...

• May 18, 2020 Classical Mechanics Is Still Fundamental

  A mechanics note about virtual work, variational calculus, Euler-Lagrange equations, Hamiltonian mechanics, and why classical mechanics still underlies modern modeling.

• May 18, 2020 Do Not Skip Variational Calculus

  A math-prerequisite note: variational calculus connects optimization, action principles, Hamiltonian mechanics, physics models, and learning systems.

• April 29, 2020 Measure Theory as a Prerequisite

  A mathematics prerequisite note: measure theory supports probability, statistics, Bayesian inference, physics simulation, quantum models, and learning systems.

2019

• August 12, 2019 Life on Earth and Computational Permutations

  A computation-and-probability note about biological rarity, state-space size, irreversible processes, cellular automata, and why repeated permutations are not a good model of history.

• July 30, 2019 Scale Invariance and Software Semantics

  The Universe is made out of the same finite set of infinitely repeating structural patterns scaled to different sizes. Scale invariance is important concept...

• July 9, 2019 Distributed Reactive Programming for Claytronics

  A distributed-programming note: scalable programmable matter needs explicit resource ownership, spatial allocation, and agreements over local regions.

• June 5, 2019 Reversible Computing and Copying Information

  Thoughts on reversible computing... Copy of information is required to avoid re-computation of sub-branches of logic expressions. Everyone knows how the cache...

• April 24, 2019 Geometric Algebra and Matrix Multiplication

  A mathematics note connecting geometric algebra, matrix multiplication, category theory, Hamiltonian action, and shared structure across formal systems.

• April 23, 2019 Live-Offline Dualism in Software

  Collaboration software as a time problem: meetings, missed sessions, reconnects, conflicts, document edits, and shared history must remain usable across presence and absence.

• April 17, 2019 A Surviving-Observer Model of Computation

  A computation-model note about declarative systems, concrete observers, testable examples, and the constraint that a model must survive contact with use.

• February 14, 2019 A Cellular-Automaton Model of Computation

  An early computation-model note connecting actors, object capabilities, membranes, reactive programming, interaction nets, finite automata, and cellular automata.

2018

• October 24, 2018 Simpler Computation Without an ISA

  An early computation-model note: reducing the machine to composed child components, local management, state, configuration, and parallel structure without starting from an ISA.