Ask HN: How to begin learning assembler for university course?

Isn't TASM "turbo assembler" ? that is 16/32 bit. What I would do is to get hold of someone from previous year and ask about the classes. If it is turbo assembler than figure out how it is setup. If it is vm etc... and once You know this you can pick probably a book that fits.

When I was in the uni we had a forum for all years where we shared info on subjects, lecturers and info needed in general. I don't know how students do it nowadays probably via messenger, whatsapp and gdrvie links.

I think TASM, isn't that difficult. I remember learning this in a university course and I actually quite enjoyed it. There are youtube videos out there.

But to be honest, just approach it like any other language.

- Learn the basic constructs (control structure patterns, loop patterns and instructions etc)

- Use it to solve easy problems (something like the easy problems in project euler)

- Just read source code to see how people use it in c/c++ programs.

In general TASM is pretty limited, but the knowledge you gain there can be used in other places which makes it worth it.

Edit: Formatting

The Art of Assembly Language https://www.plantation-productions.com/Webster/

I don't know if I'm the right guy to answer this, but I've written a lot of assembly on the side as part of VM and emulation projects. I think the first time I really understood how simple some things can be was when I wrote a simple function that did nothing but returned back to the caller.

So, how about starting out with a C program that enters main, calls an extern assembly function and then exits? And this would be the example C code:

    int main() {
        extern void my_assembly_function();
        my_assembly_function();
    }

Now you have to create your assembly file, and then compile it to an object file that can be linked with your program:

    gcc -c myassembly.S -o myassembly.o

OR

    nasm -f elf64 myassembly.asm -o myassembly.o

See: https://www.ele.uva.es/~jesman/BigSeti/seti1/nasm/nasmdoc2.h...

I've never used TASM before and I couldn't really find anyone using it. But I guess the course will cover that. Is this programming on Windows or Linux?

I have dabbled with quite a few assembly languages (8051, MIPS, A64 and a bit of x86), the first and second of which I learned in school. To be honest if your teacher is good and the class is well prepared, it should be pretty nice ! As fmax says in their comment it's not that different than learning any other new language : there are some key concepts and ideas which you'll need and the mnemonics, which are the assembly keywords like `ADD` (better to have a searchable reference handy). But all those things can be acquired by experimenting with it and writing simple programs. On top of that, you say the course is on computer architecture so I bet you'll have a very useful overview of all those concepts that are useful for assembly writing ! peterkelly's link looks very useful for that purpose as well.

For that you'll need to setup some sort of environment where you can write, assemble and run your assembly code. jakuboboza has some good ideas to check with previous students to know what can of environment you need.

Eventually you can check an even simpler assembly like the 8051 that has very simple emulators and IDEs available. Or, if you want something a bit more game-y you can look into Zachtronics' puzzle games[0] that often have an assembly-like language and come with a manual, which can help you become familiar with the basic principles. TIS-100 is only assembly writing, Shenzen I/O has a bit of wiring/"electronics" on top and EXAPUNKS makes you "hack" systems using little bots written with this assembly.

I found that knowing a bit of assembly is quite useful and interesting to learn, I hope you'll have fun with it !

[0] : https://www.zachtronics.com/

I think the idea of a course is that you will be taught. Why worry about it? Do you not trust your uni to provide the necessary course materials and exercises?

Did someone tell you assembly is hard? I will tell you that assembly is easy, very easy. It's easy because instructions are simple and stupid. They do one little thing, and maybe set a few flags. And while modern ISAs have grown a ton of cruft, you get pretty far with a small set of core instructions (loads & stores, register-register and immediate-register moves, arithmetic, testing flags, branching). Given that it's a computer architecture course, they'll probably want you to learn something about ABI and calling conventions too. Not a big deal, it just illustrates the (somewhat arbitrary) convention of what to pass in registers vs what to pass on stack, who saves registers (which registers?) and so on. Simple stuff that you just need to have a convention for if you want to make it easy to interface with prebuilt binaries.

With very basic knowledge, you could disassemble a program and just look up instructions as you go to figure out what it does. That is how I "learned" assembly. I put learned in quotes because for me learning is on-demand and is never fully done. I learn more as I need, including last week when I did some ARM assembly programming.

I think assembly has an undeserved reputation for being difficult, because building large programs in assembly is a lot of work. Also because fear of the unknown: few people learn assembly, and even fewer use it enough to be proficient with it, so in their mind it's the devil they don't know. I doubt the course has you building large applications, it'll be some rather basic things. And that's how a lot of assembly usage is in real life: you just have to do some basic bits in early stage bootloaders, OS kernels, crt, etc. in assembly. But only enough to get the code in a higher level language going. (The other significant use is in optimization, especially SIMD, but I doubt a computer architecture course would focus on that too much).

Have no fear and just dive in. That's how you approach the topic.

Knowing C and checking the compiler output is very helpful. You can do it interactively on godbolt.org, it'll even hilight lines and the corresponding machine instructions.

Like other posters said, don’t sweat learning it early, just do the assignments.

That said, Compiler Explorer [0] is very useful to see what modern compilers actually do. If you want to learn how simple programs are converted to assembly, make sure you turn off the optimisations with the ‘-O0’ compiler flag.

[0] https://godbolt.org/

8bitworkshop is great:

https://8bitworkshop.com/v3.9.0/?platform=c64&file=hello.das...

It's mostly vintage CPUs like the 6502 or Z80, but those have the advantage that they're trivial to learn, and the basic concepts still apply to modern CPU assembly.

