First Principles

Thinking Like A Programmer Begins Long Before You Write Anything

Programming is not typing. It is the slow, learnable habit of breaking a wish into steps so small and so plain that a machine with no judgement at all can carry them out without guessing.

Most people arrive at programming expecting to learn a language, and they are half right. A language is the surface. Underneath sits something older and far more portable: the practice of turning a vague intention into an ordered set of unambiguous steps. That practice is what carries across every tool you will ever meet. If you learn only the surface, each new tool feels like starting again. If you learn the thinking, each new tool feels like an accent you have not heard before, strange for an afternoon and familiar by the evening. This publication is about the thinking. The site name is a small joke about a child object, an idea borrowed from the way programs describe things that inherit from other things, and that is the last we will say about it.

The first shift is accepting that the machine does not know what you want. It knows what you said. Every beginner discovers this the hard way, usually while staring at something that is obviously correct and obviously not working. The gap between the two is not a flaw in your character. It is the ordinary distance between an intention held loosely in a human head and an instruction that must be exact. Closing that gap is the whole job. Once you stop treating the machine as an adversary who misunderstood you on purpose, and start treating it as a very fast, very literal assistant with no life experience, most of the frustration drains out of the work.

The Machine Does Exactly What You Said

What You Meant Is Not What You Wrote Down

The single most common bug is a perfectly executed instruction that was never the instruction you intended to give.

A Computer Has No Common Sense To Lend You

Everything a person would obviously infer, the machine will not infer at all.

Tracing A Program By Hand, Slowly, On Paper

Running instructions in your own head, one step at a time, is the fastest way to build real understanding.

The Four Moves Everything Is Built From

Doing Things In Order, And Only Then

Sequence and condition are the first two moves, and almost every early mistake involves confusing one for the other.

Repeating Without Losing Track Of Where You Are

Repetition is the third move, and it demands two questions that beginners often forget to ask.

Giving A Chunk Of Work A Name So It Returns

The fourth move is naming, and it is the one that lets programs grow larger than a single mind can hold.

State And Change

A Value That Changes Is Where Confusion Begins

Most genuine bewilderment in programming comes from something that meant one thing earlier and means another now.

Why The Same Steps Give Different Answers Each Run

When behaviour changes between runs, something outside the instructions is participating in the outcome.

What Is True Before, And What Is True After

Reasoning about a step in terms of what holds on either side of it turns guesswork into something you can check.

Getting Unstuck

An Error Message Is Information, Not A Verdict

The machine is trying to help, in a flat and unfriendly register, and reading it properly saves hours.

Shrink The Problem Until It Cannot Hide Anywhere

The smallest situation that still misbehaves is worth more than any amount of staring at the large one.

Explain It Out Loud To Something Endlessly Patient

Describing the problem in full sentences forces the gaps in your own account into the open.

About Java Child

Java Child is a magazine about programming logic: the reasoning that sits underneath every language rather than inside any particular one. It exists because the usual entry point into this field is a tool, and tools teach dialect before they teach thought. Learn the dialect first and you acquire the ability to produce something that works without the ability to explain why. That is a fragile position, pleasant while things behave and unnerving the moment they do not. Learn the thinking first and the dialects become a matter of looking things up. The name is a small joke about a child object, an idea from the way programs describe things built upon other things, and it is a joke about programming only.

There is a deliberate constraint here: nothing on these pages contains any code. Not a line, not a fragment, not a keyword. This is not an aesthetic preference. A worked example in any particular notation invites you to copy the shape rather than absorb the idea, and shapes do not travel between tools while ideas do. By describing the reasoning entirely in ordinary language, the material stays true whichever direction you go afterwards. If a passage here feels harder than a demonstration would be, that difficulty is the point. You are being asked to build the model in your own head rather than borrow one that only fits somewhere else.

The intended reader is an adult at the beginning, patient enough to slow down and sceptical enough to test what is claimed. Nothing here assumes prior study and nothing here talks down. The material returns repeatedly to a handful of ideas because those ideas are genuinely the load bearing ones: state your intention plainly, recognise the four moves, respect what changes over time, and build a calm procedure for being stuck. Read a section, then put it aside and try to explain it to an empty room. The parts you cannot explain are the parts worth reading again, and there is no hurry about any of it.