DEV Community: Chaesang Jung

Embedded, Then Embedding

Chaesang Jung — Sat, 31 Oct 2026 06:55:25 +0000

One word that followed me for decades — embedded system, then embedded Linux, then ML embeddings — each time a different creature.

A look back — long before any of the tools we argue about now.

For a few semesters in college I held a work-study job. Maybe it was because I was an out-of-town student who didn't live in the dorms; either way, the main task was carrying the mail that landed at the engineering office over to the department office, then sorting it out lab by lab. Half an hour, an hour a day of small errands — and warm memories of the office staff, the grad-student seniors, and the professors who were kind to a kid running deliveries.

One small perk: I got first look at the odd jobs that came into the department. One of them was translating an article from some journal into Korean. It was the kind of thing I could do from my boarding-room desk, so I picked it up out of curiosity — and that was my first meeting with "embedded system."

Embedded System

The article was about how you could now do real, high-level programming in C down in the world of sensors and controllers — small things, made to do more complicated work. My biggest problem wasn't the content. It was how on earth to say "embedded" in Korean. For context: this was before Naver, before the internet was something you reached for, and the English-Korean dictionary on my desk had probably been printed sometime in the 1980s.

After a long stretch of trips to the library, I settled on a Korean rendering that came out as roughly "built-in system." What gnawed at me most was the mirror image: if I called its opposite an "external system," what English word did I imagine sitting behind that? Embedded has no clean antonym, it turns out. My better memory is the happy ending — the senior who checked my work looked pleased, and the finished translation held together on its own terms. Translating one article doesn't exactly broaden your horizons. But it was a new experience, and years later, when "embedded systems" swept through an entire era, I felt strangely well-prepared for it.

Embedded Linux, and After

Around 2000, embedded systems and embedded Linux took off — people bolting on a CPU and some RAM and coaxing Linux to run on it, and on from there. For a while it felt a little like the AI wave does now (maybe not quite that big), to the point where labs renamed themselves just to get the word "embedded" into the title. My own lab spent a stretch as something other than "Computer Architecture and Networks," with "embedded" worked into the name — though I'll admit the lab names that kept changing after I graduated are hard to keep up with.

The Korean "built-in" reading, meanwhile, quietly faded out. I remember grumbling about it at work, handling something like an ARM7 with full Linux running on top: in what sense is this built-in? Then smartphones arrived, the whole thing shifted into another era and another class of product, and it slipped into memory.

Embedding — A Different Animal Entirely

For a while I forgot the word in both languages. Then, doing AI/ML work at the company, I ran into "embedding." Same root — just a present participle where the other was past — so you'd expect them to be cousins. They weren't. This one was a creature of pure math and vectors, asking no questions about hardware at all. Even when you reached it through NLP, it resolved into an exercise in reducing dimensions; there was surely a reason for the name, but this one was genuinely hard to put into Korean, and not really worth the trouble.

Lately, in the LLM era after ChatGPT, it has surfaced yet again. Seeing it written as embed_model still gives me a brief flinch, but mercifully people keep spelling it out as "embedding," and I get used to it. I'd half-assumed it was something you'd only touch if you were pretraining a model — but with fine-tuning and RAG, it turned into one of the hottest issues going, and picking a good one became a competitive edge of its own.

P.S. Three lives for one word — embedded system, embedded Linux, embedding — and across all of them I never did land on a Korean word I was happy with. Some terms you end up just saying in English, and meaning it.

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/40

When V Always Meant Very

Chaesang Jung — Wed, 28 Oct 2026 23:24:18 +0000

A childhood spent decoding acronyms — VLSI, VHDL, VLIW — where the V always, deflatingly, stood for "Very." And then "Large" quietly took over.

A look back — long before any of the tools we argue about now.

I came to English late. The excuse I leaned on was a childhood of calligraphy lessons and newspapers still printed thick with Chinese characters — a different alphabet to grow up reading. The English that finally stuck arrived sideways: from cramming for the theory section of a computer contest, and from games. So today's memory is about acronyms — and about how, among all of them, the letter V stood, without exception, for Very. Fascinating and a little deflating at the same time.

IC, LSI, VLSI

The very first entry in the contest's glossary was IC — Integrated Circuit. To me, circuits were the radio kits the older kids in the neighborhood soldered together, and "integrated" was a foreign idea; in Korean the official rendering was its own small puzzle, a near-homophone away from a different word entirely. Almost in the same breath came LSI — Large Scale Integration — and VLSI — Very Large Scale Integration.

