Children's Nonfiction

So You Want To Be A Coder (Computer Programmer)

by Linda Soules

3,304 words (~17 min read) 21 min audio 32 views
So You Want To Be A Coder (Computer Programmer)

Key Takeaways

A coder translates human intentions into instructions a computer can execute; computers follow those instructions literally, so precision matters.
Programming is an iterative cycle of thinking, writing, running, reading results, and fixing problems. Planning carefully before coding can prevent tangled, unreliable programs.
Coders spend substantial time reading code, documentation, and other people’s work—not just typing new code. Clear reading and writing are central professional skills.
Programming is used across nearly every industry, from medicine and education to farming, entertainment, science, and space exploration.
The work can be joyful and creative: programmers solve puzzles, build tools for themselves and others, and may create software that helps people long after the work is finished.
Failure is a normal part of programming. Successful coders treat errors as information, stay patient, and learn to step away when a break may help them think.
There is no single required path into coding: beginners can start with free tools and courses, make small projects, learn from other people’s code, and build skills over time.
Effective programmers combine curiosity and logical precision with empathy, communication, patience, and comfort with not knowing everything.
Software is a team effort, relying on many specialties and on open-source contributions shared by programmers around the world.

Summary

So you want to be a coder: to type a few strange words into a quiet machine and watch a game, website, tool, or tiny piece of art wake up inside it. Programming can seem like a kind of magic, except this magic depends on exactness. Get a comma wrong and the spell may fail; get the instructions right and the computer can carry them out. A programmer translates human intention into machine action: first deciding what should happen, then expressing it in a language the computer can follow. The computer does not do what you meant if you have said something else. It does exactly what you wrote, and its response can show you precisely where your instructions went astray.

That translation underpins much of modern life. Medical records, weather forecasts, video games, traffic lights, music streaming, and messages on phones all depend on software. Behind nearly every screen, someone once decided what should appear there and wrote the instructions to make it happen. Programming offers unusual reach: code written once can run again and again, helping thousands of people over many years. A few hours of work might keep doing useful work long after the programmer has gone on to something else.

A coder takes a problem and turns it into code that solves it, but the work rarely proceeds in a straight line. You think, write, run the program, see what happened, and fix what went wrong. Then you run it again. The process repeats until the thing you wanted to exist actually exists. In practice, a programmer may run a program many times, discover a different problem each time, and adjust the code repeatedly. Professionals organize their work to make this cycle of writing, testing, and fixing as quick and effective as possible.

The work involves far more reading than many people expect. Programmers read other people’s code so they can change it without breaking it; they read their own old code, which they may no longer remember clearly; and they consult documentation for tools other people built. Patience and precision matter because understanding what a program already does is essential before changing it. Design is just as important. Before typing, a good programmer thinks about what the program should do, what information it will need, who will use it, and what should happen when something breaks. The typing is often the easy part. Tangled, unreliable programs can result when coding begins before the problem has been thought through.

Programmers can work almost anywhere with a laptop and an internet connection: at home, at a kitchen table, in a cafe, or in an office where teams gather around shared problems. Their desks might hold souvenirs from old projects, such as model spaceships, rubber ducks, stickers, or plants that have survived several computer upgrades. And they can work in nearly any industry. Hospitals, schools, banks, farms, factories, scientific laboratories, game and movie studios, music companies, space programs, and government agencies all need software. Wherever computers are used, someone has written code for them. That makes programming a way to solve problems in many different fields, not just technology companies.

A programmer’s main writing space is a text editor, sometimes called an IDE, or integrated development environment. It resembles a word processor, but it can color-code parts of the code, flag a typo, suggest what to type next, and help someone move among thousands of files. Programmers spend much of their working day inside this digital cockpit. The terminal provides another way to control the computer: in a text-only window, the programmer types a command and the computer follows it. The terminal may look old-fashioned, but it remains a fast and precise tool.

Version control keeps a record of changes to every file in a project, including when each change was made. Git, the most common version-control tool, lets programmers find earlier versions and undo a change that caused trouble. It also helps hundreds of people work on the same code without overwriting one another. A debugger helps locate problems by pausing a running program, showing the values of its variables, and letting the programmer move through the code one line at a time. It can reveal the point where what the program is doing stopped matching what the programmer expected.

One of the job’s great pleasures comes when a difficult program finally works. After hours, days, or even weeks of attempts, a run that once more seemed likely to fail suddenly shows exactly what should be on the screen. That small triumph is part of what draws programmers back to their work. They also have the power to build tools for themselves. If a repetitive task is annoying or slow, a programmer may be able to write a tool to handle it that very afternoon. Programming is intellectual play: bugs become small detective cases, features become design puzzles, and a hard problem can absorb the mind so completely that time seems to disappear.

