# Developers' Aphorisms: Wisdom from Stand-ups and Code Reviews
Over the years in embedded development, a collection of phrases builds up that graduate to aphorisms. They capture the realities of microcontroller coding, circuit design, and project management. Here's a selection from 12 years of hands-on experience: from code principles to MCU peripherals.
Aphorisms about Code and Architecture
Programmers fall into two camps: those who write code from scratch, and those who port open-source libraries. A computer's universality as a computing device is the textbook definition—though not every physics-and-tech grad buys it.
Key principles:
- There's a config for everything: the best code is just configuration.
- Code separately, configs separately.
- Good code crystallizes over years.
- Principle of least astonishment in writing.
- The best algorithm is a table (a finite state machine boils down to a graph and table).
"Programming is a marathon, not a sprint." (Robert Martin)
Code uniformity trumps beauty: "Write code uniformly—ugly is fine." Arrays are the foundation of everything. Every setter needs a getter: xxx_write() demands xxx_read(). A function's name is its comment. Fewer text comments mean cleaner git diff.
In C: if a function doesn't fit on one screen, it probably doesn't work. Any task can be solved in one line—a function call. The best comment is the filename.
Testing and CI/CD
A repo without CI is just scrap paper. The build system has to be uniform, no matter the editor. Code without unit tests? Same story.
"A program that hasn't been tested isn't working." (Bjarne Stroustrup) "TDD is the professionals' choice." (Robert Martin)
Knowledge gets handed down in writing, for smooth handovers. A portable codebase is the bedrock of future projects. All protocols boil down to memcpy between devices.
Circuit Design and Hardware
Hardware folks quip: be like a CPU—refuse overvoltage. Electrical engineering is the science of missing connections. Development starts with debug tools.
All sensors measure temperature, just in their own way. Above 100 MHz, signals go analog. Everything in electronics is an ADC or DAC: codecs, transceivers, even GPIO as a 1-bit DAC.
Interface picks: SPI beats I2C. Russians lay out boards for European code, Europeans code for Chinese boards. Best part is no part.
Microcontrollers and Firmware
Hardware comes first, software second. The simpler the schematic, the trickier the firmware—and vice versa. Firmware without hardware is like sculpting from a photo.
Peripherals sync to the core clock. Firmware starts with a bootloader. One reset fixes seven woes. The killer feature? Firmware updates.
Universal protocols multiply: from 12 to 13. Assembler is like eating buckwheat with tweezers. NVRAM levels up anything. UART-CLI is a must: without it, it's plug and pray.
UART logs are firmware's black box. An MCU is a mortar for grinding numbers; x86 is a blender. CLI sparks creativity, GUI boxes you in. Finite state machines are the golden hammer for MCUs.
A proper MCU needs: uptime timer, heartbeat LED, UART-CLI, NVRAM, unit tests. Otherwise, it's a pointless chain. Firmware won't write itself.
Modularity means building for multiple platforms at once.
Management and Projects
We build it not because it's simple, but because we thought it was. Half of what they teach is nonsense—the trick is spotting which (Larrabee's Law).
Develop to spec: no gold-plating. Negotiating is the job. "Do nothing" on request? Task complete.
"A negative result is still a result." (Niels Bohr)
A bad solution with a good report gets axed eventually; a good one with a bad report gets killed on sight (Akin's Law). Managing means staying out of the way.
Quality trade-offs balance out positively. Don't bolt a gas tank on a dog. Better find the bug now than on the shelf. Brainstorming? Just idea-roasting.
Build not what they ask for, but what they need. The perfect is the enemy of the good. Bad stuff happens on its own. Fast and sloppy gets remembered as sloppy; slow and solid sticks as solid (Korolev).
What's Important
- Code must be portable and testable: TDD, unit tests, unified CI.
- In embedded: UART-CLI, logs, finite state machines—the debug essentials.
- Hardware-first: simple boards make software easier.
- Projects to spec, docs in writing.
- Succession planning: knowledge captured, repo pristine.
— Editorial Team
No comments yet.