Slashdot Mirror
Why Learning Assembly Language Is Still Good
nickirelan writes "Why Learning Assembly Language Is Still a Good Idea by Randall Hyde -- Randall Hyde makes his case for why learning assembly language is still relevant today. The key, says Randall, is to learn how to efficiently implement an application, and the best implementations are written by those who've mastered assembly language. Randall is the author of Write Great Code (from No Starch Press)."
Another reason: Sooner or later, you'll need to debug something without a source-level debugger. Knowing how to debug raw assembly language has saved my ass many times.
Hate to say, but the kind of optimization you learn about by knowing assembly language is just not necessary for most programmers these days.
I learned programming in the 80's, and I did learn assembly language, starting with 6502 assembly. I would subconciously code my C so that it would produce faster code. Every block of code I wrote would be optimized as much as practical. My code was fast and confusing.
When coding Perl or Java I would keep in mind the details of the underlying virtual machine so I could avoid wasteful string concatenation or whatever. I cache things whenever possible, use temp variables all the time, etc., etc.
I've spent the last few years trying to UNLEARN this useless habit. There is just no need. And in highly dynamic languages like Ruby, it's pointless. You can't predict where the bottlenecks will show up.. almost every project I've worked on has either had no performance problems, or had a couple major performance problems that were solved by profiling and correcting a bad algorithm.
Stuff like XP and agile development have it right: code as simply as possible, don't code for performance, then when you need performance you can drill down and figure out how to do it.
To me a beautiful piece of code is one that is so simple it does exactly what it needs, and nothing more, and it reads like pseudo-code. Minimalism is the name of the game.
So my advice is, don't learn assembly language. Learn Lisp or another abstract language. Think in terms of functions and algorithms, not registers and page faults. Learn to program minimally.
On another note, the tab in my Konqueror for this article reads: "Slashdot | Why Learning Ass...". Heh. :-)
Come on - all that may be great, but what really matters is what gives the most bang(features) for the buck (cheapest)... and in the minds of the average CEO with 10 billion options this is done by outsourcing to the lowest cost provider (India, China, etc..) regardless of code training, language etc..
Unfortunatly, I doubt that we are going to see many people switching to assembly language, but we can hope. I'd love to see a return to applications that were under 100K
Misuse of high level languages such as visual basic, as well as off the shelf components for everything, has led to a level of code bloat in todays applications that is inexcusable.
(note: off the shelf components and high level languages aren't inherently bad, just not always suitable for commercial applications.)
Also, given that modern optimizing C compilers can often optimize better than humans, it may make sense to embed critical sections of assembly into C code, and let the compiler optimize the rest...
Also, whatever happened to profiling? Has this become a lost art among developers? Time your code. See where it bogs down. Find the fat. Cut it out. Please.
--
This post brought to you by Save the CPU Cycles!
While I learned assembly, and found it useful for learning to understand exactly how the machines think, I'm not sure I agree with his basic premise. Namely, that great code (code that is well designed for it's job, and easy to work with and under) is always the efficient code, in machine terms.
The machine thinks one way. A human thinks in another. Code that is well designed for easy updating, and extending, is code that is easy for a human to understand. If that is not the most efficient way for the machine to do it, that may be the price for 'great' code in this project. (The ideal balance depends on the project, of course. A kernel should be machine-efficient, for example.)
'Sensible' is a curse word.
I was fortunate enough to learn assembly on a few architectures. Admittedly all of them are microcontrollers (PIC, AVR, HC11), but it really does force you to understand how the machine is working.
Some of the more serious asselbly languages still scare the hell out of me though; have you ever looked at the assembly for the TI C6x DSPs? It took me quite a while to come to terms with something simple, and the C compiler can better use the 8 parallel execution units better than I can...
I drink to make other people interesting!
Efficiency in terms of coding is a wonderful art and I think it's still applicable today. Kernel-level routines, games, drivers, etc. all benefit from tight coding in assembly language.
But let's be honest here. Computer Science 101: an efficient algorithm coded in an inefficient way will always beat out an inefficient algorithm coded by hand in 100% optimized assembly. I'll put my crudely coded Javascript quicksort algorithm against your finely honed 100% assembly bubblesort algorithm any day. Not only will my algorithm beat the pants off of your algorithm, but I'll also code it in far less time and with way fewer debugging sessions than you would. Also, the higher-level language you go, the better it is for security. How easy is it to introduce things like buffer overflows, array out of bounds, etc. errors in assembly? How easy is it to do that in Java, C#, etc.?
So yes, writing in assembly language is still good and has its places. But let's keep it to those places, shall we?
Want to improve your Karma? Instead of "Post Anonymously", try the "Post Humously" option.
Learning it is good, even if one never ends up actually seriously developing in it. It advances your ability to solve problems in a language independant fashion and equips you to be able to more rapidly model solutions to brand new problems, even in the languages that you may already know.
File under 'M' for 'Manic ranting'
Knowing what assembly is and how it works is beneficial. Mastery of assembly is completely pointless for anyone outside of OS kernel, compiler construcution and embedded development...which probably means you. Your time will be better spent figuring out how to make Java programs 10% faster most of the time.
I think there is more at stake here than just writing efficient applications. For one thing, writing proper multi-threaded code often requires thinking at the assembly level. Many of my coworkers who are all high-level-language-only programmer types couldn't understand (until I explained it) how the Double-Checked-Locking Java example was broken.
Wow. You can crash a machine with assembly language.
That may seem impressive to you (especially if you're fourteen), but the fact is that exploits can be done in almost any language.
In other news, this doesn't have a hell of a lot to do with the posted article, either.
I have to agree. I run into quite a few people looking for programming jobs who don't understand what the CPU has to do to execute their code. They do dumb things like multithread something that is CPU bound becuase they have no understanding of how what they write actually gets executed. Same thing with regard to data representation mistakes.
I'm not saying that everyone has to become a proficient assembly level programmer but I think a lot of people would be a lot better HOL programmers if they understood something about assembly language. I wonder how many Windows buffer overflow exploits are simply the result of someone not understanding that just because you can't express it in a HOL doesn't mean you can't exploit it from assembly code.
They that can give up essential liberty to obtain a little temporary safety deserve neither safety nor liberty.
Ben
Second, and perhaps more important, I think most of the performance issues in such environments stem from architectural, not algorithmical issues. Think J2EE, where if you are not careful enough you end up doing a round trip to the server every time you set a property in an object.
In a sense, he covers this in the article when he writes:
"This doesn't mean, of course, that a practicing engineer should sacrifice project schedules, readable and maintainable code, or other important software attributes for the sake of efficiency.
What it does mean is that the software engineer should keep efficiency in mind while designing and implementing the software."
But of course, most of his emphasis is on knowing how does the machine work. I ascribe more to modern thoughts considering efficiency (and other non-functional requirements, such as the maintenability also mentioned in the above quote) as architectural concerns, things that shape the architecture and that no amount of algorithm substitution and the like can fix if gotten wrong in the first place.
The revolution will not be televised.
You know, when you're trying to get a game out the door that runs at 30fps and your competitor has a similar game running at 60fps because they coded their inner loops in assembly you begin to realize why optimization is important after all.
Doesn't it make you feel good to know that our freedoms are protected by politicans, lawyers and journalists.
I have very fond memories of writing pentium-optimised asm...the rules were complicated enough to make things interesting, but still comprehensible.
Nowadays, the x86 ISA is just an API...god knows how the core actually executes instructions and in what order, which makes it very hard to optimise code beyond a certain point. You get more mileage from optimising memory access patterns and doing other such dull, dull, dull work. I get my asm coding fix elsewhere nowadays.
From your link:
"This bug is confirmed to be present when the code is compiled with GCC version 3.3 and 3.3.2 and used on Linux kernel versions 2.4.2x and 2.6.x. It has been tested to work on, and crash, several lame free-shell provider servers."
If it affects all 2.4 and 2.6 linux kernels, I wouldn't call servers affected 'lame'. Especially free-shell provider servers. That's lame, testing a local exploit on a public shell server.
Quoting: "the best implementations are written by those who've mastered assembly language".
I haven't read this book, but I'd hope that there would be some pretty good justification of the above statement. I suspect that it's not, though. First of all, who defines what the "best implementation" is?
As Knuth says, the first rule of program optimization is: "Don't do it". Trying to optimize a program when you're writing it leads to all sorts of problems including difficult to maintain code, increated time and budget required for the project, and often it's not even a hot spot anyway.
I used to be very concerned about using making my code fast, but have (over the decades) decided that making it obvious is much more important than speed, particularly in the initial implementation. Profiling allows you to concentrate on the 20% of the code that the program is actually spending 80% of it's time in, instead of guessing where the hot spots are going to be.
I've found that another benefit of using simpler code is that I'm more likely to throw away whole sections of simpler code and try radically different algorithms or mechanisms. More complicated code I find I'll try to just tweek instead of dumping wholesale. Randically different approaches can lead to 10x speedups where tweeks of existing code may give you 2x speedups, if you're lucky.
Don't get me wrong, I'm all for trying different approaches. I'm not sure I would have come to the same conclusion I have now if I hadn't spent quite a long time trying to write optimized code. It was a very different world back then, but I know I wasted a lot of time optimizing code that didn't at all need it. It was an experience though.
Sean
I am assuming you said this to be funny, otherwise it is indeed a shame.
ECE (especially those with a heavy electrical engineering lean) people deal with microprocessors. Motorola chips have special features that you can't access with most C compilers and thus it is necessary to know assembly.
Also, until recently, finding a good C compiler wasn't cheap. Now, of course, there are free ones.
Coming from an ECE program without a microprocessors class in which you apply Assembly will make you less competitive than the graduates coming from schools in which engineers are taught both practical assembly application, and high level languages.
*-*-*-*-*-*-*-*
"We are Linux. Resistance is measured in Ohms."
What Randy Hyde taught me is that it is important for a beginner programmer to quickly learn what kind of instructions the high level code you write is being translated into, how basic machine organization works and how the compiler and OS figure into running your code. Writting Assembly is no longer important (thank goodness) however the process of LEARNING how to write Assembly is a crucial step in a well rounded CS curriculum.
When Randy Hyde taught x86 Assembly to us at UC Riverside it was the toughest lower-division class and the weeder for the people who shouldn't be computer scientists. Without that core people are making it to upper-division and performing very poorly in OS, compilers and architecture.
I would agree with that. I looked at an introductory computer science class that used Java. The first few weeks involved basic programming concepts. Then they would spend a week or two on multithreading, a week on file I/O, a week on inheritance, and so on. No wonder some of the students ended up being a little fuzzy on basic concepts, like how a computer executes one instruction after another...
I'm fully in favor that most programmers should learn some assembly. But learning how to do efficient code is not the reason for learning assembly. Assembly should be learned thoroughly by systems programmers (who write operating systems, core libraries, compilers, etc) and certain embedded programmers because they might actually need to use that skill directly. Other programmers should learn some to the extent that it teaches them what's really going on inside the machine, but they should not dwell on it (unless they find it fun). Efficiency should focus on choosing (or developing) the proper algorithms for the application being developed.
If one is going to do programming where pointers would be used (systems programming and lower level applications programming, such as in C), then I suggest learning assembly as the first language. Two or more decades ago, that advice worked because most people didn't learn to program until they took a class in it or such. Now days, people destined to be programmers are learning some programming by around age 10 (usually in whatever language is easiest to get started in, which is generally not always the best to develop larger applications in). By the time they've done a lot of programming, they either "get it" with regard to pointers, or don't, and are set that way for life. This is unfortunate (and results in much insecure programming).
now we need to go OSS in diesel cars
This guy says "Efficiency Is the Key". This guy is wrong.
With the incredible power provided to us by modern CPU's, efficiency is just about completely irrelevant for 99% of non-game applications. Think... when was the last time you thought "This word processor just doesn't respond to my keypresses fast enough." or "AIM takes way too long to open a new IM window."? The reason why these programs aren't getting "faster" (as the article complains) is because there is no way to do so. They spend 99.9% of their time waiting for user input already.
Optimizing code which doesn't need optimization is Bad with a capital 'B'. When optimizing code, there is almost always a tradeoff between efficiency and maintainability. Efficiency often requires cutting corners, killing opportunities for future expansion, or, at the very least, writing ugly code. When that added efficiency does not lead to any noticeable benefit to the user, why do it?
Now, granted, you shouldn't use an O(n) algorithm when an O(lg n) one exists to solve the same problem. However, knowing the difference between O(n) and O(lg n) has nothing to do with knowing assembly. The only benefits you can get out of knowing assembly are constant-multiplier speed increases. And, frankly, shaving off 50% of 0.1% CPU time used is not going to help much.
Really, the speed of modern CPU's is sickening. I can't count the number of times I've written a piece of code, thought "This is going to be so slow...", then watched it execute near instantaneously. Even when running programs in a prototype programming language I'm working on -- which currently runs about 40x slower than C, because it's a crappy prototype -- this happens to me regularly. The only time your code is going to be noticeably slow is if you are processing a very, very large data set or you are using slow algorithms. In the former case, sure, knowing assembly will help, but such cases are extremely rare in typical applications. In the latter case, find a better algorithm.
All too often, high-level language programmers pick certain high-level language sequences without any knowledge of the execution costs of those statements. Learning assembly language forces the programmer to learn the costs associated with various high-level constructs. So even if the programmer never actually writes applications in assembly language, the knowledge makes the programmer aware of the problems with certain inefficient sequences so they can avoid them in their high-level code.
Fair enough. Like he says, it works with any speed processor to make things faster.
Most of the rest sounds like praise of free software. Free software does not suffer, "unrealistic software development schedules." Free software authors can go read the source code to gcc and gcc and the gnu debugger both have had more attention lavished to them than any proprietary equivalent.
Friends don't help friends install M$ junk.
the key to that article was the word "mastering". Anyone can learn assembly but it takes years of practice to master. Just because I can code in asm doesn't make me good at it. An investment that could be better spent elsewhere on other programming languages
did you forget to take your meds?
A solid knowledge of assembly, file formats, calling conventions, and other voodoo is the price of admission if you need to find out how something works and all you've got is a binary.
They do dumb things like multithread something that is CPU bound...
;-) ), but, I'd guess, almost a half of the people thinking in multithreading terms in this world (definitely half the total IQ, not to offend anyone ;-) ) use it to solve CPU-bounded problems on SMP boxes/multithreaded CPUs (Tera SMT; Intel's Hyperthreading on massive (ASCI) scale, things like that...)
;-)
Not that I disagree with your point (actually I do agree with it alot!
When you just start throwing processors (or thread contexts) on the problem, you will find soon enough that any problem is I/O bound...
Paul B.
That set up many 3-4am debugging sessions.
Look, exposure to low level languages and limited memory make you think about what you really need in the program and what you can do without.
In one shop I would take code from the consulting firm, trim out 40-60% of the code, and end up with a job running 25-35% faster (and cheaper). And then there was the other bug in the code. 50 lines of useless code in each of three programs was costing the company $60K in usage to a department per year!
Or how about added transfer time into an EDI program twice for each item calculated. It was causing Disney to hold $10 Million in the warehouses in inventory until I found it.
And it isn't just assembler. It is low level DBMS functionality too. I had one job where the first test ran 12 hours. By re-coding it in a completely different manner it took 5 minutes. The 12 hour method was the method recommended by the vendor of the DBMS. The 5 minute version was mine.
Finally, code can be in a high level language and still be efficient. And there are still plenty of devices out there with limited memory - how about PDAs? or Dive Computers?
- He faults inefficient coding for the failure of software speed to keep up with CPU speed (or at least, its a "large part".) This is much less true than he lets on; Amdahl's Law means that the CPU is less and less responsible for the speed of an application, while things such as disk seek/transfer times, memory access times, and network latency all play huge roles in the speed of your computer's software.
- He seems to think that it's not terribly hard to become an "efficient" assembly language programmer. Bzzt, wrong! In the modern era of superscalar architectures, pipelining, processor specific instructions, branch delays, and memory heirarchies, it takes a hell of a lot of knowledge and experience to beat the performance of a good compiler.
- He apparently hasn't tried any large assembly language porting efforts lately. I'd love to see the effort involved in porting a large x86 assembly language program to a MIPS architecture, all the while maintaining that coveted "ultra-efficiency". The reality is that a good compiler can be reasonably efficient at porting a program to a new architecture, while a programmer usually isn't.
- He also apparently hasn't tried debugging a large chunk of assembly code lately. It is a fact of life that it is very difficult to debug assembly. By using a high-level language, you are increasing the readability of your software, which tends to decreases the number of bugs.
I could go on, but needless to say, I'm not impressed with the numerous assumptions and generalizations about assembly that he makes. Learning assembly will make your high-level programming better, and limited use of it can be appropriate, but using it all over the place is a huge mistake.
It doesn't matter what language you know, crappy programmers will always write crappy programs.
A bad assembly programmer will write unreadable and unmaintainable code.
A bad C programmer will write unreadable and unmaintainable code.
A bad Java programmer will write unreadable and unmaintainable code.
A good assembly programmer will write beautifully elegant and efficient code.
A good C programmer will write beautifully elegant and efficient code.
A good Java programmer will write beautifully elegant and efficient code.
Learning assembly language will help you understand how the guts work, and yes, it can be used to optimize the last 20% that compilers can't do (ie for embedded and graphics). It will help you crack registration keys, solve stack bugs, and write viruses because you will have a better understanding of why certain behavior is prevalent in computer code. But you don't absolutely require it to write efficient and clean code.
And this is at least the third time this has been promoted on /.
So? HLA is a good teaching tool. Randy is now a unversity professor.
Even if you don't use assembly, it does make you a better programmer. Learn assembly and pointers make sense. As a teaching tool, assembly has some advantages. You are programming an abstract machine at a simplified level. (If you read Knuth, you are programming a fictional abstract machine!) Some data structures and algorithms are easy to explain in assembly.
Plus, understanding assembly gives you a sanity check on C code. For example, look at the hoops some C programmers go through to get the double length result of a multiply or the quotient and remainder from a divide operation at the same time.
In particular, I remember a library routine that came with a well known MS-DOS C compiler by a very talented programmer. I could see that the source code was written in C and it was a convoluted mess. Worse it was wrong! About 20 lines of 8088 code would have been equivalent (or 4 lines of '386 code). The author was trying to do some low level bit whacking in C that should have been done in asm in the first place.
One thing that many programmers take for granted these days is that compilers produce correct code nearly all the time. They've gotten really good over the years and are really a testament to the quality of compiler engineers. Even so...
I've been a programmer for over a decade and I've always found the worst problems to debug are when the problems aren't in your code but in the compiler. Compilers are programs too and have their own bugs. They aren't always 100% accurate at generating correct machine code for your source. And until the compiler gets fixed in the next patch or rev, you may be stuck with broken code unless you switch compilers.
Sometimes disassembly of the problem code and inlining correct assembly can be the difference between shipping a product or missing a deadline because you've spent months sitting around for the next compiler version to fix your problem for you.
ed
I didn't start programming until I was in my mid 20s (degree in Chemistry). I liked fiddling with Java but always felt uncomfortable about what was going on underneath the hood. So I took a few classes. The first was Computer Systems Architecture. We wrote a game in x86 assembler. That class completely opened up my understanding how programs actually worked. To understand the stack, the state machine nature of things, and memory was an awakening experience.
Now (~5yrs later) I'm a fully capable programmer and an even better designer. My preference is C, binary file formats, networking protocols, crafting elegant solutions for multiplexing IO. I'm lead on a project used in production by many companies large and small.
I genuinely feel assembler is a vital part of the learning process for a programmer.
They teach assembler in my school's CS program second year. The whole class is basically 8086 assembler and then the end of the class gets into more advanced assembler coding (like AT&T style and NASM). The class ended with an overview of Jasmin, which is basically a Java assembler... the purpose being to understand how the JVM works and to code directly for it. At the time I thought this was strange, but considering the only "Programming Language" courses my CS program has are in Java, this actually made sense. (Note: other classes expect a lot of programming, but expect that you already know C/C++/Java/whatever.) This teaches the graduates here who aren't thinking about it already to be wary of what kind of code is being executed by the JVM.
I do think this is important, and am spending a lot of time on my own to learn as much as I can assembler/C-wise, since I know jobs I get here and there (like my summer job) will require high-level languages (Java, C#) and I don't want to lose that low-level knowledge.
It's actually harder for us (the younger generation), because there have been so many abstractions that you really have to be on top of things to understand what's going on at the machine level. At this point, programs tend to go from source to bytecode to being executed on the physical machine, and in order to optimize programs you have to know what's going on at every step. That and you have to have a lot of discipline to learn the low level stuff, since the high level stuff can make you so productive without even thinking about it or putting in any effort. But this discipline ultimately makes you a better high-level programmer too, so it's worth it regardless...
I learned 6502 assembly in the 1980's on a Commodore 64. I even have it all imported into my system, into a few D64's full of software I wrote myself - to run in an emulator for old time's sake. (Gee, hard to believe that some of the programs are almost 20 years old now.)
I had a lot of the habits that you describe, and I now program simply in C++ for either Linux or XP.
However, I had run into some performance issues with certain critical loops that were executed millions of times, such as a loop that iterates through pixels in image processing, and I wanted to view the disassembly of it. I understood enough assembly to be able to optimize a tight loop in a plain C code routine, and verified that the assembly was just as good as handcoded non-MMX assembly. (Some compilers do an amazing job now) The only way to improve the performance further in my case, would have to have written MMX/SSE/SSE2 for this 0.05% of a computer program, but even so, I deemed it not to be still worth the effort.
Now, if you are talking about realtime video filters, such as deinterlacing and sharpening (think Adobe Photoshop style plugins executed 50 or 60 times per second for every interlaced video field at 60 Hz for NTSC, 50 Hz for PAL), you still need matrix math operations such as MMX/SSE/SSE2 assembly language if you want to do lots of video enhancement realtime on a live video source.
One example program is the open-source dScaler project - dScaler Realtime Video Processor . You can do REALTIME sharpening filters, denoising filters, motion-compensated deinterlace filters, 3D-like chroma filters, diagonal-jaggie removal filters, etc, all the above simultaneously, on a LIVE real-time video source from a cheap $30 PCI TV tuner card, on today's high end Pentium 4 and Athlon systems. All this would not be possible without assembly language. Now, they are talking about adding realtime HDTV enhancement (1080 interlaced -> 1080 progressive). Run your cable/satellite/DVD box connected to your home theater PC running dScaler, and hook the home theater PC to your HDTV, and the live homemade "upconversions-on-the-fly" you are seeing are shockingly better looking than the bad quality upconvered video you watch on TV; (Important: Don't use S-Video output, connect the VGA output directly to the TV using a component-output adaptor. It's 6 times sharper than S-Video. For more information, see AVSFORUM's Home Theater Computers Forum section for more information about getting HDTV-quality video out of your computer to your HDTV television, especially if the HDTV television does not have a native VGA input.)
(For watching live realtime videoprocessed video, I don't recommend a $30 TV tuner card, the power users like to get more expensive cards such as approx-$250 PDI Deluxe card, which is a Conextant 23882-compatible card that actually has a Y-Pr-Pb component input for computers! Supposedly better analog signal-to-noise ratio, better A/D converter electronics, better power filtering.)
The point is that you don't need assembly language most of the time, but there definitely sure are times that it's exeedingly, absolutely critical.
When I first stumbled upon this I had no idea how many system this actually works on: When I tested on my system, by chance of faith, nothing happened. I am using 2.4.26-rc3-gentoo. So I thought "no big deal". I now know my kernel seems to be the only version on this planet protected.
I then asked people on irc channels if anyone were willing to test this before compiling other kernels myself and I instantly got replies like "Works, took down free-shell provider #ali on EFNet". People who tested on their own systems also confermed crashes. I'm not sure if I cut&paste the phrase "lame free-shell provider" from my irc window or if I actually did type this myself.
I do not encourage hacking, doing so is bad whatever your target it.
Btw, the "l33t howto" is meant to be funny, you know.. a joke.
9/11: Never forget it was a false-flag operation
If you don't understand what's going on at the machine level, you are going to run into trouble eventually because your perception of the runtime environment is slightly or even wildly incorrect.
Example: When programming in languages like C or C++, you have to know what a stack frame is and basically how it's implemented, so that when something goes wrong you can correctly diagnose the problem. If you just know the corresponding language syntax (i.e. the scoping rules), you won't have the first clue where to start.
This applies to Java as well - just replace "machine code" with "bytecode" and "CPU" with "virtual machine".
In all these cases, a compiler takes your program specification (the source code) and produces the *real* program (in machine code or bytecode) - and that is what is executed and that is what you will be debugging and analysing. If you don't understand basically what machine code is and how it works, you will keep running into brick walls. I've seen this over and over again - the new graduates who just can't see why their program is behaving the way it does, because they never did assembly programming, or studied the run-time environment of programming languages, and so have these bizarre ad-hoc mental models of what's happening that bears little or no relation to reality.
I'm not saying that assembler should be used any more than it is currently, but if we are going to be using compiled languages (C, C++, Java), then it simply *must* be taught. There is simply no way to avoid this if you want to be a half-way productive programmer in those environments.
So you're saying that a utility written by an incompetent assembly programmer was slower than the shell script? Speed isn't an inherent property of assembly?
Shocking!
Due to the advancee in hardware capabilities Bloat is now excusable - and encouraged. It is cheaper to buy a big ass computer that can crank and hog bits than it is to pay somebody good money to nitpick over every bit of resource that their programs consume.
;-) ) SEVERAL computers? I may be mistaken, but I do not think that you still have the mentality of "The world's market in computers is probably 5 or 6 of them" (food is burning on the stove, no time to get the exact Watson's quote ;-) ).
;-)
What if you want to run your app on (God forbid!
Last time I checked the price difference between a $100 ARM-based unit and $5,000 G5 was still $4,900, so if you intend to run your program on a 1000 units you can as well pay $900,000 to a guy who can port from the latter to the former and keep the cool $4M.
Or if you think about selling your solution (HW+SW) to some millions of customers... (Wow!)
Paul B.
Much more useful in most systems is knowledge of the system components at a level higher than the CPU--details about how the OS works (scheduler, memory management, etc.), how the language you're programming in is designed (is tail-recursion done without a stack?
Of course, some of these, even if you don't HAVE to know assembly language to understand them, knowing assembly language makes it easier to understand. Most people who know assembly language have a much more concrete view of the differences between pointers and values. When you have personally had to think about whether to push the value or the memory location, when you have to think about which addressing mode you need to use in that situation, it makes the idea of pointers and stacks and calling conventions a TON more concrete. It also makes many of the ideas of sequencing and linearity a lot more concrete. This is something that I've found a lot of new programmers have difficulty with - they have trouble thinking in straight linear fashion, and assembly language absolutely forces you to think that way.
Anyway, that's the reason I wrote my book on assembly language. See my sig for more info. Randall Hyde actually wrote me a pretty good review on barnesandnoble.com. I got a good one from Joel Spolsky, too.
Engineering and the Ultimate
I agree with the premise of the article and I understand the logic behind his arguments. I too, believe every programmer should have a strong math foundation and learn assembly language - regardless of the architecture. Generally speaking, knowing the "nuts and bolts" is what separates the 4-year CS degree programmers from the 2-year, fast-track-to-developer "programmers". All too often schools do future developers and the companies they end up working for a disservice by churning out less-than-ready programmers with a weak foundation in the why's and theory in exchange for a bunch of how-to's on a particular language syntax.
However, regarding the article, there's a piece of the puzzle missing. In the case of a byte-code language like Java or C#, the code isn't compiled to assembly or machine code where it's easy (other than a debugger disassembly) for a developer to get at. In the case of C# or any other .NET CLR language, it's nearly impossible to know how the compiler generates assembly instructions. In the case of Java, one may be able to study the JIT compiler of an open-source implemenation like Blackdown but that's not necessarily the best option or even the most efficient implementation either. There are so many different JIT compilers for Java, which one would you study? With the .Net CLR, the only possibility would be to study the source to ROTOR to gain any insight into the JIT compiler.
The implication of the article is that the programmer has some access or insight to the compiler output other than looking at the object files. I submit that, especially in the case of a byte-code language, that insight isn't nearly as available. After all, we're talking about programmers that don't know assembly, in all probability don't know what an object file is, and perhaps don't have the expertise to know how or where to garner such information.
I would like to see these programmers learn the difference between the stack and the heap. It's not exactly easy, especially when you don't know where to begin, to figure out how the compiler for a high-level language creates assembly instructions from source. Learning that information (think YACC and Bison) is on the same level as assembly, combinatronics, and two's complements. Again I say, it's not enough to learn assembly - Without the solid background in math, data structures, and other concepts, the 2-year degree programmer is, in all probability, lost. You can't learn or use assembly without two's complement, binary, and hex arithmetic. How could you figure out how to add 64-bit numbers when you only have 32-bit registers?Like I said, I don't disagree with the premise of the article. However, simply learning (or trying to learn) assembly is not the cure-all for all programmer deficiencies. You just can't take a person that can't add 2 hex numbers, run them through assembly 101 and expect the Mona Lisa of software. I suppose there are broader implications to learning assembly like having to learn all of the aforementioned skills first but that was never indicated in the article.
If you do what you always did, you get what you always got.
Retail, banking, most all of the big financial companies all have decades of legacy COBOL programs hanging around that need maintenance and upgrades. It's not uncommon for a Fortune 500 company to have several hundred programmers writing in COBOL, but have fewer than a dozen programmers capable of writing in assembler. Of those, perhaps one or two is fluent enough to maintain an ancient BAL (Basic Assembly Language) program.
There are many more jobs for COBOL speakers than there are for BAL speakers. A community college's primary focus is very different from that of a research university. They are there to teach skills that will make its students employable. A COBOL coder can get a job. A BAL coder can get in the unemployment line behind the IBMer with 20 years BAL experience.
John
I still think that it's extremely important for a programmer to understand what's happening at the lowest level in the target system. It's also very important for low-level work such as bios code and for small system programming. On some small embedded systems, a programmer can actually be concerned about efficient stack use, etc, and if you have limited RAM, the bloated spew that a C compiler puts out just might not be acceptable.
Understanding of assembly / machine code can also be quite important for hardware people. Example: when debugging a new board design with a logic analyzer hooked up to the system's buses, C/C++ knowledge isn't going to help decipher that long list of numbers being transferred from RAM to processor.
What you are advocating is that the students should understand the cost of the code that they write and you are saying that understanding assembly is the way to do that.
But here is where you are missing the point.
It is not the only way and sometimes it is the wrong way.
With virtual machines and interpreting languages, knowing the machine code of the CPU becomes pointless. You need to know what is costly for _your_ language.
What I think that you _really_ meant was that your students should understand compiler technology. That is how you understand the cost of different language constructs in a way that is portable across compiled, interpreted and byte code languages. This is unfortunately not something that you can have beginners learn, it is more of a third year thing.
Also, I've programmed professionally for 10+ years in most programming languages known to man, and I agree with your parent poster. Write simple and sensible code. Optimize when needed. More often than not, you will find that the code is fast enough. If it isn't, then you saved so much time writing the code originally, that you can spend a lot of time optimizing the problem areas.
If you disagree with this approach (write simple code and optimize when needed) then I'm willing to bet that you've never programmed outside a university environment.
The Internet is full. Go Away!!!
I must disagree. Without having any resources, I would suggest the bulk of software developers are building business applications. You know - the non-computer science stuff. Not compilers, not operating systems, not the latest whiz-bang game, etc.
A number of us are true computer science students, and we cut our teeth in assembly, so-to-speak. That being said, I disagree that it is necessary (or even good) to understand the machine at the low-level. I have never done x86 development (instruction set and memory models never made sense to me) and I have never seen the JVM byte-code that I use daily. Nor do I care to.
If you're writing code that is supposed to be optimized for the machine, you've missed close to a decade of compiler development. Dealing with multiple pipelines, delayed branching, etc is best left to a machine. I have more pressing issues to solve - like delivering good software.
The compiler optimizations are pretty astounding today. The JVM run-time optimizations are amazing. My knowledge of hardware architecture is 20+ years old. I'll trust the compiler writers as well as the JVM designers.
The focus for the bulk of us is on maintainable applications that can be delivered "on time, within budget, blah blah blah." Illogical algorithms and/or writing code for the computer and not for the human don't help anybody. In fact, I'd probably just throw it out and start again - it's the fastest and least stressful way to deal with it.
The most important tool to hone and keep tuned is your mind. Those with good logical reasoning and critical thinking are going to do well. They are the ones *I* look up to.
I would suggest teaching unit testing (ie, JUnit) - including what to test and how to test correctly (both difficult topics) - and debugging skills (which I wished I had more of when I started) instead.
If you want to cover hardware, use a book like CODE (by Charles Petzold) to give people an idea of computer structure. Nothing more than that - and even that isn't required.
Not only should the programmer learn assembler, they should also learn Operating system mechanisms. So they understand how their program is operating relative to those mechanisms. but that is not enough, they should also learn CPU design. How else are they really going to understand? Actually they really need to learn about materials science. Not enough really is it? Physics, laws of thermodynamics, electronics, quantum theory. Then when they program they will *really* know what is going on.
Alternativly they could learn more about the problem domain, so that the design better reflects the problem domain and will be more flexible in the changing environment. Nah, that really would be a waste of time.
On behalf of all decent programmers on the planet, may I say..
DUH!
Imagine a mechanic who has built his own engine from scratch, or a painter who has made his own paint, or a musician who crafted his own instrument. Those seeking to exercise their art on the lowest possible level will always have superior insight into those that don't.
SO WHAT! Programs should only be optimized if:
1) the program is doing stuff so intensive that it runs slow
or
2) It is being run all the time in the background by the system and can slow down the system as a whole.
98% of the time it just does not matter.
I agree with points 1 and 2, however, if you're doing any non-trivial programming, I wholeheartedly disagree with the 98% figure. Not every bit of code is a throw-away piece. If your code only runs occassionally, and it's not performance critical, then yes, make readability your main priority.
But a lot of times your code is performance critical, or at least will be in the future. Code has this tendancy to stick around once it's actually working. Too often have I seen code that, when it was written, was not getting used a lot. It worked, so nobody thought anything of it. As they scaled the system up, that code became a major bottleneck and eventually somebody had to go back and optimize the hell out of it, or simply throw it out and rewrite it to be fast.
It's good to write readable code. But it's also good to write code that is reasonably optimized at the same time. No need to go to extremes, just don't do stupid things like passing around huge 4 kilobyte variables to functions and such (example I've seen). Pass a pointer instead. Or a reference. Just write smart code. You can still make readable code while making it optimal enough to scale pretty well. Only very, very rarely do you have something that needs to be super well optimized, and then you usually are better off writing the critical sections in machine code anyway.
Easilly readable code is FAR MORE IMPORTANT.
Easy readability is far more important when that code scales to the level you need it to scale to. Readable code that doesn't actually work in the system you're trying to put it in is worse than useless.
- Give a man a fire and he's warm for a day, but set him on fire and he's warm for the rest of his life.
> They do dumb things like multithread something that is CPU bound becuase they have no understanding of how what they write actually gets executed.
Erm, if you want interactive response out of a CPU-bound application, multithreading is exactly what you want to do. Timeslices are smooth, waiting til your computation finishes is jerky. You want snappy interaction if it's user input driving the calculation in the first place.
I agree. It sucks that a lot of programmers think learning assembly is just something they should do some day to gain better insight.
Personally I think the curriculum for coding should begin with asm, and the student should work his way up to the higher level languages.. c, pascal, and finally java or perl.
Than it wouldn't be an afterthought that some things are actually easier to accomplish in asm (most things depending on your line of work). Not to mention the eventual nested nested nested loop that just needs to be optimized.. shouldn't be a roadblock for any programmer.
bite my glorious golden ass.
Many posters seem to be promoting compilers over learning the nuts and bolts of a particular architecture yourself: somebody had to learn it to write that compiler! Probably a whole bunch of somebodies, because writing a good compiler is a hard task.
Even then, if you don't understand how your language is compiled, you cannot properly debug your code. With C/C++, it isn't just a case of stack frames, there's memory allocation, pointer dereferencing, etc. Sometimes you need to look at the assembler level to get a grip on some bugs.
I know from experience that compilers are buggy, don't perform the same way with the same switches on different platforms and while they may optimize generally better than a human, sometimes it's a bug to optimize at all!
Some appreciation of the assembley level is better than nothing at all.
insecurity asks the wrong question irritation gives the wrong answer
You're mixing examples. In the first, we're talking about an interpreted language being written in a compiled language, and whether or not the interpreted language can still be faster.
You're talking about a program in an interpreted language that spits out machine code. It's kind of like pretending a horse riding a human is the same as a human riding a horse - although the same two animals are involved in both cases, the overall situation is completely different.
That said, I still say Perl is going to have a darned hard time being faster than C since it has to precompile the program every time it executes whereas a C executable is already in machine code. Not saying it can't happen, just saying a situations where it happens probably aren't all that common.
Some people say you need to optimize. Other people say you need a better algorithm. So who's right? Both.
/(.+)\s(.+)\s(.+)/" and "($one, $two, $three) = split ' ', $things". However, knowing assembly does help. Since I know assembly, I know that the latter results in some executions of "scasb" to find spaces, and seperating the string, whereas matching a regular expression is pretty complicated, despite the fact that someone has really optimized it and it doesn't do as bad as it could.
If there's a better algorithm, you need to use it.
If optimizing your code can make it 10 times faster, you need to optimize it.
Now if optimizing your code will yeild less than a 2x increase (with less than simple changes), then perhaps you shouldn't bother, especially if it makes the code a lot harder to work with, but the same applies to algorithms as well. There's no need to implement a complicated sorting algorithm to sort five items, even if it will double the speed.
The problem is people usually don't know that their code can be optimized anymore than they know that a better algorithm exists.
People don't intentionally write slow code, they write slow code for the same reason they use slow algorithms, because they don't know any better.
Just as you should research algorithms for whatever you're doing, you should also learn how to write fast code in whatever language you are using. The only reason assembly language does well here is because more code equals more work for the processor, whereas in high level languages fifty lines code may execute very quickly while one single line elsewhere takes twenty times as long as those 50 lines.
Learning assembly isn't necessary. All that necessary is knowing what the difference between "($one, $two, $three) = $things =~
BTW, a compiler being "optimizing" doesn't mean it creates the best code, it just means it doesn't create as bad of code as it could. You can create a compiler that always turns certain C statements into certain code, then you can make an optimizing one that eliminates some code since it knows that this followed by that doesn't need a few of those instructions, but you can't replace someone who knows what they're doing.
After all, isn't the reason you're supposed to use C's strcat instead of copying the string yourself because the strcat uses the movsb instruction which is faster than any loop the compiler would create on it's own?
Of course, even so, you could still do better using assembly, depending on what you're doing. If you implemented pascal type strings you would remove the requirement of doing an scasb on the strings to find their lengths which you need to do the movsb. This could be a major optimization depending on the size of your strings and how often you're using strcat.
Of course this is after thinking about the design for awhile. Rarely have I just gone and said "Ok I'm going to code this function now." without thinking "Ok what will this break? What will I want to add in the future and will it mean redoing this a different way?" I spend alot more time thinking about how to get the best flexibility out of a design than actually coding. I tend to think up the data structures first, by figuring out what data I need and what I'm going to do with it. Once I have that, I construct objects around the structures and figure out what methods I need to manipulate them. Everything revolves around the data, not the process. I try to keep the objects segregated on a "need to know" basis so that it's easier to swap out one implementation for another later. I don't want to be sitting forever rewriting the entire project because I've found that quicksort sucks for this data and I'm better off with a heap than a linked list.
When I actually get around to coding, my first concern is clarity. If I can't read my code, I'm going to be screwed when I have to debug it tomorrow, and totally lost when I need to add a feature or rework something next month. I tend to name my variables and functions for what they are, sometimes with fairly long names. Sure it's a pain in the ass to type cosine_offset and I can typo it alot, but it's a hell of alot easier than figuring out that w stands for cosine offset a month from now. Compilers catch name typos, they won't tell you what the hell you were thinking when you wrote the code. I find the stupid "hungarian warts" where you get names like pfstrqlrdwFOO are absolutely worthless. The only prefixer I use is p, for pointer, because pointer screwups are bad and it's possible to forget something is a pointer and requires different operands. I can usually figure out if something's an int or float or string pretty easy by following the names and what functions it comes from/goes to. GetInputString(myinput) makes it pretty obvious what myinput is, I don't need pcstrz in front of it.
Having other people able to read your code is a huge bonus. Readability = less time debugging = more time to improve or optimize later. I don't know ASM, but if my code is readable by someone who does, it's alot easier to get them to help me if they don't have to spend a week going "WTF is this variable for? What is the point of this function?"
Another thing I do that was taught to me by a very realisticly-oriented CS professor is go for low linecount. Outside of clarity, linecount is king. Why? Because fewer lines are easier to comprehend, tend to have fewer bugs, can be easier to optimize (into ASM for example). Functions over 50 lines are rare for me. My functions do exactly one thing that they're named for, I don't group an entire 9 step procedure into a single long function. If I have to do that then it'll be a function calling a bunch of other functions in order. That way when I have a bottleneck, I can just rewrite 25 lines of code instead of poring over 250 looking for where the slow code is and misunderstanding parts of it.
Granted I'm not the best programmer. I'm probably not even an average programmer around here given my lack of experience. I had a basic course in ASM at college that mostly covered MIPS, and an EE course that covered up through basic CPUs and registers. I know some of the concepts but have never written in ASM. Maybe when I finish the main parts of my current project I'll learn x86 ASM so I can optimize it.
Introducing the new Occam Fusion! Now with sqrt(-1) fewer blades!
as there are already some 400 posts, perhaps noone's going to read this. Still, here's my two cents.
;)
Randall states that CS students don't learn assembly language anymore, or that if they do, they aren't being taught well. I have to disagree.
In our CS curriculum (Universiteit Leiden, NL) we had courses that learned us
(1) how to design a CPU, including ALU, load/store architecture and microinstructions for a fake CPU that interprets (a subset of) the MIPS instruction set. (digital systems design)
(2) write a compiler from a subset of pascal to MIPS code. The end result had to be tested on SGI Indy's. Present students still have to do this, but need SPIM, since the Indy's have gone, how sad.
(compiler construction *)
My point is that our curriculum is arguably representative of the standard CS bachelor, at least in Europe, and that learning everything from high-level languages up to micro-instructions greatly surpasses dabbling with programming in assembly.
I do agree with his main point though: you should know these things. My feeling is that more people are already acquinted with Randall's dark art than he thinks.
(*) offtopic: this course was the major stumbling point of half of all CS students. Some handed in the assignments 4 years late, after their final MSc paper.
It appears that either you are good at the math side and suck at coding or it is the other way around. I did fairly well here, but I won't go into my math
I'll give you real hard numbers.
I look after pnm2ppa, which is a print processor to convert pnm image bitmaps from Ghostscript to PPA, which are HP's worst ever printers. Ever. They are so dumb, they make Bush look like a Mensa candidate.
When I first came to the code, it was written by someone who thought they knew better than the compiler, and structured the code accordingly.
We had hand-unrolled loops, unusual and rampant use of the "register" keyword, the occasional volatile, and strange padding in structures to try to align the data to what he thought the processor would use. There were arithmetic "if"'s, nasty pointer usage, throwing away type information (ie casting to void *), and strange methods of going through the data.
When I hand simplified all the code, it went about 15% faster. In inner loop case, over 100% faster by re-rolling a single inner loop because the person who unrolled it didn't understand how branch prediction worked and even less about large data structure walking and L1/L2 cache interaction. gcc 3.3 improved the performance of the code by about another 15%.
But you know what made the biggest change? A simple replacement of floating point gamma correction with a lookup table ordered in the simplest possible way. That shaved literally 30+ seconds off every page render on my PIII/800.
And you know what? The new GLUT is shorter and more readble, and is easier to tune for color correct output. It costs about 4 MB of RAM.
Assembly has no place in the modern day programmer's skillset. Humans do not know how to schedule instructions properly. They do not know how branch prediction will work unless the data they use is static. They should not waste their time on understanding the difference in L1 cache strategies (which are wildy different in the x86 families and AMD Opterons). They cannot work out how to best keep the data pipeline full on a wide range of processors. But you can help compilers work this out for you by:
* Design the system in the correct way first time - what do you actually need to do? Don't do anything else
* Learn and keep up with the best generic algorithms for a wide range of activities (such as sorting, arrays, dictionaries, etc) and keep a library of well tested and bug free examples
* Write simple, clear, maintable code
* Never, ever, ever throw away type information
* Never, ever, ever throw away data aliasing
* Never, ever, use the "register" keyword
* Never use "volatile" unless you know why you need it
* Document tests, data and code properly. This pays off big time every time you come to add new features or fix old ones
Lastly, program like a software engineer not a cowboy. Code must be correct then fast. Not fast and wrong.
Andrew van der Stock
That seems to be a bit of a straw-man argument, arguing against the use of libraries in C, but for them in Perl.
All things being equal, any CPU-bound program written in C is highly likely to be faster than the same in Perl.
The reason I write lots of Perl and hardly any C these days is because virtually everything I write is I/O bound and just doesn't need the performance. I may as well use Perl and save myself a heap of time.
Oolite: Elite-like game. For Mac, Linux and Windows
Naturally it's helpful to use libraries in C. However, the 'libraries' I speak of in Perl are actually built-in language features that don't natively exist in C. If you read the post I was replying to, you'll see that the poster was talking about *re-implementing* all of this in C. Naturally it wouldn't have to be re-implemented in Perl, because it's already a part of Perl. And if you used external libraries that you didn't write yourself in C, then you'd have to make sure they were (a) equivalent to Perl's built-in language features, and (b) faster.
:)
All things being equal, any equivalent program written in C is highly likely to be far longer, more complex, and more difficult to write than the same in Perl--that's because Perl does a ton of things for you, many of which I have already outlined. Of course, if you don't need these features in the first place, it might make sense to write it in C. But given an arbitrary Perl program and then being tasked to write an 'equivalent' program in C... well, it's just going to end up being way more complex. If that Perl program uses eval, you might just have to write an entire Perl interpreter.
Of course this entire line of argument has been ridiculous from the start--Perl and C work together just fine, so you can always use Perl for the rapid development, and C for speed, as needed. In fact, there are tons of Perl modules that just consist of a Perl API to a bunch of C functions, usually for speed, or just to use an existing C API in Perl.
I know what you mean about being I/O bound--I do a lot of PHP programming. Now, PHP can be an embarassingly slow language sometimes, but that doesn't matter when you're busy waiting on a network connection to a database!
pb Reply or e-mail; don't vaguely moderate.
So, once again everyone is coming out of the woodwork to explain why this article is either right or wrong based entirely on the tiny subset of programming tasks that they actually do.
For some applications - embedded systems, drivers, games (my specialty), or any other real-time application - assembly is either very important to understand or actually essential. There is (or was) no other way to program the PS2's vector units, for instance.
For database work, batch or text processing, network admin, or anything else where speed is nice but not a show-stopper, "make it work" is much more important than "make it work fast."
I've always felt knowledge of assembly makes one a better programmer regardless of the application. Even on a high level, understanding why (unnecessarily) using data types larger than the system's register size is going to hurt performance can only be a good thing. Understanding assembly is fairly fundamental to understanding computers, as opposed to just using them.
sig fault
I'm a recent grad (2 years out of CU-Boulder) and we still had a course in assembly programming for the 8086. This was part of a series of courses that we called Digital 1,2,3 or the love your fellow engineer courses.
:) 4. It's efficient. Now, if the code requires next year's processor to work in a reasonable way, it fails at #1. If it's job is to RIP MP3s, it's job is to be fast.
They put CS, ECE and EE students together and grouped us up for the first two courses - assembly programming was the first. Wiring chips together and programming FPGLAs was the second. The capstone was a general "how computers work from top to bottom" course that discussed processor design and had us writing some MIPs assembly. Anyway, it was a miserable series of classes to actually take, but verry useful and great in getting engineers from slightly different disciplines to practice working together. The CS guys tended to really help a group in assembly programming while the other guys tended to be more competent when wiring things together.
I really feel that the time I took understanding computer achitecture is a bit more useful that the time I spent learning assembly - although to a certain extent learning assembly forces you to learn the archeticture. Keeping in mind that with a relatively small set of data, all the work will be done on the CPU at blazingly fast speeds, while a single fetch out to the disk changes the times you're messing in by orders of maginitude.
Being able to read assembly is good for debugging but I'm not convinced it is required to write great code. Pure blazing speed is important for some applications, but for many it just isn't. The guy in the article mentions word processors and how they aren't 16,000 times faster than they used to be. Frankly, I'm not sure how you'd measure. I know the Macs I used in high school were slow enough that a fast typer could outpace their ability to render new characters, but my current word processor puts up characters quickly enough. It also checks my spelling and grammar on the fly and unlike old word processors it's more or less WUSISYG and not markup. The only slow part is launch time. That's more a process of big code requiring disk access to be loaded rather than slow code.
For me, good code is the following: 1. It gets the jobs done. 2. It's very readable. 3. It's designed in such a way that I can change it without destroying the system
For most applications though, the easiest algorith to read is the best one to use. That said, I agree with the author that it's best to know when you are writing code that is inefficient. It should make you wince.
I winced a lot when writing a mock-up of simple app that ran against the contact database of my customer. However, despite each request looking through every record in 2 tables I worked worked with instead of using some sensible SQL, it ran effectively instaneously on an average machine. So would I look at that level of ineffiency as aweful code? Probably. Should I? I'm not so sure.
I do disagree on several points that have been raised, but they don't defeat the final conclusion:
- I do agree that premature optimization has been lethal to many software projects. But I have met as many people who commit PO in HLL's as assembler, so this is not an argument for or against the language.
- The comparisons of startup times and code sizes with the '80s (the 80's! Why, in the 70's we had only... never mind) are amusing, but uninformative; there are a lot more services embedded in the average OS or word processor today. There is a degree of bloat, but the statistics are misleading.
- Hand-crafted assembly code is unlikely to be optimal in light of processor pipelining, multiple execution units, and scheduling. I used to know how many clock cycles each instruction in the PDP-11 instruction set would take to execute for each addressing mode; this information is not nearly so useful for today's processors.
- There are architectural considerations beyond assembly. As early as 1983 a colleague of mine brought a VAX-11/780 (a screamer for its day) to its knees, and came to me complaining bitterly about the processor and/or compiler performance. It turned out that the code in question, which used massive multi-dimensional arrays (in FORTRAN), had compiled into a two-instruction loop (three-operand multiply and an increment/branch), but the code was generating six page faults per iteration! He would not have avoided the problem just by using assembler, but my deeper understanding of the machine led to the identification of the problem.
All that being said, the title of the article is "Why Learning Assembly Language is Still Good." At the end of the day, while I opt to write in Java (or Objective-C, which I'm just picking up), I am better equipped to write good code knowing assembler, and a few other things behind the language and runtime I'm using.
I interview people for jobs all the time, and you can tell right off who are the ones who've been taught a language as a tool (VB'ers), and who visualises a computer from the ground up. They think around problems and beyond the API.
Actually, HP's Dynamo project showed how JIT'ing a machine code into itself (like JIT'ing x86 code INTO x86 code) can give you speed advantages. The reason is that the JIT can look at the runtime characteristics of the code and do optimizations based off of that. It can move code so it's on the same page as other code that is called in sequence, optimize branches so that there is a higher chance of branch prediction and to save the pipeline.
Engineering and the Ultimate
Speaking about Perl and Assembly, it is important to mention that there are modern object-oriented assembly languages with asynchronous I/O, events, threads, multiple inheritance, garbage collection, built-in Unicode support, etc. See: Parrot Assembly, and IMCC:
"IMC stands for Intermediate Code; IMCC stands for Intermediate Code Compiler. You will also see the term PIR which is for Parrot Intermediate Representation and means the same as IMC, but for some each Parrot developer has his favorite term. PIR was the original term, where IMC seems to be the vernacular. It is an intermediate language that compiles either directly to Parrot Byte code, or translates to Parrot Assembly language. It is the preferred target language for compilers for the Parrot Virtual Machine. PIR is halfway between a High Level Language (HLL) and Parrot Assembly (PASM)."
How Is IMCC different than Parrot Assembly language?"PASM is an assembly language, raw and low-level. PASM does exactly what you say, and each PASM instruction represents a single VM opcode. Assembly language can be tough to debug, simply due to the amount of instructions that a high-level compiler generates for a given construct. Assembly language typically has no concept of basic blocks, namespaces, variable tracking, etc. You must track your register usage and take care of saving/restoring values in cases where you run out of registers. This is called spilling.
"IMC is medium level and a bit more friendly to write or debug. IMCC also has a builtin register allocator and spiller. IMC has the concept of a "subroutine" unit, complete with local variables and high-level sub call syntax. IMCC also allows unlimited symbolic registers. It will take care of assigning the appropriate register to your variables and will usually find the most efficient mapping so as to use as few registers as possible for a given piece of code. If you use more registers than are currently available, IMCC will generate instructions to save/restore (spill) the registers for you. This is a significant piece of every compiler.
"While it is possible to write more efficient code by hand directly in PASM, it is rare. IMC is still very close to PASM as far as granularity. It is also common for IMCC to generate instructions that use less registers than handwritten PASM. This is good for cache performance."
For a good introduction to Parrot, read Parrot: Some Assembly Required by Simon Cozens. There is a great article (also on ONLamp.com) Building a Parrot Compiler by Dan Sugalski (I have no idea why it wasn't posted on the Slashdot front page).
(By the way, for those who read off-line, here is a printable version of the linked Why Learning Assembly Language Is Still a Good Idea article in one piece.)
Sincerely,
Pan Tarhei Hosé, PhD.
"Homo sum et cogito ergo odi profanum vulgus et libido."
Superficially, that seems an obvious truth, but it doesn't necessarily hold in practice for several reasons:
In other words, with today's compiler technology, and more importantly today's run-time environments, C is no longer automatically the king of performance, and it is both theoretically and practically possible for much higher level languages to outperform even hand-optimised compiled C code.
Of course, the price you pay is the initial overhead for the JIT compilation process, usually when a program first loads. However, this is one area where rapidly increasing hardware speeds really tells, because that directly reduces the overhead of that bootstrapping process, so the field of more level the faster hardware gets.
I expect traditional, compile-only technologies to fade into the background over time; in the programming language "performance vs. safety+power" spectrum, they aim at a target nobody will need to hit any more. There will always be a need for LLLs, if only to write the underlying platforms to support HLLs, but for regular application development, their days are numbered.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Being a programmer and not knowing at least the basics of assembly language is like being a doctor and not knowing what a cell is. Depending on your specialty, you can get by all right about 99% of the time, but if you hit a problem that stumps you, you won't be able to delve deeper into it because you won't know how. A deeper knowledge gives you insights, because where the rubber hits the road, it's all bits turning on and off in registers. If you don't understand what those bits are doing then it might as well be magic and it's time to break out the prayer beads.
The Moore-Murphy Law: The number of things that will go wrong will double every 2 years.
In theory, a really good assembler programmer could produce more highly optimized code, but not on a consistent basis and within schedule constraints.
I don't argue that assembler isn't useful. I learmed more about how computers work wwhen I took an 8080 assembler class in college. And for certain problem domains like embedded systems, assembler is often necessary. But I don't write any more code in assembler than absolutely necessary.
The majority of 3D optimisations is deciding what not to draw. Quadmaps, octrees, BSPs and so forth, are all techniques for quickly discounting large areas of polygons. The bottleneck of most 3D games is the drawing of the display. You may, perhaps get 1% or 2% improvement using assembly, but I doubt it. Today, compilers can optimise code pretty well. There's little difference in raw speed between C and assembly.
In addition, games don't just compete on framerate. Games have to be very, very, very stable. If a word processor crashes, people seem to be able to live with it. If a game crashes just as you were about to rack up a new hiscore, then the player is going to be very cross indeed. The more assembly is used, the more unstable the game is likely to become.
Thirdly, there's the difficulty of time. Assembly would obviously take more time, for benefits that are pretty much negilible. Coding inner loops in assembly really wouldn't improve framerate by any great degree, and would just contribute to the overall expense and instability of the system.
There's no problem knowing assembly. In many cases, understanding how computers work is very useful. But coding in assembly on modern PCs/consoles, even for video games, isn't likely to have very good results.
3D optimisation is all about having good algorithms. Case in point; I designed a 3D, OpenGL demo in C++. I then designed a similar demo in python. The one in python ran much faster, partly because I knew what I got wrong on the C++ demonstration, but mainly because in python, I could code better optimisations (various frustrum culling and octrees were the main ones), in a much shorter space of time.
In C++/SDL I had to write algorithms for taking a bitmap and converting it into an array, and then creating a heightmap. In python/pygame, image loading was done for me, and creating a heightmap was quite simple. The rest of the time I used designing an octree interface for my terrain.
But I'd turn the premise around - I think that the best programmers learn how to code at the lowest because they want to and are interested in it. Then they learn about both the benefits and complications (pipeline stalls, cache effects...).
But on another level, teaching assembler in college is increasingly difficult. Students in many CS programs are hard pressed to learn much more than Java and C# - very few know any language other than those in the C/C++/Java/C# family plus Perl and Python. Instead they learn all about GUI's, IDE's, .NET and so on.
I'd love to see students really learn assembly language (though ideally it would be for something other than the plug-ugly x86 series architectures), but then I'd also love to see them learn Lisp, Haskell and a few more languages, as well as Unix, Windows, VMS and a few more OS's, as well as HTML, XML, TeX and a few more ways to mark up information, as well as OpenGL, Postscript, X windows library calls and a few more graphics systems, as well as Calculus, Linear Algebra and a bit more math, as well as.... (well, you get the idea).
However, I think the only times assembly is really needed is (in a few cases, C++ will do the job almost as well):
- Cracking - Obvious reasons, you'll need to know how to program in ASM to know whats going on in programs, and therefore how to 'crack' them.
- Kernel/Other core file development - Again, pretty obvious. Apart from the fact you can't really write kernels in VB and whatnot, you will want these files to be as fast as possible.
- Graphic-Intensive games - Again, you want the game to run as fast as possible, you'll maybe get 60 fps if written in ASM, compared to about 10fps if written in VB.
- Virus writing - polymorphic viruses, for example, if you want the program to actually change its contents when a virus scanner checks it, writing it in VB or something will quite a bit more than challenging.
There are probably other cases too.I think it IS important to know how computers work - as in the CPU, registers, etc. But in most cases, it's simply not needed.
If you want to optimize, you can learn how to optimize code in your own language. For example, 2 * 2 * 2 will be about extremely faster than 2^3. StrComp() type functions are faster than If (UCase(string1) = UCase(string2)), etc.
I completely disagree with Hyde about the importance of efficiency. Sure, I'd like apps to be smaller and faster. But 99% of the time, what I want to be improved in apps I use are:
* Usability
* Security
* Learnability
As a developer, I also rarely care about efficiency. I'd much rather developers spent more time making their code:
* Readable
* Maintainable
* Debuggable
I also agree with other comments that even if you think efficiency is important, assembly by itself does not help very much in understand what's efficient. That's because so many other factors besides the lines of code impact how your program runs, such as:
* Compiler and runtime environment (e.g., JVM)
* OS implementation (e.g., scheduler, virtual memory management)
* CPU architecture (e.g., pipeline, cache, superscalar execution)
Would knowing assembly be better than not knowing it? Sure. But considering all the things that it would benefit a programmer to know, how important is assembly? For the vast majority of applications out there, I think assembly is not nearly as important as many other things.
Assembly is great because you can kill any linux system you got ssh access to using assembly.
If only you had said "any Windows system", you would have gotten +5 insightful w/o a second thought.
Sometimes programmers can be a little smug in assuming that every other programmer is working in the same environment that they are and therefore they take their hard-earned wisdom from their particular niche and evangelize it to everyone else. Sometimes that evangelism borders on a geek-version of adolescent bullying as we try to put-down or shame everyone else for not doing things just as we do.
The profession of programming has broadened to the point where it is IMPOSSIBLE to advocate a one-size-fits-all mantra to all programmers.
Computers have become so ubiquitous and the things they do so broad that the profession itself has splintered into many different subcategories each with their own INDIVIDUAL best practices.
So I think anyone trying to advocate a way of doing things should always qualify it by specifying the environment that they think suits it best.
The way someone writing code for a PIC is going to approach it differently from a device driver who is going to approach it very differently from a web programmer writing C# code to deliver web pages or a game programmer doing real-time graphics or someone writing an embedded app who is concerned about battery life or a missile guidance system or medical instrument who is concerned about stability.
That's not to say that there aren't any universal best practices, but everything is a cost-benefit assessment. There are cases where the time investment in the optimization will not payoff with a measurable increase in efficiency that actually helps the bottom line to any degree. Ultimately the best programmers are those who are able to satisfy BUSINESS needs, not just thier own perfectionism.
This is true of just about any form of creation. Someone building a cookie-cutter apartment building approaches it differently from the replacement World Trade Center or a tent or a treehouse. Take artwork. A comic strip artist is not going to lavish the same amount of detail on his daily strip that went into the Sistine Chapel. The work that goes into creating a Hyundai is different from what goes into a Bentley or a Hummer or a tractor or a motorcycle.
Always customize your approach to the niche you're in.