Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

Quote from Wikipedia of the article "High-level programming language":

A high-level programming language is a programming language with strong abstraction from the details of the computer. In comparison to low-level programming languages, it may use natural language elements, be easier to use, or be more portable across platforms. Such languages hide the details of CPU operations such as memory access models and management of scope.

I.e., as the level of programming language increases, the further away the programmer goes from the hardware on which the program runs.

Now I do not know the statistics of language usages across levels, but I would suspect that the higher level languages more and more are replacing the lower level languages. If so, can this lead to a deficit of programmers with computer architecture knowledge? Would this be a problem for the industry?

share|improve this question

4 Answers 4

It can, but likely won't lead to a problem.

It's just economics. If the vast majority of people lose the ability to understand the underlying architecture, and there is still a huge NEED to understand the underlying architecture, then the ones who do will have jobs and get paid more, while those who don't will only have jobs where that is not needed (and may still get paid more...who knows?).

Is it helpful to know? Absolutely. You'll likely be better. Is it necessary in most cases? No. That's why abstraction is so great, we stand on the shoulders of giants without having to be giants ourselves (but there will always be giants around).

share|improve this answer
3  
But all abstractions are leaky. Knowing the underlying architecture is a must if you want to be the go-to guy for troubleshooting leaky abstractions. –  dsimcha Oct 20 '10 at 18:19
3  
@dsimcha, Agreed, but to be the go-to guy you need "the others" to come-to you ;-) If everyone needs to know everything, the abstraction has failed miserably. –  Preets Oct 21 '10 at 13:50

I think so. It's a trend that has me worried. No abstraction is perfect; if there was a perfect way to simplify any complex problem, it would replace the original very quickly. (That's happened in the past, occasionally with computers, and a lot more frequently in other fields that don't worry as much about backwards compatibility as we do, such as physics.)

What this means is that every time you use an abstraction, there's some important piece of essential complexity that it's hiding from you. If you don't know what that is, why it's there and what it's doing, you end up accidentally writing big train wrecks, and not knowing how to fix them because you don't know what's really going on.

Anyone who tries to tell you otherwise is either selling snake oil or simply doesn't have much experience with serious software. At work, I work on a program that runs a good percentage of all the TV and radio stations in the USA. As stations and networks get bigger and more complex, quick and dirty techniques that worked fine for designing a product for one small station end up hitting big technical walls when implemented for a network with 50 stations and 200 channels! Without a deep understanding of how the language works, (and an efficient language in the first place,) and a deep understanding of how the database works, our coders would never have been able to make the product scale successfully.

This isn't an isolated story, either. Software continues to grow more and more complex, not simpler, and I'm afraid that this level of technical expertise is going to become something of a lost art, and tomorrow's programs will be worse than today's, not better.

share|improve this answer
3  
I've heard it expressed as "you need to know the abstraction one layer down from where you work". Well, it was rather pithier; my memory's flawed. So if you're working in C or Delphi, you should know how assembly works. If you're working in Smalltalk or Java, you should know how your VM works. (Arguably, you should always know something about assembly!) If you're working with TCP, you should know how IP works. And so on. –  Frank Shearar Oct 21 '10 at 13:12

Yes, I think people will understand hardware much less as languages progress (and, similarly, as instruction sets progress). But as has been noted many other places, the primary constraint on most programs now days is not CPU time or efficiency, but programmer time. If people who design languages keep doing their job in making the abstraction efficient, and if people keep using these abstractions properly, then an understanding of the computer architecture is not entirely necessary; at least a complete knowledge is not fundamental to being a good programmer these days.

share|improve this answer
1  
In theory, yeah, but those are a couple of pretty big ifs. –  Mason Wheeler Oct 1 '10 at 16:04

No, it won't lead to a deficit of programmers with computer architecture knowledge. Languages are used to solve problems in a particular domain. If you want to solve a particular problem, you use the appropriate language or one good enough given your resources.

In reality, what domains actually need knowledge of the computer's architecture? That need to be tied down to a particular hardware architecture? Operating Systems? Device Drivers? Sure, but even then only parts of such code need specific architectural knowledge.

Performance improvement? Yes, you can apply knowledge of the computer's architecture to improve the performance of algorithms. But two other factors have a bigger impact on performance: the use of better algorithms and knowledge of the language's runtime environment.

In essence, more abstract programming languages solve problems for which details of the computer architecture isn't necessary. They allow more problems to be solved. The people that use them aren't using them to solve machine-dependent problems. People that need to solve machine-dependent problems will continue to use machine-capable languages. This isn't a zero-sum issue.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.