There is satisfaction, too, in seeing a stranger use something you helped build: someone on the street using an app, a child playing a game, or a person in another country writing to say that a free tool helped with a school project. A programmer may never meet most of the people their work serves, but the help is real.

The difficult part is that much of programming consists of things not working yet. You write code and it fails; you read documentation, search for information, ask for help, and gradually narrow down the cause. Fix one problem and another may appear, sometimes in a part of the program that seemed unrelated. This is not a flaw in the profession but an ordinary part of it. The sustainable response is to treat failure as information rather than as a personal insult. Taking each error personally can wear a programmer down; approaching it as a clue makes it easier to keep going.

Programming is also sedentary: the body sits still while the brain works hard. Walks, stretching, enough sleep, and time away from a screen are practical parts of the work. A bug that has resisted hours of effort may become easier to solve after a walk outside. The field changes constantly, too. Languages and frameworks rise and fade, so programmers keep learning throughout their careers. And sometimes the day’s effort is invisible: the programmer may untangle code, simplify a mess, or prevent a future disaster without changing anything users can see.

A workday may begin at 9:30 with a standup: a brief check-in where teammates say what they did yesterday, what they plan to do today, and what is getting in their way. You might mention that a data migration is proving harder than expected, and a teammate may offer to help after lunch. The meeting is short, but it helps everyone understand where the work stands and where someone might need support.

At ten, you settle into coding. The code editor and test window are open, headphones are on, and the morning offers a chance for concentrated work before messages and interruptions accumulate. You may become so absorbed in a problem that two hours pass unnoticed. Then it is lunchtime. A walk around the block can help loosen a stubborn thought; sometimes the answer to the morning’s bug arrives when you are no longer staring at it.

After lunch comes code review. A teammate has finished a feature, and you read their code carefully, looking for mistakes and places where the work could be clearer. This can be harder than writing code yourself: careful reading takes time, and useful feedback must be thoughtful. But code review catches problems early, helps the team learn, and spreads good habits through a project.

At three, you might pair program, working with another coder at the same computer and taking turns at the keyboard. The two of you notice different things: you catch what your partner overlooks, and they catch what you miss. It may feel slower than working alone, yet the result is often better, and each person learns from the other. Later, once a feature works, you write documentation: a README, an explanation of a function, or notes that tell your future self what the code is doing. Clear explanations are a generous gift to whoever has to work with that code next. At 6:30, the workday ends. Some evenings, though, a programmer may return to a quiet personal project, building something no one assigned simply because curiosity will not let the idea go.

Programmers rarely create real software alone. A team brings together people with different responsibilities. Front-end developers shape what users see and touch; back-end developers build the engines and databases underneath. Designers consider how a product should look and feel, while product managers decide what should be built next and why. Quality-assurance engineers, or QA, deliberately try to break the software so problems can be found before users encounter them. DevOps engineers keep servers running and software releases smooth. Technical writers explain the system in documentation that people outside the coding team can understand. These roles fit together: a good product depends not only on code, but on people who can plan, test, explain, and maintain it.

The team also reaches beyond the people in the same office or video call. Around the world, programmers contribute to open-source projects, sharing software that anyone can use, study, or improve. Much of the language and many of the tools a coder relies on were built by strangers who chose to share their work. A programmer’s own code may become one more useful building block for someone they will never meet.

That work can help far more people than the programmer sees. Hospitals and schools rely on software, and code has helped scientists design and test medicines. Some AI programs can predict the shape of a protein in seconds, work that once took scientists years. Buildings are designed with software; food is tracked, packaged, and delivered with it. Nearly every kind of profession depends on digital tools: astronauts need spacecraft systems, doctors use patient records, paleontologists analyze data, teachers manage grades, and veterinarians examine images. When a programmer makes a good tool, they increase what its users can do. And the help can continue long after the programmer has left the project: the software keeps sorting, checking, and calculating for people who need it.

Certain qualities make this work easier to sustain. Patience with failure matters because programs often do not work on the first try. A coder who can treat a failed test as information rather than an insult can investigate it and keep moving. Curiosity is another essential quality: the urge to ask why a website loads in a particular way, why one game feels different from another, or why a piece of code behaved unexpectedly. Curiosity keeps questions coming, and questions lead to learning.

