Advice For Programmers Right Out of School 469
ari1981 writes "I recently graduated from school with a CS degree, and several of my classes were very theoretical in nature. There was some programming, but it seems not as much as in other schools. I'm currently working at a company where I'm doing primarily c/c++ app development on unix. But as I read slashdot, and other tech sites / articles, and realize for some of the software being written nowadays, I would have absolutely NO IDEA how to even begin writing it. I remember first time I saw them, I thought console emulators were really cool. After my education, I have no idea how someone would begin writing one. With the work I'm doing now, it doesn't seem I'm going to be using (or creating) any of the really cool technology I hear about. How did everyone here begin learning / teaching themselves about different aspects of programming, that they initially had no clue about? How did you improve? Programming on your own? Through work?"
My Advice (Though You May Not Agree) (Score:5, Insightful)
While this wasn't what pulled me into computing, it may be your addiction. Here's what I would suggest doing--take a well developed open source emulator (you know, like an NES emulator [sourceforge.net]) and pick apart the source tree. You might find that the code is obviously doing some low level translation of the ROM which essentially changes its executable language to be IA32 or some such thing. It may be that you don't understand the architecture of the NES itself and therefor you can't really develop this yourself. So there's some insider information you lack but it will still be a good learning experience and may prompt you to figure out how to A) dump ROMs and B) reverse engineer a console architecture. Even if these are fruitless searches, how far you're willing to go will be a good indicator of whether or not CS is for you. Yeah, I hate to say this but I know people with CS degrees that simply don't have the debugging mentality to be programmers. A simple test is to think back to the times you saw something neat. Did you ever have a strong internal urge to find out how it worked or to try and modify it to augment its task?
Fear not your own ignorance. Only fear your acceptance of it. I am confident that if I wanted to build an emulator I could. I personally find other things more interesting but you just have to buckle down and really pick it apart and look for answers. As I said above, these emulators might have proprietary reverse engineering so these backwards black boxes might not be the best place to start as you may be met with frustration. On top of that, the newer consoles are now fighting a war & implementing encryption scheme which just makes the emulator all that more complicated. Why don't you pick a project like Firefox? Get the source, find out what the common developing environment is and step through the code when you visit a page. That's where it all starts.
Most importantly, you don't need to do everything from the ground up. It helps to know everything that's going on below the abstractions you sit upon but you don't need to think about that every time you write code. Learn to use libraries & frameworks. To quote Salvador Dali: "Those who do not want to imitate anything, produce nothing." I couldn't start writing an emulater either. But if I looked at the source trees and structures of the more popular ones out there, I'm damn sure I could figure it out. That confidence I have in myself is infallible and that's important to me. Sorry to sound like Dr. Phil but you asked for my opinion.
There are different tricks to different applications. Some are more simple than others. In my opinion, the less tricks you need to get started in a language, the better. Because we're not all world class magicians (although every language has some players that could rock your world in said language). This is why Java, while not as efficient as C, is probably taught to you first. There are very few tricks one needs to know in Java. But you know what? Java is still quite useful. Those responsible for implementing it did a decent job and now the web service programmer needs to know very little about them because configuring them has been abstracted and made easier by many UI & IDE tools out there. But web services are a very practical and widely accepted concept out there today. In fact, pay the bills by writing some very inane web se
Re: (Score:3, Insightful)
Re: (Score:3, Informative)
A more appropriate name would be SDS; 'Standard Diagram Set'.
From the Ground Up? (Score:5, Insightful)
There has only been one program ever written from from scratch, and that was "Hello World." Everything other program has been cut-n-pasted from that.
(Well, that's true at least from the advent of "high level" languages like "C", but it's probably true with respect to most Assembly programs too.)
Re: (Score:3, Interesting)
The first time I ever saw a "Hello, World" program was in the 1980s.
I wonder when they originated.
Re: (Score:3, Informative)
Re: (Score:3, Informative)
Re: (Score:3, Informative)
Re: (Score:3, Insightful)
Writing in a program
digg around (Score:2, Informative)
Re:digg around (Score:5, Funny)
You, sir, must not be a true programmer. If you were, you would know that goto has long been considered evil. Instead, you should make sourceforge into a function, and call it as such: sourceforge().
Re: (Score:3, Funny)
Re: (Score:3, Interesting)
findProject [] = []
findProject (p:ps)
| not ((checkProj p)=="suitable") = findProject ps
| otherwise = p
-- now just implement the trivial function checkProj::Project->String and off you go:
findProject sourceforge
Re: (Score:3, Funny)
As in:
Program manager says you need to implement (X, Y, Z) by $FOO date. Only a stable (X) or a very, very unstable (X, Y, Z) possible by that date but the VP is backing the project managers demands.
In this case, a "goto hell" is 100% acceptable.
"Never" is harsh language (Score:3, Interesting)
There is never, under ANY circumstances a justifiable use of a "goto".
Without goto, how would you do the following?
make things on your own (Score:2)
Write new code (Score:5, Insightful)
write more code of your own
write more code
read more code
read LOTS of other people's code (DL a smallish OSS project at first, then larger ones).
rinse, lather, repeat.
If you're concerned that you're not learning "cool new things" on the job, learn them off the job. Your destiny is your own, as hokey as that sounds...
love your work.
Re: (Score:3, Insightful)
Well, that's one theory I heard about, which seems good enough on the surface, but in reality, you'll probably read just enough to find that one algorithm or method of doing something that you're looking for. If you want to write a terminal emulator, go grab the source code for a terminal emulator and see how they did it.
Re:Write new code (Score:4, Insightful)
That's pretty sound advice.
Re:Write new code (Score:5, Informative)
Re:Write new code (Score:5, Interesting)
Especially here: http://thedailywtf.com/ [thedailywtf.com]
Learning what not to do can be as valuable as learning what you should do. The comments can be useful too, the problems get picked apart pretty extensively and can be quite educational. If anything you ever write never ends up on a site like that, you can't be that bad off.
Re: (Score:3, Insightful)
Re:Write new code (Score:5, Informative)
Pick something with realistic goals for whatever sized team you have (or self) and set goals
Design your work first
If you don't do those, you'll probably never learn to finish code. Setting goals with a team usually needs to be done based on time and skill levels of members. If it's just you, set goals for yourself and stick with them as best as possible. Don't worry too much about missing a date as long as you made progress towards your goal (but make sure to set a new goal).
Also don't be afraid to axe a project if you have to. I had a flight sim with some beautiful code in it (the blitter was fantastic... too bad blitters died with that era of hardware) and over a year of work and I killed the project even though completion was probably only a few months away. Why? because it had a problem at the core of the engine that was unfix-able and needed to be recoded from scratch to boost it to optimal framerates (specifically, I used virtuals at a low level not knowing that they have an expensive look-up table). I also had bought my first Voodoo card by that point and knew that was the future, not painter's algorithm and blitters. As sad as I was killing what I hoped would be a shareware quality flight sim, I learned so many lessons that it was worth the time spent.
I can't tell you how many kids I've talked to that want to make a commercial quality MMORPG or a 3D shooter in a few months...
Re: (Score:3, Interesting)
You've gotta be careful with that approach. I've seen some very poorly-coded OSS projects, and they tend to be the smaller ones. Just because it's open source doesn't mean it's well-coded!
Rather, it may be more helpful to look at large OSS projects, but one where you can concentrate only on a smaller module. Something like Apache, Subversion, the Linux kernel, etc. These projects tend to have much better coding guideli
Re: (Score:3, Insightful)
Re: (Score:3, Funny)
Re: (Score:3, Funny)
Books, Books, Books... and Notes. (Score:4, Insightful)
You may also want to read is The Elements of Programming Style by Kernighan and Plauger. I've only skimmed through it, but it talks about writing code so that its function is obvious to other programmers. (Trust me, few people can look back on code they wrote five years ago and remember why they wrote a particular routine that way.)
Another book I would recommend is Structured Computer Organization by Andrew Tanenbaum. It will take you from circuits and logic gates, through how a CPU works, to how Operating Systems work.
The only other recommendation I would make, is to become an organized note taker. The top programmer in one of the companies I worked for was such a person. If there was a question with the way something worked, he could pull out a notepad, flip through a few pages, and tell you what issues he was dealing with in the code, and why he made certain design choices. If he got an error message, he would write it down, and what steps he used to correct it.
I'm sure others have mentioned continually educating and upgrading yourself, and that an IT career these days means having lots of short term jobs, rather than a single lifelong job, joining clubs and associations, etc. The only thing I would add to that is Practice, Practice, Practice. Write code until it is second nature to bang out high quality code.
Refund? (Score:4, Funny)
Sounds like you should ask your school for a refund.
Re:Refund? (Score:4, Funny)
Re: (Score:3, Funny)
seriously (Score:3)
Re:Refund? (Score:5, Insightful)
Re:Refund? (Score:4, Insightful)
A real Computer Science degree should have taught him the principle of Turing-equivalence. It should have had at least some assignments expressing algorithms on Turing Machines, Unlimited Register Machines, Petri Nets, Lambda expressions, etc. The principles of converting between one universal mechanism for computation and another should be deeply ingrained. How do you prove that a model of computation is universal? You implement an emulator for an existing universal model of computation (typically a Turing Machine) in it.
That covers the basic theory. Then you need to understand how a real computer works. Any half-decent CompSci programme should have explained the basics of a relatively modern architecture. From there, it's just a matter of learning the instruction set, memory layout, devices present and how to communicate with them; anyone who actually gets a CompSci degree should have the ability to read the relevant documentation and understand the architecture.
Past the theory is implementation. The first bit of that is understanding how to parse an instruction stream. Any CompSci course that doesn't cover the automata theory required for this should be regarded with suspicion. Once you've parsed the instructions, and understand what they are meant to do, it's just a matter of implementing functions that handle them, which is time-consuming, but not conceptually difficult.
Now, the emulator produced using these steps would be slow. I would estimate between 1% and 0.1% of the native CPU speed. Fortunately, on a modern CPU that is fast enough. If you want to get in to dynamic (JIT) recompilation and caching, it's a little bit harder, but the compilers course (plus some reading of the documentation for the target architecture) should provide the requisite knowledge.
To me, it sounds like the original poster has sat through a Computer Science degree and managed to gain some of the knowledge but none of the understanding that it was meant to impart.
Re:Refund? (Score:5, Insightful)
At most schools, Computer Science is mostly the study of algorithms. My school, however, had a degree called "Computer Science and Engineering." In this program, students learned not only algorithms, but also digital logic, electronics, and computer architecture. Students had to design an entire computer using basic digital logic components (by first building multiplexers, decoders from and/or/not gates). Then we had to write an emulator for a simple computer. Finally, we wrote a compiler/linker for the emulator.
FYI, the BSCS&E is a significantly harder program than the B.Arts in CS program. While we were taking extra physics and EE courses, the CS people were taking French, Theatre, and other easy courses that had real, live girls in them. We got the better education, sure, but I'm not sure it was worth it
My advice (Score:2, Funny)
(They sent a memo, you know.)
Re: (Score:2)
Remember the decimal point... (Score:2)
Focus. (Score:2)
Find a development community if you don't like working alone, and see what you can contribute, or lurk for a little while until you pick up enough knowledge to feel more c
Starting is HARD. (Score:5, Informative)
Where that isn't an option; I've always turned to O'Reilly books, and online tutorials to learn some new skills. I've written some tutorials for people who are interested in getting started with embedded electronics, for example. It's not hard to do, but you need to know about a half dozen things before you can get started.
I suspect you're either giving up too easy, or not looking online enough, or in the wrong places. For console emulation, there's a LOT of documentaion in the source code for MAME, and I am sure the others are similar.
Most of the people who are doing complicated OS programming have 10, 15, or even 20+ years of hacking away. Spending thousands and thousands of hours in front of a computer helps. Unless it's spent playing WoW, maybe.
You just need practical experience (Score:5, Insightful)
Yes you do. You just don't know it yet. (Assuming your school wasn't out and out terrible.) There's a huge divide between theory and practice that every new programmer has to overcome. The best way to overcome it is to dive in and learn about the practical designs of today's technologies.
For example, you want to write an emulator. Many of the early game consoles were based on the 6502 microprocessor. If that scares you, it shouldn't. Read this webpage:
http://www.obelisk.demon.co.uk/6502/ [demon.co.uk]
It will introduce you to 6502 assembly. It explains not only the text commands you can use, but also the hex codes that will be output by the assembler. You can get an assembler like DASM [atari2600.org] and try it out for yourself. Try writing a simple program like: Next, run it through the assembler. Open it in a hex editor [handshake.de] and you should be able to see the direct mappings between your code and the program output. If you target a specific platform like the Atari 2600, you can use an existing emulator with a debugger like Stella [sourceforge.net] to watch your code execute line by line.
Remember, learning doesn't end when you exit school. It just begins. So start digging up everything from reverse engineered documentation to documents put out by standards commities like the IETF's RFCs, the W3C standards, and the ECMA standards. You'll gain a much greater appreciation for how things work after you take them apart and understand them.
Re: (Score:2, Insightful)
Invest in yourself. Assume no one else will. (Score:5, Informative)
An entire generation of creative software people who had great ideas and deaf employers grew sick of their cubicles and started the open-source software revolution. They wanted to learn stuff and do stuff, just like you do.
Grab the code, read it, mess with it. Invest in yourself and assume no one else will.
My experience has been that you MUST teach yourself... especially if you work for the big cubicle farms. Teach yourself so you become better, so you keep your skills current, so you energize your imagination, and so you can go elsewhere when your employer enters the BRED ("Beancounters Rule Every Decision") Stage Of Atrophy.
BRED means that your employer is unlikely to pay for you to learn anything useful, especially not during the sunny hours when their BMWs and Porsches are in the parking lot. BRED means that good ideas die unless you happen to drink whisky with the CEO once a week.
Cowardly employees and consitutionally cheerful employees are easier to flog and much less frightening and expensive than people who want their employer to invest in them. People who have the latest skills aren't chained heavily enough. And when the expenses grow and the balance-sheets and Powerpoint slides don't show the Beancounters at the top any benefit ("any chance of getting more stock options"), you can bet that your Red Swingline Stapler is going to Bangalore.
Re: (Score:2)
Re:Invest in yourself. Assume no one else will. (Score:5, Insightful)
I don't know where the big cubicle farm comes into play, here. Working as an independent contractor has led me to the exact same conclusion. Always learn, ALWAYS teach yourself. It's pretty much ALWAYS worth it.
And don't limit yourself to Comp Sci, either. For example, I'm currently training to be a private pilot. Why? I don't know, and never do. It's fun, I like to fly, and having more skills and experience has always paid me well. One of the best things you can do is to spend a few bux at the local Barnes and Nobles on a subject you know little about. B & N is a goldmine of business plans, technology information, and income opportunities!
I've attended numerous business courses in salesmanship and capital investment. They've also served me well, and helped me identify a startup with real potential, and gave me the skills to sell my way into partial ownership of the company. (that's now growing by leaps and bounds)
Another example - I did some research into using PHP as a scripting language for an SMTP daemon. I wanted to do some dynamic proxying that I didn't see elsewhere. I got it to work, using PHP as a script under xinet.d on Linux. Although that original business idea went nowhere, I used that very same software code to build a daemon that today transfers many gigabytes of data in a distributed software database, with about a thousand daily users.
Having more saleable skills will always pay.
Re:Invest in yourself. Assume no one else will. (Score:5, Insightful)
> I guarantee I'm a much happier person than you. Oh, by the way, go fuck yourself asshole.
That is by far the most contradictory statement I have ever read on slashdot. (and I've been coming here for many years)
Copying, translating, teaching (Score:3, Insightful)
Teaching it was also useful because it made me convert awk, korn, bash and sed functionality *and* taught me that Perl wasn't the slowpoke I'd thought an interpreted language would be.
Follow Your Heart/Use The Force Luke (Score:2)
Yoda advice (Score:4, Insightful)
Re: (Score:3, Funny)
"There is no try"? We're coding without exception handling?
I'm pretty sure I've read code written by Yoda, too. Nobody else could write backwards syntax like that which still manages to function. Jedi Master, indeed.
Just start and be prepared to fail. (Score:5, Insightful)
You need to write a mountain of code before you reach the level where you can debate the finer points for or against C# / Java / Python / LISP... You will learn the most from your mistakes, so go forth and screw it up. Do it often. And then fix it. Each iteration will make you better, and remember it takes time.
Re: (Score:3, Insightful)
I'm not too crazy about this attitude. You can certainly begin the debate before then. Sure you may be smacked down, but at lea
10 years of experience (Score:3, Insightful)
To do that you have to always look for a challenge. When you get to saying "I can do this standing on one ear" its time to go do something you don't think you can handle.
As a beginner though, the big thing to learn is that software experience doesn't scale. Writing a 100 line program does not prepare you to write a 1000 line program which is nothing like writing a 10,000 line program and when you get past about 20,000 lines its totally different b
Fear. (Score:5, Insightful)
That's called 'fear' in the world of programming. Instead of digging into an open source project, or just jumping in and seeing what you could do, you turned away, and asked others to make it easy for you. Learn to recognize your fear, and you can master it.
All programmers feel it, some of the best just mastered it without ever thinking about it. None of us were handed this information on a silver platter. If you spent enough time in college to learn enough programming to be a master, you'd be retired when you were done.
The fastest way to learn programming is to jump in, not to go to school.
Reading and Writing , Arithmatic (Score:5, Insightful)
2) Reading - get books. Educate yourself. Self-starters are valuable.
3) Writing - don't just read, but practice by coding. It's the only way to learn. The more senses you invoke the more you comprehend.
4) Arithmatic - (depending on your field, but for 99% of them...) keep up on your math skills. Sharp math skills will make your job easier
I've been employed for a year, so I'm fairly fresh in the field but those are the things I've found and am taking to heart. They seem to work for me.
for me, a Masters really helped (Score:2)
You want advice? Here's advice (Score:3, Insightful)
some tips. If you don't like them, stick to what you're doing
and be happy.
1) Learn assembly language. Play with it. Think in terms of
what you can and cannot do with it. Read the -S output of
your compiler and understand it in terms of your source.
2) Play with algorithms. Can you code up a heapsort without
referring to a book? Can you do it in assembly? Read Jon
Bentley's "Programming Pearls".
3) Know your platforms' hardware and software. Install a
from-source Linux distro like Gentoo. Configure, build,
and install kernels from source. Play with the kernel;
even a simple thing like adding your name in a printk()
can be exciting.
4) Iterate. Keep current on the basics. Do you really know
your programming language? If you don't know how something
works, read up on it and read the sources. It's all just
ones and zeros.
5) Read "Hacker's Delight". Slowly. Enjoy it.
6) When low-level stuff gets to not be fun, play with high
level things. Write some Emacs Lisp. Learn Prolog.
Play with Squeak. Think about how they're implemented.
I have been doing this for a long time and I cannot emphasize
strongly enough the importance of refreshing your basic skills.
And play. Computers are fun. I have written compilers and
kernels from scratch, worked on instruction set architectures,
and a bunch of other stuff, and haven't yet exhausted the fun
that computers can be.
But they're not fun for everybody. If all this sounds dull to
you, it probably will be, and maybe you should pursue some other
hobby while pounding out C++ to pay the bills.
A website as an ongoing programming project... (Score:2)
Read before you write. (Score:2)
A good point to start would be collecting and reading all kinds of datasheets, especially if you're doing something that hardware oriented. You'll need to know how the CPU and peripherals you want to emulate work on a hardware level.
That goes for many software projects. Once you've read and digested all the information you need, only then you can even think about writing any code. Ideally, you should start with diagrams and pseudocode s
Your work is your education (Score:2)
Yes, there's lots of "cool" technology that benefits someone somewhere, but how much of it will be useful? Impossible to know, since fads happen in programming just like any other industry: 4GL languages (application/code generators) (see Texas instruments ATI? ATL?), PowerBuilder, etc.
Your work will be your education. Pay attention to the failures you see and ask lots of questions. Of course, if you're an engineer in mindset, you're doing this already.
CODE READABILITY SHOULD BE YOUR PRIMARY OBJECTIVE.
Just my 2 cents (Score:2)
theory vs experience (Score:2)
Jack of All Trades, or Master of One (Score:2, Interesting)
College doesn't teach you a trade (Score:5, Insightful)
College teaches you how to learn. Once you realize that, your education truly begins.
Whatever works best for you (Score:2, Insightful)
Could be a problem... (Score:2)
From the sounds of it, programming might not be for you. I don't mean to insult your intelligence, but there's more to programming than getting a four year CS degree. As you've found out, there's a lot that school doesn't teach you. In my opinion, the one skill you need to master is learning how to take an abstract concept (e.g., writing a console emulator) and utilizing your concrete understanding of CS concepts, algorithms, data structures, and th
I know a site... (Score:5, Funny)
Hmmmmm (Score:4, Insightful)
There are many details in a real emulator, but then, there are many details in GCC, too. The fundamental structure is still there.
If you missed compilers in your "theory heavy" education, that could be a problem. (I think compilers ought to still be a required course; the requisite skills form the basis of far, far more programs than just your C compiler. Almost every text to text converter is better written as a compiler than a series of regexes or some other such hack, and with proper tools and the understanding to use them it's usually easier, too.)
While you may not quite know enough to correlate them, many other programs use fundamental constructs from computer science too.
What you probably lack is experience, and there's only one way to get that. Fortunately, there's a large body of open source to study. As others have said, grab and interesting program and read it. As I haven't seen others say, after you've poked around for a bit, take the program and make a change to it. Emulators are probably not the best target here because at best you'll probably just degrade the performance, but who knows? Maybe SNES will let you plug in to their resolution upsampling framework easily and you can add your own interpolator or something. You'll find the first change is harder than you think, but this too is a valuable skill you'll use over and over again in real life; you will frequently be called on to make a change to a codebase you don't really understand. (One could argue that that is actually the general case....)
The REAL value of university (Score:2, Insightful)
join a club... (Score:2)
My advice: (Score:2)
Re: (Score:2)
This is a thread about programming. Are you sure you didn't mean to say 0xDEADBEEF?
Divide and Conquer... (Score:2)
Divide and Conquer
Most humans can't deal with a gigantic trainload of work - they get caught up in details and start dropping important bits and pieces as they go along. Instead, partition the task in nice bite-sized chunks and deal with them one at a time - and while you worry about that one chunk, presume that anything farer away then, sa
Excuse me? (Score:2)
I would be writing a stern letter to your faculty if I were you, because you just wasted 4 years of your life.
jump into it (Score:2)
How do you eat a cow? In bite size pieces. Instead of asking "How do I make an emulator?" ask yourself "What parts make up an emulator?" Keep breaking down the parts into smaller and smaller parts until you have a part that you are able to cr
I got my BSCS from 19 years ago... (Score:2)
Much of what I've learned over the years has come in a wo
CS vs Programming (Score:5, Insightful)
1. Don't confuse "Computer Science" with commercial programming. They are NOT the same thing.
2. You will soon realize that coding is a far smaller portion of your job then you expect. The coding portion decreases as you move up the food chain.
3. Do not ignore the business/finance side of your job. The business side keeps you employed.
4. As you learn more, you will realize how little you actually know.
5. Your current position is nothing more than a software assembly line job. All of those "cool" technologies are being developed by more experienced engineers.
6. "Engineering" software and "programming" are more different than you realize.
7. Coding is the easy part. You can teach a cat to bang out code. It takes an artist to design good software.
8. You have one of the best jobs in the world. Your technology base allows *you* the ability to build wondrous applications. Use it!
9. Have fun coding. Make it a personal challenge. Reallize a job is just for paying the bills. Your much more free than you realize.
Good luck.
Re:CS vs Programming (Score:5, Insightful)
Especially these days. When I received my degree, all IT-related degrees were CS degrees at a fair number of schools, and one simply chose a specialized track (systems, scientific, business) after finishing the CS core, but that's not the approach used at many schools today.
I liked the mix of practical and theoretical classes I took in the program I went through, though, since I think I've derived a lot of benefit from both types of classes over the years.
Yes, unless you're a dedicated code monkey (something I've never personally encountered), you will be expected to do design work, create specifications, do support, talk to customers, help to coordinate tasks on complex projects, etc.
Probably sound advice. In a large IT shop, you won't necessarily USE that type of knowledge in an overt manner, but it never hurts to be able to understand the business process and how it relates to your current position, and in future positions it could be tremendously helpful.
There's always someone else out there who's been doing it longer or better than you have. Or both. :-)
Pay attention to them -- such people are valuable teachers and resources, and I've learned a lot from people like that myself. Some programming tricks might be as old as YOU are. :-)
In all the shops I've worked in over the years, we NEVER had folks who did software in an assembly-line manner. Even folks like me right out of school were doing (mentored) design work for the live system. Other shops may be different, obviously, but even the folks I've seen who were writing software from a func spec that someone else created had a certain amount of latitude in terms of its actual implementation (even if screens and inputs/outputs were all predefined, the internal structure was often left up to the coder).
Don't be afraid of trying to create things on your own. I've seen folks right out of school make a huge difference by writing a little utility or by applying something they learned from another platform, and sometimes even something small can make a large difference. Experienced people are often very smart, but their tred-and-true experience (while often relevant) can also blind them to new approaches at times. I'm guilty of that as much as anyone at times. :-(
Both should involve a formal process (although not all processes which people have in place are constructive or even useful). However, real "engineering" seems to rarely apply to software development. I still haven't decided if that's a good thing or a bad thing overall.
Absolutely. The top priority should be readable code that is easy for someone unfamiliar with the gory details to maintain. That means relevant comments in the source and (hopefully) a good set of programmer support documents written in parallel with the software. I've had the privilege to work in two shops where that was done quite well, but that's the exception, not the rule.
My appro
It's a craft after all (Score:3, Interesting)
The reason for this gradual approach is that there are multiple elements of craft: materials, patterns, tools and workplace practices. It takes at least ten years in any reasonably sophisticated craft for all these elements to fall into place.
You could, right out of your vo-tech class, attempt a piece of fine furniture all on your own. And with enough determination, you would succeed. But you would not succeed fast enough to make a living at it. You'd waste a lot of material with trial and error. You'd waste a lot of time with the wrong tools, or unknowingly fritter it away because of a poorly organized workspace. All of your attention would be consumed by small problems of a single project, where a master craftsman may have several projects in various stages of completion.
Speed, organization and economy are what set the master craftsman apart from the journeyman. You don't need mastery to do something original; but having it makes originality much more practical.
Software is a somewhat different animal than carpentry. You may even have an idea that nobody has ever had before, one that is simple, yet original, that with journeyman skills you can bring to fruition. But you still have a decade or more of hard work ahead to achive your full potential.
So -- separate out the meta problem from the problems at hand. If you have an idea for creating a console emulator -- that's a problem at hand, that even as a beginner you can make some progress upon. If, however, the problem is to become the kind of programmer that can create a console emulator, that's not a problem to be addressed by sitting down and writing one. It's one to be addressed by contributing to an existing project, under the guidance of somebody more experienced.
here's a nickel's worth of free advice (Score:2)
Unless your education was very different from the majority of CS programs out there, your education was not designed to help you develop software. To make an analogy, programmers are like writers; they rely on their ability to express their ideas to earn a living. Computer Scientists are like academic scholars; they rely on a broad knowledge of concepts to evaluate the effectiveness of
Starting an application is hard (Score:3, Insightful)
It's exacerbated by the fact that you actually need to ship your product. You don't have the luxury, usually, of sitting around arguing the finer points of various architecures and algorithms. What toolset should you use? What framework? Libraries? Product dependencies? OS?
All of those require tradeoffs, and incur costs that may not be known for weeks, months, or years.
In fact, there are no right answers. There are things that make life easier or harder down the road. Unfortunately, those of us that have written multiple apps from scratch have a hard time explaining what the design choices were or even how to do it. Some things work, some things don't, and depending on your application, budget, and timeline you choose differently. If you're good, you keep up with the various technologies (on at least a passing basis) so you can learn new stuff/ideas/concepts that may help.
What are some of the factors to consider? Some simple ones are:
deployment - how do you deploy it?
Maintenance - how do you maintain the applcation?
How do you updates?
Are there enough people who know what you're using to hire? If not, is it easy to learn?
What features are requested, but not in this release? You can architect today for functionality tomorrow.
Toolset: are there too many moving parts? How many moving parts is too many?
Certain technologies, like J2EE,
If you use new stuff, is it stable enough to actually use in real life?
Then when you start writing your app, what do you start with? Again, it depends. Some people design and write from the inside out (internals to GUI), and some write from the outside in (GUI to internals). A user app should do the latter, since the capabilities of the UI have to be supported by the back-end. Blah blah blah.
In short, you have to learn by doing, making mistakes, and doing it again. Learn from other programs, etc, by asking: why do they do things that way? You can see design decisions and how they impact the application everywhere.
Yeah, it's rambling, but it's late for me.
learn software engineering and design skills (Score:2)
When I was taking a senior-level networks class, we had an assignment to emulate a physical layer, data link layer and the network layer. We had senior CS students who had trouble designing a prorgam to do that! The TAs spent more time explaining how to structure
Pick something. Do it. (Score:2)
- Find something interesting (hereafter "IT") to do. Just pick something that fascinates YOU, one thing, no matter how odd or far-fetched IT seems.
- Do IT. Completely. I mean, if it's gonna take 10 years to pull IT off, take a deep breath and start your 10 years. If IT requires a whole new technology, well then develop a whole new technology.
- Eradicate "can't" from your vocabulary. Lots of stuff exists precisely because someone didn't know it couldn't be d
Greeting card (Score:2)
Seriously, I am a CS major, graduated 2002. I don't even do dev work, but I work with a bunch of developers and for many of them it worked like this: Manager: I need you to build App X in .NET
Developer: But I am a SQL admin.
Manager: We need it by July.
Developer: Sigh....ok.
6 months later...
Developer: Here is your app, had to learn .NET, work a couple hundred hours OT but it works as expected.
Manager
Yeah, we got yer advice right here! (Score:5, Informative)
As quickly as you can, get in a position of supporting your own code when it goes out into the world onto customer machines. This will teach you a profoundly important set of convictions that CS professors -- having never done the aforementioned -- are clueless about:
- bad: "Error: operation failed."
- bad: "Error 0x8009000b during update!"
- good: "Error: the mailslot update failed, probably because the mailbox is locked by another process; please contact technical support. (COM synchronize call returned 0x8009000b)"
Every low-quality error message equals ten calls to tech-support and probably two days of some support programmer's time and remaining hair pigmentation.Most programmers never acquire these convictions, because they never retain ownership of their code long enough to see the patterns that occur during field support. Hopefully you will be different... because honestly, in the long run it's easier to write supportable code than it is to have to check under your car for bombs every morning.
Do you love it, like it, or is it a job? (Score:3, Insightful)
If you like coding, then your options are more open. Big companies often give you a shot at expensive training and new technologies.
Take frequent breaks to save your hands. Get books on carpal tunnel and read them *NOW* before you develop problems.
If you only "like" it, then learn about project management and when you get tired of programming you can move up instead of out.
You got a crappy education (Score:4, Insightful)
A "console emulator" can be a straight forward emulator in which case, you should know enough from just your basic architecture courses. Did you discuss instruction decoding and ISAs?
Modern console emulators are probably Just In Time compilers. You should have had a compilers class and the prof should have at least mentioned binary translation. Even if they didn't, you should have spent a little time on JITs in an architecture class.
A college education is not necessarily about knowing how to solve problems, but how to decompose a problem into a series of problems that you can then figure out how to solve. For a console emulator, that may mean that first you know you have to read about the architecture your emulation (what's the ISA, what are the components, etc.). Then you realize you have to parse the actual ROMs (here's where your automata/compiler background kicks in). Then either emulate each instruction (tedious) or do dynamic translation.
If you wouldn't even know where to start, you didn't get the right education. I'd recommend trying to find a masters program or pick up some text books.
It's time to choose your fields... (Score:5, Insightful)
Next thing you need to do after deciding that is start focusing on it. If you want to be a game programmer, start programming your own game. A company that hires you won't just look at your education, they'll look what else you've done, and a big bonus is "self starting". It doesn't matter if you don't know how to make a finished game or a finished project you can learn how to do the final stuff, and most of the time they don't care. What will matter is that you've designed something and worked towards it. In addition the code can show the employers "I know how to code".
If you want to go into IT start looking for work now. Anything you do outside of the field isn't going to help you too much in the long run, but be sure to learn as much as you can about networks and hardware for it (routers and so on, not just lan adapters). Try to learn Linux as well for IT, that might not help you but it's good to know it so you can work with networking apps with out dealing with the BS that Microsoft gives developers (dear god, what ever you do don't expect CSocket to be all you need for networking experience).
If you want to make money start networking. And I mean P2P.. Or rather that's person to person. Talk to people who can help you get jobs in major companies. You want a job in finance to make the most money the fastest.
Overall it's important to take a direction and start working towards it. The biggest mistake you can make is think your goal is to radical to start working towards it (something I had to learn.. Now I work at a video game company. What I always wanted to do.)
The second mistake you can make is undervaluing your skills. Don't take a job for 24K, even if they promise a pay raise in 3 monthes (finance, personal experience.) Demand 40K a year at the minimum. Short and simple that's the bare minimum you deserve and that's even low. If you're in a good job, you should be making more.
Also always be willing to move, that'll give you many more options, and don't be afraid to seek out big name companies to apply to. Nothing is wrong with apply somewhere expecting relocation expense. They should be provided.
Don't worry if you get into something and don't like it. You're still learning and no one expects you to be a good coder yet, school is to teach you the basics, they'll train you to be the programmer they want (or they arn't worth working for).
Plastics. (Score:4, Insightful)
I assume graduate school is not a consideration right now since you're working.
Do you like tinkering? That is the essential skill/attitude. Everyone that I know who is happy and successful in software is a tinkerer. A hacker, in the old and honourable sense of the word. When we were kids (before computers, if you can believe that!) we amused ourselves with homebrew "chemistry experiments" and electronics and taking apart household appliances, especially clocks. Now we do the same thing but in software. (Most of us continue to hack in other fields as well, building airplanes and clocks and furniture.)
The other vital skill is learning. Things keep changing. If you enjoy learning about cool new stuff you'll have no trouble staying employed. If you've written some non-trivial chunks of C/C++ and you have a CS degree from a decent school like Berkeley you'll do fine. Be good at your assigned tasks so you can get it done early and done well. (Try not to get involved in office politics if there is any.) This frees up time to think about cool stuff, whether that's free software or work-related extra credit.
And don't forget there's life out there beyond software and work.
Wrong priorities (Score:3, Interesting)
It sounds to me like you are looking for a solution without identifying the problem. Because there are so many programmers like this, ones who feel compelled to create something for the sake of creating something, for their own ego or amusement, in lieu of any real world application, the industry is filled with crappy technology that doesn't serve any significant purpose. So let me be the first to discourage you path before you even start and add another dingleberry to the crop of mediocre technology that's out there that will fail.
No disrespect, but you're going about it wrong. If you want to program a console emulator, hook up with the teams online involved in that. Oh you want to create your own? This kind of thinking won't get you anywhere. The real cool technology is what you learn from other people through experience both in coding and (most importantly) through an *understanding of the application and the market you're addressing*. So what you need to do before anything else is not whine about how you haven't created the next Halo, and figure out what field, in addition to programming, in which you're an authority, and what void in that field can you develop something that addresses a real need or solves a problem, and then and only then, should you be asking people how to develop such technology.
The best software in the market will have always been created by people identifying a niche, a need, a problem, and then designing software to address it. Not the other way around.
Practice and modular design (Score:5, Insightful)
The real skill in programming is knowing how to break down a complex project into suitable pieces - top down modular design. The skill is not just being able to do this at all for arbitrarily complex projects, but being able to do it well - to select a breakdown that will be easy to develop and maintain, easy to debug, easy to modify and extend.
I really don't think there's any substitute for experience in learning this, since that's the only way it's really going to sink in and become second nature. The best thing you can do therefore is to practice, and push yourself with new challenges all the time. At work push to get on the most demanding projects, and out of work do hobbyist projects that push yourself too. When you switch jobs, don't shy away from switching industries and into new areas. You'll become a stronger programmer by being a generalist rather than a specialist, as long as there's also plenty of depth (don't skip around *too* fast).
What you're really learning via experience is a set of design patterns and approaches, so that when you look at new problems they will intuitively fall apart into "obvious" breakdowns. Nowadays it's fashionable to read books on design patterns, and that can maybe help, but I'd tend so suggest a more back to basics approach of just paying attention to the interfaces between your modules... A good modular breakdown is one that results in modules that may have a fair degree of internal complexity (but not too much - break it down further), but have simple/thin external interfaces. An overly complex module interface is often a sign of choosing a sub-optimal modular breakdown (you've drawn the dividing lines in the wrong place). Good modular design will also hide as much internal design as possible to keep things simple and flexible - if you've kept the interface simple and abstract, then you have more flexibility to change the implemenation.
One word: Deadlines (Score:3, Informative)
26 years ago, I did part-time work on a PDP-11-based system as I entered college. I found that in my classes, I'd write a 1000-line program that produced ten lines of code... and at work, I'd have a 1000-line program that produces 10,000 pages of output a month, on a much more constrained system. And my 1000 lines of code were equivalent to 3000-line versions by other students (and yes, I had documentation in my code)
Constraints make you work better. Read 37Signals' blog [37signals.com] to find out how to work with less.
Big projects happen in little steps. Take a project management class -- look at the Project Management Institute [pmi.org] to understand "work units" and "earned value" -- understand how to get work done and measure it.
Re: (Score:2)
Re: (Score:3, Insightful)
I don't mean to bash you, man. But I realized this my sophomore year. All of the theoretical geniuses basically have to work for a company. They are energized by science, not business or other practical things. That's when I switched my minor to Business. I'd sit in the computer lab and think about which of my theoretical genius buddies I'd like to hire someday.
So
Re:What school did you go to? (Score:5, Informative)
What large software project doesn't already start with a huge number of the pieces being already written? Nearly all modern software is taking building blocks, tools, libraries that exist or are bought and then using them to get whatever task done.
The vast majority of work is done this way so a program concentrating on that type of work would not be as relevant. Very little work is done actually starting from scratch on anything.
Like others have pointed out the best way to learn these other areas is with OSS projects and you don't need to pay a college to teach you how to get involved with them. You can do them on your own time.
Get a job in an advanced development team (Score:5, Interesting)
Every website has different naming conventions for their code. Some have you use the IDE's designer a lot, some not at all. The resulting software is such a patchwork of Internet examples it makes me puke. And worst of all, the developer think's he's the stuff because he figured it all out without any professional training.
The best thing I ever did was to work for a couple large companies that did cutting edge software development. They had a team of real engineers with many many years of experience. They understood the value of Best Practices. They had documented development standards. They forced us developers to follow the conventions. The software I write now is very much what I learned then. I own my own software dev company now and I absolutely love writing software. People who work with my code are thrilled by the consistant patterns and well-thought-out design.
The best software is designed well by experienced engineer-minded professionals. Don't fall into the trap of thinking that you can learn much of value from Google. Google is only a basic starting point. People who cut their teeth on Google end up being self-taught hackers (as in, ugly, hacked up code). And it shows. Want to be a great developer? Work under highly-skilled and experienced professionals.
Re: (Score:3, Interesting)
What I mean is this. The people and environment you learned in/from is quite possibly ideal. However, just because you've got a room full of smart people that think things through doesn't necessarily mean that they will always come out with the best solutions. They will come out with great solutions, but will likely all have common patterns (a good thing to some extent
Re: (Score:3, Insightful)
Except it teaches really terrible programming practice in general... Only partly because it doesn't enforce good practice the way java tries to (gag!), but more because even with all of its horrendously overblown (I'm talking about C++ now) set of features, it still doesn't provide the kind of features that you really need to organize everything in a nice intuitive easy to understand (and therefore maintain) manner. When I spend more of my time fightin
Re: (Score:3, Interesting)
Re: (Score:3, Funny)
So, you are the guy I always have to clean up behind when your applications break...