I remember worrying over them in earnest. If Large was already large, how large was Very Large? And what on earth would they call it once it got larger still? It struck me, even then, that whoever coined these had done the hard part — integration — and then reached for the laziest modifiers within arm's reach. Large. Very. As if the care had simply run out.

VHDL

Freshman year or sophomore year — I can't place it now — the seniors warned us we'd soon meet a notorious tool: Synopsys, and a language called VHDL. From a worldview where Basic was most of what I knew and C was still a novelty, the idea of describing hardware in a language was startling, and I took to it with more enthusiasm than I expected to.

VHDL, it turned out, stood for VHSIC Hardware Description Language — and VHSIC, in turn, for Very High-Speed Integrated Circuit. There it was again. V for Very. By then I'd stopped chasing the Korean translations altogether. And something nagged at me: for all the super- and ultra- prefixes I knew by heart from watching Dragon Ball, not one of them ever surfaced in these terms. Just Very, over and over.

VLIW

The last skirmish I remember between super and very was in an architecture course: superscalar versus VLIW — Very Long Instruction Word. As an approach it was audacious, rebuilding the machine from the ground up. But measured against the promise that words like super and very carry, the reality — instruction words of 64 to 1,024 bits — felt thin. That's Very?

My running impression by that point was that very wasn't much to write home about; the whole vocabulary was oversold. I'd half-concluded that any acronym opening with a V meant one of exactly two things — victory, or very.

LSTM, LLM, LMM

Years later, when AI came back around and I found myself reading papers again, the alphabet had shifted under me. Past the NN, CNN, RNN — things no translation could make legible — a new pair of words kept surfacing: Long and Large. LSTM (Long Short-Term Memory). LLM (Large Language Model). LMM (Large Multimodal Model). Long and Short are relative; fair enough. But LLM's Large — that one had earned it. This was genuinely big.

Maybe very simply never got its chance. The numbers ballooned so fast, and the word stayed Large the whole way up, that there was no opening for it to slip in. In Korean the field settled on "giant" and "super-giant" language models — and for once I think the loose translation lands better than the literal one would have.

P.S. "Super-giant language model" I can live with. "Super-giant AI," though, I find quietly unbearable — partly the discomfort of collapsing all of AI into a single model, and partly, I suspect, the occupational hazard of having learned the entire trade in English first, however shallow that English was to begin with.

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/38

When R Stopped Meaning RISC

Chaesang Jung — Sun, 25 Oct 2026 21:00:07 +0000

From hand-typed hex on a Samsung SPC-1000 to ARM assembly on an embedded Linux board — the long, slightly anticlimactic story of RISC vs CISC.

A look back — long before any of the tools we argue about now.

Reaching for machine code

The first machine code I remember was a handful of game routines for the Samsung SPC-1000, copied out of a computer-study magazine. Long strings of hexadecimal, written out like an incantation; you keyed them in value by value, ran a final call, and got one of two outcomes — something happened, or you had to switch the machine off and back on. I had no idea what any of it meant. I do remember coloring in graph paper, square by square, building little mosaics — though looking back, those were fonts and black-and-white pictures, not instructions.

MASM

My first real encounter with machine code was the Microsoft Macro Assembler (MASM), a final project in a systems-programming course in my sophomore year. Until then, programming had been the things you could more or less reason about — if/then, for, print. Then came this alien thing called an assembler — assembly? — that wasn't even quite machine code, and the project was to implement one. I solved it with a great deal of patience and one enormous switch statement, stitched together by hand. I was quietly proud of it.

RISC vs CISC

A lot of memories are tangled here, but the birth of RISC, as I learned it in an architecture course, genuinely moved me. The idea of a better machine somewhere out there — and what it took to make it possible: first, you put a pipeline inside the CPU and arrange the instructions so several can run at once; second, you handle all the side effects, the hazards, that this creates; third, the improved compiler techniques that make it all work; fourth, the cache that maximizes the whole thing. Exam questions were the how would you resolve this hazard sort. I have a memory of building actual circuits in Synopsys VHDL too, so it must have been somewhere in there.

I thought of it as a beautiful story, set against Intel's CISC camp on the other side. But CISC vs RISC turned out to fizzle, anticlimactically. For one, RISC's instruction count was never actually small — reduced, really? Intel's Pentiums were CISC but borrowed RISC ideas internally; PowerPC faded; and so on. Did these camps even need to fight? It came to feel a little pointless.

ARM / StrongARM / ARM7 / XScale

