Understanding C by learning assembly

https://www.hackerschool.com/blog/7-understanding-c-by-learning-assembly

by davidbalbert • 14 years ago

188 66 14 years ago

hackerschool.com

erichocean• 14 years ago

A thousand times yes.

If you are going to use C, then at least know what it's doing!

prophetjohn8• 14 years ago

Can't this reasoning be applied recursively?

If you're going to learn C, you better learn assembly, so you know what the C is doing.

If you're going to learn assembly, you better learn CPU architecture, so you know what the assembly is doing.

If you're going to learn CPU architecture, you better learn digital logic, so you know what the adders and multiplexers are doing.

If you're going to learn digital logic, you better learn solid-state physics...

I mean, it's always useful to know what's happening under the hood, but it's not always realistic to expect that to happen. I don't think the average C programmer need to know assembly any more than the average Ruby programmer needs to know C.

ori_b• 14 years ago

I've played around with all of those levels at various points in school and my career. My knowledge of solid state physics mostly goes unused, mostly, but every other level is something I've had in mind at various points. I'd file them all under "good to know".

Sure, you can generally get by without low level knowledge, but it's nice knowing why certain design decisions were made. And as far as C goes, I think it's extremely useful to be familiar with how it translates to assembly, at least in general. It is knowledge that you will use regularly if you're programming in C in any significant capacity.

For example, reasoning about ABIs is something you'll have to do if you ever write a stable library interface. Reasoning about ABIs requires you to know the asm-level calling convention for the platform you're coding on.

tmurray• 14 years ago

I don't think that is true. If you're writing C, it's probably because you want to be close to the metal and want many of the guarantees that such proximity provides. If you're focused on that sort of thing, then it's definitely useful to understand what your compiler is actually outputting so you can react accordingly.

(I'm a C programmer, I don't look at assembly that often at all, but it's certainly helpful to be able to do so and my knowledge of the x86 ISA, calling conventions, etc has informed many decisions I've made in the past, especially re: performance)

wreckimnaked2• 14 years ago

I disagree. Given that C exposes you to some hardware details that are abstracted when developing in some higher level language such as Ruby, for instance having to deal with overflow on signed/unsigned types and register variables (I know that compilers will mostly ignore that, but it's still a language feature).

The average Ruby programmer, on it's turn, can perfectly live without knowing C programming. A more accurate analogy would be to a Ruby programmer to know about the language implementation being using (MRI, JRuby, Rubinius, etc.)

Homunculiheaded• 14 years ago

I think someone who claims expertise in 'software' should understand the process until it stops being software, which is architecture. Honestly I think the 'average' Ruby programmer ('average' reflecting their understanding of ruby) who really claims to understand software should know C and ASM.

I really don't have an issue with someone being a dev in Ruby who doesn't understand pointers or how if/else statements can be constructed from jmp primatives. But if you're on the road to expertise I don't think you can remain ignorant of these.

whatshisface• 14 years ago

It can be applied recursively, but with diminishing returns and an increasingly alien (to a software developer) set of rules as you go down. If learning one thing made you 10% better at the thing above it, you would also become 1% better at the thing above that.

agumonkey3• 14 years ago

There's a course adressing this, full stack knowledge but from bottom to top. Building a system from 'Nand to Tetris' as they pitch it. They probably left ceramics as an exercise for the reader.

http://www1.idc.ac.il/tecs/

iyulaev• 14 years ago

I think you should know at least one level of abstraction, in each direction, beyond what you presently know. So if you're writing a C driver, you should know what the assembly will look like and also what the application developer will be writing with the help of your driver. This probably has more to do with communication and understanding of the people problems involved than with performance though.

ChuckMcM• 14 years ago

It worked for me.

ericd• 14 years ago

Welcome to the MIT EECS degree program, quite literally :-D

bigiain• 14 years ago

It certainly works back up the other way, lots of bits of Perl make a lot more sense with some C background.

And, FWIW, when I did CompSci back in the '80s, the first courses/tutorials involved building half-adders and flip-flops from NAND gates and wires on a plug-board.

You don't _need_ to know that sort of stuff, especially not in any level of detail, to build another CRUD webapp - and with luck a hugely successful business on the back of your CRUD app - but I think there's a personality trait that comes along with all the other stuff that makes some people "hackers" which characterises many of us as insanely curious. Many of us don't want to treat the latest Ruby ORM features or Node.js's async callbacks as a "black box", we want to "know how it works" - sometimes out of pure curiosity, and sometimes because it fails _hard_ and we can't work out why without understanding what it's doing "under the hood".

irishcoffee2• 14 years ago

My comp. sci. program stopped at the solid-state physics point in your recursion example. Every step has made me a better programmer.

jonhess• 14 years ago

There are diminishing returns to going deeper and deeper. But there's a big return for the first level.

I think it's useful to have a basic understanding of assembly so that you can debug better, or understand why some behaviors are undefined. I think that only takes a basic understanding of assembly though.

If you want to be an expert at assembly, you probably want to go deeper, but most people don't have that goal.

thirdhaf• 14 years ago

In a strange way I sort of did this with my EE and math degrees. I did draw the line at the Hartree-Fock approximation for doing ab-initio band structure calculations for silicon though so there's still room at the bottom for me. Since then I've come to realize that programming is more fulfilling to me but I do feel prepared for this particular line of rabbit-hole questions :-)