There's also a DOSBox wrapper for x86 assembly though (sadly nothing 68000 based, because this was by far the nicest CPU for assembly coding).

Have a look at this: https://hackaday.io/course/178733-raspberry-pi-pico-and-rp20...

His youtube videos are interesting as well.

I liked this book for TASM. However, it's pretty much outdated now

https://www.amazon.com/Mastering-Turbo-Assembler-Tom-Swan/dp...

Why would it stress you out?

If the university is any good at teaching, it will pace the course in a way that at least ⅔ of the students will be able to follow the course. If you have time _this_ semester to read a book about _next_ semester’s stuff, you aren’t struggling to keep up, so I would expect you to be in that group.

Also, assembler breaks down stuff into smaller steps, but that doesn’t mean it’s hard. It ‘just’ makes it more work to write large programs.

If you have done some C programming, assembler is a bit like having a program where you declare a fixed number of integers (say A, B, and C) and a fixed set of double's (say D and E), a huge array of bytes called MEMORY, functions for reading bytes and integers from, and writing them to it, and then limit your program to.

- simple expressions (e.g. A=B+C is fine, A=B+C+D isn’t. You would have to do A=B+C; A=A+D; instead). The exact set of allowed things varies by CPU. Some allow you to do “A=B + MEMORY[C], some don’t, etc)

- not using while, for

- if is only allowed as if A op 0 goto FOO; (where op is ==, !=, <, etc)

The exact set of int's and double's and the set of allowed expressions varies by processor. also, assembler syntax is different. you'd write something like (this is different per processor, and even between assemblers) "ADD A,B,C" for "A=B+C", for example.

You could start with a small C program and see whether you can change it to adhere to some of these restrictions.

Sample programs could be

- computing the GCD of what’s in A and B

- counting the number of times each byte value occurs in MEMORY between offsets 10,000 and 20,000.

- checking whether the memory region between offsets A and B contains a range of values equal to that given by offset C and number of bytes D.

The result won’t look like assembly, but I think it would give you the right mindset.

I would be sooo excited if I were you. I don't know if you're the type of person who likes to break stuff and figure out inner workings of programs. But the moment I fell in love with assembler was, when I was able to DISassemble a program and understand it bit by bit. Read process memory from another process, inject and modify code. IDK to me it was the first moment I felt 'in control' :)

What's your background? Obviously, if you're studying marketing or sociology, learning computer assembly is going to be a challenge.

At uni, we didn't learn to write assembler until we'd already been taught about Boolean logic, finite automata and RISC processor design. So we were already familiar with basic processor operation before writing any code for it. But I studied electrical engineering, not computer science.

Knowing your current background/field of study is going to be essential to give useful recommendations, I think.

I've never heard of prepping for a university course - the whole point of taking the course is to learn.

I think I learned more from Ben Eater’s “Building an 8-bit breadboard computer” series [0] than my intro to computer architecture course at university. Highly recommended.

[0] https://www.youtube.com/watch?v=HyznrdDSSGM&list=PLowKtXNTBy...

Don't stress on assembler. This should be a fun class for you. If they are using TASM then it's early x86, so not the funnest (like 68000 or 6809), but not especially hard.

I would get ahold of the TASM manual early and give it a read through, then take your x86 instruction reference and write each instruction on a 3x5 card in the proper format for the assembler and what registers the instruction changes (directly and via conditions). You'll be fine.

I'm pretty sure there is no equivalent of the IBM 360/370 banana book.

The basics of assembly aren't bad, but there's a lot of bad tutorials out there. Look for the ones that start by explaining what a processor register is.

https://www.cs.virginia.edu/~evans/cs216/guides/x86.html

My Uni had this weird notion of teaching assembly with made up processors. It was some professor's hobby to write emulators with a semi-graphical environment that showed the registers, and so on.

I didn't buy it. We should have used real processors or, at least, those fantasy processors should have been reflections of real ones. I thought then that we should have started with 8-bit processors.

Anyway, later we had a chance to do some work with real 8086 assembly and that was a lot more exciting.

Go download Exapunks, Shenzhen IO, and TIS-100. I didn’t have that option when I was in your position, so I read Intel’s pentium programming manual and made a Winamp viz plugin instead.

The notion that assembly language is somehow difficult is just silly exceptionalism.

It's a lot of work to do complex things, that's for sure, but it isn't in any way hard to understand. There will be a reference guide for your processor which will be exact and succinct.

It's the easiest language there is to learn. It's hardly even a language. Even if modern processors have layers of abstraction to them, you still get to get to program a processor directly.

Don't be surprised if you also get a much better understanding of how some common data structures work when you have to code them yourself. I remember being baffled by pointers but after coding assembly a few times it suddenly seemed completely natural. It was a few years ago though.

I wrote a guide that may help -- it enables gdb debugging within consistent containerised environment: https://blog.devgenius.io/getting-started-writing-assembly-l...

I highly recommend Assembly Language and Computer Architecture using C++ and Java by Anthony Dos Reis. This book will teach you a lot of stuff in assembler.

If you already know C or C++, I’d recommend checking out Compiler Explorer [1]. It helped me tremendously when learning assembly as I could see how source code translated to assembly, which helped me learn common patterns in assembly, etc.

[1] https://godbolt.org/

Note: It supports more languages than C and C++, but with the exception of Zig, the others will typically have more complicated assembly output.

40HEX and 29a computer virus ezines. I can also recommend Ralf Browns Interrupt List for a great reference for BIOS/DOS interrupts (procedures).

Definitely not along the lines of what you're going to be taught, but fun.