Using chatbots wisely

If you have some basic background in programming, or even if you don’t, but want to get some then you can turn to chatbots and in particular to Windows Copilot (I’ll refer to it as Copilot for shortness). You can use Gemini, ChatGPT, Claude etc. if you prefer, and they’ll be as useful.
This is what I did just recently when I stumbled upon a post by Dave Plummer at X, where he talked about the need for programmers to understand how compilers produced their output, hence the need to know assembly language. By the way, Dave Plummer developed Windows Task Manager when he was a programmer with Microsoft . He has a YouTube channel where he posts interesting videos related to programming.

Why chatbots can be helpful in this case? First, if you didn’t program in assembly before it can be difficult to approach it. Second, chatbots are very helpful in explaining existing code in any programming language they had in their training data. And, I guess, it means it should know details about most modern programing languages.

Well, next I’ll provide a screenshot of that post, then I’ll show you that chatbot can transcribe the code from an image alone and explain what we are looking at there. The short summary is that post was about binary to ASCII (BTOA) conversion program written in PDP-11 computer assembly. By the way, all these details where extracted by Copilot from the code in the image.
Then, I’ve used Copilot to explain to me in detail how the code works to get full understanding of it.

Pay attention, that I use line separator to mark when the response from chatbot has finished.

Original post

I suppose there’s a whole class of programmers for whom a compiler is akin to magic, but knowing what’s getting emitted and how it works is fundamental to your success over the long haul. Write some assembly. Read the Dragon book on an airplane. AI will still be here when you get back. In five years, anyone capable of structured thought will be able to become a prompt engineer, but only 1% of software developers will actually be able to debug the stuff that comes out the other end. Be the 1%

What did I do next?

As I’ve mentioned I’ve copy and pasted the image in Copilot and asked it to transcribe the code from the image and explain what it’s doing.

Prompt:
Transcribe the code from the image and explain (an image was attached as can be seen in the screenshot below).
Response:

Below comes a full response.

Here’s the full transcription of the PDP-11 assembly code using MACRO-11 syntax, followed by a detailed explanation:
Transcribed Code

.TITLE  BTOA                ; Program title
.MCALL  .PRINT,.EXIT,.TTYOUT ; System macros

HELLOMSG: .ASCIZ /BTOA Example/

        .EVEN               ; Ensure we're on a word boundary

START:  .PRINT  #HELLOMSG
        MOV     #12345., R0 ; Number to convert
        JSR     PC, BTOA
        .EXIT

BTOA:
        MOV     R0, -(SP)   ; Save R0 on stack
        MOV     R1, -(SP)   ; Save R1 on stack
        MOV     R2, -(SP)   ; Save R2 on stack

        MOV     R0, R1      ; Move number to R1 (low part of dividend)
        CLR     R0          ; Clear R0 (high part of dividend)
        DIV     #10., R0    ; Divide R0:R1 by 10, quotient in R0, remainder in R1

        TST     R0          ; Check if quotient is 0
        BEQ     PRINT       ; If quotient is 0, print digit
        JSR     PC, BTOA    ; Recursive call with quotient

PRINT:  ADD     #'0, R1     ; Convert remainder to ASCII
        MOV     R1, R0      ; Move ASCII digit to R0
        .TTYOUT R0          ; Print the digit

        MOV     (SP)+, R2   ; Restore R2
        MOV     (SP)+, R1   ; Restore R1
        MOV     (SP)+, R0   ; Restore R0
        RTS     PC          ; Return

.END    START

🧠 Explanation

This program converts a binary number (in this case, 12345) to its ASCII decimal representation and prints it to the terminal.

🔹 Header and Setup

• .TITLE BTOA: Sets the title of the program.
• .MCALL .PRINT,.EXIT,.TTYOUT: Declares macros for printing, exiting, and terminal output.
• HELLOMSG: .ASCIZ /BTOA Example/: Defines a null-terminated string.
• .EVEN: Ensures the next instruction is aligned on a word boundary.

🔹 Main Routine (START)

