next »

[Triplefox]

Here is an (arbitrary) list of Things That Are Worth Understanding(whether or not you're doing game programming specifically), in somewhat descending order of importance:

• Data structure implementations, their performance characteristics, and their situational uses
• Memory management techniques
• The distinction between mutable and immutable data
• Hardware instruction sets
• The lambda calculus
• Concurrency
• Techniques for implementing programming languages
• Statistics
• The relational calculus
• Networking theories and protocols
• GUI/Web application techniques
• Source control, bug tracking, build management

The bottom ones are "resume skills" - specific libraries, specific domains and applications. The top ones are a mix of low-level concepts needed to make things efficient, and high-level ones that allow you to do wizardly things and make life easier. A deep understanding of data structures will allow both, hence which it is at the top of the list. The actual importance of any of these things is going to depend on the situation, anyway, so take the rankings with a grain of salt. Anyway, in a lot of cases you only need to know enough to recognize the applicability of a technique; the rest is sweat and some research.

But I will say this: "Architecture" and "Software Engineering" practices come and go in fads, as do languages themselves. Don't invest your ego too deeply in those things. While there is some evolution taking place when a new technique or a new language becomes the hot thing, it's evolution within a specific context, and is less transferable over the course of a career. If you want to learn the good stuff, skip over the self-interested windbag bloggers and "learn in 24 hours" books and go straight to research papers and textbooks.

[SoftBlade]

Well, thanks a lot for all the input! I'm learning much more from my post than I anticipated.

I'm asking about OOP since it's what I'm being taught in my degree. It shouldn't start to fade right after I had to start putting time into it xD But since it'll gradually fade, if it is fading, I have no worries

You (the OP) mention you're starting your final year of your Computer science degree: how the hell did you get along without learning a programming language at all? 

Wait, what! I never said that xD Along the way it seemed like people started assuming that I wanted to know which language I should start learning when all I really wanted to know was whether it would be worth it to invest time in libraries like OpenGL or DirectX if I want to show experience. I consider myself pretty competent in C++ by now (well, I've never really done anything "big" with C++), and I can program with Java. The Java course also focused a lot on Design Patterns.

@Average Software. At least I'm doing Qt next year as part of the degree, so something worth while. I'll also be learning Prolog and, wouldn't you know it, OpenGL, so I might as well start OpenGL now if I wanted to. I'll definitely take a look at some of the other languages you mentioned, and also C# (Tons of C# jobs here in South Africa, or so it seems). I'm currently developing a program in Java that applies the algorithms I learned in my course on Numerical Methods, so I'm hoping that will count as some experience, but I'm sure it will give me that extra drop in the bucket that the other programmers hunting for the job might not have.

In the end I think the best would probably be to put my game programming on hold and rather learn a new language or 2. Considering the amount of time required for to work on a game, it would probably be best. I mean, unless I suddenly drop, I still have a lot of time after getting a job to work on game programming... I hope.

Thanks again for all the input. Most post, if not all, were extremely helpful!

EDIT:

Here is an (arbitrary) list of Things That Are Worth Understanding(whether or not you're doing game programming specifically), in somewhat descending order of importance:

• Data structure implementations, their performance characteristics, and their situational uses
• Memory management techniques
• The distinction between mutable and immutable data
• Hardware instruction sets
• The lambda calculus
• Concurrency
• Techniques for implementing programming languages
• Statistics
• The relational calculus
• Networking theories and protocols
• GUI/Web application techniques
• Source control, bug tracking, build management

Wow! Thanks for the list. At least I can happily say that I understand a little more than half of the concepts you mentioned on some level (some not too in depth but still something )
Thanks for the other advice too.

[Sar]

functional programming
...
pretty popular in academia
...
Good to learn, though, I advise you to pick one up if you can.

While I totally agree that it's well worth any software engineer learning a functional language specifically because of the breaking-your-head part (like any Lego model, after you drop it and rebuild it the first time it's generally put together in a much better way, you've found out where the weak points are and reinforced them), but it's worth mentioning that functional languages are - generally speaking - totally worthless on your CV. I sincerely doubt that my current boss has ever even heard of Haskell (or SML, the one I learned at university), and if he had he'd not consider it relevant to my job at all.

Personally, I think that Functional Programming was the single most useful course I took at uni, and if I was running a profitable software company and could afford to be selective I'd be very tempted to task new hires with learning and solving some relatively-hard problems in a functional language before I let them through their probationary period, but realistically nobody in the business world cares at all, they're considered toys.

I'm asking about OOP since it's what I'm being taught in my degree. It shouldn't start to fade right after I had to start putting time into it xD But since it'll gradually fade, if it is fading, I have no worries

I'll add my voice to the choir of "what, OOP is dying? First I heard of it". If anything, OOP has been gaining more ground, recently, as far as I can see. I would tend to consider anyone who calls OOP 'a fad' in the same way I would consider someone who maintains it's worth coding everything in assembler instead of C++ for performance gains.
As it goes, I work in business software; of course it's entirely plausible that the situation in the games industry or science is different, but I get the distinct impression that business software is a far larger job market, so you're more likely to find a position in business.

all I really wanted to know was whether it would be worth it to invest time in libraries like OpenGL or DirectX if I want to show experience.

(The other side of the coin that I don't think I remember seeing in the thread so far is simply that learning any library at the very least shows flexibility, interest in your craft and learning ability, all of which are important in a programming job regardless of whether you'll actually be using DirectX or OpenGL.)

and also C#

As it goes, if you know Java you probably shouldn't have any trouble learning C# in a day or two, API aside. We don't have to declare which exceptions our methods might throw and some of our methods aren't virtual, but the two langages are pretty similar in a lot of ways.  Whether you like it or not probably depends on whether you think Java is a nice, sound, engineering-oriented language or a horribly-long-winded over-prescriptive language. (Personally, I wouldn't be surprised if the Java compiler started requiring that open-braces were on the same line as the function declaration and not the line below, so I quite like C# in comparison. ;-)

[bateleur]

@Ben Kuhn - Watch your quoting there, please! Whilst I'm sure thaaks is a fine gentleman, I'd rather not have his comments quoted as mine!

[powly]

And I think Ben Kuhn would rather have you talk about SoftBlade instead of him.

[thaaks]

And I think I was only quoted by SoftBlade, the original poster. BTW: Apologies for misreading your initial post 

And to bateleur: my wife says I'm a fine gentleman 

All is good 

[Average Software]

When I refer to the fading of OOP, I'm referring to the fact that we seem to finally be reaching the tail end of what I call "The Java Blitz," which was the ridiculous effort by Sun's marketing team to convince the world that any and all problems could be solved with OOP (and hence Java).  A lot of people were fooled by this, and there has been a ton of terrible code written in the past 20 years or so that overengineers OOP solution to non-OOP problems.  People are finally starting to realize that OOP is not the panacea that Sun claimed it was.  In fact, one could get even argue that software has gotten quite  a bit worse since OOP became mainstream, but correlation is not causation and all that.

It's also worth mentioning that in C++ at least, the general feeling among the language elite is that generic programming is making OOP largely obsolete, at least in C++.  C++0x's new generic programming capabilities (concepts, RIP, we'll get you later) make some really incredible stuff possible, and I would expect that after the new standard is released, you will see less and less OOP in C++ in favor of generic template based ideas.

Scientific research is done by PhDs with usually little training in compter science, away from the "mainstream" of development. They produce impressive works, but I wouldn't look to them for future trends.

I was referring to much of the research being done by computer science PhDs.  That is where the future trends will come from.  Commercial languages don't innovate anything, despite their marketers' claims to the contrary.  I can't think of single thing in either Java or C# that wasn't done in an earlier language, and usually done better.  Sun and Microsoft's marketers would have you believe differently of course, I remember reading MS's description of C#'s generics and they basically claimed to have invented constraints, despite the first language with generics (Ada) having them 30 years ago, and implementing them better.

In fact, Ada is the only commercially developed language I can think of that ever innovated anything, but it was developed under very unusual circumstances (for the US military, by contract).

In short, academia is exactly where you should be looking for new programming trends, that's where the action happens, it just sometimes takes a few decades to see it pop up anywhere else.

[BorisTheBrave]

Oh, computer science research. Well, less argument there, then. Not that I would still advise looking at that stuff to predict the future, there's much junk produced too (as part of the research process). Also, Java did innovate in a few areas: after the first few years the garbage collector was/is pretty damn advanced, for example. They've enabled all these JVM based scripting languages, which wouldn't have got off the ground otherwise. Not academic advances, really, but still important.

Still, strong disagree on your OOP statements. Java has an "everything is an object" ethos, which might well be waning (it was always stupid). But that's not the important part of OO. OO, to me, is more about encapsulation, inheritance/polymorphism, reification (making objects you can manipulate to represent previously implicit concepts), and composition.

Templates and functional programming are orthogonal to objects, and their perhaps increasing prevalence doesn't make objects less used. I'm not really sure how in C++ templates make objects obsolete - virtually all major templates are implemented in terms of objects and classes, and the end results are also real objects (i.e. not shoe-horned for syntactic reasons). Concepts kinda double for inheritance, but it's way too early for anyone to be making calls on that one.

[gimymblert]

What serious alternatives are there to OOP? I've always been in web and games so I'm not very aware of the scientific research side for example.

It's true that in the games industry, OOP seems to have recently begun to make a very slow decline (though I imagine that it'll never be totally gone;  it's much simpler and easier to hack out OOP code than what's arising in its place).

That's not to say that the games industry is slowing in its use of C++ or objects;  just that there's currently a slow shift towards not having the objects represent "things", as is suggested by classical OOP design.  Instead, trends seem to be moving toward setting up individual processes as objects, and passing them large blocks of data.  Some call this "component-based programming", but I like to call it "Process-Oriented Programming", or POP.  Or, since the processes are implemented as objects, you could even get away with calling it "Process-Object-Oriented Programming".  If you really wanted to.

Anyhow.  In POP, you don't have objects representing each individual enemy on the screen;  instead, each enemy instance has a blob of AI data that sits in an array with the AI data of all the other enemy instances, and that array gets passed to an "AI" object to work on, and the results of that get sent in an array to an "EntityMovement" object, the outputs of which get sent to a "Physics" object, and so on.

The big advantage of this approach over OOP is that you can gain some surprisingly large performance wins due to data locality (no cache thrashing as each process advances through its array), and code locality (not jumping around wildly through code), and because each of these bits have defined inputs and outputs, it's much easier to put game code onto the different cores of modern multi-core CPUs, than it is with traditional "one monolithic object per entity" approaches;  if you were really gung-ho about it, .you could probably make the engine calculate and implement optimal multithreading automatically, just based upon timing data and the movement of data through the various processes.

Of course, this approach is harder to think about (or at least it is for me!) and harder to implement.  But it's difficult to argue with the performance gains on modern multi-core machines like current PCs, XBox360s, and PS3s.  And if it means that I get the benefits of multithreading without ever having to think about mutexes in my game code, then sign me up!  

Additional info for the curious:
http://research.scee.net/files/presentations/gcapaustralia09/Pitfalls_of_Object_Oriented_Programming_GCAP_09.pdf