Computing Pioneer Who Invented the First Assembly Language Dies at Age 100 - Slashdot

2022-11-08 01:19:00 By : Ms. Selena wong

Follow Slashdot blog updates by subscribing to our blog RSS feed

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way. Level Shifter Uart

Computing Pioneer Who Invented the First Assembly Language Dies at Age 100 - Slashdot

Surely age 0x64 or perhaps 064H

On second thought, given the era, 0144.

Her first assembly language was presented in this paper: https://albert.ias.edu/bitstre... [ias.edu]

She only uses decimal and binary, no hexadecimal or octal! In fact she used Binary Coded Decimal, with 1 bits per digit on a paper tape, complete with examples of the holes that need to be punched. By then BCD was already well established for use with mechanical tabulators and the like, on punched cards or tape.

You can see that she never writes numbers in her assembly code, except where they are implicit in the instruction (such as incrementing a register). All the code is generic algorithms, with data read from tape into memory before hand.

This is Slashdot. For once the jokes [slashdot.org] are both funny (relatively - for nerds) and respectful. Which is kind of sweet.

I have actually done some programming directly in machine code (very little). Assembly is a huge step up and represents an even bigger shift from directing a machine's actions to a fine grained expression of program logic.

it's just assigning pneumonics to numbers. I don't see how this is really all that different than just the substitution of abbreviations for operations. machine: A9 assy: LDA description: Load Accumulator It's just finding a middle ground between description and machine code, something that's shorter but still easily recognized. Like a nickname.

And yes I've coded in assembly, and machine, and microcode. (all self-taught) The only slightly off thing is that (in the example above) "LDA" can represent several o

Leaving it to the assembler to choose the correct variant as well as having labels represents a shift towards semantic programming. Perhaps not huge in the overall scheme of things but huge from the standpoint that it was the first step. It also represented a particular and useful more abstract view of the processor and it's instructions.

I'm not so sure any potential for bugs arising from a single mnemonic representing multiple opcodes outweighed the programmer choosing the wrong opcode variant himself.

The best part about assembly vs machine code: labels! Insert or remove code and the assembler recalculates the (relative and absolute) jumps for you.

The best part about assembly vs machine code: labels! Insert or remove code and the assembler recalculates the (relative and absolute) jumps for you.

Maybe that is why in some languages, assembly language is called "symbolic address language". People who named it that way did recognize the major advantage of that.

Symbolic addressing: alpha names or small-space number codes for branch/jump destinations, is the greatest payback for stepwise development. Memory constraints were severe and assembler capabilities grew as memory sizes and machine cost targets increased enough to permit more complexity in the assembler. My background was IBM 1401, and the Wiki article on 1401 SPS is informative.

Early examples of those machines were essentially precision wood chippers with a restaurant refrigerator sized cabinet of electronics over a small memory space of magnetic cores, and a potentially larger memory space of dead trees. An early assembler might take your source deck of punched cards, punch an "intermediate deck" of partially translated instructions, then take the intermediate deck back in to resolve marked addresses against a "label table" of branch destinations and data fields, punching a final object deck. This in turn required a small loader program of a few cards to be placed at the front, with the first card being written under constraints of the hardware card program loader function.

Assemblers - e.g. your mentioned Merlin - also got very early Macros and some of them, e.g. the Assembler coming with the UCSD Pascal environment had even stuff close to procedures.

I don't see how this is really all that different than just the substitution of abbreviations for operations.

I don't see how this is really all that different than just the substitution of abbreviations for operations.

There isn't exactly a 1:1 substitution here. But beyond that, there is a degree of abstraction from the raw operation of the machine. Remember that you're looking back at things from a modern context. While I don't know about those old machines specifically, I do know that op codes were what they were because each bit had some function in directing the operation of the machine. Giving names to those bit patterns is an abstraction that isn't necessary obvious.

The PDP-8 might be a good example here, specifically the OPR instruction. At first, programmers needed to carefully construct operations by setting individual bits. It wasn't until later that we assessed each possible combination, grouped, and named them. It's a nice analog to the invention of assembly.

The only slightly off thing is that (in the example above) "LDA" can represent several opcode variants

The only slightly off thing is that (in the example above) "LDA" can represent several opcode variants