I met RISC again later, through ARM, once I started working on embedded Linux. ARM stood for Advanced RISC Machine — or Acorn RISC Machine — and at a small company whose iPAQ days are now a fond memory, I chased one CPU after another, working on the Linux kernel, compilers, device drivers. I did a fair amount of ARM assembly. I knew back then that the R stood for RISC, but the fact slipped out of memory for a long time, and seeing ARM mentioned everywhere now, I pull it back out and turn it over. The R isn't really the R of RISC anymore — it's just the R of ARM.

Intel even built a new CPU called XScale, and I remember using it early on, with projects that dynamically scaled the CPU clock. The smartphone we tried to build on Linux, QT, the Sharp Zaurus — those memories run on to Symbian, and then to Android at Google. But that's a 2000s story, for somewhere else.

P.S. Watching how neatly all of this is now laid out on Wikipedia, I think back on the enormous effort it once took just to gather that information — and I suspect the patience it demanded had something to do with making me who I am.

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/36

Cache: The Third Word, and the Teacher Behind Them All

Chaesang Jung — Sat, 24 Oct 2026 14:35:59 +0000

The third word a professor gave me to carry for life — and the one closest to his own heart. This is also where I say goodbye to him.

A look back — long before any of the tools we argue about now.

He must have given us many more words after the first two, but my college years blurred them out. The third — and the last I clearly remember — was the one he called the word that would run through my whole career: cache. It sits right alongside trade-off as one of its cleanest examples, and it happened to be his own field. It's also the moment I fell, for good, for computer architecture. A few memories that cluster around it.

Locality

Temporal locality — you tend to reuse the same data again soon — and spatial locality — you tend to touch nearby data next. Use both, in software and in hardware, and the whole system runs faster, for almost free. The requirements are unusually well-defined, and the payoff is enormous. The professor used to call it beautiful. At the time, buried in benchmarks and the dozen techniques you had to understand, I couldn't see the beauty he meant.

It floored me that hardware was implementing this logic in silicon, and that gave me the nerve — and the recklessness — to push deeper into operating systems and file systems. And then the fussier, more obsessive side of it: the tricks for feeding hints to the compiler. I tried to hack on something like GCC to make a few of these ideas real, failed, and hit one wall after another. With a little more patience, maybe a different future would have opened up.

Other kinds of memory

As an undergrad, a new machine showed up called the Intel Pentium, and suddenly "L2 cache" was a phrase I could actually understand — though my grasp of it was about as deep as more and pricier must be better. After that came SRAM and its cousins, NOR and NAND flash, SSDs — a corner of the world that kept exploding, and that I had to keep learning whether I meant to or not.

I only ever got a taste of it. The professor and the grad students above and below me lived at the center of it, ranging across compilers, operating systems, controllers — taking the same idea and implementing it as is, or improving on it. Watching them, I caught a small revelation: maybe this is what it means for something to run through a fast-moving world for years and still hold.

Cache, everywhere outside

I started out in the so-called orthodox school — computer architecture — but every concept I met outside touched back to this one, and by now it's a word everyone uses without thinking. Hardware caches, network caches, software caches. In a few system-design interviews I've given and heard the same lazy answers — "just put a cache in front and it gets faster," "just buy more machines" — and in practice you end up nodding and doing exactly that. Memoization, CDNs, a cloud storage gateway: all the same idea, and it'll keep being the same idea.

Professor Sang Lyul Min

I only knew him through my master's, but I still remember him — now gone — with love and resentment tangled together. There was real resentment by the time I graduated. I had too many gaps to take in everything he offered; a lot of it I only understood once I'd grown up a little. Today he's the closest thing I have to the adult I'd want to become. I'm sorry it took me so long to see what he meant by the pursuit of goodness and beauty. The last time we really spoke was when I came by to tell him I'd gotten into Google; he gave me a wide, bright smile. I didn't know it would be the last time.

In an interview, he once said something I keep coming back to:

"I tell my students to understand the whole system. So I suggest that people who studied hardware as undergraduates go do software research, and people who've worked in software go do hardware."

"Getting to 99 percent is easy. But to make something beautiful, something at 100 percent, you have to spend five to ten times all the effort it took to get there."

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/35

I Picked It for the Name

Chaesang Jung — Wed, 21 Oct 2026 14:23:26 +0000

As a teenager I chose the field mostly because "Computer Engineering" sounded cooler than its old name: Electronic Calculator Engineering.

A look back — long before any of the tools we argue about now.

I'd studied hard enough as an exam-taker to be in a position to choose which department to apply to, and I gravitated, naturally, toward one with "computer" in the name. A few stories from around that choice.

Computer Engineering vs. Electronic Calculator Engineering