qznc• 14 years ago

With a diminishing amount of knowledge you might be right.

A master C programmer knows assembly well, a good chunk about CPU architecture, some things about digital logic and superficially about the physics.

Toenex• 14 years ago

The best undergraduate project I ever did was one where we had to design and simulate a 4 bit microprocessor (this was 1991). Whilst it pulled together strands of our analogue and digital electronics classes the biggest impact was on my software development. It brought the programmers model of a CPU completely to life and stuff that I knew I now Knew. I became a pretty mean C programmer (even if say so myself) because of this.

How far you go down the rabbit hole depends of how much of this supporting knowledge you need to work at the level you work. Given the layers of software abstraction that exist in systems these days is it really necessary for a programmer to have a detailed knowledge of how a transistor works? Not at all. Your much better spending the time building a mental model of how your VM or OS layer is working and going to interpret the code you write. Or even looking up and understanding the layers that will use what you write - like users and customers (now there is a real challenge!) For sure take an interest in all things, but as you go down the layers your thinking can be increasingly abstract and like any model, plain wrong and it won't really matter.

perlpimp• 14 years ago

Domain of working with C implies working with hardware and raw code - instructions that CPU executes. Same as working with JavaScript(in browser) suggests knowledge of how browsers parse HTML, generate DOM tree and subsequently render it.

When things go wrong it is useful to have knowledge of n-steps deep to immediately cut through ton of output and nail down a few places things seem to work not as expected.

tapertaper• 14 years ago

If you wish to make an apple pie from scratch, you must first invent the universe.

-Carl Sagan

dude_abides• 14 years ago

  $ CFLAGS="-g -O0" make simple
  cc -g -O0    simple.c   -o simple
  $

This is so handy. I never knew that you could call make without writing a default Makefile. Thanks!

davidbalbert• 14 years ago

Thanks. I was first exposed to this in Zed's Learn C the Hard Way: http://c.learncodethehardway.org/book/. I think it's quite handy.

agumonkey3• 14 years ago

You probably heard it already, but you should read make documentation. It's full of convention like this aimed at helping the C ecosystem.

beagle32• 14 years ago

And after you have read it, read the documentation of apenwarr's implementation of djb's "redo", and see how everything about make can be simplified to the point that a 150 line portable bash script can be used as a non-dependency-tracking replacement (that is, rebuild everything on each run).

redo makes everything much simpler, more consistent, more dependable, and more robust. e.g all files are atomically replaced; dependencies are checked by a crypto hash of the content; dependency setup is sane; and it's all faster than make.

eckyptang• 14 years ago

You can use the default makefile with no targets to set options globally for a directory as well i.e.:

   echo 'void main() { printf("omg\n"); }' > simple.c
   echo 'CFLAGS=-g' > Makefile
   make simple
   ./simple

(yes I know that is not valid C but it serves this example and compiles fine :-)

sigjuice• 14 years ago

If you set CC=c99, then you can change void to int.

dllthomas• 14 years ago