It's actually really common for the same mnemonic to refer to multiple opcodes. This might not seem like a big deal to you when it's just a few variations, but it gets pretty wild with some processors. In the CP1610, for example, some mnemonics refer to as many as 64 opcodes. MIPS is even crazier with its 32-bit wide instructions; the advantages of an assembler there becomes obvious very quickly. Some assemblers even include mnemonics which translate to multiple machine instructions. This is common with RISC, as you might imagine.

If anything, I found it more likely to cause b bugs due to the similar interpretations.

If anything, I found it more likely to cause b bugs due to the similar interpretations.

You must not have done much work in it then. Using assembly is absolutely going to reduce errors over using machine code. If you think LDA #$00 look similar enough to LDA $00 to cause problems, things aren't going to be any better when you see A500 instead of A900.

That's the 6502, which is nice and easy compared to a lot of other processors. x86 has an absolutely absurd number of instructions. If you think working directly in machine language there is going to cause fewer bugs, you're out of your mind.

Anyhow, sjames is absolutely right about this. Assembly languages are a big step ahead of machine code.

The 6502 family, the 8080/Z80 family, the 6800 family, and now ARM and RISC-V families have lots of DNA in the agar of her work.

And while SmallTalk as an environment shaped the movement from human interface to thinking in UI, the evolution of it all has been stunning. None of this would have evolved had not a few bright people (Von Neumann, Booth, K&R, etc) kept adding DNA to what we use without thinking today.

it's just assigning pneumonics to numbers. I don't see how this is really all that different than just the substitution of abbreviations for operations.

it's just assigning pneumonics to numbers. I don't see how this is really all that different than just the substitution of abbreviations for operations.

a) Assemblers calculate the jump offsets for you, you don't have to sit and count how many bytes away it is.

b) It's a lot easier to insert a few instructions in the middle of an assembly language function than it is in a big block of hexadecimal. In hexadecimal you often end up patching a jump instruction in the middle of the function then do thigns and jump back again.

I've written a lot of Hexadecimal. I remember aligning my functions to 16-byte boundaries to leave little bits of space everywhere in case they need patching later.

(it also makes it easy to see the start of functions, the extra padding makes the functions look like paragraphs in a book when you view them in hex)

The other thing that assembler did for us was not just for the creation of the program, but for me it was that I could read someone else's program and figure out what the heck they were trying to do, in a fraction of the time.

She should have allowed 3 digits for the age field.

> No jokes, just respect.

Come on she was 100. Can't we do both? And while we are at it respect for her more famous husband, Andrew Booth, who probably did not get a slashdot post for his obituary.

Oh, and why was this modded troll? A troll mod? Or a slip?

Anyway, this begs the question (pun intended) who was the mind behind Andrew Booth?

"Recently, mod ratings are usually inversely correlated with how truthful a post is" How recent is that? I've been hearing variations on that sentiment almost as long as I've been on Slashdot & I go back a long ways, even longer than my UID implies.

Back then I'm sure it was just mnemonics, the assembler was vastly simpler than it was now, and most of this was done by hand. Macros get complicated fast and you need some memory, whereas these machines had very little memory.

Kind of surprising that with all of the press in recent years that people like Ada Lovelace and Grace Hopper got, that Kathleen Booth is not mentioned more often... maybe because developing an assembly language is just too esoteric?

Makes me think I really need to hunt down better and more comprehensive computer programming history books and read through them sometime.

My most recent foray in to assembly was porting some legacy embedded software to a more modern development environment, from Sun Programmer's Workbench on Solaris (yikes!) to gcc and make on Linux. Since the code ran on the bare metal there were some pieces I needed to code in assembly, translating the original assembly to something gas understood. All the while making sure my code was compatible with the compiled code it linked against.

This started as one of those Friday afternoon playing around sessions

There may be more comments in this discussion. Without JavaScript enabled, you might want to turn on Classic Discussion System in your preferences instead.

Dogecoin Surges 70% After Elon Musk's Twitter Deal

Computing Pioneer Who Invented the First Assembly Language Dies at Age 100 - Slashdot

Tri State Level Shifter Developer Proposes New (and Compatible) 'Extended Flavor' of Go