
You Owe it to Yourself to be Old-School - abyx
http://www.codelord.net/2011/02/22/you-owe-it-to-yourself-to-be-old-school/
======
fleitz
I think a more relevant portion of what Joel what talking about is the 'full
stack'/'ductape' programmer. The number of times I've seen people optimizing
their for loops instead of their DB queries or their caching mechanisms in a
web app is simply astounding. Few people realize that there is far more 'slow'
code in the parts they didn't write than the parts they did write.

Think about it, in the 'full stack' of browser -> client -> interweb -> web
server -> app server -> db server the little bit of code that you wrote is
minuscule compared to what you didn't write. Tune up your TCP stack, tune your
webserver, add cache headers, add indexes, etc. Most apps can drastically
increase their performance with out even changing a single line of code. And
when you're tuning up your code, look for single lines of code to change.

Definite protip in there on debugging with wireshark.

We had a client once that we could only login to their IMAP server but not
download mail. A little bit of digging with wireshark and we figured out that
he had some old POS router that couldn't handle window scaling. Solution? Turn
off window scaling on one of the servers.

~~~
silentbicycle
Again, the assumption that everybody is a web programmer. No wonder people
approach the command line with obsequious awe!

~~~
perlgeek
For the non-web (and sometimes even for the web) programmer, strace can be a
real life saver.

An application complains about not being able to find a file, but doesn't
report where it looked for it? strace can tell.

Do you want to know why a system call failed, and the app is too crappy to
report the error? strace to the rescue!

Of course, if you're lucky you might even have access to dtrace...

~~~
fleitz
Yes most definitely, strace / truss have been absolute life savers. And if you
are looking for something similar on Windows Process Monitor is excellent. You
can also do a lot of DTrace style stuff with WMI and VBScript.

~~~
GFischer
The Windows equivalents would be the Sysinternal tools, I guess (Filemon,
Procmon, etc..).

<http://technet.microsoft.com/en-us/sysinternals>

------
reedF211
The House example is horrible. In the show rarely does house diagnose an
illness thorough intellectual debugging. In most episodes House sits around
and insults his team while they run tests and about 5 minutes from the end he
out of nowhere has an epiphany (while talking to Wilson most of the time)
which often has little to do with what tests the team ran and he solves the
case.

~~~
mfukar
OK, maybe in Season 7, but in Season 1?

~~~
silentbicycle
Yes, absolutely.

If you like House (for the medical mystery aspect rather than the snark), you
may also like Berton Roueche's writing. _The Medical Detectives_ is a pretty
good collection.

------
Starmonkey
A good article, but intimidating, in a way. And I see this quite a bit in
terms of budding programmer advice. It boils down to "you need to read this,
and then read that, and then read this," and then the comments section will
have even more suggestions for reading.

As I get older, and have kids, I find my ability to sit down and read all of
this, and somehow retain it, decreasing. I've recently decided to "get back
into" coding (won't go into the history as it isn't tangential to the
discussion). I've been having some fun with very, very tiny beginner level
programs in Ruby. When I build a list of jobs I would want with Ruby
involvement, I find I also need to brush up on my Javascript and learn JQuery.
I need to get a full understanding of Git/Github. I should also learn Rails
and Sinatra, VIM, and get reacquainted with CSS.

On top of that, it really does seem that C is a requirement to really
understand what is happening in Ruby. It seems a lot of things that _why_
wrote for Ruby, he wrote in C.

Then there is all the additional readings, such as in this article, and
comments section. All of which seem incredibly legit, but leave me feeling
like I will never actually find the time to write code due to all the reading
I don't have time to do.

Is there an order of importance with all of this?

~~~
stuhacking
This article emphasises the important of building your baseline knowledge on
the aspects that haven't changed since the dark ages (and probably aren't
likely to for a while). As opposed to learning the flavor of the month web
framework that might be yesterday's news a week from now.

Learning about C and how to use a decent debugger/tracing tool will help you
track down exactly where those unhelpful errors are being generated. Learning
how to listen in on network traffic will help you find out why the foo you
sent is arriving as a bar (or not arriving at all). Learning to use the shell
opens up a lot of quick reusable operations and automation possibilities.

The books he listed are old, but certainly valuable. I don't think they're
going to suddenly go out of date.

On the other hand, how much more reading will you do when you have to learn a
new high level language every month to keep up with the latest trend?

