← VCC Plus product guide

Inside VCC Plus / Assembly Development

Assembly, close to the machine

Turn an instruction into a visible result. Write for the 6809 or 6309, assemble a program, stop at its entry and follow the bytes that reach the screen.

Choose the processor you are writing for

Assembly language gives names to the instructions a processor executes. Where BASIC might print a string and C might call a function, assembly lets you follow the loads, stores and branches that make the result happen.

Develop → Assembly Development… opens the workspace. Use File → Open Source… for one source file or Open Project Folder… for a larger program. A single file is enough for a first experiment. A linked project can combine modules and a linker script when you need more structure.

Set Target before assembling. An MC6809 program uses the instruction set understood by both the emulated Motorola 6809 and Hitachi 6309. A program using 6309-only instructions needs an HD6309 target and the Hitachi processor selected in the running machine. Your Mac’s Apple Silicon or Intel architecture is a different choice from the CoCo processor being emulated.

Changing the guest processor cold-restarts the machine, so save valuable guest work first. The editor target and the machine configuration each have a job: one determines which instructions the build accepts; the other determines which processor will execute them.

Give one instruction a visible purpose

A useful early exercise stores a character in text-screen memory. Instead of asking only whether the whole program “works,” ask which instruction chooses the screen cell and which instruction chooses its contents. Change the address by one cell, assemble again and compare the output.

That small experiment connects several ideas: a register holds a value, an address identifies a destination, and a store changes memory. A register update may produce no visible screen change at all. The display changes when the program reaches data or hardware that affects it.

The installed Your First 6809 Programs provides a guided first path. Assembly Language Programming goes further into the instruction set, graphics, interrupts and the machine’s memory organization. Start with the beginner book if mnemonics and hexadecimal addresses are new; use the deeper book as your project begins to ask those questions.

Assemble, then inspect the result

Choose Assemble to create the binary and its associated build information. Read Build details for the listing and diagnostics. Select a diagnostic to go to the corresponding source location. A successful assembly establishes that the tools accepted the source and produced an artifact; it does not yet establish that the logic behaves as intended.

A listing is especially valuable in assembly because it connects source instructions with emitted bytes and addresses. If a branch lands somewhere unexpected, those details let you compare what you wrote with what is actually in the machine. Keep the listing with the build you are investigating.

Use Run to start the program normally. Use Debug from Entry when you want to stop at the first instruction rather than chase a program after it has begun. The difference is helpful for short routines: by the time you manually pause them, they may already have returned to BASIC.

Make a stop mean something

Select an executable source instruction and choose Set Stop. Continue runs toward that stop. Step executes an instruction so you can examine the next machine state. The program counter and registers let you follow the work even when the screen remains unchanged.

Try to predict one register before stepping. For a load, which value should appear? For a store, which byte should change? For a conditional branch, which condition decides where execution goes? Inspecting a single before-and-after pair is often more instructive than stepping a long program without a question.

Source stops in the native assembler-and-linker workflow can be checked against the assembled bytes. That verification matters: a source line, a symbol name and an address from an old build should not be treated as interchangeable evidence. Reassemble after an edit and make sure the stop belongs to the program now loaded.

When you need to inspect a custom-built binary without that same source-stop evidence, use the machine debugger. Disassembly and address breakpoints still let you examine the executing code at the CPU level.

Organize a multi-file program

Project Settings… explains the project settings file and the inputs it names. A linked project can specify a main source, additional modules and a linker script. This keeps the relationship between source modules and the final address layout explicit rather than relying on an undocumented sequence of commands.

A custom Makefile project identifies its recipe, target and output binary. The app asks before running that recipe. Make can execute commands on your Mac, so use a recipe you understand and keep required support files within the reviewed project scope.

The native assembler route and a custom recipe are useful for different starting points. A new teaching program can use the built-in workflow. An existing project can keep its own build organization. Do not assume the custom route automatically supplies every debugger capability of the native verified route.

Editor search and replacement work as they do in BASIC and C. Find an instruction label, inspect all its uses and review replacements before assembling again. A textual match in a comment is different from a label reference even if the search highlights both.

Export something another CoCo can load

Export Binary… keeps the built program for later quickloading. Export Disk Image… places a named binary on a CoCo disk and displays the command needed to load and execute it. That command is part of the useful output: the person receiving the disk should not have to infer its entry point from a filename.

The disk export can also Install DOS bootloader, giving the disk a DOS startup route. This workflow targets a BASIC machine. An OS-9 executable has a different format and should follow an OS-9 build and loading path rather than being assumed equivalent because both contain machine code.

A disk file, the binary inside it and the source used to create that binary are separate artifacts. Keep the source and the relevant build configuration so you can reproduce a correction later. Keep a writable copy of test media when the program also saves data.

Add a collaborator without losing the instruction-level view

File → Local Assistant Access… can share the intended assembly document or project with ChatGPT. Ask for a small edit with a specific observable effect: move one cell, change a color, alter a branch or explain a register transition. Review the proposed source and assemble the current revision before testing it.

The strongest conversation stays attached to the actual program: which target was assembled, which instruction changed, which binary ran and what the machine showed. A plausible explanation from an assistant is a starting hypothesis. A verified stop, register value or framebuffer result helps test it.

The AI coding guide explains the connection and review choices. You can move between that collaboration and direct source inspection while keeping assembly’s distinctive advantage: the machine’s work is close enough to follow one instruction at a time.

Your next discovery

Choose the next part of your workbench.

Explore the machine, the development tools, and the books that connect them.

Back to the product guide
A closer look

Open original