Since some BASIC dialects have been discussed here, it seemed like it was a good time for this:
It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration.
-Edsger W. Dijkstra
Source:
How do we tell truths that might hurt? in
Selected Writings on Computing:A Personal Perspective.
We have obviously seen a few examples here that not everyone is mutilated beyond regeneration, but BASIC definitely stunts one's growth as a programmer, in my opinion.
What I am willing to bend on is some assertions that it's better to start OOP, rather than build towards it. I don't think this is unworkable, but I feel that when one is first starting to program, there's so many new things that must be learned. I think that adding concepts that aren't particularly applicable for small programs as one is beginning to learn can muddle things. I feel that learning how to work with objects, how their methods work, etc. is much easier once you know what a function is, etc. If one picks a language by which OOP is supported, but optional, the pathway is more direct when one is ready to learn about objects, and they don't need to adjust to a new environment. On the flip side, if one learns a pure OOP language, then moves to a procedural language, a lot of knowledge will transfer, but some problems may seem more daunting when one is unfamiliar with things like structs to transport a "bundle" of data, since they are used to doing so with Objects.
Also, starting with Java I feel that some concepts get missed. Is Java pass-by-reference or pass-by-value, or can you do both? So often people are passing around objects, that this can get muddled and lost. It's strictly pass-by-value, but so often that value is really a pointer to an object. But you don't really know it's a pointer, since there aren't pointers in Java. Perhaps some think it is archaic to deal with passing conventions, pointers, memory-allocation, etc. but I think that these concepts make you well-rounded, and do apply to higher-level languages where these things aren't immediately applicable.
As
eviltobz stated, knowing these things can help you be more careful with your algorithms because you have some idea about what's going on "underneath", and might have a better idea of the complexity of, say, inserting an element into a dynamic data structure. Without knowing the specifics, one might think that every insert into a balanced binary tree has O(log(n)) complexity, or not think about the complexity at all. In reality when the tree needs to be rebalanced, an insert can be an O(n), so the true complexity of such an operation is amortized O(n). Just knowing about pointers isn't going to teach you that, but there are plenty of other examples where low-level knowledge makes for a better high-level programmer.
I suppose one example is assignment, with or without something like clone. It seems like a pretty basic operation. In some OOP languages, assignment of an object results in a user-authored or system-generated copy of all of it's fields, perhaps even a deep copy of dynamic data structures stored in the object. This can be very costly, but how would one expect that with a simple assignment statement? Understanding the difference between a single value that is pointed to by many pointers vs. making many copies can be helpful in deciphering this sort of situation.
This ended up much longer than I intended. I guess my main argument for avoiding object-orientation up front is to save complexity. Especially languages that allow operator overloading, like C++, you can be very surprised by what a simple x = y + z; operation actually does when these are not primitives.
To the OP: You've now been told to use a great many modern languages, and not to use each as well. If Java is going to be of the most use to you in the near future, it isn't going to hurt you to start there. The learning curve might be a little steeper, but you'll get there. I would highly recommend learning straight C sometime in the future, though, as I think it forces a stronger understanding of how the machine works, and other important programming concepts that are hidden away from you in higher-level languages.
-Lee
).
