In this exciting episode of not learning asm by working through a book called, The Art of Assembly Language, we write the program linked below, which features a string that we input, that is copied to another string by reference.

In chapter four, Hyde introduces a variety of data types and declarations,
including how to declare and use constants, scalar variables, integers, reals,
“data types”, pointers, arrays, records/structures, unions and namespaces.

Early in the book, Hyde asserts that there are performance benefits to working with data that is aligned on word boundaries. In today’s reading, he proves it.

Today’s adventures in assembly are all about the importance of memory alignment for variable storage. Apparently, if you believe things on the internet, all modern processors read memory segments on word boundaries. Therefore, if you want to maximize efficiencies of accessing data in memory, you should declare your variables so that they align on word boundaries.

Following the packed data treatment, Hyde moves into a discussion of floating point arithmetic and the shortcomings of trying to perform infinite precision arithmetic, that is to say, math where there are an infinite number of numbers between say zero and one.

mov ( $1234_5678, ebx ); copies the hexadecimal value 0x1234_5678 into the ebx register.

Today’s adventures in asm, courtesy of Mr. Hyde, have me packing dates of the form mm-dd-yy, cough (terrible), into a one and two byte locations in memory (al and ax and possibly other non-register locations, it’s a bit opaque to me at this point). Ultimately everything fits into two bytes, though at first glance it may seem like more would be required.

Today’s reading included bits about twos complement and how numbers may be signed or unsigned. This seems wrong to me. Unsigned numbers have a sign, all of them are positive. Signed numbers have both positive and negative numbers. There are no unsigned numbers, only mixed signed (pos and neg) and positively signed only.

Today marks hitting some new material on the quest to learn asm. I vaguely recall dealing with sign and zero extension before, at least conceptually, but I don’t recall having learned the instructions for these concepts.

That’s all I got today, logical operators – AND, OR, XOR and NOT.

Today I learned or maybe learned again a long forgotten algorithm for converting decimal numbers to binary, courtesy of Hyde’s The Art of Assembly Language.

If you want to put AI or machine learning somewhere, put it in my command line interpreter so it can do what I mean, not what I say.

Just getting started down the path of learning asm. I’ll be documenting my journey here. I’m using Randall Hyde’s book The Art of Assembly Language, which teaches asm via Hyde’s own creation, High Level Assembly. Let’s see how it goes.