There are actually a fair number of default rules you can use that way. Check the documentation for details...

sltkr• 14 years ago

Note that this uses the Bourne shell feature of modifying the environment of the make process by prefixing the command with an environmental variable assignment. The more portable/shell-agnostic version is to pass such assignments as arguments to make instead, i.e:

    make CFLAGS="-g -O0" simple

(This also works with many other build tools like CMake or configure scripts generated by autoconf.)

If you're curious which rules exist by default, try running:

    make -p

(This produces a lot of output; a bit much to study in detail, but still useful to scan just to get an idea of what default rules exist.)

toughluck• 14 years ago

"make -p"

Of course this only applies to GNU make.

niggler• 14 years ago

You can run gcc with the -S flag, which will dump the assembler output (so you dont have to go through gdb)

You can also use `objdump` from binutils

tsahyt3• 14 years ago

gcc -S is usually preferable, since you don't get all the code produced/included by the linker to get the thing running.

dbaupp• 14 years ago

And using gcc -S allows you to get a few extra annotations (variable names etc.) using the -fverbose-asm flag.

nullc• 14 years ago

Mixed feelings here:

* Knowing what the machine is doing is useful and important, especially while debugging. I think every really good C coder I know has been comfortable with assembly at least on some platform.

But…

* C is not a fancy macro assembler. C's behavior drives an abstract machine, and any machine code that achieves the same output assuming that all the C behavior is defined is equally valid. The believe that compiler is just transliterating your code to ASM is responsible for many serious bugs. C Compilers haven't been like that for 20 years (or more). E.g. aliasing rule violations. The fact that it isn't is utterly essential for performance, especially as things like good SIMD use become more critical for performance.

Even when the compiler is mostly transliterating the expectations from the simplified mental machine model can be misleading, e.g. alignment requirements on load on some architectures.

novalis2• 14 years ago

Fascinating, reading it made me remember how fun it was to use Softice.

zwieback2• 14 years ago

I loved SoftICE, especially the NMI button that you could slide into an ISA slot.

novalis2• 14 years ago

I think I lost track because of the lack of support after Windows XP. But I did read (on some dedicated forum) someone had it running with Vista and onwards, just never been able to find it. I think there was a symbol table no show release and a company buy out. Do you use something with Ring Zero now, to substitute it?

habosa• 14 years ago

I'm not sure how long this has been the case, but this is how C is taught at my school (Penn) and I'm sure many others.

In my CIS240 class (currently enrolled) we learn computers from the ground up and eventually learn C. First we do binary arithmetic by hand to get a feel for it, then we design basic circuits (and some complicated) that can perform the basic computer instructions (ADD. MULT, SHIFT, AND, XOR, etc.) then we keep building up off of these basics until we are finally writing C, at which point we will (hopefully) have a good grasp at what is going on and appreciate our programming language of choice a whole lot more.

naavinm• 14 years ago

Hmm, interesting..

b3b0p• 14 years ago

Assembly was always daunting to me. Then I took Computer Systems at the University. It ended up being seriously fun. The way it made me think and try to solve problems were engaging and different it seemed. It required a new way of thinking and made me think about things I never thought about. Although we only wrote smaller programs for the class, I found them fun and I still remember the class nearly 10 years later.

In regards to the original post, I'm not sure I would be putting C with assembly or learn one over or for the other. They both have their uses and reasons for knowing. Forcing yourself to learn one before the other does not seem like a logical way to go. I think it's best to start with what makes the most sense for your end goal and / or you are most interested and motivated to begin and get most deeply into.

ginko• 14 years ago

I sometimes think that an ideal approach to learn programming might be to learn it on several abstraction levels at once to see how things interact.

One good combination would be Assembly + C + Python for instance. Assembly helps understanding C and C helps with understanding Python.

jstrayer• 14 years ago

It's been more than a decade since I've worked in C, but don't C compilers have an option to emit assembly directly?

pacman128• 14 years ago

I used to teach Assembly and I spend a lot of time talking about how it connected with C since assembly is almost always used in conjunction with C. I have a free text on the web that was used in the class. It only covers 32-bit x86 since that's all there was back then. http://www.drpaulcarter.com/pcasm

Understanding C by learning assembly

Related Stories