Filling out the application, I remember thinking — without quite examining the thought — that this department's name was cooler than the others. Had it still been the old one, Electronic Calculator Engineering, my teenage self almost certainly wouldn't have applied.

As the department's own history tells it, it was called Electronic Calculator Engineering back in 1978. National universities weren't permitted to put English in a department's name in those days; somewhere around the 1988 Seoul Olympics an ordinance changed, and English names became allowed. Once it became Computer Engineering, the story goes, both it and Industrial Design drew a kind of buff from their new names and spent a while as the flagship departments of their respective colleges.

CompEng? EE? CompSci?

By the admissions guides of the day, there were three ways in if you wanted to work with computers:

Computer Engineering, in the College of Engineering — 75 seats
the Electrical, Electronic, and Control Engineering group, also in Engineering — 270 seats
the Computer Science track inside Computational Statistics, over in the College of Natural Sciences — 30 seats

I applied weighing how cool the name sounded against a class size that felt about right, and I suspect I got in on the back of a quota increase. The software-to-hardware balance, we were told, ran roughly fifty-fifty for Computer Engineering, two-to-eight for the EE group, and nine-to-one for Computer Science.

The name bred its share of misunderstanding, too. Freshmen who'd come in hoping to make games were soon disappointed, and it wasn't long before the students who had shone at the olympiads started grumbling about professors a step behind the times.

The School of Computer Science and Engineering

None of it touched me through my master's, which I finished in 1999, but the reshuffling of schools and departments came afterward, and the department has since been folded together with the Natural Sciences' Computer Science into a single School of Computer Science and Engineering. My thirty Computer Science contemporaries became fellow alumni after the fact — though with no real overlap between us back then, running into one out in the working world still feels a little awkward.

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/31

Orthogonal: The Word That Taught Me to Cut Things Apart

Chaesang Jung — Tue, 30 Jun 2026 03:46:26 +0000

The second word a professor told me to carry for life. It took me years — and a lot of vectors — to start understanding it.

A look back — long before any of the tools we argue about now.

The same professor — Sang Lyul Min — handed us these words one at a time in lecture. After trade-off, two more stuck with me. But before the second word itself, here are the two pieces of news he brought to class around then. The internet barely existed; information moved through journals, magazines, and word of mouth. Looking back, it's a little amazing how much still got through.

When a chess machine started winning

The first breakthrough I remember: computers had finally started playing chess on roughly even terms with the world's best. Deep Blue beat Kasparov around 1996, so the machines he was describing came just before — names like Deep Thought, ChessMachine, Socrates II. He told us, deadpan, that one human competitor's head had "physically burst" from the strain — and we groaned, "Come on, Professor, that's a bit much."

We live on the far side of AlphaGo now, so it's easy to forget how much we shrugged at all this back then. I was a decent amateur — a 1-dan at Go, hopeless at janggi (Korean chess) against any program — and I still remember the hollow, slightly bitter feeling the AlphaGo era left even in someone who only ever played for fun.

A full-body scan

The second: in the US, death-row inmates had consented to the first dense full-body image scans. That was the news that taught me — embarrassingly late — that this kind of computing could reach all the way into medicine. Computers, it turned out, showed up in the strangest places.

orthogonal

Back to the words. The second one, the professor said, would run through my whole career: orthogonal. The Korean rendering — 직교하는, "at right angles" — was, naturally, a word I'd never heard. The plain-language version was "unrelated, independent." It came back hard years later, when I had to take vectors seriously — first in linear algebra, then in ML and AI.

If trade-off was his word for engineering, orthogonal was his word for the researcher's method: the thing that makes a proof, or an argument, easy to make. Recently, while prepping AI/ML lectures, I met matrices and vectors again — their particular discomfort, and the cleanup that comes after something like matrix factorization lops dimensions off — and found myself reaching back for this word.

I still haven't accepted it all the way down; I'm still learning it. It lives mostly in research and papers — in hypotheses, verification, methods you can trust — where half the job is cutting away what isn't related. Real-world data never splits as cleanly as you'd like. But the method is to prove your way down, lowering the dimensions, peeling off the things that have nothing to do with each other. When what's left is two or three dimensions, your eyes and your head can finally follow along. I still remember the small thrill of watching a little universe of three-dimensional somethings — orthogonality proven — collapse into one or two clean dimensions.

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/34

Trade-off: The First Word I Was Told to Carry for Life

Chaesang Jung — Mon, 29 Jun 2026 05:13:01 +0000

Before I understood what engineering was, a professor handed me a word to look up in a dictionary. I've been using it ever since.