Logical precision is central because a computer follows the instructions it receives, not the intention behind them. A coder must notice what they actually told the machine and where their instructions leave room for error. Empathy also has a practical role. Code is often read more times than it is written, and the next person opening a file may be confused. Keeping that future reader in mind—whether a teammate or yourself months later—can mean leaving code clearer and kinder than you found it. Finally, a programmer needs comfort with not knowing. The field is too large for anyone to know everything. Being able to say, “I don’t know yet, but I’ll find out,” without embarrassment makes it possible to keep learning.

Some important skills might not sound like programming at all. Writing is part of the job every day: coders write comments, documentation, messages about changes, and notes to teammates. Naming a function well or explaining a difficult idea in a few clear sentences can make a project easier to use and maintain. The keyboard is for sentences as well as code.

Communication also means translating between people who understand the software and people who do not—doctors, teachers, designers, executives, or customers. A programmer needs to explain a technical choice in plain language, listen carefully to what another person needs, and notice when the requested solution does not match the real problem. And there is the skill of stepping away. Walks, sleep, meals, and time away from a screen are not wasted time; they can help a tired mind find a way forward. Knowing when to pause can be part of solving the problem.

The history of programming includes people who imagined what computers might become before the machines could fulfill their ideas. In the 1840s, Ada Lovelace met inventor Charles Babbage, who was designing a mechanical calculating machine called the Analytical Engine. Lovelace understood the design unusually well. In notes published in 1843, she described the first algorithm written specifically for a machine to run: a sequence of steps for calculating with the Engine. She also saw beyond arithmetic, predicting that machines might work with music, words, images, and anything that could be represented with symbols. The Engine was never built during her lifetime, and her algorithm waited a century for a computer to run it. She is widely remembered as the first computer programmer.

Grace Hopper devoted her career to making computers easier for people to use. After joining the U.S. Navy during World War II, she argued that programmers should not have to speak only in a computer’s numerical language. In the 1950s, she built one of the first compilers, which translates human-readable instructions into machine code, and helped create COBOL, a language still used in much of the world’s banking. Hopper also made an abstract idea tangible: she carried short pieces of copper wire, each 11.8 inches long, the distance light travels in a billionth of a second. She used them to help audiences picture a nanosecond. She retired from the Navy as a rear admiral at seventy-nine.

Margaret Hamilton led the MIT team that wrote the onboard flight software for the Apollo missions. She coined the phrase “software engineering” when many people still doubted that software work counted as engineering. During Apollo 11’s lunar landing, alarms sounded as the computer was asked to do too much. Hamilton’s team had designed the code to discard less important tasks and preserve the work needed for landing. The astronauts touched down safely. A famous photograph shows Hamilton standing beside a stack of code printouts taller than she is. Tim Berners-Lee, meanwhile, grew up with parents who worked on an early computer and built his own from an old television and spare parts. As a scientist at a Swiss research lab, he proposed linking information across computers by clicking. In 1989, he wrote the code that became the World Wide Web. He could have sold it, but gave it away for free, allowing anyone to use it.

Programming reaches beyond the devices people see. Engineers on Earth still send commands to Mars rovers, where signals travel for many minutes before a car-sized machine turns its wheels in the dust. The word “bug” was already used for engineering glitches in Thomas Edison’s time; in 1947, a team found an actual moth inside an early machine and taped it into their logbook as the “first actual case of bug being found.” Voyager 1, launched in 1977, carries code so small it could fit on a modern thumbnail-sized memory card, and that code is still working more than fifteen billion miles from Earth. Code also protects online messages and purchases through encryption, and breaks messages into packets that can travel by different routes before being reassembled. The first programmers of ENIAC, the first general-purpose electronic computer, were six women who had been hired during World War II to calculate artillery trajectories by hand.

There is no need to wait for permission, expensive equipment, or complete confidence before trying programming. A free place to begin is Scratch, a visual tool for young people in which blocks snap together to make games, animations, and stories. Many professional programmers began there. Python is a common next step: its code reads relatively like English, and free beginner tutorials are widely available. The key is to make things, even when they are clumsy. A small finished project teaches more than a grand idea left unfinished. Start with a calculator, a sortable list of favorite books, or a guessing game; complete it, learn from it, and then try something a little more ambitious.

Other people’s code can be a useful teacher, even when most of it is confusing at first. Open-source projects make their code public for anyone to read, use, and improve. Free lessons are available from Code.org, Khan Academy, and freeCodeCamp, while many libraries host coding clubs. Practicing typing can help remove a small but real obstacle. Projects can also be more fun with others: beginner-friendly hackathons bring teams together to build something over a weekend, and local Code Clubs or CoderDojo groups offer chances to learn in a room with other young programmers. Sharing a Scratch project lets other people try it and remix it. Girls Who Code and Black Girls CODE offer clubs, programs, workshops, camps, and other support for young learners.

