what differs a computer scientist/software engineer to regular people who learn programming language and APIs? [closed]

Question

In University, we learn and reinvent the wheel a lot to truly learn the programming concepts. For example, we may learn assembly language to understand, what happens inside the box, and how the system operates, when we execute our code. This helps understanding higher level concepts deeper. For example, memory management like in C is just an abstraction of manually managed memory contents and addresses.

The problem is, when we're going to work, usually productivity is required more. I could program my own containers, or string class, or date/time (using POSIX with C system call) to do the job, but then, it would take much longer time to use existing STL or Boost library, which abstract all of those thing and very easy to use. This leads to an issue, that a regular person doesn't need to get through all the low level/under the hood stuffs, who learns only one programming language and using language-related APIs. These people may eventually compete with the mainstream graduates from computer science or software engineer and call themselves programmers. At first, I don't think it's valid to call them programmers. I used to think, a real programmer needs to understand the computer deeply (but not at the electronic level). But then I changed my mind. After all, they get the job done and satisfy all the test criteria (logic, performance, security...), and in business environment, who cares if you're an expert and understand how computer works or not. You may get behind the "amateurs" if you spend to much time learning about how things work inside. It is totally valid for those people to call themselves programmers.

This makes me confuse. So, after all, programming should be considered an universal skill?

Does programming language and concepts matter or the problems we solve matter? For example, many C/C++ vs Java and other high level language, one of the main reason is because C/C++ features performance, as well as accessing low level facility. One of the main reason (in my opinion), is coding in C/C++ seems complex, so people feel good about it (not trolling anyone, just my observation, and my experience as well. Try to google "C hacker syndrome"). While Java on the other hand, made for simplifying programming tasks to help developers concentrate on solving their problems.

Based on Java rationale, if the programing language keeps evolve, one day everyone can map their logic directly with natural language. Everyone can program. On that day, maybe real programmers are mathematicians, who could perform most complex logic (including business logic and academic logic) without worrying about installing/configuring compiler, IDEs?

What's our job as a computer scientist/software engineer? To solve computer specific problems or to solve problems in general? For example, take a look at this exame: http://cm.baylor.edu/ICPCWiki/attach/Problem%20Resources/2010WorldFinalProblemSet.pdf . The example requires only basic knowledge about the programming language, but focus more on problem solving with the language.

In sum, what differs a computer scientist/software engineer to regular people who learn programming language and APIs? A mathematician can be considered a programmer, if he is good enough to use programming language to implement his formula. Can we programmer do this? Probably not for most of us, since we specialize about computer, not math. An electronic engineer, who learns how to use C to program for his devices, can be considered a programmer.