• .PRINT #HELLOMSG: Prints the greeting message.
• MOV #12345., R0: Loads the number 12345 into register R0.
• JSR PC, BTOA: Calls the BTOA subroutine to convert and print the number.
• .EXIT: Ends the program.

🔹 Subroutine (BTOA)

• Saves registers R0, R1, and R2 to the stack.
• Sets up for division: moves the number to R1, clears R0 to form a 32-bit dividend.
• DIV #10., R0: Divides R0:R1 by 10. Quotient goes to R0, remainder to R1.
• TST R0: Tests if quotient is zero.
  • If yes, go to PRINT.
  • If not, recursively call BTOA with the quotient.
• PRINT: Converts the remainder (digit) to ASCII by adding '0', then outputs it using .TTYOUT.
• Restores registers from the stack and returns.

This recursive approach ensures digits are printed in the correct order (most significant to least significant). Would you like to see how this would look in C or another language for comparison?

Let’s try to understand how it works in more detail.

Question: First of all, what is BTOA?

Response:

Great question! 🧠

BTOA stands for Binary To ASCII. It’s a common abbreviation used in programming to describe the process of converting a binary (or numeric) value into its ASCII character representation, typically for display or output purposes.

🔍 What does “Binary to ASCII” mean?

• Binary: In this context, it refers to a numeric value stored in binary format (e.g., the number 12345 in machine-readable form).
• ASCII: The American Standard Code for Information Interchange — a character encoding standard that maps numbers to printable characters like '0' to '9', 'A' to 'Z', etc.

Okay, now that we know what that mysterious BTOA was how about we understand what happens inside this block of code that resides inside the BTOA function?

        MOV     R0, R1      ; Move number to R1 (low part of dividend)
        CLR     R0          ; Clear R0 (high part of dividend)
        DIV     #10., R0    ; Divide R0:R1 by 10, quotient in R0, remainder in R1

        TST     R0          ; Check if quotient is 0
        BEQ     PRINT       ; If quotient is 0, print digit
        JSR     PC, BTOA    ; Recursive call with quotient

Also, before jumping to Copilot for help we can see assembly language program that is doing some computation using registers in CPU such as R0 and R1. We can see the data is moved, cleared, a division is done and then there is a conditional logic on lines 5, 6 and 7. In the screenshot it corresponds to lines 22, 23 and 24.

So what is the explanation ?
Response:

This block of PDP-11 assembly code is the core of the binary-to-ASCII conversion logic. It performs division by 10 to extract digits from a number and uses recursion to print them in the correct order. Here’s a breakdown of each line:

🔍 Line-by-Line Explanation

18 MOV R0, R1 ; Move number to R1 (low part of dividend)

• Copies the number from R0 to R1.
• This sets up the 32-bit dividend for division: R0:R1 (high:low).

19 CLR R0 ; Clear R0 (high part of dividend)

• Clears R0 to zero.
• Now the full dividend is 0:R1, effectively treating the original number as a 32-bit value with high word = 0.

20 DIV #10., R0 ; Divide R0:R1 by 10, quotient in R0, remainder in R1

• Performs a 32-bit division of R0:R1 by 10.
• After this:

• R0 contains the quotient (i.e., number / 10)
• R1 contains the remainder (i.e., number % 10), which is the rightmost digit

22 TST R0 ; Check if quotient is 0

• Tests if the quotient is zero.
• This determines whether there are more digits to process.

23 BEQ PRINT ; If quotient is 0, print digit

• If R0 is zero, it means this is the last digit.
• Branches to PRINT to output the digit.

24 JSR PC, BTOA ; Recursive call with quotient

• If R0 is not zero, it means there are more digits.
• Recursively calls BTOA with the quotient in R0, continuing the process.

🧠 Summary

This block:

• Extracts the least significant digit of the number.
• Uses division and recursion to process digits from most significant to least significant.
• Ensures digits are printed in the correct order by printing only after recursion unwinds.

Conclusion

Well, I guess it clarifies a bit what the code is doing. And you probably got a point of how you can use a chatbot to help you understand a piece of code in a programming language you probably never saw and drill down to nitty gritty details of the implementation and really understand how it works.