The right question is not whether you already know enough to begin, but whether the work sounds interesting. Do you enjoy puzzles, especially figuring out why something has gone wrong? Are you curious about how websites, games, apps, or even appliances work? Do you get ideas for things you wish existed? Can you stay with one problem, tolerate mistakes, and keep looking for an answer? You do not need to match every quality on the list. Even a few may be reason enough to try. Programming does not require a single approved route or a person who knows everything in advance; learning means asking questions, looking things up, and building skill a little at a time.

A small vocabulary helps make the field easier to explore. An algorithm is a step-by-step recipe for solving a problem. A bug is an error, not proof that the programmer has failed; debugging is the work of finding and fixing it, sometimes by explaining the problem aloud to a rubber duck. A compiler translates readable code into instructions a computer can run. A function is a reusable piece of a program designed to do one job, while a loop tells the computer to repeat instructions. A variable is a named container for information, such as a number or word. Open-source software is shared publicly so people can read, use, and improve it. These words describe tools and ideas that become familiar through practice.

For anyone eager to continue, the book points toward more places to explore. Linda Liukas’s Hello Ruby introduces computational thinking through a picture-book adventure, while Ada Lovelace, Poet of Science and Grace Hopper: Queen of Computer Code tell the stories of two pioneers. Coding Games in Scratch offers step-by-step projects, and Python for Kids provides hands-on practice with real code. Online, Scratch supports block-based projects; Code.org offers free courses; Khan Academy includes Python lessons that run in a browser; and Code Club Projects supplies guides in Scratch, Python, and web design. The invitation is practical: find a club, try a course, or make something you can share.

Programming, the author suggests, is a kind of writing: precise, compact, and capable of beauty when every part is doing its work. Learning to write for a machine can also strengthen writing for people, teaching clarity and the habit of breaking difficult ideas into smaller ones. The first creation need not be good, useful, or impressive. It only needs to be yours. Make it small, finish it, and then begin another. Every programmer started with curiosity, an empty screen, and the brave first act of typing a line.

Chapter Summaries

1
What If You Were a Coder?

The book introduces programming as a kind of carefully spelled “magic”: a person writes instructions, and a computer brings a game, website, tool, or other idea to life. A programmer acts as a translator between what people want and what a machine can do. Because computers take instructions literally, a tiny mistake can make the result fail—and a precise description can make it work exactly as intended. Programming also underlies much of modern life, including medical records, forecasts, traffic systems, entertainment, and messaging. Its reach is unusual: code can be written once and used repeatedly by people all over the world. The work therefore offers young readers a chance to build things that may help many people, even if the creators never meet those users.

2
What Coders Do, Where They Work, and Their Tools

A coder turns a problem into a program through a repeated cycle: think, write, run, observe what happened, and fix what did not work. Much of the craft is not typing but deciding what a program should do, what information it needs, and how it should respond when something goes wrong. Reading is equally important: programmers study their own old code, teammates’ code, and documentation so they can make changes without breaking existing work. Programmers work in homes, offices, cafés, and organizations across nearly every industry. Their toolkit includes an editor or IDE for writing and navigating code; a terminal for issuing text commands; version control, especially Git, for tracking and reversing changes; and a debugger for inspecting a running program one step at a time. These tools help individuals and teams work efficiently while making mistakes easier to find and undo.

3
The Rewards and Challenges of Programming

One of programming’s strongest rewards is the moment a stubborn program finally works after repeated attempts. Coders also have the unusual ability to build tools that remove frustrations from their own work, and they can experience deep concentration—often called flow—while solving a difficult problem. The satisfaction can extend beyond the screen: a programmer may encounter a stranger using an app or game they helped create and see the real-world value of their work. The book is candid that failure is not an occasional interruption but a normal feature of the job. Bugs, confusing documentation, and unexpected side effects require persistence and a willingness not to take every setback personally. Programming is sedentary, the field’s tools and languages keep changing, and useful work may be invisible when it consists of simplifying or preventing problems. Walking, resting, and continuing to learn are presented as practical parts of a sustainable career.

4
A Day in the Life, the Team, and the People Software Helps

A sample workday shows that professional coding involves much more than solo programming. A developer might begin with a short team check-in, spend the morning focused on a problem, discuss a bug during a walk, review a teammate’s code, and pair-program on a shared task. Documentation at the end of a project helps colleagues—and the programmer’s future self—understand how the software works. Personal projects can also provide a space to follow curiosity outside assigned work. Software teams bring together front-end and back-end developers, designers, product managers, quality-assurance engineers, DevOps specialists, and technical writers. They also rely on open-source tools built and shared by people around the world. Good software can save time and strengthen the work of doctors, teachers, scientists, and many others. Since a program may keep helping users long after its creator has moved on, coding can multiply the impact of a person’s work.

