Slashdot videos: Now with more Slashdot!

View

Discuss

Share

We've improved Slashdot's video section; now you can view our video interviews, product close-ups and site visits with all the usual Slashdot options to comment, share, etc. No more walled garden! It's a work in progress -- we hope you'll check it out (Learn more about the recent updates).

An anonymous reader writes At work yesterday, I overheard a programmer explaining his perception of the quality of the most recent CS grads. In his opinion, CS students who primarily learn Java are inferior because they don't have to deal with memory management as they would if they used C. As a current CS student who's pursing a degree after 10 years of experience in the IT field, I have two questions for my fellow Slashdoters: "Is this a common concern with new CS grads?" and, if so, "What can I do to supplement my Java-oriented studies?"

but gawddamn, if I meet ONE more unshaven skinny ratty-haired white dev/programmer in his late twenties/early thirties with an aversion to water, soap, matching colors and food (what is it with devs and eating disorders???) here in Seattle, I might just have to defenestrate the fucker to save my sanity. Preferably out an upper window at the downtown Macy's, so that said dev/programmer might actually observe cleanliness and fashion through visual osmosis prior to becoming one with pavement. I don't care if said beautiful mind is autistic, aspie, or what-not--Hygiene is source code!!!!!! Execute it on a daily basis! And if the sensory stimulus is THAT much of an overload then spend some of your six figure salary to get therapy and coaching on how to minimize input while maximizing the ability to incorporate the close proximity of other people!!! I much prefer the Indian and Chinese devs and programmers, not least because they don't have eating disorders and they both understand and practice a minimal standard of hygiene.

Java schools are a menace, but since it's nearly impossible to find grads with a "real" programming curriculum any more, I think we've just sort of given up and accepted our fate as needing to teach new college hires everything.

If you can code - really write code beyond simple toy assignments - in any language, you're already doing above average. But if you want to be top tier, you really need to understand the crufty details of what compilers do and how they do it. While there are no lack of Java jobs, you're really missing something if you don't have a good mental model of computers at the machine language level, and if you've never done any "bit bashing" (working with unsigned ints as arrays of bits, not as numbers).

My suggestion for getting a rounded education is to go write some C code. Write code to count the '1' bits in an unsigned int -- no googling the answer! -- and then keep brainstorming for ways to optimize that (when you can snatch the bitcount with "n%63", you will be ready to leave the temple). Write code to do other bit-bashing - reverse the bits in a word, find the base-2 log of an int, and so on. Write your own "bignum" implantation from scratch, to have a larger problem to solve with lots of corner cases and ugly cruft.

These are toy problems, and they won't teach you all the stuff you can learn in Java about "software engineering", but they'll cover and important gap. Most importantly of all - debug through all your solutions and get comfortable with debugging. Debug through the generated object code, stepping through one instruction at a time until you understand what's happening. Debug through the object of non-optimized vs highly optimized code.

Don't stop until you're totally comfortable with bit-bashing, with pointers and pointer-array equivalency, and so on. Once you start debugging through C code, especially the object, natural geek curiosity will serve you well to cover the gaps in a Java-only background.

...which includes being aware that arrays in C are not just syntactic sugar around pointers.

This includes understanding what this means:

Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue. If the

Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue. If the array object has register storage class, the behavior is undefined.

You do know that sort of obsessive language-lawyering is exactly what turns people off to exploring C, right?

Someone well-versed in Java won't be surprised that arrays know their own size. That's not the interesting lesson here, for someone who's never seen the difference between big- and little-endian in a debugger.

I can't believe that you can graduate with a CS degree today without having at least one assembly language class which should show you about bit-twiddling and memory management just a bit. Not to mention an OS class that would expose you to exercises to modify a Linux kernel - written in C.

What do they actually teach in a CS degree these days? Don't tell me... Gamification, HTML, CSS, and Javascript, right? Do they actually make you take a database or an algorithms class any more?

Modern CS degrees are focused on building applications from blocks, kinda like Lego with some glue logic. Students do a lot of database stuff (SQL) and a lot of OO concept stuff. "Hard" things like calculating a CRC or efficiently sorting an array are usually covered by library functions.

