Beagle Bros Two-Liners: A Coding Magic Trick

One of the things I miss most about the Apple II era is how much personality surrounded the machine. The Apple II was not just a computer you used – it was a computer you explored. You typed things into it, made mistakes, and discovered strange memory locations. Apple II users learned that a single POKE could change the way the screen behaved, make a sound, or unlock some odd little behavior that felt like you had found a secret passage inside the machine.

And nobody made that feeling more fun than Beagle Bros.

Beagle Bros.?

Beagle Bros had a very specific kind of genius. Their software and publications were useful, yes, but they were also funny, strange, stylish, and playful. They made Apple II programming feel less like homework and more like joining a secret club of clever people who knew how to make the machine dance.

Some of my favorite Apple II disks came from Beagle Bros. I loved DOS BOSS, which let you modify DOS commands and create your own custom commands. That idea was thrilling. The Apple II suddenly felt personal. You were not just using the operating system as delivered, you were bending it a little, renaming things, making it yours, and adding a bit of personality to the command line.

DOS BOSS diskette by Beagle Bros

Then there were the Beagle Bros posters, especially the ones filled with PEEKS, POKES, and CALLS. I had those on my wall as a reference for Apple II BASIC programming. If you were writing Applesoft BASIC, those charts were like having a wizard’s spellbook hanging above your desk. You could glance up, try a command, and suddenly the machine would do something new.

Two Liners

But my absolute favorites were the Beagle Bros Two-Liners. The name says it all, but it almost does not do them justice.

A Two-Liner was a complete Applesoft BASIC program squeezed into just two numbered lines. Not two short lines in a modern editor. Two Apple II BASIC program lines, packed with commands separated by colons, clever math, graphics routines, sound tricks, strange control flow, and sometimes outright mischief.

List 1 – Moonshot: Guess the launch power from 1 to 9. You get 5 tries.

10 HOME:N=INT(RND(1)*9)+1:W=0:PRINT"MOONSHOT":PRINT"FIND POWER 1-9"
20 FOR T=1 TO 5:INPUT"POWER";G:W=W+ABS(G=N):PRINT MID$("TOO HIGH! TOO LOW! BLASTOFF! ",1+10*ABS(G<N)+20*ABS(G=N),10):NEXT:PRINT MID$("MISSION FAILYOU REACHED ",1+12*ABS(W>0),12)

Moonshot listing and running on the Virtual ][ emulator

Tiny programs with big personalities

A good Two-Liner might draw a hypnotic hi-res graphics pattern. Another might make the disk drive chatter like a train. Another might create a little game, animation, puzzle, or oddball visual effect.

The point was not just to save space. The point was to see how much creativity could be compressed into the smallest possible form. That was the Beagle Bros magic.

The Two-Liners were funny, but they were also deeply educational. They taught you how Applesoft BASIC really worked. You learned how to chain statements with colons. You learned how FOR/NEXT loops could be squeezed into tight spaces, how expressions like ABS(A=B) could turn a true-or-false comparison into a usable number. How PEEK and POKE could reach outside ordinary BASIC and touch the Apple II hardware directly.

In other words, the Two-Liners taught programming through surprise.

That was very different from the dry way programming was often presented. A typical manual might explain a command, show a simple example, and move on. Beagle Bros did something better. They gave you something cool first. You would type in a tiny program, run it, and see something unexpected happen. Then, because the program was so short, you could actually study it.

Every character mattered, each shortcut had a reason and a simple colon was doing work – the code even invited you to reverse engineer it.

List 2 – “Treasure Map” Two-Liner: Guess the hidden treasure’s coordinates. Try to get close.

10 GR:X=INT(RND(1)*40):Y=INT(RND(1)*35):S=0:PRINT"TREASURE MAP":PRINT"FIND THE HOT SPOT"
20 FOR T=1 TO 6:INPUT"X";A:INPUT"Y";B:C=ABS(A-X)+ABS(B-Y):COLOR=1+14*ABS(C<5):PLOT A,B:S=S+ABS(C<5):PRINT MID$("COLD!HOT! ",1+5*ABS(C<5),5):NEXT:PRINT MID$("LOST!FOUND",1+5*ABS(S>0),5)

For a young programmer, or even just a curious Apple II user, Beagle Bros made experimentation feel safe and exciting. You did not need to build a giant program to feel like a programmer. You could type two lines and produce a visual effect. Learn one new POKE and feel like you had unlocked a hidden feature. Customize DOS commands with DOS Boss and realize that the computer was not fixed in stone. It was flexible, waiting for you.

The Two-Liners also represented a very specific kind of programming challenge. Today we might call it code golf, creative coding, or the demoscene spirit. But on the Apple II, it felt more homespun. It was not just about being clever for cleverness’ sake, but rather about understanding the machine so well that you could make something delightful with almost nothing.

That is why the Two-Liners still have charm. For me, that is the real legacy of Beagle Bros. They made learning code feel cool.

DOS Boss made the operating system feel customizable. The PEEKS, POKES, and CALLS posters made the Apple II’s hidden world visible. And the Two-Liners showed that programming could be playful, compact, surprising, and beautiful.

They were not just tiny programs. They were little invitations: Type this in. Run it. Laugh. Wonder. Change it. Break it. Fix it. Learn.

That was Beagle Bros at their best.

William W. Winter is the creator of Text Adventure Studio, where you can try your hand at making text adventures with a modern web-based design tool, and you can try it out and make your own text adventures for free at https://textadventurestudio.com. Old School Gamer Magazine readers can sign up for a free account. More articles from William can be found here.

The post Beagle Bros Two-Liners: A Coding Magic Trick appeared first on Old School Gamer Magazine.