A look back — long before any of the tools we argue about now.

Engineering, before I knew the word

In Korea, boys in middle school took a subject simply called "Technology," and high schools offered an elective called "Industrial Arts." Mine taught "Commerce" instead — so my entire pre-college image of engineering came down to a screwdriver, a few nails, and an AM radio kit I'd soldered together. No Lego that I can recall, but I remember playing with science kits, and blowing my allowance on Academy plastic models. The closest thing to "advanced study" was learning to read resistor values off their color bands — black, brown, red, orange, yellow, green, blue, violet, gray, white. That was the whole of my hardware education.

I walked into a computer engineering department without ever really asking myself what engineering was. What I noticed first, honestly, was the gender ratio: about one in ten classmates was a woman, which — after six years in all-boys middle and high schools — was its own small culture shock. Having women as classmates and seniors at all felt like news.

The first word

Our first major course was "Introduction to Computer Engineering," which in practice meant learning C. We could finally touch the machines at school; you did your homework in Turbo C and handed it in on a floppy.

I can't forget Professor Sang Lyul Min, one of the second class our department ever graduated. One day he said, "Let me give you a few fundamental words you'll need for the rest of your life." The first was trade-off. This was before the internet was something you could just search, so I went home and dug it out of a Korean–English dictionary, like a piece of slang I'd never heard.

From that one word I learned three things at once: that there's no free lunch; that this is exactly where engineering parts ways from science; and why the comparison with mathematics would keep coming back. The further I went into my career — and the more decisions I had to actually own — the more that word kept surfacing.

The word that kept coming back

It showed up in my algorithms course, the moment we started weighing time complexity against space complexity. It showed up again and again as I began reading papers, as a way of making sense of the world. If someone asked me today what engineering is — or made me pick a single word for it — I wouldn't hesitate.

I'd say: trade-off.

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/32

Lode Runner, Ultima, and a Samsung Tape Drive

Chaesang Jung — Sat, 27 Jun 2026 20:17:49 +0000

Before I studied computer science, there was a contest in Busan, a cassette that loaded games, and code I typed in from a magazine.

A look back — long before any of the tools we argue about now.

These episodes come from studying computer science in Korea in the 1990s. But the memory starts a few years earlier, with a handful of words from the 1980s.

A personal-computer contest

In 1985, my elementary school in Busan ran an after-school class to pick kids for a math competition. That year the regional district math contest happened to be discontinued, so the class was quietly converted into a computer class instead — and that's how I first met a personal computer, and the idea of a contest built around one. It was probably an early ancestor of today's programming olympiads. I got lucky: in 1986 I went up to Seoul for the first time, to a place called Jamsil, as one of Busan's representatives. Picture a large hall where each kid hauls in their own computer and sits an exam for four hours, a little like candidates at an old civil-service examination. To get there you had to win your way through the district round, then the Busan city round.

My first time out, a bug knocked me out — a real heartbreak. Trying to get past it, I took several more runs at the regional contests through the eighth grade, and along the way I picked up some real skill — and got a lot friendlier with computer games. I never made it back to the national round, but I climbed to first in the district at my last contest. A reasonably happy ending.

The Samsung SPC-1000

The first Samsung product in our house was this computer. I'd run into one at school, and after I earned the ticket to the national round in Seoul, I begged my parents until it followed me home. The strange mechanical whir of loading from a cassette tape; the games that started once the whirring stopped; the small charms of dots arranged across a black-and-white screen. It saw me through elementary school, came with me to every contest, and gave me my first taste of disappointment and failure.

Computer Study

This was the first reason I had to get — or earn — an allowance every month. There was a sister magazine too, Students and Computers, and some months I'd agonize over which of the two to buy; there were fancier books around, I remember. The content was a fair mix of fun pieces, new technology, and games. But what really mattered about this magazine was the source code. Typing those listings in, line by line, built a patience I didn't notice I was building — and it paid off later.

The Apple II+

I begged for a new one in middle school, ostensibly for the contests. I don't remember exactly which model it was — maybe a IIe. I loved the clack of that keyboard, and it's where I first stepped into the new world of the floppy disk. The contests were the pretext; honestly, I was one step from full game addiction.

Lode Runner, Ultima 4, Ultima 5, Ogre

The companions of my middle-school years. Lord British, thou art, and an endless vocabulary of game spells, ingredients, weapons, dragons…

After that I shifted into exam-prep mode, head down for college entrance, and that's how I walked into the 1990s.

Adapted from my Korean essay on Brunch: brunch.co.kr/@chaesang/30