I know what the OP is getting at - some of these people don't know what a function is (they only know about methods) and see C as some kind of black magic operating system code that only gurus understand. That is by no mean

They still have all of that stuff, or at least did when I got my CS degree, but the problem is that there aren't a lot of jobs where you'll need to use that kind of stuff. A lot of the jobs are using Java, Python, C#, or other languages that deal with those many of the low-level things for a person. Sure there are still jobs out there that require C and a good knowledge of memory management, etc. but they're in the minority. The field of computer science has grown extensively over the last several decades a

The funny thing about your comment - which, despite having done everything recommended here and more* in college, I still can't help but read in the voice of a sour, grumpy old man - is that you don't need to know anything more than JavaScript to study algorithms. You don't even need that much, in fact; I'm not sure if my algorithms professor actually *knew* any programming languages; examples were written in pseudo-code and code could be turned in in any language that the TAs knew. A programming language (

heh. When I did my computer science degree we were taught more about statistics than software.

At the time I figured what a waste of time, and for a few years it was right... until we got to the large scale systems where job throughput matters quite a bit. Then all that old crap turned out to be useful. Who'd have thought modern, super-fast computers still have the same limitations as the ancient mainframes! (well, with a lot more users, admittedly)

Same here, statistics and logistics were both a large part of my late 80's CS degree. CS is a branch of maths and that's the way it was (and still is) taught at the degree level in Australia. At the time there were actually two streams in the CS course, one was software based, the other hardware based. I was in the software stream meaning I got more math under the heading of "operations research' (AKA - Logistics), meanwhile the hardware guys did extra applied subjects such as programing microcontrollers.

Most students I've talked to recently took one semester of "C programming", but just did the sorts of things in C they already knew how to do in Java (except awkwardly in C), and didn't understand the pointers of the class (and perhaps the class was pointerless)

Eww Octal??? My gosh, the PDP-11 is the purest of the pure! It is the excuse, the reason for Octal to exist!

No, octal was a much better fit for machines such as the PDP-6/PDP-10, PDP-5/PDP-8, and other multiple-of-6-bits-word-size machines. It worked well for PDP-11 instructions, not so well for PDP-11 data words if you cared about the individual bytes in the word.

And as soon as you work for Facebook or Amazon, you will never have any use for 'bit bashing' again.It is interesting as a mental exercise... but has bottom line nothing to do with serving web pages to 100,000,000 concurrent users accessing the same DB of products and hosting all the infra structure on 4 IBM mainframes that run the web front ends on 10,000 virtualized linux boxes running slackware linux (2002) and IBM Java 1.3....Sorry, how good are you actually in classic greek? It would do wonders to yo

You've repeatedly missed my point that you won't think to use bit-twiddling if you've never studied bit-twiddling. However easy it may be to learn, if you don't have the tool in your mental toolbox, you'll try to solve the problem with less-good tools.

Recursion is the same way - it's quite rare that it's useful it in business coding, but when it is your code will be vastly better for it. If, however, you're not comfortable with recursion, you'll instead solve the problem in some horribly-awkward way.

Outlandish, unsupported claims are responsible for 90% at least of the garbage on the internet.
shared_ptr can eliminate virtually all memory leaks while avoiding the two annoyances of GC languages: the GC overhead, and the lack of destructors (the thing that bothers me most about doing Java development).

While you are correct, the comment is about students. If you don't learn to program without a garbage collector, you haven't really learned to program. I'd go further and insist that you need a good foundation in an assembly language. MIX is good enough, you don't need anything fancy. You just need to learn how things work at the basic level.

I'd also say that you need to learn a range of languages (not well, be adequately). I'd include Fortran, Lisp, Forth as the basic level. Then C for a more advance

I think the problem is that web programming it actually one of the hardest things to do properly, and yet everybody seems to try to do it without really understanding what's going on. You can't just take a single class on web application security, because there's way too much information to cover. First, there would have to be a lot of prerequisites such as SQL databases, Actually understanding Javascript as well as at least one server side language (PHP,.Net, Java, etc). Understanding how HTTP works. And

You study ENGINEERING (a discipline) to become a LICENSED PROFESSIONAL ENGINEER.You study MEDICINE (a discipline) to become a LICENSED MEDICAL DOCTOR.You would have to agree an automotive engineer is not the same as a mechanic which is not the same as a scientist in combustible fuels.

Software development is an art form. Software engineering is a discipline. Computer Science is a science.

Studying computer science by itself enables you to become:1. A computer scientist2. A computer programmer3. A computer technician

Even becoming a computer science teacher would require you to study EDUCATION as a discipline.

There are no shortcuts. While life experience may teach you SOME things to become an engineer, there is no substitute for a Computer Science degree that focuses on software engineering. You could become an engineer after years of experience. or you could simply learn the discipline and stand on the shoulders of giants and open yourself up to learning from and teaching others in the discipline for a lifetime.

The next time you ask yourself, "Where on God's green earth would I use this knowledge", stop yourself. And think: "Why on earth would I want to work harder and solve problems already solved by others."

An engineer solves problems a new way because the outcomes of all the known methods are not satisfactory. An engineer can predict reliably how long something should take from his body of knowledge.A developer solves problems a new way because it's fun, it's cool and it's artistic. A developer, like an artist, works until he's done.

There is nothing wrong with being a developer or an artist. But just as we should never confuse industrial art with fine art, we should never confuse software development with software engineering.

If you can only solve the problem at hand, you will not have fun doing engineering. If you are happier solving higher order problems of how things are put together and how to do things efficiently or discovering how to things MORE efficiently by building on the knowledge of others or collaborating, you will have fun doing engineering.

Software engineering and software development is the same thing.For any of both you have to study computer science (except you want to proclaim yourself a self taught or otherwise taught 'engeneer'/'developer')

Programming is not an art, like painting a wall or some tapestry is no art.

In all human crafts we have a progression from apprentice, journeyman, craftsman, master to engineer, scientist, artist.

Or is more like a tree than a strict line. I would not know how you can at the high end of the spectrum distinguish an artist from a scientist. And in the middle ground a master still can be a scientist and an artist. Actually everyone can claim both 'titles' for themselves. After all it is a matter what you seek. Do you want to research/seek and explore knowledge? Then you are more the scientist, do you as well like to formulate theories and 'best practices' then you are even more a scientist. Do you more research/seek expressiveness, intuitive understanding, inspiration, interconnection to other arts then you are more an artist.

Do you need an education in arts to call yourself an artist? No!Do you need an education in science to call your self an scientist? No!

Do you need an education in science to call yourself an engineer? YES!

This. Memory management isn't difficult in the brain power sense, it's difficult in the pain in the ass sense. We've decided years ago that there are much better things to be thinking about than releasing objects and reference counting and that sort of garbage, especially since it can be automated.

What you are reading is people who are trying to elevate themselves by referencing a new obscure technique. Hey, I know AT commands for a modem. Does anyone give a shit? I certainly hope not.

If the only thing that differentiates a great CS grad from a crappy one is memory management, that's a pretty shallow argument. Google it, read it, manage memory for a few hours and poof you're an expert.

The trick is knowing what is happening under the hood -- whether you do it on a day-to-day basis or not. It's good to know why you wouldn't want to send a LONG into a function that requires a FLOAT. It's also good to know what the difference is between a MAP and having two Arrays or linked-lists. These things don't require doing memory management by hand, but being able to demonstrate what and why is the difference between a code monkey and somebody who is architecting code. Because a lot of the higher-

Ya the OP is asking the wrong question really... Honestly a school that is cranking out pure Java monkeys is called a "Tech School". If your Bachelors isn't providing you with the breadth of experience/knowledge you need then sorry you picked the wrong school.

I was in school during the transition.. my Intro to Programming was in "C++" (in quotes because it was taught by a C dev who barely knew any of the ++ besides basic OOP). A had a couple other classes using C++ but that quickly transitioned to Java mid-sophomore year. Of course I also learned MAL/SAL, Various hardware languages, Lisp and a number of "scripting" languages.

The important part of all of that is that the language in question was the "tool" we used to learn what the class was teaching. The class was not teaching us the language (although plenty of off-hours support was given if you didn't know it going in). Honestly I learned WAY more about memory management in my Operating Systems class which used Java as its reference language than I ever did in the handful of C++ classes I had.

Side Comment: As someone who's spent a majority of his professional career writing Java code, a Java programmer who doesn't think about memory management is a terrible Java dev (and yeah I know there are a LOT of terrible Java devs out there). I have had not a single project where close attention to Objects' memory utilization and freeing wasn't required. The terms used are different as are the calls you make but just about any software that just "leaves it up to the GC" will have issues.

I've been out olf college for *mumbles 26 years* - I had Pascal, C, 2 Different Assembly Languages (X86 And VAX). Not to mention classes in Data Structures and Compiler Design. I've also done Embedded Systems Programming (Aircraft Engine Controls and Fire Alarms as a couple of examples). Too many people get the attitude - 'Oh. My program needs more memory, Just add some to the server.' which is a bad. Why write optimum code ?

I'd LOVE to see the Code Monkeys code working in some of the systems that I had to

But, seriously, having been through assembly, Pascal, C, Data Structures, Compiler Design, telecomms, and some bare-metal hardware programming... I do lament that for a lot of people it's just "oh, well, we're gonna need an infinite supply of memory" instead of actually writing compact code which doesn't just keep getting bigger.

I once had a former co-worker who followed the mantra that optimization was a pointless exercise. He tended to include every library known to man, not give a damn about the efficiency of the library, and ended up with code which was slow but couldn't be optimized because he had no control over anything.

I never understood how someone could continue to claim that optimization was pointless, and then write slow code. You'd think some empirical evidence to the contrary would have helped sway him.

99% of code is better slow and simple. Because it simply doesn't matter.

Right up until it does.

And the people who think optimization is pointless because it doesn't matter are generally clueless about how to fix it when it does fall apart, because they're so reliant on their frameworks and libraries they haven't the slightest idea of where to begin.

I can't even tell you how many times I've seen code which was written to look pretty, but which in practice was bordering on unworkable.

I've seen more than a few OO developers who write what looks like clean, elegant code, but which actually has a huge amount more overhead and convolution which is masked by the library -- so much so that they're calling an n^2 algorithm n^2 times, instead of just writing something which didn't suck from the beginning.

Because, in their mind, the magic library and compiler would make it super efficient, when it did anything but.

You work with RTOS development and don't know the difference between speed and reliable response times?!? Me thinks you are a bloody liar...

Example: The TLSF (Two Level Segregated Fit) memory allocation algorithm isn't used for RTOS because it is the fastest one - it isn't. But one can do analysis of the execution time and therefore determine the worst case execution time for all operations. _That's_ why it's used!

As to Java or Assembler, neither are computer science. CS is about algorithms, run time, data models, paradigms, approaches. BTW, without understanding memory management, you will have memory management problems regardless of the language used. It is just the degree of how bad the problems are, whether they cause program to terminate only or also may become attack vectors.

I would disagree that C isn't good enough, but I do agree that at least a semester of asm would be helpful.

Watch out for mips though--that's what they used at my uni, and while it taught the principles that are found in all architectures, I found it discouraging that our only interaction wound up being through a vm. There was an excellent electrical and computer engineering class that used x86 assembly, and that's the one I'd recommend any CS student take (assuming your school offers something like that).

I had CS professors that really didn't know how to program (just basic pseudocode). Those professors would argue that the only thing important was the mathematics and logic. Everyone is always going to claim they know what's best for CS. It's usually what was important to their professors during the time they graduated.

FWIW, I went to an ABET accredited school and an assembler course was still required.

I agree with the parent (@HornWumpus -- good name), but I'd like to elaborate.

First, I agree that "There have always been a subset of CS students that didn't get anywhere close to the metal. They suck.", and I agree that "C isn't good enough." No language is good enough by itself. If you haven't played with Functional, Procedural, Object-Oriented, and hardware-level (Assembler) languages by the time you've graduated, you've missed something.

There are different tracts in CS degrees, with some focusing on C++ and low level coding (embedded systems, OS, robotics, etc.) and others focusing on Java and other more abstract languages (automated reasoning, AI, NLP, web programming)...so I think it really depends on what the student choose to focus on.

CS should be different from programming. Back in the day when I did my undergrad, the programming was something you mostly figured out on your own time. When I took Operating Systems 1, we were studying memory management, Belady's anomaly, semaphores, etc, but we were also expected to become proficient in Unix scripting by the end of the semester. The exchange on the first day of class went something like this:

Prof: Homework for this week is to write a tcsh script that will set your environment variables when you log in based on a menu.Student: What's tcsh?Prof: It's one of the shells in Unix, you can write scripts using it.Student: How do I learn to use it?Prof: The manual command is "man" in Unix.Student: How do I use the "man" command?Prof: Use "man man" to find out how to use "man".(whole class looks bewildered for about 10 seconds - not sure if he's joking or if Unix is really that insane)Prof writes across the top of the board: THIS IS A UNIVERSITY, NOT A TRADE SCHOOL. RTFM.

If you can't figure out how to learn the mechanics of Java, Python, whatnot on your own time, you really don't have the brain needed to do computer science. The problem is that everyone and their plumber is getting a 4 year degree these days, so it's become the equivalent of a high school diploma in the 80's.

1. Yes.
2. Learn some lower level languages like assembler, C, or C++. Even if you don't use the techniques, understanding them will give you a better understanding of what's going on in your Java programs.

Learn some assembly. Not because you will use it every day (or ever) but because it helps remind you that all the code we typically write is just layers of abstraction on top of a machine (which even assembly is, albeit very low level abstractions).

An old boss from years ago (a mentor for me really) watched me troubleshooting a network issue in an application. He said to me "you seem to be having trouble spotting the problem. Have you tried going lower down the stack?". So I tried ping by name, nothing, ping by number, nothing, etc. Finally after reviewing ip configurations, arp and routing tables and probably a few other things I forget I figured out I had a bad cable.

That taught me a lesson that I've applied to many areas of computers, including programming, over the years. If something seems like it should work but does not maybe something underneath it is the problem. If you want to be able to debug code at the library level or interfaces to lower level languages it helps to understand things like memory layout, registers, the call stack, etc.

Well, in MY opinion, CS students who learned in C or C++ or Pascal or PL/1 are inferior because they use the stack as a crutch, instead of manually keeping track of callback history. If you don't have to write explicit code to keep track of every call, or allocate every local variable, your code will... well, actually, it'll likely be easier to read, easier to maintain, and easier to optimize. But it won't be as good as the code we had to write back in my day.

CS students who primarily learn Java are inferior because they don't have to deal with memory management as they would if they used C

You know, I wouldn't want to specifically use the word 'inferior', but you do learn a hell of a lot from having to deal with your own memory management.

When I was in school, lo these many years ago, I and a fellow student wrote the same basic assignment for a course.

He was one of the sysadmins on the VAX and could set his process to use a vast array which was mostly empty, and rely purely on virtual memory. I had a tiny little 80286, and had to implement the same thing in a sparse array which took up a fraction of the space.

We both got the expected results and got good grades, but the prof basically said since I'd done so much more thought on memory management and the other guy didn't, I'd get the A+ and he got the A.

The Prof also stole my code to use in his own project, because by the time you accounted for architecture mine was about 4x faster and 100x smaller, and he'd basically given us an assignment which overlapped with his own research.

Would I want to do bare metal memory management in C every day? Probably not. Do I think it was valuable to have had to learn how to shoehorn something into a small amount of memory and explicitly be the one to make sure my memory wasn't leaking? Absolutely.

I think more modern software would suck less if developers didn't just assume there were massive gobs of memory sitting around, and implement everything in the easiest way possible without having to factor in resources. Most modern browsers seem to grow their memory usage at a pretty linear rate, even if you're not using the browser.

Because, really, pretty much every piece of software seems to double in it resource requirements every few years.

And understanding pointer arithmetic and semantics in C is valuable, even if most people will never directly see anything resembling a pointer these days.

It really depends on what you want to do. If you're trying to wring the last iota of performance out of an algorithm, then understanding TLB misses and cache protocols can be useful. Even accessing RAM can be an order of magnitude faster or slower, depending on what you do. So, maybe a class on microprocessor design?

OTOH, I find that an ability to understand functional programming, recursion and data structures is very useful. They're the sort of things I quiz people on when I'm looking for really stron

In my totally completely unbiased opinion, I think that everyone should have a basic understanding of how computers actually work, from the ground up. A little bit of basic logic (and how that is implemented in hardware), introduction to low level programming (assembler) and using C to make hardware DO something. From there just keep moving on up until you get to Java. Learning operating system functions and why they are important (handling I/O devices, memory management, process and thread management, e

Computer Scientists understand the theory of computing. Software Engineers understand how to build software. Information Managmentstudent know how to apply computers to business problems. IMHO CS students are not prepared for real world coding applications. If you're going to program you don't need a CS degree, you just need a background in the programming language du jour. If you're going to solve difficult problems with a computer, you need a CS degree (theory, algorithms, heuristics). But to build a web

I've recently watched my wife (C++ environment) deal with a new-grad (Java-based education.) It's true that pointers are a sticking point -- in the process of being taught Java, they get taught that pointers are bad and dangerous (all hail Java for solving the problem,) and can be made only barely tolerable by using auto_ptr, but really should just be avoided. Yeah, it's a problem, sure.

But the bigger problem we have with new-grads and junior-devs, in general, is the same problem you'd have in any field: they're green. They don't test well, or at all. They don't think designs through. They don't communicate well. They ask too many questions, or maybe worse, they ask too few. They try to fix things that aren't broken. They're bad at estimating task sizes (admittedly, people rarely get much better at that even after decades.) In an attempt to not suck, they reach out for best-practices and apply them zealously and inappropriately. They can't imagine how things will fail, or be abused. They spend too much time fixing small problems, and not enough time fixing big ones. And maybe worst of all, they're under the illusion that what they learned in school ought to prepare them for the workforce, when really it just gets their foot in the door.

We, as their seniors, are the ones that should be spending the time fixing their misconceptions, fleshing our their education, filling their minds with the horrors we've seen, and setting up their work habits. When they fail, it's because we fail to do these things, usually because we brought them in too late in a project, gave them too much responsibility, and are fighting a deadline. So we "just fix it" for them, and they don't learn from the experience, while we gain nothing in terms of productivity from having them.

But if I were to nitpick their education? Databases. Recent grads have little or no understanding of relational databases. Their thinking on organizing data, in general, is fuzzy at best, which impacts more than just database code, it impacts class and API designs, often crippling whole features with incorrect cardinality. It deserves more attention in school. The rest, we can fix in production. =)

Yeah, the database thing is a big issue. In college, I actually tried to sign up for a database management class and couldn't, because it was in the Information Systems department instead of the CS department, and I hadn't taken the official pre-requisites. (I had taken a similar class in CS, but that didn't count. From everything I heard, the CS version was harder, but who knows.) So I had to get on-the-job training to understand databases, and it's still one of the weaker points in my skillset.

I agree that it is up to the greybeards to teach the young 'uns, but a large part of that is corporate culture.

When I was fresh out of school, I worked at a place where cameraderie was paramount. We went for lunch. We went for coffee. We went for smokes.

And we talked about issues and the problems they'd encountered over the years, and how they'd approached them and solved them.

The last few jobs I had, if you spent any time on such "idle chit-chat", the management came down on you hard for "not doing your job." It's pretty damned hard to educate the younguns if there is no opportunity to talk with them.

One of my favorite Computer Science instructors said to us: Learn the fundamentals, and a hot button.

A hot button is the 'new cool thing' that everyone is asking for.

The fundamentals are, well, the fundamentals.

So, when I went to school to work on my Bachelor's, we used ADA, c, c++, x86 assembly. ADA was for the "intro to computer science", clang was for many, I chose to use c++ for compiler class. x86 assembly was for assembly language programming.

I remember learning a couple of assembly languages, 3 procedural languages, sql, lisp, and prolog during my undergrad CS degree, while learning three more languages including Forth, Basic, and SmallTalk in summer jobs around that time.

But in my recollection, particular programming language (details of) was not the main point of the majority of my CS (or EE elective) courses, especially not after first year. Quickly learning any programming language was just the price of admission to learning and practicing other CS knowledge. Computing general concepts, algorithm and database general concepts, intro to and practice with different styles of programming such as functional, declarative, procedural, particular types of applications as examples, cool AI'ish stuff, and a few things about software engineering practice, were much of the point.

So if your degree program is "about Java" and "experience with Java and an N-tier JEE stack", then RUN and take some MIT or Stanford online courses in more interesting and useful stuff!

The department I go my masters in computer science from divided the discipline into three chunks:
systems
languages
theory

I think this is a good way to divide computer science.

It sounds like your Java / C question involves mostly languages, and a little bit about systems (since Java programmers do not need to have a fundamental understanding of memory works at a system's level.)

I don't think this question really addresses the underlying issue - what is computer science? To me, I tell people that my formal education is closer to applied mathematics than what I do on a day to day basis. I also like to humorously use the derogatory term "code monkey" to people that have learned everything through the "languages" chunk above. A lot of times when I've worked with these people, they haven't even really studied languages (Why did the language designers make the choice that they did? What does the formal language specification say the language should do in this case? How is this language related to earlier languages?)

Again, about 90% of what I do on a daily basis could be considered "code monkey" level. It's when a customer has a REALLY difficult math problem that my formal education comes into play, and for giving people confidence in me.

Many of the modern CS students spend all there time in a single environment and a single language (Java on Windows). If this is the case for your school they are doing you a disservice. I was exposed to the at least 5 operating systems and 7 or 8 programming languages and wrote assembly that ran on bare metal in school. If you experience a variety of environments and languages you will have a much better base to judge what is good and bad when developing solutions.

Yes, the concern is real and common. The antidote is building stuff. A bunch of stuff. The more stuff you build, the more likely it is you'll have to get "dirty" with the underlying guts of it, the more you'll know, and the more valuable you'll be.

For instance:Of the many garbage collectors Java offers, have you ever used anything but the default? Do you have any idea what the trade-offs are and when you might want to use another one?Have you ever profiled any Java code?What do you know about Java byte code?Ever SWIG wrap anything into Java?Ever used Java serialization? Do you know what's wrong with it and why you wouldn't want to use it?Custom class loaders?

My adivce: go learn everything there is to know about "something", it doesn't really matter what (maybe you want be the worlds foremost expert on malloc). In the process of gaining a very, very deep understanding of that 1 specific sliver; you're going to also learn about a ton of other stuff on the way.

C does offer the ability for explicit memory management and if thats what you want to learn I suggest picking up C. In programming the lessons are transferable and always useful when looking at another language. What you learn in C can be applied to what you do in Java.

That being said, Java does a lot of the heavy lifting in memory management, but it isn't fool proof. If its java you want to learn about, try running your jvm with less and less memory. This will make you conscious of the size of large objects and ways of getting around memory barriers. In java this really starts to apply when you are using huge data sets and repetitive tasks. Poorly written code will start to see oom and stack overflow errors. There are plenty of tools out there that will analyze memory usage of your code. I'd suggest getting some and trying to decrease your programs memory footprint without a loss in speed.

This, of course is all computer science, and has little to do with most software engineering done today. Knowing these things, though, will definitely put you leaps and bounds in front of other software engineers.

Web development? Keep learning Java. You will rarely ever have to worry about memory management. Learning C won't make you a better Java programmer, and there are plenty of jobs for people with Java backgrounds. Of course, you should also know HTML/CSS etc. if you're going this route.

Video games? Learn C and C++, probably in that order. Java isn't going to cut it, you'll need to learn things like memory management and graphics programming. However, the object-oriented programming stuff you learn in a Java-centric curriculum will still be very helpful in C++ (or C# if you go in that direction), so you have a solid base to work with.

Embedded systems? You're in either the wrong school or the wrong major for that, you need to focus on C and Assembler for that. Completely different world from Java.

You get the idea. Figure out what you plan to do with your career if you don't already know (in a broad sense, you don't have to nail down a specific job), and steer your studies that way. If you want to keep your options open, teach yourself some basic C or C++ and see if it's right for you. If you can't figure out how to manage pointers, then you know what type of programming not to get into.

The problem isn't so much that new grads are missing some specific piece of technology or some specific piece of information. It's that new grads are typically missing, quite frankly, everything.

Programming and software engineering are -hard-. If you're a couple standard deviations above the average IQ, you can become barely passable in four years and reasonably good after ten. 'Reasonably good' is ideally the minimum standard that most companies would prefer to hire at, and the percentage of new grads w

Do you want to go work somewhere and write Java programs for a living? Maybe you'd like to go write games or work on an office suite? Then learning high level languages like Java will serve you well. Do you want to write low level stuff and do "real" computer science? Maybe you want to develop a new high level language, or do hardware development or other significant development. If that's what you want to do, then you're right. High level Java and other languages should just be a footnote. Focus on

I'd trust a programmer who's never dealt with the sorts of problems caused by manual memory allocation (or, even nastier, compiler bugs) about as much as I'd trust a plumber who's never gotten shit on his hands.

It's not that I think garbage collection is bad, but the sorts of bugs caused by memory stomping tend to be some weird non-deterministic stuff which makes you question your sanity and your tools. You have to learn to narrow things down as deep as possible, to trust nothing, question everything, abuse

The problem I've seen in CS grads over the last 10-15 years is they have little to no engineering background (even when their degree is "Computer Engineering"). Most applications are complex systems. And most CS grads don't understand systems. I've been able to teach EEs, a chem E, a civil E, an MD and a CPA (among others) how to program. And they've had no trouble implementing solid class hierarchies and robust applications. It's much harder to teach a CS grad about structural integrity, analyzing a design for weaknesses, and root cause analysis. In some cases they won't accept those are even an issue since "software is so different from physical structures". So they keep building things that pass all the tests but repeatedly fall down once they get to production.

Or those who can write in C#, and those who can write the.NET runtime.

Or those who can write in PHP, and those who can create PHP. Wait, those are the same.

You get what I'm saying. The programmers who whine about requirements to understand low-level memory management are in the first category, and their knowledge and skills are laughable compared to the kind of programmers who get hired by the likes of Google, Apple, and Microsoft.

Stop trying to pretend you're as good. If you were as good you'd be doing something interesting instead of slapping together enterprise bloatware.

Real should be replaced with "Good". Are there "good" Javascript, Java, Visual Basic, etc., programmers? Yes there are always exceptionally gifted people -- however that is not the norm as those language encourages sloppy design principles. If programmers come from a C background they tend to be "better" programmers:

If somebody just goes to university and gets their computer science degree, odds are that they actually are very bad programmers. Anybody who has actual programming skills has most likely had paid internship, or has their own github account or open source project commits where they can demonstrate that they can product actual code. There isn't even required programming in CS courses to make somebody a good programmer by just doing the required assignments for their degree.

Exactly. When you become a dev, you simply call up a sysadmin on the phone, or preferably his boss or, better, the highest level exec you are on first-name terms with and complain that your app isn't being given enough memory.

I just went on a rant at work because one of our programmers decided, at some point in the past, to write blocks of code in inline hexadecimal. With little to no comments. It had a bug... five bugs actually. I spent two days in the code, finding and fixing problems which should have taken at most a couple of hours, all because someone decided to be a "Real Programmer", aka elite ass. I don't care what the esteemed Mr. Raymond and Mr. Nather (the author of the article in catb.org) believe; we created hig

I used to think I was a computer scientist, but now I'm not sure. Euclid? Diophantus? Babbage? Lovelace (albeit she'd be a founding mother)? Church? Goedel?

Not Babbage or Lovelace I wouldn't think... too practical:-)Church and Turing, perhaps; the functional programmers can follow the former and the procedural ones the latter. I'd probably also include Claude Shannon.