However, I wouldn't let this get in the way of doing what you want to do,
which is writing code, I guess. Learn bits and pieces as you need them and I
think you will see the benefit. Don't let them weigh you down.

------
stcredzero
The other side of the coin: I've seen frequent indications (even on HN) that
there a hordes of programmers out there that know about almost nothing outside
of their web app server, HTTP, and their database of choice. This isn't to say
such specialists aren't valuable. Specialists are valuable, but if I see a
medical specialist, I want them to have a good grounding in general medical
knowledge. Likewise, I would prefer all of my computer colleagues to have
basic general knowledge as well. Sometimes such knowledge can avert a
disaster.

~~~
moggie
What do you consider general knowledge?

~~~
stcredzero
A better way to say it would be background knowledge.

Some idea of:

    
    
        - How computer hardware is put together (from the NAND gate up)
        - How computer memory is organized/optimized
          (and how the abstractions involved can break down)
        - How compilers/interpreters/computer languages work
        - How a handful of the most commonly used algorithms work
          (and the implications of their time/space complexity)
        - How networks are organized and implemented
        - What operating systems do, and how that relates to hardware
        - Basic security, how exploits work
    

The thing I see, is a lot of people learn something about the above, but only
in the very narrow confines of their particular web development stack. I
suspect they're just reciting a set of best practices by rote without
understanding principles. They're completely unable to _generalize_ the
knowledge, to the point where they say patently incorrect things in comments,
even sometimes here on HN. If people can't generalize in a basic way about
computer systems, how do they properly think about things like security?

It's like my sister, who is a choreographer and has an exquisite understanding
of physics and geometry -- as it applies to dancers. Yet, as far as I can
tell, she's completely unable to generalize this to driving and furniture,
though she would benefit greatly if she could overcome this limitation. For
one thing, when she's driving the family around in a rented car in Italy, she
wouldn't end up straddling the center line _every time_ we go around a blind
curve. For another thing, her DIY kitchen table made from salvaged parts
wouldn't have 3 inches of shear wobble, and her custom desk made from IKEA
parts wouldn't have a huge sag in its center. I know she understands the
physical ideas behind static mechanics and diagonal bracing applied to dance.
I know she has a knack for spatial geometry, because she can have a half dozen
dancers move around between each other, keep them from colliding, get everyone
where they need to go for the next move, and make the whole thing look
beautiful.

I'm also reminded of that Richard Feynman story about teaching physics in
Brazil.

------
iuguy
Yorkshireman #1: "Bah, C programmers. They don't know how good they have it!"

Yorkshireman #2: "When I were t'lad, we'd have to use assembler by hand!"

Yorkshireman #1: "Assembler? Luxury! We never had an assembler. We had to poke
the data in by hand!"

Yorkshireman #3: "Poke! Oh what I wouldn't have given for poke! We used to
live int' shoebox int' middle of road, and we'd bootstrap the OS using toggle
switches on't front of case."

Yorkshireman #4: "Oooh toggles! What I wouldn't have given for toggles. We
used to live int' hole int' ground, and all we had to go on were scraps of
hard stale bread, on which we'd punch holes and use as hollerith cards!"

Yorkshireman #2: "Holes? Holes? Bliss, oh what I wouldn't have done for
holes!"

*shamelessly plagiarised from <http://www.youtube.com/watch?v=-eDaSvRO9xA>

~~~
stcredzero
I've actually programmed an 8-bit processor in binary code by repeatedly
flipping 8 metal toggles and pressing a "commit" button.

A roommate of mine in school actually TA'd a programming class where he saw
some frustrated students take their IBM _punch card_ stack out of the reader,
shuffle it, then put it back in.

~~~
iuguy
8 bits? You were lucky to have 8-bits. We never had 8-bits. We had to make do
with t' abacus, and we never had any beads!

------
sliverstorm
_How can you spot and truly understand memory leaks without having to manage
memory allocation by yourself?_

My peers (students) and I have discussed this several times. It's a good
example, and we use it to argue _for_ continuing to teach C to new CS students
at our school.

(It often seems the CS department is trying to move in the Java + Python, and
nothing else, direction)

------
angrycoder
Another worthy pursuit: buy all of Brian Kernighan's books, not just The C
Programming Language. It is well worth the pain of becoming slightly familiar
with Fortran and Pascal to read these little gems.

