The 'Anti-Java' Professor and the Jobless Programmers
itmanagement.earthweb.com
itmanagement.earthweb.com
Similarly, the idea of quizzing candidates on whether they can diagnose and track down compiler or processor bugs is similarly useless; there are far more critical skills to test for in an interview. If I was interviewing someone for a position at a hardware company writing software for prototype chips, then I'd probably care; if the job was for about 98% of the other programming jobs in the world hardware knowledge is about 152nd on the list of things I'd care about.
It's hard to imagine how someone could take this guy as an authority on how universities should educate people and what job skills graduates will need when he's so obviously out of touch with the real world.
#!/usr/bin/python
####################################
# Curmudgeon_Article_Generator.py #
####################################
import random
i=[ "C", "Ada", "Assembler", "Fortran", "lisp", "binary programming with patch cords", "time sharing mainframes",
"by dropping off punch cards and wait two days for the output", "butterflies", "a magnetized needle and hard disk platters",
"C++", "C#", "Python", "Ruby", "Django", "Ruby on Rails", "Cobol on Cogs", "Scheme", "Smalltalk", "Haskell", "Erlang",
"Distributed Systems", "Parallel algorithms", "network programming", "Win32 API's", ".NET", "Perl", "Unix", "Windows 95",
"Windows Vista", "GUI's", "VAX command line", "vacuum tubes and a sodering iron", "an abacus", "clay tablets",
"wire, duct tape and spit", "transistors", "slide rules", "microcomputers with 5 1/2 inch floppies", "machine language", "a PDP 10"]
for x in range(20):
print "\nKids today don't know squat about programming."
print "Why when I was that age, we didn't have %s." % random.choice(i)
print "We learned programming the hard way, using %s!" % random.choice(i)
print "Boy, am I ever grateful."I've done a lot of performance optimization of Java apps in the last 6 years and I've never once had to look at bytecode or think about processor instructions or OS issues; I've had to think about memory allocation and consumption, synchronization, algorithmic complexity, caching, query plans, database denormalization, etc. Obviously optimizing a C application is a different world, but it's definitely not the case that even the majority of software engineers ever need to dive that close to the hardware these days given the rise of managed/VMed languages like Java, Ruby, Python, and C#; it's good to hire someone who can do that or who can learn to if your application might need it, but in general it's just not as important as a lot of other skills, and I think it's pretty incorrect to say that engineers who can't do that will have no job prospects in the US.
If my interest is in consumer internet applications learning about compiler-level and hardware-level bugs is probably not the best use of my time.
Do you think the first version of Google took all this into consideration? I'm pretty sure they used NFS for distributed storage!
Separating people who want to build car engines from people who want a liberal education at the secondary level is seen as a sort of elitism.
Maybe Ada compilers have lots of bugs. :-)
Everything around them? Oh dear god yes.
Such a breadth of options! Surely if we teach students how to create avionics systems for commercial aircraft or military aircraft, they will never want for jobs!
If he were to point out that using any single language as a vehicle for computer science is bad because it ties the knowledge to APIs rather than underlying concepts, that would be one thing. If he were to further point out that a lot of complex systems nowadays aren't written in a single language, and that being able to quickly acquire competence in new technologies is possibly the most valuable skill a university can give to its students, that would lend even more weight to his argument.
But no, he's just whining that no one thinks Ada is relevant anymore. I'm sure he's having trouble finding fresh college grads who share his passion for safety-critical avionics systems, but I really can't muster up that much sympathy.
I am not sure what has changed, but I wouldn't want to be doing stuff that different now with a general purpose programming language (be that Ada, Java or for reasons I would never understand, C).
There's not a strong argument to be made for using Java in an industrial setting, but I'm not clear that a finite-state machine that compiled down to JVM bytecodes would be inherently less safe than anything else.
Ada doesn't guarantee the correctness of your program, and C certainly doesn't. This interview reads more like an inarticulate complaint about how things keep changing than a real argument against trends in education.
If you're just saying Ada doesn't guarantee that the program does what you really need... no language can do that.
C is the 2nd most unsafe language I've worked with, asm being the first.
That was basically my point.
I agree Ada's pretty cool, but Dewar listed Ada and C (!) as the only two languages suitable for safety-critical systems.
I mean, really. What does one say to that.
What does one say to someone who is using C because it's suitable for safety-critical systems? Please don't!
I think the bottom line is that Students who's university career consists of only programming in Java miss out on a lot of the low level technical details about how a computer works. A good CS program will teach concepts instead of tools and languages. That would be called a "technology" degree. There is a place for Java but to teach it exclusively at the expense of C, C++, Assembly, etc... is foolish and leads to exactly what this article says it does people who don't really know what they are doing and are easily replaceable by cheap overseas labor.
Difficulty comes in all shapes and sizes. Your next point is better: "[...] teach concepts instead of tools and languages".
That approach to education sees any language and/or run-time environment as an opportunity to work with an underlying concept.
A study of any language or run-time to the exclusion of an underlying concept is short-sighted. Any student with a language-centric approach to learning faces many difficulties in their professional life. We must all be able to adapt to changes in our field. We must be able to separate fad from fundamentally different.
"A scientist builds in order to learn; an engineer learns in order to build."
http://www.stevemcconnell.com/psd/04-senotcs.htm
It seems to me that this professor is teaching CS to students who actually should be enrolled in a SE program.
What is the probability of that happening?
The last time this happened in any significant way was the FDIV bug on the original Pentium. That was 1994. It was extremely rare in practice. That's a ridiculous question and completely irrelevant to 99%+ of software development.
I agree with sofal that reading all these "you should think and work exactly the way I do or else you're stupid" pieces I see get really fucking old.
Fucking around with disassemblers and assembly language instead of just running on AMD chips instead of Intel until the problem gets resolved is a massive waste of time.
Actually he's looking for people who know how to track down a processor bug, report it appropriately to a manufacturer, and work around it. Would it demonstrate complete incompetence and a failure of my CS education to answer: "I would learn how to track it down, learn how to submit a report, and then figure out how to work around it."?
It's one thing to expect job candidates for AdaCore to be experienced embedded-system developers, but it's another thing to expect university CS departments to throw their resources into that small corner of computer science so that he can hire new grads without having to bring them up on embedded systems work. I'm sure that CS departments with tons of resources can provide an embedded-systems track for undergraduates.
If you want hardware knowledge, ask about pointer arithmetic and memory hierarchies, which is still mostly irrelevant to what most developers spend most of their time doing.
Before someone launches into a jihad about memcached and load balancing and super high-scale stuff, most people never have to do that.
Another case is for programmers working in Operating Systems. I remember like this url http://marc.info/?l=openbsd-misc&m=118296441702631 was mentioned a while ago when OpenBSD group found a lot of hardware bugs in Core 2 Duo.
The danger is the misplaced blind faith on the reliability of the system that we are using. And teaching only Java to students is a sin for computer science to build such a blind faith.
The professor in the OP seems to be angry that there are people who spend their time doing things other than making toys for the Pentagon, and I say I don't give a hoot about his Ada silliness.
He just belongs to a very old school in this discipline that holds the belief that you need to know what are you building from the lowest level components. You don't need to be an expert unless you work in that domain. But at least you are not clueless.
My recollection may be wrong. But I thought his Ph.D. was in fact in Chemistry. And he built and sold Cobol compilers before he worked on SETL language and Ada.
I didn't take Dennis Shasha's class. But his heuristic learning and distributed computing are also project based.
I wonder how much of this is headline grabbing (which is fair enough, it will help enrollments perhaps of the smarter students I think).
In fact you can learn the similar experience just by doing a project yourself. I learned most stuffs in my life from projects. A course just gives a pressure to finish something before deadline. PG and YC are using the demo day to push applicants to finish something and with a potential payoff for finishing it. (Why? because of human nature tends to procrastinate!)
So maybe you just pick a non-trivial but not too difficult problem (Unless you aim for Turing Award and wants to be the first one to prove/disprove P = NP), find some friends/comrades who wants a challenge. Set up a deadline and payoff and go for it. You learn by doing it and the more you do it, the easier it will be.
I personally have run into compiler issues for Lattice FPGAs where it was outputting incorrect binaries. And I couldn't run on another chip until the problem got resolved, because hardware was being developed in tandem with the firmware and we had already progressed beyond the point of component selection.
I understand that this is beyond your experience. These are obviously not the droids you are looking for.
We were required to write all of our own data structures/classes as we learned them.
After we proved our competence in making proper structures, our professors would then allow us to use certain classes from libraries to get to the meat of more advanced topics.
While I don't agree with using Java as a first CS class language solely based on popularity, the future of students who take one or two CS classes is greatly benefited by the word "Java" on a resume. Java isn't THAT bad. And at least the C-style syntax matches up with a lot of the most popular languages.
That's a low blow :-P
The point is that if you start out by using a really high-level language like Java or Ruby or, going even higher, JavaScript then overall you won't be a very good engineer. To give an extreme example, JavaScript is Turing-complete, so you can re-implement anything in it, but I still wouldn't hire somebody who's only ever used JavaScript, even if he wrote an "OS" in it.
The reason is simple: sometimes you have to go down to the C/C++ level, sometimes you have to go down to the TCP/IP level, and so on. If you can't do that, you're not as valuable as someone who can, and you'll be outsourced.
I can even give an example from my own life: For 3 years I worked as a C/C++ programmer, where the work involved lots of debugging, dealing with memory managers, all kinds of fairly low-level crap. It wasn't rocket science, but it required a different mindset then working at higher levels. I hated it, because I wanted to do more interesting, more modern stuff. So I quit. The company desperately tried to keep me on, but I wouldn't. I went to work for a smaller company, like a startup, where I was given a small project to design and implement on my own, since I was hired as a senior programmer. Now, I'm not a particular fan of Java, but this project just cried out for it. 1 year later I was basically layed off (among other reasons) because the company realized that since the work I'm doing is not low-level, they can hire any "PHP-monkey" for 1/3 of what I make. I've basically been "outsourced", although not geographically.
So the lesson to engineers is: don't go work for small webby startups unless you're a co-founder, because most of the stuff they do requires moderate skills and thus they don't need to pay good engineers, plus they're always short on cash =)
Low-level is not superior to high-level. They each have their own different challenges. I don't think it is a bad thing to focus on high-level for your career. That does not mean spitting out half-baked PHP web pages. Of course it's helpful to have been exposed to low-level concepts at some point.
This is the same tired old argument about how real engineers program in binary and you ignorant handicapped kiddies can only program in C. The only thing that changes is the level of abstraction at which the 'real engineers' work, and that just keeps going up.
Somewhat related: http://www.yosefk.com/blog/low-level-is-easy.html
So what do you do if you cannot because you have no conception about the lower-levels / overall architecture? I've seen PHP programmers run into bugs and throw up their hands and yell "It just doesn't work! But the bug cannot be in my code!". Of course the bug was in their code, they just have no deep understanding of even their own environment.
The main language we used was C++ (although for the intro course, it was the C subset of C++, but with C++ style I/O). In our classes we were expected to implement our own data structures, we weren't allowed to use the STL (except for strings). When we got up to classes where they assumed we knew how to implement the classic data structures (say, compilers), we could use the STL.
Personally, I don't think Java is a good first programming language. But it's still possible to construct good courses that use Java - it depends more on how the course is structured than what language is being used.
I'll add an Nth comment to how ludicrous this article is. Is building a highly scalable server really so trivial as all that?
Higher levels of abstraction are good. Using libraries and avoiding low level recoding of basic functionality is good. Get serious this is so obviously trash it's not worth commenting further.
I think it's fair to say that most professional programmers in developed countries (a) make plenty of use of existing libraries, (b) may not have 'deep programming skills', and (c) probably don't have a formal education in Computer Science. It also seems unlikely that the majority of developers in India or wherever have these either.
The main reason it's hard for a CS graduate to get a job seems to be that agencies and companies want commercial experience, which can be hard to come by.
'Dewar says that if he were interviewing applicants for a development job, he would quickly eliminate the under-trained by asking the following questions... "I am afraid I would be met by blank stares from most recent CS graduates"...'
...and by many 'professionals' too, I would imagine.
Of course, there are "higher-level issues" that you can't express in Java. Java convinces students (and professors, sadly) that the only kind of OO is single-inheritance with interfaces and no MOP. Java convinces students that programming is all about making the not-really-static types match. I won't even mention what a hack functional programming is in Java (and I'm sure most students never even hear how to hack in FP to Java). Checked exceptions were widely considered a huge failure. Honestly, I think most of the time you'll spend with Java is going to be time spent working around its retarded limitations. Do we really want to teach kids that programming is about dealing with limitations in your tools?
At the very least, limiting yourself to Java limits your ability to learn programming. Java isn't a very good language. It is missing features that were widely considered "a good thing" 20 years before its invention. Note that I don't care about teaching memory allocation and freeing the memory, that's monkey work, not computer science. So I'm not advocating teaching C. But languages like Lisp will let you teach all the computer science without workarounds, and still have all the "safety" of Java. (Plus, Lisp programmers get paid a lot more than Java programmers. Surely that's a selling point?)
A good programmer has to know both high-level and low-level stuff. And also has to be able to understand or, at least, to make a decent hypothesis on why GCC core-dumped.
A curriculum shouldn't be dumbed down, for sure, but if you can make the learning curve easier, increase retention, and keep exit standards high, why not?
Once qualified, sure don't reinvent the wheel, but when you are learning it's a vital experience.
You make it sound like that's a good thing ;-)
As to having a formal education - I did a year of Computer Science, and I'm glad I did, but I think that programming requires so much self-learning that it probably isn't that important.
http://en.wikipedia.org/wiki/Ada_(programming_language)
In brief Ada is a safety and reliability oriented language popular in aerospace and the military. It is the official (computer) language of the US army.
That would only be the case if there was a finite amount of programming to do. Since there isn't there's room for local and outsourced programmers.