If the programming languages keep being simplified, may one day the software engineers, who implements business logic and create softwares, be obsolete? (Not for computer scientist though, since many of the CS topics are scientific, and science won't change, but technology will).

Answer 1

I read a bunch of contradictions and a wall of text.

I used to think, a real programmer needs to understand the computer deeply (but not at the electronic level)

Why not at the electronic level? There are so many edge cases that MAKE you think about the electronics below (arm processor vs desktop/hard disk vs SAN vs ssd) - that this assertion is not right.

Programmer - is just a term. My mom is a programmer because she can program our microwave to cook! An Engineer means a lot more - and that is what is the term you are looking for. An Engineer is a person whose job is to make things easier/better.

And no, I don't think programming languages matter as much as the engineer using it. A good engineer will transcend these temporal concerns. And yeah, learning VB is not gonna make everybody a software engineer overnight.

Answer 2

Some one once said it best:

A computer scientist has as much to do with a "computer" as as a cosmologist has to to with "telescopes".

There are two types of programmers (in this context)

• Black Box Programmer
• White Box Programmer

The white box programmer does not have to stay within his box abstraction and can do things that the black box programmer can not do.

Having more knowledge is never a hindrance. However for most Line Of Business application the black box abstraction is more than enough.

Edit:

As Steve Melnikoff has pointed out, the proper quote is:

"computer science is no more about computers than astronomy is about telescopes" -- Edsger W. Dijkstra

Answer 3

I think there are several questions here, and it's almost worth splitting them out separately, but I'll try to answer the general gist:

I think what marks out the true experts (in any engineering discipline) is a particular way of thinking, even an understanding of how to think. I don't think programming is a universal skill (nor could it be taught to everyone) because not everyone is able to think in the right way.

In other engineering disciplines, experts tend to look down on less capable people who are merely "fitters" - that is, those who only know how to replace and fit new parts.

I once had a problem in a car which prevented the rear wiper working. The dealer tried twice to fix it by replacing the wiper mechanism, but each time the fault re-occurred.
A more experienced mechanic I knew took a look at the copper contacts on the tailgate latch, noticed dirt and oxidation there, brushed them with wire wool, and solved the problem.

He solved it because he thought about the problem, and had a deep enough understanding (and experience) to understand what the probable cause was, whereas the fitters' thought process was more like "part faulty, so replace the part".

I graduated in Computer Science, and I'm pleased to say I don't remember most of what I learned then. I usually don't have to. If I think about it a little, yes I know how to write sorting routines, hashing functions, image processing filters, etc; but I don't ever have to write one, because those things are usually provided in some library.
I used to write in assembler, but C compilers meant that I didn't have to. I used to code in C, but scripting and JVM-based languages mean that I don't need to write C very often.

And it's nice having the abstractions, the black box routines and the high-level languages, to save me from unnecessary work; but I also think it's important to understand what's going on underneath, because if you don't you end up producing highly inefficient software based on highly inefficient algorithms, of the kind that end up on TheDailyWTF, and this is how we end up with systems that need 8-core servers and still run slower than the old thing did on a 12-year-old VAX.

What sets apart the computer scientists and software engineers from the amateurs is a deep understanding of algorithms and data structures, which influences how they design systems, and hopefully prevents them designing bad ones; and this understanding applies to any language, any platform.

Answer 4

One difference besides better knowledge on design, it's the hability to innovate.

A programmer who doesn't understand computer science in a more complex level can only develop software because he works with abstract structures and high-level languages, but if he ever finds a complex problem that he does not know a solution using his classes and librarys, he only have google to save him. If google don't give him an answer, he drops out of that idea. It does not matter if it was a great solution, if it would differentiate his company from all others, he just can't go beyond that level.

A software engineer (or something like that) works exactly on the same path, but if google can't help him, he analises if it's worth to develop that solution, if it is, he can do it.

Answer 5

I think programmer can be thought of as a form of translator for the computer. Rather than translating into italian or spanish from english, we're translating into instructions computers can understand.

Of course, there have been milestones for what concerns improving what can be considered "instructions that computers can understand." We've gone from shifting bits in 1s and 0s to being able to write extremely complicated programs in under 20 lines.

However, when you compare this improvement to the improvement programmers have made mastering their discipline, it puts us to shame. There are fundamental concepts which still cause many a decent programmer to stumble and fall on his face. We lack the discipline to be able to write a well-structured program, despite all the technologies meant to increase abstraction and improve readability with the programming languages we use.

And that, ladies and gentlemen, is very much why computer science is very much still in its infancy. We demonstrate same the consistency and quality in our programs as blacksmiths did when hammers were used to shape iron-forged instruments: every product was misshapen and incompatible with another, and even the best blacksmiths somehow managed to put out an eye out every now and again.

Mathematicians are known to be stubborn down to a fault for what concerns correctness, however programs are not mathematical proofs. Even if you could prove the correctness of a program to do what it's designed to do, you'd then have to take into consideration the amount of memory available, disk size, hardware failures, multithreading, etc. There are so many variables here that I seriously doubt it will ever be practical to truly prove the correctness of a program.

Answer 6

The functional distinction between "regular" programmers and CS grads is absolutely blurry. CS majors often become good developers, but only learn how to be after getting a whole lot of experience that didn't come with their degree. Non-CS majors (overgeneralization, i know) often learn a great deal about CS through their experiences.

In the end, amateur programmers come from both camps. The non-amateur will carry a good balance of practical knowledge and theory applicable to what they decide to focus on.

Answer 7

Simplifying programming languages do nothing about the fundamental problem with computers -- the logic inside them is very complicated. Take a normal int number, you can choose any number from the range [-2^31..2^31], and if we choose a number 6643387462, your program will necessarily work different from if we chose 468464842, and encoding these differences will take hard work of many people. This is why programmers are needed. It's not going to be obsolete, as long as the complex logic is still required to run the world.

The real problem is that the complexity in the world is increasing - nothing we've seen so far is actually removing it. Simpler programming languages make it look simple, but underneath, it's still running complex algorithms and logic. Understanding the whole behaviour of the system in java is more difficult than it ever was in c++; it's because it's just hiding the complex stuff, not removing it. The complex stuff still exists.

A good programmer regognizes correctly the level of complexity in the system, and writes his code to exactly match the level required. Adding complexity just for the sake of making it more flexible is a bad decision. Think for example a sequence of bits: 0101001101, compressing those bits to take less space using some algorithm -- the same information might look 011101, but the problem is that those bits are less stable. Any modification in the original bit sequence is doing huge modifications in the compressed bit sequence. Understanding what will change in the system when changes happen in the original data set is going to get more and more difficult.

Our solutions like the compressions algorithms above are not actually removing complexity; it's still there but just in different form. Same happens with programming languages like java and C++. The new abstractions are just hiding the complex logic behind simple primitives. It's giving new names to some complex primitives. If the name is short, it'll be easy to use; if it's long, it is more difficult to write it. But the fundamentally the complex primitive is still there. The link between length of the name and the real complexity buried inside it is disappearing with each abstraction. Good programmers know the whole behaviour of the systems they're building in such detail that there will never be surprices or broken behaviour in them. Simpler programming languages are not helping as much as you'd think - definitely not enough to remove programmers from the equation.

Answer 8

The difference between a computer scientist and a computer programmer is the same as:

1. the difference between an electrical engineer and an electrician.
2. the difference between a mechanical engineer and a mechanic.
3. the difference between a chef and a short-order cook (e.g. at McDonalds).

The former can learn new things more quickly and can extend and apply his knowledge into areas that were not anticipated.

The latter can only do a few things, albeit very well.

Also, if you want to be cynical, the difference is about $40K/ year (California money). Source: personal knowledge and glassdoor.com

Answer 9

I was a self taught programmer for 10 years before doing a mathematical sciences comp sci degree.

The degree gives me alot of math ability I didn't have, which may or may not be valuable depending on your domain. But my programming self-education and intuition was far greater than any student gets at university both qualitively and quantitatively.

in short:

intelligent amatuer programmer > intelligent graduate programmer

stupid amatuer programmer < stupid graduate programmer