Being familiar with how things work is undoubtedly useful, but I argue if you
are an application developer, learning software construction is equally if not
more important.

See also: Code Complete, Programming Pearls, and C interfaces and
implementations.

~~~
spitfire
I never knew Kernighan wrote a pascal book. (or a version of a book in
pascal). Neat. Also ampl seems quire useful, I've written my own versions of
some of that stuff in mathematica. It'd be great to have it already done for
me.

~~~
angrycoder
Software Tools in Pascal. There was a previous version with examples written
in something called Ratfor, which from what I've read is a hybrid of fortran
and C. [http://www.amazon.com/Software-Tools-Pascal-Brian-
Kernighan/...](http://www.amazon.com/Software-Tools-Pascal-Brian-
Kernighan/dp/0201103427/ref=sr_1_6?ie=UTF8&qid=1298360333&sr=8-6)

~~~
cema
Ratfor, if my memory serves me well, was a set of macros which sort of turned
Fortran into a simplified C. Better read the Pascal book, the language
(Pascal) would be easier to follow.

------
jfm3
I agree that it is good to be a "generalist" or a "full stack programmer". I
try to be one myself.

Be careful when you hear these classifications coming from recruiters.
Whenever I have heard "generalist" what was meant was "someone who can
magically already do everything within our narrow domain of concerns."

------
bryanlarsen
Not that long ago "old-school" meant assembly language. Knowing assembly
language makes one a much better C programmer.

And we had to walk uphill to school both ways.

------
Murkin
This is the #2 reason I am sorry I didn't grow up during the 60's.

A competent programmer could known the whole stack, down to the micro-
controller. (Mainly because there wasn't much stack there..)

* Free love&drugs is #1

~~~
bbsabelli
Emulation programming is a good way to learn this stuff today. Just pick a
platform, emulate it, and you're guaranteed to know the whole stack.

~~~
Nick_C
I'm having a lot of fun with this MSP430 microprocessor that cost $4.30,
delivered to Australia(!). Great way to teach/refresh some skills in simple
assembly or C.

Here's the original HN article where it was mentioned:
<http://news.ycombinator.com/item?id=2202737>

------
silentbicycle
I fully agree, but all it really says is, "learn how things _actually work_ ,
people!" This is still mostly fluff and identity politics, hoping people who
_know_ they're old-school will upvote it. Flagged.

~~~
abyx
No fluff intended. And no upvotes phishing - I don't write for upvotes. Been
bothered by this, and hope to help someone understand this is important.

Good day!

~~~
silentbicycle
I think posts like this mostly just encourage people to use the command line
to feel "old-school", not because it _works_.

Kernighan and Pike's _The Practice of Programming_ covers similar material
very well.

And yes, I was a bit overly critical. I'm annoyed by that style of article,
not that specific one, sorry.

------
davidk0101
I think he's just saying develop better debugging skills, the stuff about the
good old days is irrelevant.

~~~
stcredzero
My read is that the debugging skill is just one example of the benefits of
background knowledge.

------
zby
Ironic - this newfangled wireshark seems more usable then the old-school
tcpdump that I used to use.

~~~
pnathan
I might be misremembering, but I think wireshark is/was a frontend for
tcpdump.

~~~
rl1987
No it's not. TCPdump and Wireshark both use libpcap, however.

------
16s
Great article. This is why I use and love C++. It will be used for the next 50
years or longer. Learning it (or any other foundational, open source
programming language) is a must.

------
JonnieCache
Baby, I played truant from hacking school.

------
derleth
You also owe it to yourself to learn the newer techniques.

The article is true and useful and contains many good pointers, but my god is
it annoying when you either misunderstand the concept or take it too far. This
kind of rot sets in when you refuse to use a tool or technique for no good
reason.

Maybe this is a function of age or, more precisely, maturity level: Young
people use bad tools to be 'hardcore', old people use bad tools because they
stop learning new ones. Either way, the image I immediately dredge up when
someone says 'old-school' in this context is someone writing a program using a
machine code debugger instead of getting a decent text editor and development
tools. Unless you can actually tell the difference in the resulting output,
and I guarantee you almost certainly can't when it's assembler vs debugger,
use the best (most likely, newest) tools you can get.

(The above doesn't apply to people doing things a certain way for fun. Heck, I
run obsolete OSes on emulated hardware for fun. I just don't confuse that with
reality.)

------
alphamancer
You got me at the House reference. Good one.