5
The Qualities and Unexpected Skills of a Coder

The book highlights patience with failure, curiosity about how things work, logical precision, empathy for future readers, and comfort with not knowing. Computers do exactly what they are told, making it essential to notice when an instruction is unclear or does not match the intended result. Curiosity keeps programmers investigating, while patience and humility help them continue learning in a field too large for anyone to know completely. Several less obvious abilities matter, too. Programmers write comments, documentation, change messages, and explanations, so clear writing is valuable alongside technical skill. They must communicate across the gap between technical and nontechnical colleagues, listening carefully to understand what people actually need. Knowing when to take a walk, rest, or look away from a screen also supports better problem-solving and healthier work.

6
Famous Coders and Surprising Facts

The historical profiles show how programming developed through people who expanded what machines could do. Ada Lovelace wrote an algorithm intended for Charles Babbage’s Analytical Engine and imagined that machines might eventually work with music, words, and images. Grace Hopper helped develop compilers and COBOL, making computers easier to instruct. Margaret Hamilton’s team wrote Apollo flight software designed to prioritize essential tasks during the lunar landing, while Tim Berners-Lee created the World Wide Web and made it freely available. The book connects that history to the hidden reach of code today. Programs guide Mars rovers and keep Voyager 1 operating far from Earth; encryption protects private information, and network packets let messages travel in pieces before being reassembled. It also notes that “bug” was already an engineering term before a real moth was found in an early computer, and that women were among the first programmers of ENIAC. Together, these stories reveal programming as both practical engineering and a field shaped by creativity, collaboration, and sharing.

7
Getting Started and Deciding Whether Coding Fits

Young readers are encouraged to begin with Scratch, where visual blocks can be combined to make games and animations, and then try Python, a beginner-friendly text-based language. The book recommends free learning options such as Code.org, Khan Academy, and freeCodeCamp, as well as coding clubs and libraries. Rather than waiting until they feel fully prepared, beginners should make small projects, finish them, read other people’s code, and practice typing. The self-check asks whether readers enjoy puzzles, wonder how everyday things work, can stay with a problem, and are willing to fail and try again. A short list of questions—what the code does step by step, what the simplest working version might be, and what could go wrong—models the practical thinking coders use. The overall advice is to start small and complete something: a simple game, calculator, or sortable list can teach more than an ambitious project left unfinished.

8
Words, Resources, and the Author’s Invitation

A glossary explains foundational terms such as algorithm, bug, compiler, debugging, function, loop, open source, and variable. These definitions introduce the basic ideas behind programs: instructions arranged into steps, reusable pieces of work, repeated actions, stored information, and the process of locating and correcting errors. The suggested books, websites, clubs, and organizations give readers concrete ways to continue learning and find a community, including Scratch, CoderDojo, Girls Who Code, and Black Girls CODE. In the closing note, Linda Soules describes programming as a form of writing for a reader that takes language completely literally. Learning to write precise instructions can also make a person a clearer writer and thinker in other parts of life. Her central invitation is simple: make something of your own, however small or imperfect, finish it, and then try another. The book frames curiosity and the courage to type a first line as the beginning of a possible career.

Notable Quotes

A programmer is a translator. Not between human languages — between human intention and machine action.

Programming is mostly thinking. The typing is the easy part.

The willingness to fail many times an hour — and to take it lightly rather than personally — is the habit the whole job rests on.

The job is not knowing all the answers. The job is being good at finding them.

The keyboard is for sentences as much as for code.

A finished tiny project teaches more than ten unfinished ambitious ones.

The work goes home; the help stays.

Start small — smaller than feels worth doing — and finish it. Then start the next one.

Who Should Read This

This book is ideal for curious readers, especially children and teens around ages 10–14, who enjoy puzzles, games, apps, or wondering how technology works. It is also useful for parents, teachers, librarians, and mentors looking for an approachable way to discuss computer programming without presenting it as only a technical subject. Readers get a realistic picture of the daily work, the frustrations as well as the rewards, the people and tools involved, and practical ways to begin coding with free resources and small projects. Unlike a programming textbook, this is a career exploration book: it focuses on what coders do, how their work fits into teams and society, and which personal qualities can help someone thrive. Its emphasis on patience, communication, clear writing, and learning through mistakes makes it a useful companion to hands-on introductions such as Scratch or Python courses. It is especially encouraging for beginners who assume they must already be an expert—or have special credentials—before they can start.