3 ms·
Actually I largely agree with what you say. Here are some rules that I think they should have taught in college, but never did: 1) A good percentage of your t
by kenjackson 16y ago
Actually I largely agree with what you say. Here are some rules that I think they should have taught in college, but never did:
1) A good percentage of your time will be spent understanding how a library or framework works. When I was in school the only real library I made much use of was the CRT. This may have changed recently though, as its been a long time since I was in college.
2) You will actually ship a product with known bugs. Triage shocked me when I first joined industry. I was like, "Wait... you're not going to fix that bug? I can fix it, just give me a day!!"
3) Being a great ACM contest programmer doesn't translate to being a great SW engineer. I recall one of my first code reviews where the architect was asking why I didn't use a set of patterns to solve a given problem. I was generally like "The who pattern?"... "Inversion of where?" On teams people like to see patterns for problems they're familiar with. Not my new homebrewed cool method that I just came up with as I typed.
4) People seem to respect how fast you can fix bugs more than the absence of bugs. This is a weird one, but it seems to be something I've seen across multiple places I've worked. People are impressed by people who can fix a lot of bugs. But those people who write fewer bugs to begin with seem to get less praise.
5) Being a debugger whiz is often the difference between fixing a bug in an hour vs a few days. I used GDB in school, and even then, not often. Largely printfs. I can't imagine ever going back to that. I guess this is really "a craftsman knows her tools".
- ciupicri 16y agoRegarding number 5, Brian W. Kernighan & Rob Pike mention this in "The Practice of Programming": As a personal choice, we tend not to use debuggers beyond getting a stack trace or the value of a variable or two. One reason is that it is easy to get lost in details of complicated data structures and control flow; we find stepping through a program less productive than thinking harder and adding output statements and self-checking code a1 critical places. Clicking over statements takes longer than scanning the output of judiciously-placed displays. It takes less time to decide where to put print statements than to single-step to the critical section of code, even assuming we know where that is. More important, debugging statements stay with the program; debugger sessions are transient. P.S. The book was published in 1999.
- kenjackson 16y agoI think its a personal choice, but I've yet to meet anyone more productive using printfs (although I'm sure some must exist). And I've met people who say they are, and watching them debug is a chore. And I should note that using a debugger doesn't mean you don't think hard. I think we've all had this experience, you hit a breakpoint, look at the values and suddenly see that a given value is not what you expected. Then you sit there for five minutes thinking about how this could be. A combination of thinking and debugger tools helps. And note, you don't have to click over statements. For example, if I use Intellitrace I can break my program after it hits an issue and then look at the callstack for a whole bunch of points in the past. One big problem with printfs is that I need to know add code ahead of tmie in order to look at it. And if I don't pick the right set of printfs, I have to place them and rebuild. And then after I fix the bug, I have to remove the printfs (or debug output statements more likely). Another thing that I do often is "set next instruction". I'll be stepping through code and see that a method returned null unexpectedly. Hmm... how'd that happen? Well rather than have to rerun the program, I just have the IP go back to the method and step into it. And lastly debugger sessions may not be transient, but the breakpoints/tracepoints can be saved and packaged in a way that's even nicer than prints. Here's something from MSDN: "Export your breakpoints. Tag and filter them in the breakpoints window. Export and give to a co-worker to let them import them and figure out a bug in some code you know". I mean there are probably people who do fine w/o debuggers. But you better be a darn good debugger otherwise you'd lose almost all credibility w/ me.
- ciupicri 16y agoWell, I must admit that IntelliTrace looks nice, but let's not forget that it's very new and that the book was published in 1999. Also, what do you do if can't use a debugger for various reasons? I've debugged code using both approaches and while the debugger was nice, a good printf went a long way. On the other hand, I'm not good at debugging (other people's code), so I might not be credible :-)
- kenjackson 16y ago@ciupicri, I had to go grab my copy of the Practice of Programming to see the full context of the statement. The also say, "In the right environment and in the hands of an experienceduser, a good debugger can make debugging effective and efficient, if not exactly painless". I think I'm more in this mode as I'm generally on MS stack and have used their tools for years. Now what if I don't have access to a debugger? Then its back to printfs and asserts. I can do it, but I'm not happy. And in fairness its a skill that's good to have. I used to work on systems where I didn't have access to reliable debugger (it often crashed), so writing logs was the best thing. But I'll tell you, it's hard to beat debugging with Visual Studio.