Hardware obeys nature's rules, software obeys humans' rules
Incidentally, I’m a hardware guy.
The hardware guy’s perspective, the software guy’s perspective
Among colleagues and friends, this sometimes turns into something like an exchange of complaints disguised as debate. On the surface it goes “Software guys really do have it better, huh~” “No no, it’s hardware guys who have it better” That kind of exchange. But underneath it, there’s “Hardware guys are getting the short end of the stick. Look at the recent job postings for mid-career hires. It’s all software.” or “Software guys are getting the short end of the stick. We have to keep endlessly learning new languages and algorithms as they keep appearing.” complaints like that lurking beneath the surface.
Both sides seem worth listening to, I think. (It’s not someone else’s problem for me either.) Let me try to sort this out a bit.
On defining software guys and hardware guys
By the way, “software guy” and “hardware guy” here mean “software engineer” and “hardware engineer.”
Interpreted plainly, this means
Software guy = someone who makes programs Hardware guy = someone who makes hardware (some kind of physical thing)
but this scope is far too broad, so to avoid unnecessary misunderstanding let me define both terms.
That said, I can only speak with real authority about the areas I’ve actually experienced, so:
Software guy
- Someone who writes firmware for embedded products (home appliances, industrial products)
- Someone who writes apps for smartphones
- Someone who writes applications that run on the Web
Hardware guy
- Someone who designs the mechanical enclosure or robotics of an embedded product
- Someone who designs the electrical circuits of an embedded product and the electrical components used on it
I’ll arbitrarily define things this way. Of course there are hardware guys and software guys in plenty of other domains too, but for this discussion they’re sitting this one out.
Let me state one fundamental difference between the two. It’s this:
Who decided the rules?
That’s the question.
Hardware’s rules
A hardware guy’s job is, fundamentally, entirely built on top of the physical laws of nature.
The composition of matter, the properties of electricity, the properties of magnetism, weight, materials, mechanics, and so on.
The underlying stance is: how do you arrange the products of natural science research to make something useful? When you hit a question, you often go back to the fundamentals of physics, and new ideas are often pulled from theories developed in the past — sometimes centuries ago.
No matter how hard you rack your brain, you can’t stop current from flowing from higher voltage to lower voltage, and no matter what sophistry you come up with, you can’t bend a thick steel plate without a large machine.
Nature decides all the rules.
Software’s rules
A software guy’s job, by contrast, fundamentally requires skillfully working within rules someone else decided. That’s because software itself is something humans created.
Of course, if you flip over the foundations of software down to their bedrock, you find mathematics.
But, for example, in C, when you include a header file, there’s no logic to why <> reads from a library while "" reads from the current directory, and i = 0 makes sense but what’s with i++? The questions never end.
It’s simply decided that way, so that’s how you use it.
In other words, as long as you keep being a software guy, you have to keep repeating the act of “someone decided it this way, so this is how I use it” and “it’s been decided this way next, so I’ll do it this way.” But more often than not, that’s accepted because it’s “an act that makes things more convenient.” For example, a complex feature that in an older language required writing a scattered total of around 1,000 lines might be achievable with just one line in a new language. Put simply, it’s that kind of thing.
Organizing the above difference in abstract terms
This might get a little sentimental (lol).
The hardware guy works atop an unshakeable, absolute logic.
The software guy can freely create the future according to their own ideas.
The hardware guy cannot escape nature’s laws.
The software guy, in the end, exists at the mercy of someone else.
So, what do you think?
On the philosophical side it’s a toss-up — I suppose we could call it a matter of personal preference.
Digging into the advantages and disadvantages
Next, let’s dig into the murkier parts. As the title says: who comes out ahead?
From a few down-to-earth angles. Specifically:
- Skill acquisition
- Supply and demand
- The global industrial paradigm
Let’s touch on these themes.
The skill-acquisition perspective
To put it bluntly: hardware guys mature slowly. Software guys mature quickly.
As mentioned above, hardware guys must build up from foundational technology. Even a fairly narrow, specialized job — say, “designing the wiring on an electrical PCB” — wiring isn’t something you can just “connect and be done.” To route wiring so that a product doesn’t run into trouble, you need a lot of knowledge: radio waves, discharge, capacitance between conductors, the relationship between trace width and impedance, and so on. You probably can’t become a decent engineer unless you train under someone with abundant knowledge and experience for three to five years.
But take a new hire assigned to some portion of a software job — say, the UI part of an app, handling the display of windows or screen transitions. If they’ve dabbled at all in some object-oriented language like C++, they’ll probably be plenty useful after just one or two months.
Where does such a large gap come from? The keyword is
Modularization
I’d say.
In the software domain, modularization has historically been pursued extremely aggressively. In proper software terminology, that’s the “library.”
You could even say the history of modularization is the history of software.
Have you heard the term “machine language”?
As the name suggests, it’s the general term for the language the machine (the computer itself) uses to operate — describing, one by one, each sequence, each port, each internal state transition. I want you to understand it here not in a strict technical sense, but roughly at the level of a hardware driver. (It’s binary rather than textual notation, but let’s not get hung up on details.)
Ultimately, all software reduces down to machine language to run.
For example
Suppose some web application on a PC performs the action of “displaying a circle on the browser.” Of course it’s written in some web language — maybe Flash, maybe PHP. But that command is interpreted by the OS and an instruction is sent to the display IC. That display IC interprets the instruction, controls the display, produces color, and the circle appears. Partway through that process, it’s almost machine language.
But
what fraction of web app designers understand machine language? I’d confidently say that fraction doesn’t exceed 1%. (There are some truly software-obsessed people out there, but they’re clearly a minority.)
And here’s the point: if asked “isn’t a web app designer who doesn’t understand machine language therefore not excellent?” I want to answer with everything I’ve got: “No, no — that’s a completely separate question.”
Now let’s go back to the earlier topic.
Suppose there’s a PCB designer who barely understands EMC theory or the skin effect. I’d think, “I don’t want this person designing anything.”
There’s clearly a huge gap here. It’s the benefit of modularization.
In the software domain, all kinds of knowledge and know-how has been wrapped up and turned into libraries, and “you don’t need to worry about that anymore” is the gift past sages have smilingly handed down.
Another way to say modularization is “abstraction.”
Make it abstract, and even if you don’t know the concrete details, that’s fine.
Abstraction in hardware
Hardware had a similar case in the past too, in the domain of PCs — personal computers.
Have you ever built your own PC?
That’s actually not very hard. You just buy parts and assemble them. But why is it so easy? Because each function is properly “modularized.”
First you buy a motherboard. Then there’s a range of compatible CPUs and memory standards, so you buy accordingly. Same with hard drives and power supply units.
And honestly, by the time you’ve done just that much, it basically works. Because each function stands alone independently, you just buy it, plug it into the right connector, and it works.
And if you want more, you buy a Blu-ray drive, a sound card, a USB expansion board, and again just plug them into the right connectors.
You need a bit of knowledge, but you can get it running properly without ever needing to dig into questions like how the CPU actually operates, what each connector means, how signals are exchanged with memory, or what that one component on the motherboard even does.
A beautiful example of modularization.
That benefit supported the explosive evolution of computers and the Internet in the 90s.
In other words, modularization lowers the technical barrier at the individual level, which raises productivity as an industry. The software industry is precisely in that state.
So why hasn’t modularization progressed in the hardware industry?
Actually, saying that is a bit misleading.
Hardware has a history of modularization too.
Screws, springs, ICs, for example. Or the function boards that came up in the PC example earlier.
Each is a fine module built to realize some hardware-level function.
But hardware has two major problems.
One of them is optimization.
In hardware, optimization always matters. It’s fair to say it’s clearly more severe than in software.
For example, a common scenario: you decide to just reuse a “proven” PCB from somewhere. In that case, component size, board size, cost, and so on all end up wastefully excessive.
This almost always happens.
In software, people point to similar concerns like “code size,” “processing load,” “processing speed.” “We need to optimize,” they say. But it doesn’t come with the same severity as in hardware.
Because the foundation software runs on — hardware specs — keeps improving by leaps and bounds. The price of high-performance ICs keeps dropping, and processing that once needed two or three DSPs can now be handled by a tiny DSP tucked as an extra inside an SoC. In other words, thanks to hardware’s support, software tends not to need to think much about optimization.
Of course some software guys work in situations where code size severely matters. But they’re clearly a minority.
So software guys can turn a blind eye to a bit of waste or duplication, aggressively turn things into libraries, and devote their brainpower to flying forward to the next idea.
Modularizing hardware is actually not easy
The other problem is that in the hardware world, in most cases simply combining “modules” doesn’t make things work.
For instance, mechanical parts have something called “tolerance” — variation in error. With a design that doesn’t control this properly, you end up with something embarrassing like “three of the four corner screws tighten fine, but the last one just won’t tighten no matter what.”
This isn’t a joke.
Likewise with ICs: to get a given IC to work properly, you need to pay attention to supply voltage, power consumption, access speed, and many other parameters. If you don’t observe them properly, it may simply fail to work under certain conditions, or behave unexpectedly, becoming a source of trouble.
People often talk about PC memory “compatibility.” What that really means is that it’s actually unclear whether both sides fully cover each other’s required characteristics, and the fact that it sometimes just doesn’t work gets papered over with this vague expression.
In other words, hardware has too many attached conditions.
And the process of learning how to interpret and work around all of those is precisely what “skill acquisition” means for a hardware guy. But that’s not something achieved overnight.
In other words, as stated at the start, hardware has a high barrier to skill acquisition, while software, conversely, is easy for anyone to enter.
I think we can state this nearly as a certainty.
Following this thread, let’s move to the next theme:
Engineer supply and demand
Let’s talk about that.
Let’s look around and pose this question.
Among working adults who call themselves “software guys,” how many actually came from a background in “information engineering”? In reality, people from all kinds of careers — to the point of near chaos — have drifted into software.
That’s clearly due to demand.
Given that society has come to see value in software services and customers are willing to pay for them, this is only natural.
Some people spend hundreds of dollars on online games, while fewer people find value in a few thousand dollars worth of high-end audio equipment. I suppose that’s just the way the times are moving.
So there is demand for software guys. But the problem is that “supply is also thriving.” That’s because, as mentioned, the entry point for software is extremely easy.
Because the initial barrier is low
These days, few people put together a soldering iron kit and start building hardware on their own, but plenty of people think about trying to make an iPhone app. In fact, even a complete novice can produce a reasonably decent app within a month. That’s impressive in its own right.
But that also means people can get in at that level. At that level, rivals are born who threaten your own position.
Picking up on the earlier question of “how many software people actually came from information engineering,” let’s pose another: “Are people from information engineering backgrounds really the only talented ones in software?” Opinions may differ, but I want to say NO, emphatically.
If anything, someone who spent their free time steadily writing source code as a hobby out in the wild is probably a hundred times more useful than someone who graduated with excellent grades from an excellent information engineering department at an excellent university, learned the theory, but says “Well, I don’t really write much code.”
Software is something you can challenge with just a PC, and with just the Internet you don’t even need a textbook.
In the software industry, if you’re not constantly honing your skills, constantly studying, you never know when or by whom you’ll be overtaken.
Now, conversely, the hardware story.
About ten years ago, a guy nearly 50 at the time told me, “Master high frequency and you’ll be set for life.” A so-called transferable skill.
We’re currently in the smartphone era. It’s said that Apple hired tens of high-frequency engineers in developing the iPhone lineup, and high-frequency expertise is, in my experience, quite specialized and difficult to handle.
I think this is pretty much on the mark.
In contrast, software is no longer a “transferable skill” kind of job. It only looks that way because demand currently exceeds supply; you should assume a gradual winnowing is already underway.
Here’s a real example.
Feature phones lost to the rise of smartphones. There’s no helping that now.
I’ve heard of companies that collapsed or scaled back operations (i.e., restructured).
Think of the engineers who worked there. Imagine, ideally, a veteran engineer — someone who spent, say, 20 years solely on feature phones.
Now, in this situation, who survives: the hardware guy or the software guy? This is a cruel question. And the answer is obvious.
The hardware guy survives.
((Note)) It feels almost too obvious to even say, and of course it depends on individual aptitude. So please understand what I’m describing here is strictly a general tendency.
The difference between feature phones and smartphones is bigger than you’d think.
The design philosophy itself differs, and a large portion of the components used differ too. The assumed data volumes and the amount of internal information processing in the phone differ too.
Crossing this large gap and smoothly sliding into a smartphone development team is quite difficult.
But here’s where the earlier question — “who decided the rules?” — comes into play.
In hardware, no matter how much the design philosophy, components, or materials differ, the underlying logic — natural science — stays the same. Absorbing know-how in a new field and catching up with other engineers takes effort, but it doesn’t actually take that long.
Software, on the other hand. The language you use changes, the platform changes, the OS changes — that means an absolute change of rules. I’ve seen, more than once, software engineers with real skill get swept up in that kind of upheaval and effectively “nullified.” Seasoned veterans starting over from “Hello World.”
That said, most languages, platforms, and OSes tend to have some compatibility with each other, or feel somewhat similar, or partially draw from common roots. Still, that’s only the difference between starting from “zero” and starting from “one or two.”
During such a large-scale transition, there’s an overwhelming amount that a software guy has to newly learn.
And there’s a very serious problem with software that becomes apparent whenever such a large-scale shift occurs.
That’s the fact that the young are stronger.
Feature phone engineer survival simulation
Let’s consider a hypothetical. A veteran senior engineer with 20 years of feature phone experience. A young engineer who’s spent three years in the department since joining the company and is just about to graduate from being a junior engineer. Both get transferred to the smartphone division.
How does that play out?
One is in their mid-20s, still growing; naturally their own phone is the latest smartphone, and in their spare time they secretly make and sell smartphone apps. The other is in their late 40s, with eyes and shoulders getting worse every year. Can the veteran survive? It’s hard not to call this an extremely harsh situation. Effort, individual aptitude, level of awareness — various factors come into play,
but, again, it’s hard not to call it an extremely harsh situation. (As someone with one foot in “middle-aged guy” territory myself, I really do hope people in that position can pull through.)
But for a software guy, this kind of thing is an everyday occurrence. Put coldly: those who can’t get past it disappear.
Now, back to the keyword: software today has very strong demand, but supply is also thick and fluid. New talent keeps popping up left and right. I don’t think this boom in software services is going to stop anytime soon, and demand isn’t just staying steady — it may well keep growing. But as already noted, the problem is that the breakdown of that demand keeps shifting constantly. The absolute amount of demand is there, but you have to be prepared to always be in a tough spot — that’s the resolve a software guy needs.
Hardware, on the other hand, faces a supply-side problem with young people turning away from hardware, and beyond that, it’s in a critical state on the demand side, socially.
Carrying this thread forward, let’s move to the final theme.
The global industrial paradigm
Let’s talk about that.
Japan used to be called a nation of manufacturing, and these days we have to add “used to be” — in the near future, Japan will likely end up with a considerable surplus of hardware guys. My reasoning is very simple: companies and businesses connected to hardware, regardless of scale, are all uniformly trending toward shrinkage.
The background has many factors, which I’d like to sort out another time, but this trend isn’t easy to stop.
It’s not that simple.
Money is no longer gathering around hardware.
This might be because the evolution of integrated devices like smartphones and laptops has reduced the absolute number of hardware items an individual owns, or it might simply be that younger generations, raised in a prolonged recession, have less material desire.
That’s outside my expertise, so I won’t dig deeper. I’ll leave that to the economic commentators.
In any case, hardware guys are increasingly unnecessary. This is an unshakable fact.
As I briefly mentioned at the start, mid-career hiring for hardware guys has cooled off. Directly, that’s because manufacturers’ finances have cooled off.
And even when positions do open up, well-paying ones are rare. That could be said to indirectly reflect social status.
Young people will say hardware guys are outdated.
To them, having the Internet connect at 100Mbps, having a phone that never loses signal even in the subway, having a laptop battery that lasts five or six hours — none of this raises any question at all anymore. It’s simply taken for granted.
You might even call it “mature technology.”
In the past, Japan could call itself a “technology powerhouse” without embarrassment, built on the crystallization of technology it had accumulated independently. But these days, many people would say the center of manufacturing is China. A little before that, perhaps Taiwan.
Historically, the technology Japan and America built up was outsourced to Taiwan and China for production and had its software written in India, and through that kind of technology leakage, the crown of “manufacturing” gradually slipped out of Japanese and American hands over the course of decades.
This isn’t a matter of good or bad — it’s simply an established fact now. There’s no turning it back.
A bit of a tangent, but —
I once saw inside a smartphone made by a certain Taiwanese manufacturer. A certain component was slapped on indiscriminately everywhere, and I had to laugh.
There’s a certain expensive component used on PCBs for a particular purpose, and judging whether it’s “needed” or “not needed” is actually quite difficult — it requires both knowledge and experience. Because it’s an expensive part, engineers generally verify it fairly seriously before deciding whether to include it. That kind of component exists.
But that particular manufacturer was genuinely slapping it on indiscriminately everywhere. When I happened to meet a salesperson from the company that makes that component and mentioned this, they said, “Oh, we’re grateful they’re using it in bulk. Well, we’re giving them a fair discount, of course.”
Right. They’re solving this problem not through technology, but through business deals.
For a latecomer manufacturer to beat the incumbents, speed is everything. They stay on the offensive, commit to large component purchases, push for discounts, sweep technical problems under the rug, and prioritize “getting it done” and “meeting the deadline” above all else — and through that they’ve won trust and market support.
As a business strategy, this is absolutely correct.
But it does expose that, frankly, their engineering level still has a long way to go.
That said,
it’s hard to argue against the accusation that this amounts to “sour grapes.”
We live in a capitalist society, not in an academic conference or a technology competition.
Now, shifting perspective a bit —
among the “fast-growing companies” that are hot right now (excluding China and Taiwan), how many are actually doing hardware?
Thinking about that sends a bit of a chill down my spine. This too is an extremely clear trend in modern society.
But once, drinking with the president of a certain hardware startup in San Francisco, he said this:
“People say Amazon is an IT company, but we shouldn’t forget that what actually underpins Amazon’s business model is the robots in its warehouses handling inventory management and picking and packing orders, and the control technology behind them.”
Incidentally, he’s a robotics engineer.
Software can’t run without hardware.
This too is a fact.
Countless software services are, after all, built on top of a hardware foundation, and the need to support that clearly exists.
But that absolute demand, if left alone, keeps disappearing as time passes.
Because our powerful, hungry, business-savvy neighbors are waiting eagerly for the opportunity.
Looking ahead: a summary
The many hardware guys currently in Japan
will, before long, face a moment where they have to take stock of themselves, and will need to find an answer for how to put that “universal technology” to use with an eye on the future.
One answer is to keep doing what you can, in whatever modest scope is available. Even in a shrinking industry, some amount of product still sells, and making the effort to keep that going as long as possible is also a respectable stance.
At the individual level, that’s fine. But that alone won’t let many people make a living.
New industries, and in turn, the discovery and creation of new needs, will be necessary.
“The needs of the world” — surely plenty of correct answers are buried in the ground somewhere. But finding them by dowsing rather than digging is quite difficult. And the resources to pay for the drilling costs needed to dig indiscriminately everywhere have, before anyone noticed, run out for every manufacturer.
Software, in that respect, has cheap, cheap drilling costs. It’s only natural that it looks enviable.
In this extremely harsh situation,
will a savior actually appear?
If none appears, who will make the hardware, I wonder. Surely the world would become a dull place.
This is the moment to hold the line.
Now,
as for the software guys, whose numbers will presumably keep growing from here,
the world will welcome them warmly. But only at first. There are many rivals. It’s a world where you keep programming through every waking hour of the day, and even then it’s a question whether you manage to stand out even slightly.
Let your guard down for a moment and you’ll be swept up and tossed aside along with everyone else.
But for those who approach this with resolve and effort, the future will surely be bright. The protagonists of the age, as it were.
That much is certain.
Closing
To anyone who read this far hoping for a tidy, one-sided conclusion, I’m sorry, but this problem isn’t that simple.
Still, I’d like to think I’ve scattered a few “keys” along the way.
How to ride out a paradigm shift depends, first of all, on correctly reading the situation.
How do you see this situation? Which way is the era heading? What are the sacrifices and what gets left behind along the way?
Humanity has seen all kinds of things.
Including important things, lost and left behind by the passing of an era.
“Riding the wave” isn’t in itself the right answer — “riding it skillfully” is what matters.
Its meaning and value can never be easily judged, at any time.
Originally published in Japanese at https://clazytech.com/2013/01/75/. Translated with LLM assistance and reviewed before publication.