That said, The Pragmatic Programmer is my favorite resource for it. https://refactoring.guru/ is also a nice reference point, in an easy problem-solution format.

https://pragprog.com/book/tpp20/the-pragmatic-programmer-20t...

For that, I'd recommend The Pragmatic Programmer, A.Hunt, D.Thomas.

Kent Beck's 4 rules of simple design is great. You can find the rules online.

Some great books are Clean Code, Pragmatic Programmer, Working Effectively with Legacy Code

This book is amazing and still holds up today, for the most part.

...
I think a toy robot would be great

- the pragmatic programmer

- clean code

I'm not sure I believe articles like this, but myself and colleagues have found these books to greatly improve our coding.

Agreed, that's why I listed that book in my linked comment:)

Well, the first book recommended is The Pragmatic Programmer, we can all get behind that one :)

Doing this attaches your reputation to your code. Anybody reading it knows to expect a certain level of quality given it is written by you, and you get the much needed motivation to write good code.

Amazing piece of advice I picked from the Pragmatic Programmer.

Also going to dojos and doing katas.

I did find some value in Code Complete, but it is a little too long for my tastes. The naming and abstract data structure sections were probably my favorite parts of that book.

- Computer Architecture - A Quantitative Approach (Hennessy/Patterson)

- Expert C Programming - Deep C Secrets (van der Linden)

I woud call the Pragmatic Programmer though by far the most influential.

Also got Rapid Development for 5 dollars, but haven't started on that. Haven't really read any software engineering books like these before, but enjoying them so far.

The Pragmatic Programmer - It has been recommended to me by a good developer that is self-taught like me. So far so good. Some things are a bit dated though.

It reads a bit like "the 7 habits for effectice developers", except that it contains about a 150 "habits". I have wished many, many times that I could force colleagues to read this.

http://www.pragprog.com/titles/tpp/the-pragmatic-programmer

http://pragprog.com/the-pragmatic-programmer

I read both The Pragmatic Programmer and Code Complete (2ed) before Thinking Forth. The latter provides a wonderful software engineering foundation (in clearer, more concise language too).

* Head first design patterns

* Agile Web Development with Rails

It's not obvious, but the rails book is a great introduction to test-driven development in general.

Or, more seriously, I think an O'Reilly book on common Lisp would go a long way toward promoting the language. As would one from the Pragmatic Programmers.

The Pragmatic Programmers offer their authors 50% of the net. I was lucky enough to publish one book with them, and despite that book's anemic sales I made out pretty well. Cant recommend them enough to prospective authors.

The Pragmatic Programmer: Hunt and Thomas

The Mythical Man Month: Frederick Brooks

- Code Complete by Steve McConnell

- The Effective Engineer by Edmond Lau

- The Pragmatic Programmer by Andrew Hunt and David Thomas

Then there was The Kite Runner
Also, Zen and the Art of Motorcycle Maintanence
Then Becoming a Technical Leader by Gerald

I wish I had read more.

Pragmatic Programmer is a much better book.

Learning to keep it simple & methods for avoiding code duplication. I tend to find when learning a new language that avoiding duplication teaches me how to use the language properly.

And the book, The Pragmatic Programmer helped me to communicate better.

[1]: https://pragprog.com/book/tpp/the-pragmatic-programmer

[2]: https://pragprog.com/book/ahptl/pragmatic-thinking-and-learn...

I've finished reading the fist draft of the Pragmatic Programmers new book on Clojure and I can't wait until they release another draft. The first draft only contains about half the chapters.

For a Software Engineering book, it's hard to beat The Pragmatic Programmer.

A good working-with-other-people book is Extreme Programming Explained 2nd ed.

    1) "How to Win Friends and Influence People"
    2) "The War of Art" 
    3) "The Pragmatic Programmer"

Software engineering has more to do with people than with software. Have you checked Peopleware? Also, perhaps The Phoenix Project could help as well.

Reminds me of Jesse Storimer http://jstorimer.com/ who originally published 'Working With Unix Processes' independently which subsequently got picked up by The Pragmatic Programmers: http://pragprog.com/book/jsunix/working-with-unix-processes

Currently working on some books myself.

Code Complete, Rapid Development, The Mythical Man-Month, The Pragmatic Programmer, Peopleware and A Discipline for Software Engineering? (The last one is controversial).

Unfortunately it looks like you have to watch the video in order to find out what the practices and details are.

Do what needs to be done to make the intent of a block of code super clear, in plain English. Comments don't count, as illustrated clearly in The Pragmatic Programmer, for instance.

* Making Software, edited by Oram & Wilson. A bunch of papers about evidence-based software engineering.

* Beautiful Code, also edited by Oram & Wilson. A bunch of papers about especially elegant pieces of software.

* Eiffel, by Bertrand Meyer. What Java should have been.

* The Devil's DP Dictionary, by Stan Kelly Bootle. A satirical look at the computer industry circa 1980.

* The Jargon File. (http://www.catb.org/jargon/html/). The language of the Elder Days.

* Facts and Fallacies of Software Engineering by Robert Glass.

* The Pragmatic Programmer by Hunt & Thomas.

2) The Decision Maker by Dennis Bakke. This one pairs well with the more thorough Reinventing Organizations which has been mentioned in another comment.

* Code Complete https://www.amazon.com/Code-Complete-Practical-Handbook-Cons...

* Programming Pearls https://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp...

* Pragmatic Programmer https://www.amazon.com/Pragmatic-Programmer-Journeyman-Maste...

The wife and I bought a new car this Christmas season, so I think that counts. We already have it though. '06 Volvo S60.

  The coupon is valid for the entire contents of an order
  (excluding books we do not publish such as The Pragmatic 
  Programmer and a handful of other titles) but does not
  affect shipping costs.

This and "The Pragmatic Programmer" are my top two books, relating to Software Development and Running a small business.

The Pragmatic Programmer - My all time favorite. Awesome book to learn best practices of various aspects in programming.

The Code Book: The Evolution Of Secrecy From Mary, Queen Of Scots To Quantum Cryptography, if you have a thing for cryptography.

To misquote the "Pragmatic Programmer" book... don't use wizard code you don't understand. The opposite applies in my opinion.

I bought this ebook when it was first released. The level of care Dave has given to it is astounding. I believe he's released at least 10 significant updates to it as the language has evolved.

Maybe he said somewhere on the book's marketing page that he was going to be doing that, but if he did, I missed it. Extremely pleasant surprise.

With that in mind, it makes it easy to write tests and more comprehensible variable names (still thinking and re-thinking how to best do documentation...was checking out github's Ruby guide and Tomdoc yesterday http://tomdoc.org/)

[0] https://pragprog.com/titles/tpp20/the-pragmatic-programmer-2...

Thanks for the suggestions, I'll give it a listen on Audible.

Context: it was published in 1999.

I have used the concepts in this book weekly, if not daily. Note: The tracer bullet framework helps with thinking about any complicated system, not just software.

Database Internals,
Snowden book,
Algorithms book,
BPF Performance tools,
Your Linux Toolbox,
The Go Programming Language,
The Pragmatic Programmer,
Quantum Computing,
A Programmer's Introduction to Mathematics,
An Elegant Puzzle

I had to go up to page 14 of the items list to find all of the items you listed and to find the wire-type soldering iron tip cleaner.

Edit: Took out unneeded snark. It seems I fell prey to Amazon algorithms.

The Pragmatic Bookshelf published it's most important book, in my opinion, in 2017 with the first pytest book available from any publisher.

Topics:

The Pragmatic Programmer, the book
The Manifesto for Agile Software Development
Agile methodologies and lightweight methods
Some issues with "Agile" as it is now.
The GROWS Method
Pragmatic Bookshelf, the publishing company
How Pragmatic Bookshelf is different, and what it's like to be an author with them.
Reading and writing sci-fi novels, including Conglommora, Andy's novels.
Playing music.

- A quick reference for the important points in Pragmatic Programmer :https://blog.codinghorror.com/a-pragmatic-quick-reference/

- Code Complete: http://codecourse.sourceforge.net/materials/Code-Complete-A-...

I have a few of their books, and they're pretty good. Their store is also very straightforward and friendly.

Does anybody have experience writing for them?

I'd definitely be interested to see two different programmers write up their approach to a given problem. Something like this would be an excellent monthly blog post.

People feed the beast and then wonder why it's come back for more.

I'd go for that and some JS on the side but if you got an iPad, I'd definitely try Swift with the Playgrounds app.

Pragmatic Programmer fills in the gaps you need to succeed as a professional programmer.

Code Complete is a field guide to managing software complexity.

But from the writers:

    * Refactoring
    * Patterns of Enterprise Application Architecture
    * Smalltalk Best Practice Patterns
    * Agile Software Development, Principles, Patterns, and    Practices
    * Domain-Driven Design
    * Structure and Interpretation of Computer Programs
    * The Pragmatic Programmer
    * Design Patterns
    * Analysis Patterns
    * Implementation Patterns

> The trouble with DRY is it has no reference to the knowledge bit, which is arguably the most important part!

Okay. Now what does this mean? Is this article effectively a tantalizing recommendation to read The Pragmatic Programmer?

- Code Complete 2nd Ed.

- Quality Software Management Vol 1-4, by Gerald M. Weinberg

I'd also throw in: Code Reading - The Open Source Perspective

I also like the debugger. It allows you to easily capture your steps as you click around your application, save those steps into a file, and send that file to other developers, which allows them to run through your steps on their own machine; seeing Elm's output at each stage. It works like a "steps to reproduce" bug report, only automated, which makes finding and fixing difficult bugs easy.

There is a lot of good documentation for Elm as well. Elm's documentation itself is good. Manning and Pragmatic Programmers both have good books on Elm (both are still early access versions though). Pragmatic Studio also has an excellent video course on Elm for about $60 (https://pragmaticstudio.com/courses/elm), if you're interested in learning it.

https://pragprog.com/titles/tpp20/the-pragmatic-programmer-2...

It's been a long, long time since I had access to the book; and much of it is internalized by now; but back then it changed everything for me.

    Software Requirements - Karl Wiegers

    Programming TypeScript - Boris Cherny

    Associate Cloud Engineer Study - Dan Sullivan

    Design Patterns - Gang of Four

    Refactoring - Kent Beck, Martin Fowler

    Programming Pearls - Jon Bentley

    Patterns of Enterprise Application Architecture - Martin Fowler

    The Pragmatic Programmer - David Thomas, Andrew Hunt

    CSS: The Definitive Guide - Eric A. Meyer, Estelle Weyl

    Working Effectively with Legacy Code - Michael Feathers

    Head First Design Patterns - Eric Freeman, Bert Bates

    Code Complete - Steve McConnell

    Peopleware - Tim Lister, Tom DeMarco

    Clean Code - Robert C. Martin

    The Clean Coder - Robert C. Martin

    Clean Architecture - Robert C. Martin

    Don't Make Me Think - Steve Krug

    Functional Design Patterns for Express.js - Jonathan Lee Martin

    The Surrender Experiment - Michael A. Singer

    Principles - Ray Dalio

    The Power of Now - Eckhart Tolle

    The Effective Executive - Peter F. Drucker

    Think and Grow Rich - Napoleon Hill

    Extreme Ownership - Jocko Willink, Leif Babin

    Influence - Robert B. Cialdini

    The Startup Way - Eric Ries

    The Lean Startup - Eric Ries

    12 Rules for Life - Jordan B. Peterson

    Measure What Matters - John Doerr, Larry Page

    The Fish That Ate the Whale - Rich Cohen

    The E-Myth Revisited - Michael E. Gerber

    The Score Takes Care of Itself - Bill Walsh, Steve Jamison, Craig Walsh

    Management - Peter F. Drucker

    Thinking in Systems - Donella H. Meadows

    Blue Ocean Strategy - W. Chan Kim, Renee Mauborgne

And yes, being able to rollback bugs or things your users don't like in a systematic, traceable way is absolutely the best. Undo only works up to a point lol.

Check out The Pragmatic Programmer for more nice ideas about being a developer. http://www.pragprog.com/the-pragmatic-programmer

As a programmer :

1. The C++ Programming Language by Bjarne Stroustrup.

2. Operating System Concepts by Silberschatz

3. Compilers by Aho

As an agile software developer:

1. eXtreme Programming by Kent Beck

2. Pragmatic Programmer by Hunt and Thomas

3. Continuous Delivery by Jez Humble

As an architect:

1. Domain Driven Design by Evans

2. Pattern-Oriented Software Architecture by Buschmann

3. Envisioning Information by Edward Tufte

As a CEO:

1. Good To Great by Collins

2. Lean Startup by Eric Ries

3. Beyond Budgeting by Pfläging

  1. The Mythical Man Month, Brooks
  2. Peopleware, DeMarco and Lister
  3. Paradigms of Artificial Intelligence Programming, Norvig
  4. The C Programming Language, Kernighan and Ritchie
  5. The Ruby Way, Fulton

I know the original list was supposed to be more esoteric books, not classics, but I'm anticipating this becoming a thread of everyone's favorites. : ))

Thank you for your comment, I thoroughly enjoyed it. Thank you also for summarizing the many forseeable possible discussions upfront so that we could have avoided them here.

The books were chosen by a group of five, half of us with 10-15 years of experience, so no, they aren't the latest books the author by a chance happend to read.

I admit that, as others have complained, the title might be percieved as misleading. The reason is that these are books that our company recommends to its developers and we want the developers to be something more than coders (= what most people understand under 'developer'). Though it's important to write great code, it's even more important, IMHO, that it is the right code that gets written, i.e. that the resources available are used to produce the maximal business value possible (and we believe that this cannot be planned but must be discovered based on feedback from reality - that's why lean/agile). Going quickly (great coding skills) in the wrong direction isn't progress.

Some of us have read Code Complete or The Pragmatic Programmer but it hasn't made it into the list. More of us will read it now and we will reevaluate the list afterwards. I hope it's good with you :-)

- Pragmatic Thinking & Learning by Andy Hunt

- The Design of Everyday Things by Don Norman

-

- The Pragmatic Programmer by Andy Hunt and Dave Thomas

- SQL Performance Explained by Markus Winand

And http://teachyourselfcs.com curriculum is pretty good as well.

As a side note, there's so much we can learn from game programmers and OS/database/compiler engineers.

So, Ruby on Rails.

Rails is a stack that has:

Ruby - a very simple developer friendly language. This is responsible for putting together

JavaScript - this lang is responsible for all the fancy stuff you see on websites. The animations and all.

HTML, CSS - this is the stuff that websites are made of. Ruby and JavaScript are used to generate this the way you want.

I used to be an accountant and started coding in Nov 2014. I have many rails apps ever since as prototypes and maintain one app that is in production (meaning people use it).

I used this Rails Tutorial by Michael Hart (https://www.railstutorial.org/book) significantly. You will end up with a cool website at no cost at the end of the book.

I also highly recommend Codecademy courses on HTML, CSS, JavaScript and Ruby.

If you are really serious about this stuff, which is great news, you might want to read more about making software. Start with the Pragmatic Programmer. It is a great book to read in your formative years.

And finally (this is important), try to solve a problem (like building a website for yourself or a friend etc) with programming. Learning just to know doesn't stick for long in my experience and probably is true for others.

There's a wiki article about it here:

http://www.c2.com/cgi/wiki?RubberDucking

The examples and language tend to be programming related (for example one chapter is titled "Debugging your Brain" iirc) because that's the intended audience but I'd also recomend it for non-programmers.

Very good blend of theory (Dreyfus model, r-/l-mode) and practical advice on how to improve your learning and generally use your brain better.

http://pragprog.com/book/ahptl/pragmatic-thinking-and-learni...

Last year, I was lucky enough to sign a book deal with The Pragmatic Bookshelf to write an intermediate level book on Python. (The Pragmatic Bookshelf is the publishing company founded by the authors of one of my favorite programming books: The Pragmatic Programmer.)

Having written Python most of my professional career, I wanted a resource that I could give to engineers who might have deeper experience in some language that wasn't necessarily Python. I wanted to help teammates newer to Python quickly discover its virtues (and limitations). I think there are tremendous Python resources available online, but wanted to capture another perspective to help teammates level up their skills.

The book ("Intuitive Python: Productive Development for Projects that Last") went through a beta release this spring, and was officially released this month.

It's available (including a few free sections) here: https://pragprog.com/titles/dmpython/intuitive-python/

In case anyone is thinking of becoming an author with the The Pragmatic Bookshelf, I'd be happy to share my thoughts about the publishing experience there (spoiler: I had a positive experience).

I'm proud to have released this book, and excited to share it here.

Thanks!

-David

I've also had good experiences with SCPD courses from Stanford, if your budget would cover those (they are at the other end of the price spectrum).

What you’re reading now is not a collection of mazes for you to solve. No, this is something much more exciting. This is a collection of ideas to inspire you.

You’re about to learn how to generate your own mazes. Random mazes, unique, each one different than the one before. It’s a voyage of discovery where you never know quite what you’ll find when you crest the next hill."
Mazes for Programmers by Jamis Buck — Pragmatic Programmers (3 / 121)

Read more: https://medium.com/pragmatic-programmers/introduction-f7e108...

Luckily with many tech and non-fiction books, the author isn't quite as important as when you're buying fiction or high profile books from the likes of Seth Godin or Malcolm Gladwell. Those guys will always be able to charge the premium rates :-)

- Code complete

- Pragmatic programmer

- Design patterns

- Programming pearls

- If you're going for hardcore programming: the dragon book, something on modern hardware and something on OS internals.

According to the preface, "As a result, this book is something of a Ship of Theseus. Roughly one-third of the topics in the book are brand new. Of the rest, the majority have been rewritten, either partially or totally. Our intent was to make things clearer, more relevant, and hopefully somewhat timeless."

It looks like it did get a substantial update.

Code Complete is fantastic. I haven't re-read the Pragmatic Programmer in probably a decade but I remember that giving me a very good handle on approaching code as a young developer.

https://www.amazon.com/Pragmatic-Programmer-journey-mastery-...

Books are great, but I prefer using solely online resources to learn; I find it to be a more efficient use of my time. Though there are notable exceptions: The Pragmatic Programmer (http://pragprog.com/the-pragmatic-programmer) and Getting Real (http://gettingreal.37signals.com/) come to mind.

Maybe it would be a good idea to put a bit more stress on the "no" in "no sacred cows", that's an important point beyond just K&R. Nothing should be sacred, including "Learning C The Hard Way" - and a "question everything and everyone" mindset is generally a good thing to have as a programmer [I think I read that in "The Pragmatic Programmer" ;-)]. But other than that I now think that chapter is fine. I do apologize for the somewhat passive-aggressive form of my question.

Thanks a lot!

I'm a fan of "The Pragmatic Programmer".

Other books I thought were a good read: getting things done, 4 hour work week, and founders at work.

I've also got all 6 seasons of 24 on my bookshelf =/, probably not the most productive times of my life.

I have a previous comment on this site about reading. That is actually what I look for, intellectual curiosity and a desire to continue learning and growing.

I'll just quote myself:

"""
What I look for in a developer: READS BOOKS. ( Audio books count )

That's the only thing. I'm sorry, if you are not reading and studying to keep up, you are getting left behind. There are so many brilliant people writing amazing books on a huge array of subjects. If I could get every one of my developers to read ONE book on software design[0] a year, I would die happy and the entire industry would be 10 years ahead.

They don't even have to be technical books. I just want to see intellectual curiosity and a commitment to self improvement.

- 0: In the vein of Clean Architecture, The Pragmatic Programmer, The Mythical Man Month, Designing Data-Intensive Applications, The Google SRE book, etc
"""

Things like amount of unit tests and comments are influenced heavily by this effect.

It's elaborated further in The Pragmatic Programmer (http://pragprog.com/titles/tpp/the-pragmatic-programmer), which actually introduced me to the concept some time back.

[1] https://pragprog.com/book/btlang/seven-languages-in-seven-we...

[2] https://pragprog.com/book/7lang/seven-more-languages-in-seve...

as with the same argument presented in that book, i have a little trouble with this since i've been under the impression the broken windows hypothesis was discredited...

Also, IMO, the worst of such "considered harmful" essays were those that advised against the use of stored procedures and programmatic constructs directly on relational databases in favour of the shiny new hive-mind created ORMs.

The funny thing is, just as the best ORM technologies are beginning to sort their shyte out, we are seeing essays that they are now considered harmful. Reboot.

I don't think this is fair or accurate.

Authors are choosing to put their articles behind Medium's paywall because they want to get paid. So when you see a paywall that's the author's choice. It's not any different than a Substack newsletter other than scale. So to say Medium is preventing people from reading... it's really that Medium is home for a lot of writers who want to get paid for their work and probably wouldn't even have written the piece you are trying to read without that incentive.

Then this Skymall article isn't even behind the paywall and doesn't have any sort of block on it or login wall. Or am I seeing something different than you? I tested it while not logged in.

FWIW, there is a ton of great writing on Medium even if there is also a lot of trash. For example, I helped port the full back catalog of books from The Pragmatic Programmers over to Medium. Those are great and it's great to have easy access to all of them.

I also like most of O'Reilly's Perl books.

Also, Jonathan Rockway's book on Catalyst was very helpful for me, although there were some issues with typos in the first edition (which is to be expected.)

Also, Philip Greenspun has published a good free collection of computer-science and web-development related texts on his website.

(Sure, he's a little arrogant and some people find his writing style to be somewhat abrasive or even borderline nonsensical, but I certainly liked most of his work. And I believe I learned quite a bit from it, as well, though I'm sure that is debatable.)

In my years of software development I had the fun but unfortunate experience of coming across not one, but two compiler bugs. The program would segfault on a seemingly innocuous line, but after looking a the assembly, it was clear the compiler was doing something screwy. These types of bugs are exceedingly rare, and they can be maddening to debug, but when you catch them you get a nice sense of satisfaction.

Code Complete is a problematic book. It has some good ideas but also has some very bad ones (cone of uncertainty, 10 times productivity in good programmers, etc).

Design Patterns is mostly obsolete. Functional programming techniques made a lot of Object Oriented techniques irrelevant (e.g.: observer pattern vs callbacks with lambdas).

Art of Computer Programming is the book everyone mentions but no one reads. A classic that people actually read is Structure and Interpretation of Computer Programs.

My recommendations: "Code" by Charles Petzold,"Don't make me think" by Steve Krug, Working Effectivelly with Legacy Code, by Robert Feathers, Clean Code by uncle Bob,..

I really don't know the answer, but find it fascinating and can't wait to see what Facebook is doing in 10 years time.

It has good parts. But it has some very bad parts too, when it reinforces myths that, IMO, are very wrong (e.g.: cone of uncertainty, X times better programmer, etc).

I'd recommend to read it with care.

> - The Pragmatic Programmer by Andrew Hunt and David Thomas

After many years I still read parts of it, again and again. And I still like it.

* The Pragmatic Programmer
* Clean Code
* The Clean Coder
* Domain-Driven Design
* Growing Object-Oriented Software, Guided by Tests

All of these books take the simple maxim:

"Be organized, and stay organized"

and spend thousands of pages expanding on that.

Read the "classics" - Code Complete, Pragmatic Programmer, Clean Code etc. Google "best books about programming" and you'll find plenty.

When you're reading think about the why. You're job is dealing in complexity and there is no one true way. Understand as many of the different ways as possible.

If you think an idea is weak, try and figure out a question that exposes the weakness (how does this handle a date before 1970?). Expect that sometimes this question will reveal the idea isn't as weak as you initially expected.

Remember you only need to solve the problem that's in front of you. If that problem doesn't seem easy try to break it up into smaller problems.

Complicated solutions are often bad solutions.

Complicated solutions can be good solutions.

Write your code for people to understand.

Advice on good writing is often very applicable to code... See Orwell(1), particularly "Break any of these rules sooner than say anything outright barbarous"
1.https://www.writingclasses.com/toolbox/tips-masters/george-o...

I think they're assuming that everyone has read The Pragmatic Programmer. To quote the original DRY principle from there:

Every piece of knowledge must have a single, unambiguous, authoritative representation within the system

Note that this has only an accidental relationship with code duplication, and in some cases could increase the latter.

You were lucky because you consistently had the entire page width. For mine, because the book's formatting was pre-defined, the column width was variable depending on content type. I could have anywhere between 20 to 65 chars for code. The only place I had control was in the screenshots of code in Vim, but even Production decided to scale those down to make it fit.

http://en.wikipedia.org/wiki/Fixing_Broken_Windows

Generally, programmers who are afraid of the command line aren't very good at putting textual commands into a program text file, either.

They will cling for dear life to code generators and other such facilities in an IDE. (but not the good kind of code generators that define an original source DSL to be expanded into otherwise unseen code by the build process itself, always the IDE based code generators that generate mountains of crap code that now must be read and saved in source control)

They will cling to rigid, bloated, frameworks that require that they fill in parameters in an XML file, and write (many, scattered) tiny pieces of code to fill in the blanks for that framework, but which allow little variation from the application style which the framework mandates.

Beware the illiterate, programmer, grunting at cave paintings on the wall (clicking pictures on the screen, only).

See also: Pragmatic Programmers - power of text/shells sections; Neil Stephenson - "In the Beginning was the Command Line" essay.

All this to say: despite the negative comments here, this is worth your time to read.

* Song of Ice and Fire series. I never really liked fantasy but this series is wonderful. The TV-series (Game of Thrones) is okay but a far cry from the books.

* The Pragmatic Programmer. The best programming book I've seen. A must read for programmers I'd say.

* Introduction to Algorithms. Haven't really gone through it but so far it's been great.

Should you invest time in learning for interviews or your own personal growth once you are 2-3 years in the industry ?

I understand that both sets are not mutually exclusive, but where should you put your time on ?

Investing time specifically to give interviews: Leetcode, Cracking the Coding Interview, TopCoder, etc., may increase the chances of getting a better job then your current one (and will make you a better programmer too).

On the other hand reading books like 'the pragmatic programmer' and other classics, won't necessarily put you in a better position to get a better job (in most companies), but will surely make you perform better in the current one.

So, is it ok to put it this way:

* If you are happy with your job and you can see that you can stay 5+ years at the company (basically FAANG ?): Invest time in learning for personal growth (Design Patterns, Refactoring, etc)

* If you plan to switch / want a better salary / company sucks / <every_other_reason> : Invest time towards preparing for interviews specifically ?

We are legion (We are Bob) - Finally broke down and listened to all the praise. It wasn't misspent. What fun!

The Emotional Craft of Fiction - Can never have enough writing advice

The Pragmatic Programmer (20th anniversary) - Again, relenting to the pressure to read classics

Norvig, Paradigms of Artificial Intelligence Programming (I agree with plinkplonk and am quoted on Norvig's web site saying as much; a good book about all of {AI, Lisp, programming}).

Hunt and Thomas, The Pragmatic Programmer (no big surprises but lots of little insights and very little I disagree with; nicely written).

Bentley, Programming Pearls (absolutely superb for the sort of low-level algorithm-heavy stuff that, er, hardly anyone does any more).

Cormen/Leiserson/Rivest/Stein, Introduction to algorithms (best single-volume algorithms text I've seen, but not for the faint-hearted; might be well supplemented with Skiena's The algorithm design manual, a very different sort of book).

Full agreement on this point. Once I started looking at my own career from this perspective I couldn't stop. Books like The Passionate Programmer and The Pragmatic Programmer as well as heaps of prose from pg, patio11, edw519, and tptacek guide my continuing quest for increased leverage.

That has been my experience. The best book club discussions (we do probably 10 different groups a year for 5+ years at this point) have been for books like The Pragmatic Programmer, Rework, Lean Startup, etc -- ones that focus more on a methodology or have room for discussion about trade-offs. Framework/language specific books tend towards the reference material side of things and don't have much room for discussion. One exception is the Seven Languages in Seven Weeks book -- we would work the exercises on our own and then meet together to discuss and share our solutions.

I avoided The Passionate Programmer when it was called My Job Went To India, deterred by the title and lack of reader recommendation. Maybe I'll give it a look now. Somewhat related, I found Land The Tech Job You Love to be a comprehensive and insightful resource.

Other resources that were helpful for me as well

Books:

  - SICP (http://mitpress.mit.edu/sicp/full-text/book/book.html)
  - The Pragmatic Programmer: From Journeyman to Master

  - Almost all udacity CS classes 
  - SaaS courses at edx.org
  - Scala course and most CS courses in coursera

  - browse most popular OS projects on GH, and try to contribute
  - create your own open source project, and get feedback / pull requests

  - Stackoverflow
  - http://codereview.stackexchange.com

edit: SICP has an online course at MIT OCW:

http://ocw.mit.edu/courses/electrical-engineering-and-comput...

it might cover a lot of things you know, but I think it's a must have for every developer out there.

2. Pragmatic Programmer - A classic, learned many practical tips for day to day programming job.

3. Founders at Work - Motivated me to work on my side projects and be constantly learning.

It's disappointing that they don't discount The Pragmatic Programmer, as that's a book I wholeheartedly recommend to every working developer. I think that's still owned by Addison Wesley.

My mentoring CS professor's recommendations included these 5 books as well as the following:
* Pragmatic Programmer
* Gödel, Escher, Bach.
* Programmer Pearls

He also had a great deal of Computer Vision expertise/recommendations (his specialization / side job was as doing R&D for RED Cameras). Great professor, even better guy.

However, computer science and software development are not the same thing. If your primary goal is to up your game as a software developer, you might get more out of well-regarded software development books like "The Pragmatic Programmer," "Working Effectively with Legacy Code", or "Design Patterns."

Hope this helps.

"Text manipulation languages are to programming what routers are to woodworking. They are noisy , messy, and somewhat brute force. Make mistakes with them, and entire pieces can be ruined. Some people swear they have no place in the toolbox. But in the right hands, both routers and text manipulation languages can be incredibly powerful and versatile. You can quickly trim something into shape, make joints, and carve. Used properly, these tools have surprising finesse and subtlety. But they take time to master. "

Quoted from https://flylib.com/books/en/1.315.1.37/1/

The problematic activities described here, overgeneralization and solving imaginary problems (aka Coding for A Rainy Day), are simply typical newbie mistakes.

Otherwise highly competent developers almost always fall into this trap early in their careers, so the important thing is to have someone experienced in charge of the project who can veto their weirder ideas until they mature.

I think every software company should hand out a copy of "The Pragmatic Programmer" to all new hires. It gives much good advice on how to not overcomplicate things.

Also Pragmatic Programmers has very good books on both, written by the creators.

I love Phoenix but I will disagree with the OP in 2 points.

Yes probably Elixir/Phoenix will manage better thousands of concurrent connections, but if you are doing personal projects or are a start-up that condition is irrelevant in the meantime. So that only lefts us with the big established applications. That does not mean Phoenix is not good, it only means you will not notice a difference with Rails for most of your projects.

The second thing, that OP failed to mention is that the Rails ecosystem is at least an order of magnitude larger. From the gems available, job opportunities,developers available, instructional material, SOP for many tasks and so on.That is boring, but valuable.

Leo Brodie, 'Thinking Forth'

Roland, 'Program Construction'

Ullman, 'Elements of ML Programming'

De Marco, 'The Deadline'

Brooks, 'The Mythical Man-Month'

Skiena, 'The Algorithm Design Manual'

Hunt, 'The Pragmatic Programmer'

Stevens, 'Advanced Programming in the Unix Environment'

Stevens, 'TCP/IP Illustrated, Vol. 1'

Ross Anderson, 'Security Engineering'

Also, the Phoenix Project is a ripoff of Goldratt's 'The Goal.' I suggest reading Goldratt instead, and then think very carefully about what transfers from manufacturing to software.

Also, you don't necessarily need to cover something completely in order to get started. And these will be useful mostly if your work is in some way part of a software product instead of being some "offline" analysis, model build or forecast. Just learning to use version control, to collaborate with other developers and to run tests goes a long way.

http://www.infoq.com/presentations/Simple-Made-Easy

The "Joy of Clojure" is the best book on understanding the mid and high level constructs and design of Clojure (and FP). It's not a beginner book though - for that the books from the Pragmatic Programmers or Oreilly are excellent.

* High Output Management by Andy Grove https://www.amazon.com/gp/product/0679762884/

* Turn the Ship Around by David Marquet https://www.amazon.com/gp/product/1591846404/

* The Score Takes Care of Itself by Bill Walsh https://www.amazon.com/gp/product/1591843472/

For interns I give out these two books:

* The Pragmatic Programmer https://www.amazon.com/Pragmatic-Programmer-Journeyman-Maste...

* The Passionate Programmer https://pragprog.com/book/cfcar2/the-passionate-programmer

"The Mythical Man Month" - http://amzn.com/0201835959

"Peopleware: Productive Projects and Team" - http://amzn.com/0321934113

"The Pragmatic Programmer" - http://amzn.com/020161622X

"Managing the Unmanageable: Rules, Tools, and Insights for Managing Software People and Teams" - http://amzn.com/032182203X

"Joy Inc: How We Built a Workplace People Love" - http://amzn.com/1591845874

"A Lapsed Anarchist's Approach to Being a Better Leader" - http://amzn.com/0964895692

"Becoming a Technical Leader: An Organic Problem-Solving Approach" - http://amzn.com/0932633021

"Code Complete" - http://amzn.com/0735619670

If you passed that stage, I recommend the book The Pragmatic Programmer as a very good book on how to become a good software developer. The book Clean Code is a good starting point too.

Other than it depends on your circumstances. A good heuristic (particularly in frontend world) is to study the language, not frameworks.

But I've also heard about math PhDs write the sloppiest code code imaginable: functions 1000+ lines long, copying and pasting functions to add a parameter... (in production code for a software company, not a research project).

So like you said, math helps but I'd like to extend that thought and say that you can make bigger gains elsewhere. For example, if you're a sloppy coder and don't know math, go out and get a book like "Code Complete," "The Pragmatic Programmer" or "Clean Code" first.

1. The Pragmatic Programmer by Andy Hunt and Dave Thomas

2. The Clean Coder by Robert Martin

3. Design Patterns: Elements of Reusable Object-Oriented Software (the "Gang of Four" book)

The first two contain a range of advice pertaining to working as a professional software engineer. The third one, although very dated, is still a great resource for understanding many of the design patterns used in OOP.

My go to recommendations:

http://www.amazon.com/Structure-Scientific-Revolutions-50th-... - The Structure of Scientific Revolutions, Thomas Kuhn, (1996)

http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master... - The Pragmatic Programmer, Andrew Hunt and David Thomas (1999)

Things I've liked in the last 6 months:

http://www.amazon.com/How-Measure-Anything-Intangibles-Busin... - How to Measure Anything, Douglas Hubbard (2007)

http://www.amazon.com/Mythical-Man-Month-Software-Engineerin... - Mythical Man Month: Essays in Software Engineering, Frederick Brooks Jr. (1975, but get the 1995 version)

http://www.amazon.com/Good-Great-Some-Companies-Others/dp/00... - Good To Great, Jim Collins (2001)

Next on my reading list (and I'm really excited about it):

http://www.amazon.com/Best-Interface-No-brilliant-technology... - The Best Interface is No Interface, Golden Krishna (2015)

When I first read Refactoring, IntelliJ wasn't released yet and refactorings still needed to be done by hand. Automated refactorings are so incredibly useful when it comes to improving code quality over time that I don't know what it was we did without them.

Right now I've got:

- Design Patterns by the Gang of Four

- The DevOps Handbook by Gene Kim

- The Phoenix Project by Gene Kim

- Designing Data-intensive Applications - Martin Kleppmann

- Peopleware - Tom DeMarco

- Code Complete - Steve McConnell

- The Mythical Man Month - Frederick P Brooks Jr

- Growing Object-Oriented Software - Steve Freeman

- Domain Driven Design - Eric Evans

- The Clean Coder: A code of conduct - Robert C martin

- The Pragmatic Programmer - Andrew Hunt

- Building Evolutionary Architectures - Neal Ford

- The Design of Everyday Things - Don Norman

- Don't Make me think - Steve Krug

I find that the best way to evaluate yourself is to look at your code all the time and think critically. Be careful not to overdo it though, maybe take a closer look in between projects or in some interval is fine.

What should you work on? What do you find interesting? I think you're a lot better off working on something you find interesting than forcing you into something that you don't find thrilling. As always you should do stuff you're not comfortable with: do some low/high level stuff, try a new framework or do something you think is hard.

I wouldn't obsess too much on how good you are compared to others, there's always someone better, period.

Instead focus on your relative improvement. If you read your old code (which you should) you should think "this is awful, I could write something better" or at least "this is ok... but if I did it this way it would be much better".

And finally read code, read books about code, try to code with other people and try to make something useful.

Some book tips:

The Pragmatic Programmer:
Read this!

Introduction to Algorithms:
If you don't know algorithms, here's a nice book for it

Effective Java, Effective C++, More Effective C++:
Just good practices

1. Micheal Heartl's Rails Tutorial.
2. Pragmatic Programmers Bookshelf - Agile Rails 3.2 (4th Edition)

Both are a good start but delve far too much into unit testing with the horrific RSpec. When you're learning something new, you don't want to muddle with learning a DSL on top of things.

Read "The C Programming Language", by Kernighan and and Ritchie. Written decades ago, still accurate and relevant today. "The Mythical Man-Month", "The Pragmatic Programmer", "Design Patterns"... books like this will always be relevant.

Maybe a good rule is to stick to CS books that have been in continuous print for at least ten years.

Good books to read about practical software engineering are sold here:
https://pragprog.com/
I'd start with The Pragmatic Programmer.

By copy-pasting things, you've gotten yourself into a habit of just banging things until they work. Now, you should approach things from a scientific prospective: try to understand why they work, then write something to test that understanding. Build coherent and clear mental models.

Two I've enjoyed are:
"The Pragmatic Programmer" by Andy Hunt and Dave Thomas
"Clean Architecture" by Robert C Martin

That being said, no harm in deep diving individual languages. Secrets of a JavaScript Ninja by John Resig was an excellent introduction to JavaScript!

2. "The Power of Your Subconscious Mind" by Joseph Murphy. Sold me on the idea of positive thinking, but generally I found the book crappy.

3. "To Kill a Mockingbird" by Harper Lee. The only nover on the list. Definitely a good read.

4. "The Pragmatic Programmer". I fell in love with the idea of "the network" of views and controllers.

5. "The Software Craftsman" by Sandro Mancuso. Great one. Made me recosinder a few (quite a few!) things in my workflow and project.

6. "Deep Work" by Cal Newport. Amazing one. Can't wait for Monday to implement some at work. I even ordered 3 more copies for my team.

For patterns, "Head First" is a bit childish maybe, but the content is fine for someone learning to recognize patterns. "Patterns of Enterprise..." is also good, but more dry. I'd stick with one of those two. And then skip the one by GoF, unless you want to read the "original" for some reason.

"The Pragmatic Programmer" is probably the book that has shaped my work the most.

2) Create software (for about 10 years at least) for fun and profit. Assume others must read and understand your code. Write it for them. Also love the code you write. Find the beauty in solving problems elegantly and simply. You'll learn a lot.

3) Teach others how to create high-quality software, most especially focusing on "why". This keeps you thinking about what you're doing and leads to you finding ways to improve.

4) Listen and evaluate honestly when others criticize your choices. Maybe you did do it wrong or you don't have the whole picture. Have strong opinions, weakly held.

5) Repeat.

These aren't qualifications so much as guidelines for when people ask me how I got "so good." My title has been "Software Architect" for the last twelve years.

There's a lot more to it, naturally. Your biggest job as an architect is to extend the reach of the entire development team. Be it by writing libraries and frameworks for the project, mentoring developers, or creating designs and guidelines for developers to work within. Like a building architect, you are responsible for crafting and engineering the space in which people will live and work. For a software architect those people are the users, the developers, and the stakeholders. Your job is to strike the right balance between the three groups.

The reason you see so many posts in this thread deriding software architects is that as an industry we have largely forgotten what software architecture is. B-School and CIO Magazine have been selling executives on out-sourcing so that they don't have to "worry" about that kind of thing (and we're just now recovering from this). Capital "A" Agile came along and sold them another bill-of-goods that doing Scrum would fix all the issues.

For these and other reasons, the title basically came to mean "really good programmer" and was handed out as a simple promotion. But the real software architects are never just that. When doing their job properly, they become the foundation for excellent software development teams, and for excellent software.

"Unwritten Laws of Engineering" https://www.amazon.com/dp/0791801624

Originally meant for mechanical engineers, it provides specific and general non-technical career advice. It focuses on what we call “soft” skills today. This field puts so much weight into technical prowess that we often think of these “soft” skills as somehow beneath the “hard” skills. Nothing could be further from the truth. If you don’t spend time on learning how to navigate your career, you’ll be as well off as a dragster on the backroads: you’ll get nowhere fast. I only wish I could have read this book sooner; it would’ve saved me a lot of trouble early on.

"Becoming a Technical Leader" https://www.amazon.com/dp/0932633021

Don’t let the title fool you: this is not just for people planning on becoming a “Tech Lead.” It’s for anyone in the tech field, period. If you pickup this book you must work through the exercises to get the full effect. It will be worth it. It’ll be like having your own therapist, life coach, and mentor, except that it’s just you and a notebook answering very important questions.

"The Pragmatic Programmer" https://www.amazon.com/dp/020161622X

I consider this book 10x better than Clean Code and Code Complete combined! (Though that may just be because I read PragProg first?) As the name suggests, this book provides more tactics advice but also gives great career advice too. The most famous is to “learn a new language each year.” This kind of advice seems a bit much, but over my career I’ve had to write in over a dozen different languages, even though 90% of the code I’ve written has been in just one language, the ability to pickup new languages quickly and easily is a solid skill to have. And that’s just one particular tip from this book.

(These are excerpts from my suggested reads blog post: https://valbaca.com/posts/my-suggested-reads-3cie)

There's some overlap in contents, but I feel they complement each other very well.

If you make decisions reversible or abstract away the interface from the implementation, you may be doing it for nihilistic reasons, but still a decent idea.

Also, "good enough" is underrated.

How come you give this example just now? This can't be a coincidence. select() just caused us a major production outage.

FYI: select() is broken on pretty much all Linux kernels up to very recent ones. Doesn't work when there are more than 1024 opened file descriptors, not a lot for a server app. Side effects include crashing the application.

These books will help you day-to-day with your general programming knowledge...

> Philosophy of Software Design https://www.amazon.com/Philosophy-Software-Design-John-Ouste...

> The Pragmatic Programmer https://www.amazon.com/Pragmatic-Programmer-Journeyman-Maste...

> Clean Code https://www.amazon.com/Clean-Code-Handbook-Software-Craftsma...

> Mythical Man-Month https://www.amazon.com/Mythical-Man-Month-Anniversary-Softwa...

But I do have two formative things:
Feynman's lecture on Cargo Cult Science is excellent, with this gem:

"The first principle is that you must not fool yourself--and you are the easiest person to fool. So you have to be very careful about that. After you've not fooled yourself, it's easy not to fool other scientists. You just have to be honest in a conventional way after that... I'm talking about a specific, extra type of integrity that is not lying, but bending over backwards to show how you're maybe wrong, that you ought to have when acting as a scientist. And this is our responsibility as scientists, certainly to other scientists, and I think to laymen." - Feynman [0]

I can't tell you how many times this has saved me in the field. Replace the word 'scientist' with '<YOUR DISCIPLINE HERE>' as needed. (And I think moreso for engineers than scientists, since safety absolutely requires this mentality.)

And I really like the ideas in The Pragmatic Programmer [1]. More than anything specific, the idea of not being married to any particular concept or solution, but rather to pragmatically chose what is correct then for that circumstance helps a lot. The book is opinionated, but reasonable, and copying that pleasant tone is a fast way to make allies when solving problems in a group. And it's a pretty good book to boot.

[0] http://neurotheory.columbia.edu/~ken/cargo_cult.html (and is an HN favorite, to be sure)

[1] https://pragprog.com/the-pragmatic-programmer (another HN favorite, though not always brought up in terms of engineering)

I agree, that's why I'm asking this question. I think these particular books are mostly helpful to the junior engineer.

But it's hard to believe that from here on out the only thing that's left is to learn how to deal with people. Surely there's more to the software side of software engineering than what TPP and Code Complete have covered. Surely very experienced engineers have written books on software engineering that cover something more than entry-level knowledge. (Clearly, since I haven't found such books yet, there's a chance they haven't been written. But I find that hard to believe, considering the broad audience of software engineers that are interested in that knowledge.)

[1] https://learning.oreilly.com/library/view/the-pragmatic-prog...

That's really what Medium aspires to be--a place worthy of a five dollar subscription.

Many people here probably end up on Medium repeatedly via Google search and yeah, the results are mixed. But also, it's worth noting that a lot of those results wouldn't exist at all without Medium paying and encouraging writers and editors.

What I hoped would start to take Medium over the top though was the addition of all of The Pragmatic Programmer books. That was paid for by other tech people who had already subscribed. (And I played a role in bringing them on board).

There's more coming. But overall, this is 100% Medium's direction and belief that a soft paywall is a better business and a bigger win for all parties than free & ad supported. So this paywall isn't going away, and it's really on them to do more to justify it.

Set up the CI/build server on your machine, have it email everyone when the build fails. They will see the use of the tool then, and when the team accepts it they will hopefully get an official server to host it on.

Write tests for your code, and when other devs work with you on issues, or break things, write tests and send to them "Hey, i wrote this test that shows the code you wrote is failing, can you make it pass?" Also ask others to make unit tests. You will have to write the bulk of tests. You probably know which others on the team are open to writing tests and working with you on the pocket of excellence. Get them involved first, and then the idea will spread. A good idea would be buy them copies of Pragmatic Programmer too.

No, you aren't process oriented. A software team that doesn't at least like the idea of automated builds, and tests is crazy. As far as if it's a good place to work and improve one's skills? That depends. In some teams you might never get them to adopt the pocket of excellence. If you are working in a place like that, then it's probably not a good place to work. But if you have a shot at converting them by just doing it on your own first, then it would be a great opportunity to get experience with setting up these aspects of a software shop. And you can put that on your resume, blog about it, etc. In that case it would be a great experience.

1-4: Books on computer organization, operating systems, networks and distributed systems (I like the ones by Tanenbaum, but there are many).

5: Another about compilers/languages (the dragon book is a classic, but there are many others).

6: Something about Lispy-languages (e.g. SICP, but the Little/Seasoned Schemer is another favorite).

7: A book about algorithms. I have Knuth, but something less thorough covering a wider area may be preferable.

8: A book about the practice of programming. My favorite is The Pragmatic Programmer.

9: A book about software engineering as a profession (I recommend Peopleware.)

I've learned that lesson the hard way I think. I read the Pragmatic Programmer early in my career but I don't think I understood it very well.

http://fivesimplesteps.com/books/practical-guide-designing-f...

It's more about the theory of design, but presented in an accessible style and 'web' context.

There's also the Pragmatic Programmer's 'Design for Developers' book, but I haven't gotten around to anything more than skimming that one yet.

http://www.pragprog.com/titles/bhgwad/web-design-for-develop...

Hope these help.

The Pragmatic Programmer, by Dave Thomas and Andy Hunt, is a fairly slim book that aims to cover the unwritten knowledge that experienced programmers have. It came out a long time ago, but it's one of those timeless classics. If you can read this book and everything in it seems obvious, you are probably the equivalent of an intermediate-level software developer.

Similarly, Code Complete, by Steve McConnell, explains how to think like a project lead. In contrast to The Pragmatic Programmer, this is a large book: it aims to cover many concerns. Again, the less that you know, the more value that you will get from it: if you are starting with no training in programming, this book could be immensely valuable.

It's one thing to say, I'd do it different. I'd have this book, or that book, or my list would have more this focus or that focus. It's a whole different beast to claim this list is "poor." And it is stupid to do so without countering with a list of exactly 5 books. Yes stupid.

I have read all 5 books. All 5 are excellent books. All 5 are very highly regarded in the field of programming and computer science. The descriptions that are attached to the list in TFA are accurate and useful to anyone reading the list. If there's a book on that list you haven't read, I'd say read it. This list simply isn't in the same postcode as "poor" and the descriptions of it as poor can't back it up in a meaningful way. Maybe there's another reason why the general mood of this thread is hypercritical? Smells a bit though, don't it? Do you really think if Guttag submitted that list the tone here would be the same or would the whole "this book is better" comments be rather more respectful of the original list and author? I've stated my opinion and why. You may of course, disagree.

Here's mine, Petzold "Code", Kernighan and Pike's "Practise of Programming", "The Pragmatic Programmer", Abelson and Sussman "Structure and Interpretation of Computer Programs" (with video lectures on youtube), Richard Stevens "Unix Network Programming" or maybe "Advanced Programming in the Unix Environment" - Which betray my OS accent. I'm not sure it's better than Ana Bell's. You can decide for yourself on that point.

The DRY principle was created by the authors of The Pragmatic Programmer, and as they formulated it, your example is not DRY.

DRY is about requirements, not code or logic. The specification of a requirement should exist in only one place in the code. It aims to reduce instances of "The requirement changed, and I thought I fixed all the places in the code, but I forgot one and it became a bug." If two pieces of code have very similar logic/code structure, but are tied to different features, then the DRY principle absolutely does not suggest you should refactor to make that logic appear in only one place.

Pretty much every time I've seen people complaining about DRY, they're complaining about something unrelated to the original DRY principle.

Equally important are your soft skills. I would recommend reading The Hard Truth About Soft Skills: Workplace Lessons Smart People Wish They'd Learned Sooner by Peggy Klaus.

I usually recommend:

* Code Complete (Steve McConnell)

* The Pragmatic Programmer (Andrew Hunt and Dave Thomas)

* Clean Code and The Clean Coder (Robert Martin)

* The Mythical Man-Month (Fred Brooks)

* Test-Driven Development By Example (Kent Beck)

I also recommend blogs for more bite-sized knowledge. Jeff Atwood's blog at https://blog.codinghorror.com and Joel Spolsky's at https://www.joelonsoftware.com in particular have been helpful to me.

Here is Bob responding to OPs link: http://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Releva...

Stating:

“SRP) The Single Responsibility Principle.

Gather together the things that change for the same reasons. Separate things that change for different reasons.”

That’s a pretty clear delineation IMO.

IDEs exist for the same reason 7/11 exists. Convenience. You pay a higher price (lost productivity) to experience certain comforts (clicking a button instead of issuing a keystroke command).

My experience has universally been that IDEs only get in the way of focusing on creating. They might be necessary when you are literally just beginning with software and you need a lot of scaffolding to help you -- and I don't think anyone would begrudge university students using IDEs.

But not using a power editor once you are an experienced programmer is hard to understand. I mean, it's so important that it was even included as a whole chapter in The Pragmatic Programmer.

Paying the up-front costs of proficient editor usage is like paying the up-front costs of wearing braces so you can have straight teeth or wearing correcting shoes so you can walk properly. Of course it's more convenient in an absolute sense to simply not wear braces or corrective shoes. But that's not the point. The point is that the value you get from the outcome (e.g. straight teeth, proper walking, or dramatically increased productivity when developing) is far greater than the cost.

In other words, I think you're using a hyperbolic discount function. You are placing such a high value on absolutely immediate "focus on creating" that you incorrectly discount how much more focus on creating you would be able to do with the power of a real editor framework.

1. [The Pragmatic Programmer](https://pragprog.com)
2. Martin Fowler's [Refactoring Book](https://martinfowler.com/books/refactoring.html)
3. Kent Beck's [Test Driven Development: By Example](https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/...)
4. [Thinking in Systems: A Primer](https://www.amazon.com/Thinking-Systems-Donella-H-Meadows/dp...)
5. [Zen Mind, Beginner's Mind: Informal Talks on Zen Meditation and Practice](https://www.amazon.com/Zen-Mind-Beginners-Informal-Meditatio...)
6. [Pragmatic Thinking and Learning: Refactor Your Wetware](https://www.amazon.com/Pragmatic-Thinking-Learning-Refactor....)

I'm surprised that you didn't mention The Pragmatic Programmer..

I think that a lot of the people here (and who read your blog) could do worse than to check out "Team Geek". It's about people, not programming, but the impact it has had on me is equal to PoEAA..

I read the Pragmatic Programmer last year, and it was .. very boring. Most of the tips were like "doh, of course". It's a beginner's book, not for someone who have been trying to improve their code (and processes around it) already for some years.

2. Learn to fail and feel good with that. And as above, to gain as much knowledge from that, as possible.

3. Learn to be confident enough to defend your solution.

4. Read as many non stricly technical books related to programming as possible. Ie. "The Pragmatic Programmer", "Rework", "Clean code", etc.

5. Don't take your job too serious. If you worry about your code after hours, stop! And if you can't, change your employer.

6. Everyone makes mistakes. Just try to not repeat them.

There have been some long threads here about other people's evolution as programmers and what kinds of things they felt helped them improve. I don't have one in mind right now, but maybe you could find one.

You could also try reading a couple of software engineering books that talk about some of these concepts. Wikipedia mentions The Pragmatic Programmer, and there's also Code Complete and others. (I haven't read either of those.)

Here's a list of the best "software engineering" books, although the focus of these is incredibly varied and some probably wouldn't be relevant to you.

http://noop.nl/2008/06/top-100-best-software-engineering-boo...

People who are passionate about what they do have a tendency to stand out (pg makes a similar argument on Amateur section of http://www.paulgraham.com/opensource.html).

If you are passionate enough about software development aspects, most HN articles will not feel overwhelming, as you will be constantly improving on your craft. But then you will know how much more there is to learn. Just don't feel overwhelmed then.

The idea was to construct development teams in a way similar to the surgery teams - one lead developer, one assistant developer (these two "adult" and very good), and a 3-4 other people who
's job is to make the life easier for the main devs - someone to manage documentation, someone else to do detailed testing, one average dev to do the simple and boring stuff, and so on.

That way, in a company of a 100 devs, you'd need 15-30 super-smart developers (who don't need methodologies and scaffoldings), and the remaining 75 just junior/average specialists doing specific tasks and fitting into the structures provided by seniors.

Either you already knew that the things it recommended were good ideas and were doing them, or you haven't yet learned why the things it recommended were good ideas. I know "soft skills" is a euphemism for a bunch of stuff that I'd rather not unpack here, but personally I do think learning good practices around how to write maintainable, testable code are actually, y'know, important and useful, even if they get communicated with icky horrible soft words instead of burly awesome hard math symbols.

This means algorithms and math.

If you say so. But the niche for heroic god-tier 100000000000000000000x rockstar wizard ninja gurus who roll their eyes at tiny puny baby-child beginners while channeling the heartbeat of the universe to derive the Perfect Algorithm™ is... pretty small, and getting smaller ever year. Working programmers don't -- or maybe shouldn't, but oops, that's a "soft skill"! -- actually re-invent all of CS from first principles on a daily basis. And there's really no level of programming you can run to anymore to escape. It's frameworks and libraries and gluing stuff together all the way down, even into the "bare" metal (which isn't so bare anymore, and is a rich programming environment in its own right).

I mean, maybe you work someplace that routinely has to invent entire new fields of theoretical math just to describe the stuff you're building. But I've worked at a household-name place, and known plenty of other people who worked for other household-name places, and in my experience and their anecdotes that kind of stuff is vanishingly rare.

Also, I'd be willing to bet almost anything that you didn't start out as a programmer by reading Turing's "On Computable Numbers" and going from there. You probably started out with an already-built, friendly programming environment in which you could slap things together to see what happened, and only later -- possibly years later -- started to dive into all these "fundamentals" that you now insist everyone learn up-front instead.

i don't think you've really leveled up until you get past using phrases like 'Level Up'. You're not a 14th level Ranger with a potion of strength and +4 leather armor. You're supposed to be an engineer ( or software developer or pick your favorite name ) helping real people solve real problems.

About CI server, it is on its way but only for production release. No continuous build for now mainly because there is no unit test infrastructure setup.

About writing test, well, no one uses unit-test for the reason above. It maybe a good time to introduce that and get to show them the light :)

"In some teams you might never get them to adopt the pocket of excellence. ". I am a bit afraid of that. Why ? I have spent some time trying to change things and yet I see little or no effort from others.

What are you thoughts on documenting things ?

Good unit tests are absolutely crucial to any kind of future refactoring effort. They are helpful at finding regressions and give you some confidence that you do not break the paths that are tested. If you work in a team larger than one, code reviews are a must. Code reviews allow both participating parties the opportunity to learn, improve the overall codebase, and catch bugs. I also think writing code comments and documentation is absolutely important. Mostly so the "next guy" understands why the code is doing what it is doing. Most of the time the "next guy" ends up being you.

One lesson that often comes later in one's programming journey is that there are surprisingly, shockingly, many bugs that won't be found by just running the code. Like you're debugging one thing, and you find this other thing that has been in the shipped code for a year, intermittently causing crashes, but no one was the wiser. The "how could this possibly be working?" moment.

So, I fully embrace the idea of of incremental ground-up development, but running the code just to see if it crashes is too low a bar. Beginner versus craftsperson. I would suggest a high-value compromise is to single-step through any function that you just wrote. This has revealed a huge number of logic errors to me, even without writing additional tests. It's super low-hanging fruit that a lot of people don't even pick. I think that suggestion came from Code Complete, which although old, is still a great resource for beginning programmers. I also recommend The Pragmatic Programmer.

EDIT> Liked the article. Am also interested in standup. Also just recently had a very productive couple of evenings kit-bashing together some wood scraps where the tactile nature of holding a battery here, there, trying to orient it etc. seems to have been vastly more productive than sitting down with Solidworks or overthinking the early design.

Can anyone comment how, if at all, these books are different from classics in the field, such as The Practice of Programming, The Elements of Programming Style, The Pragmatic Programmer, or Complete Complete?

I can't think of anything new that another book on writing good code could say, that hasn't been said already.

That's why I haven't looked at these books yet. It feels to me these books are like another book about Newtonian mechanics, there just can't be anything new.

Thoughts?

Rails 3 does have many improvements, but it's still a "beta" in every sense of the word as many of the plugins don't work yet, or require many modifications to work.

I still think just about the best book/introduction to Rails is the Pragmatic Programmer book: http://pragprog.com/titles/rails3/agile-web-development-with... - They don't yet cover Rails 3 yet, but in the meantime you could fill in the gaps with weblog posts and the like. If you get a solid grip on 2.3, you should have no problem adjusting to 3.0 once it becomes final.

I also have a few for purely nostalgic value, representative of key moments in my past. Notably: the OpenGL Red Book and C++ The Complete Reference.

Nowadays, most students have a library of pirated PDFs, meaning they have the information on hand where they need it and with no need to return it or find it already borrowed in the college library. Most colleges will give you access to online databases of journals, so they aren't a draw either.

The other problem encountered was that of QC. At least in my institution more substantial books were always in short supply, as they'd never have more than 5-6 copies of a single book, so you'd arrive at the computing section and find... "Java 2 for Dummies". Or "Teach yourself C++ in 24 hours". Books that might have been fine to self-learners (when they were not significantly outdated), but nothing that wouldn't be covered in a textbook and nothing more substantial.

Probably this is a disconnect between the people running the library and the lecturers, but the attitude of the library was "Yes, we have software development books. What do you mean 15 years is out of date? The psychology books have been there since the 70s. And our figures show that more students have taken out 'Java 2 for Dummies' than 'Design Patterns' or 'The Pragmatic Programmer', so we don't need more copies."

But those two factors, the greater accessibility of pirated PDFs and blogs (and for some of the slightly more recent students, Stack Overflow), and the lacking quality of what was probably available on the shelves at any given point you chose to look meant that the library was definitely way more useful as a study space than for the contents of the shelves for the other students and myself during my degree.

That example sticks with me.

They're both big and both published by Microsoft. Two strikes, yes, but don't be fooled. These books have so many nuggets that I've gone back to again and again as a programmer. "Code Complete", in particular.

Neither book is a cover-to-cover read. They're both books you dip into for a tip, a skill, some perspective. But they've held up amazingly well, and for my money and time, they're both a step up from the Pragmatic Programmer. If you like what you found in "Pragmatic", you'll love "Code Complete".

I just wish it wasn't from MS, at the peak of MS evil in the 90's.

I have a STEM (non-CS) degree but very recently, started working as a programmer. Doing my first internship at a 'techy' corporate company. One of the things I'd be doing on the side is to go through https://mitpress.mit.edu/books/elements-computing-systems. The video introduction to it just gives me goosebumps to this day. I don't know why. It's fascinating.

Than there is other paradigm books such as "pragmatic programmer", "Thinking Like A Programmer", "Design Patterns: Elements of Reusable Object-Oriented Software", etc.

So far, I've done plenty of reading on Algorithm & Design Structure and leetcode here and there. In the past, I didn't qualify for internship at Google, Amazon or M$ as a software developer/engineer. I feel the reason why I didn't was because I didn't have a "computer science" keyword mentioned anywhere on my resume. Hence, my hope is after getting through "Element of Computing System" & Design Pattern, I'll be able to shove in "computer science" keyword one way or another on my resume.

[1] https://www.goodreads.com/book/show/4099.The_Pragmatic_Progr...

[2] https://en.wikipedia.org/wiki/Broken_windows_theory

[3] http://www.artima.com/intv/fixit2.html

  * The Pragmatic Programmer [1]
  * Apprenticeship Patterns [2]

[1] http://swanson.github.com/writeup/2010/10/25/pragmatic-progr...

[2] http://swanson.github.com/writeup/2010/10/26/apprenticeship-...

poll() was broken on early versions of Mac OS X for quite a while[1] :-). And I thought I recalled select() being broken too, but might be mistaken. Looks like some reports of kqueue() being broken too.[2][3]

[1]: https://daniel.haxx.se/blog/2016/10/11/poll-on-mac-10-12-is-...

[2]: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#OS_X_AN...

[3]: https://discussions.apple.com/thread/4783301?tstart=0

However, even if I agree with the great use I really use it more for code reviews than for actual hardcore debugging. (This could be my fault because I use distributed async processes in my work)

I think the rubber ducking has more advantage if you use a high level dynamic type language to code in (rather than more low-level C with pointers).

Another good one is The Pragmatic Programmer.

Lastly, this wiki is a gold mine of wisdom from hardened devs: http://wiki.c2.com/?StartingPoints

I really recommend you read lots and lots of those pages.

Your wish list is all over the place. It would help to pick one of the goals listed (i.e. Ruby, or Node, or Python) and hone in on that. Once you figure out what language you want to learn, devour everything on the topic from these sources:
* Peepcode tutorials
* Slideshare slideshows
* Youtube videos or other longform tutorials

Get a Hello World example running in your new language, and then see if you can get it wired up to a database. Congrats, now you're up and running...

It's not sexy or new, but the book the Pragmatic Programmer is the bible on how to become a good programmer and not just a hack.

RE: How to build a web app - read Getting Real by 37signals, this will give you a nice high level approach. This is also a great introduction to agile development principles.

"but I never really have an itch to scratch" sounds like you're not brainstorming hard enough. Even in your post there's the seeds of many different itches. Find the most basic thing you trip over every day, and write a tiny tiny software tool to fix that problem.

Last but not least, sounds like you could use some more experience with front-end concepts. I recommend Bulletproof Web Design by Dan Cederholm as a great overview.

Technology moves too fast for anybody to keep up, just do your best and always keep learning! Good luck

The Pragmatic Programmer serves as inspiration for me every time I read it. I know everything in it, but somehow I always come away with at least one "I could totally be solving my current problem with this!" insight from a re-reading.

Code Complete, on the other hand, is a little more hit-or-miss. Some parts of it are still very relevant, like how to write clear, readable code. But other parts have been supplanted by better practices. The book tends to lean more towards waterfall development approaches.

Use programming adjacent tools that he is familiar with or wants to play with. Excel, html, no code solutions. This should be a low time investment but will either get him hooked or deter him.

Read some core books like "The Pragmatic Programmer" about general skills.

Pick up a friendly book like https://www.railstutorial.org/ for web development. I'm sure there are other similar books for other types of development.

Does anyone have any recommendations for finding interesting papers? Do I need to buy subscriptions? Is there a list of “recommended” papers to read like we have with programming literature e.g. The Pragmatic Programmer?

Something like React is the norm now. It's not necessarily any simpler or faster, but it's more efficient past N hours, which is the case for many larger companies.

It's also why functional programming has regained popularity, or at least writing functions the way you would for functional (immutable, output of one is the input of another).

However, we're still using a lot of old techniques. The best book on Design Patterns was written in 1997. Pragmatic Programmer was written in 1999 (though revisited a few years ago). The best TDD book is still from 2002; a lot of modern takes on TDD gets the philosophy completely wrong. TDD was meant to reduce fear, not improve test coverage.

In absolutely no way is this true, and if this is your view, you need to take a hard look at your future as a software engineer, which to be honest I'm not even sure you've ever been paid to write software with other people if you think what's in Pragmatic Programmer is common knowledge.

Your comment reeks of the classic attitude that comes with getting a CS degree (or some other STEM degree) and never actually working an hour of programming professionally. The fact is, programming jobs don't involve solving hard problems, for the most part, they involve perfectly executing on an already-solved problem, and in order to do that you need to ace a bunch of "soft skills". Not just understand, but ace.

Software engineering is not computer science, for the most part. Two entirely different groups of people do those things, and use two entirely different skill sets to do them. Your advice is not for the audience or author of this article.

I am so sick of the attitude your comment represents.

Generally, good software would have to be first defined and there's no universal definition. In most projects, I require it to have the following properties:
* New developers find it easy to ramp up on
* A handle on the defect rate (usually through adoption of best-practices like unit tests, fuzzers, automated tools, CI/CD, reproducible builds, etc).
* "Fires" infrequently enough relative to team size that it's manageable to accomplish your business goals.
* No "surprises" in adding new features/fix bugs where you didn't expect them.
* Meets business requirements today & can meet them tomorrow.

However, in other cases, like prototyping, "good software" means, "explores the problem space as quickly & cheaply as possible without worrying about any of those other things". Some of those other things can be useful in accomplishing this, especially if you plan to pivot from prototyping to the above definition. If you don't use them effectively then throw away your prototype before productionizing & start from scratch.

I kind of believe that, have I not read the book, I would have stumbled upon the ideas later anyhow, by reading blogs, tinkering, and making mistakes. Albeit, it is wrong to expect any magical words that can shift your direction completely, but still I am not sure how much value do printed ideas provide vs learning them by experience. I am not implying that books like it are futile but I don't buy that they are "career-changing".

Same goes for reading about Design Patterns. I believe it is better to learn "Design Patterns" by building and reading code and finding a certain code organization better for your use-case, rather than enforcing a kung-fu-singleton-ninja pattern where it might be simply an over-engineering.

Definitely check out "The Pragmatic Programmer"! There's definitely some good nuggets in there that helped me. Distinguishing full-blown prototypes vs. prototypical kernels that can be productionized, a.k.a. tracer bullet prototyping, is one.

Robert C. Martin, Clean code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsma...

Vaughn Vernon, various: https://vaughnvernon.co/?page_id=168

Steve McConnell, Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Cons... 2

Clean coder: https://cleancoders.com/ videos

Hunt and Thomas, The Pragmatic Programmer: https://www.amazon.com/Pragmatic-Programmer-Journeyman-Maste...

Hitchhiker's Guide to Python: https://docs.python-guide.org/

Dustin Boswell The Art of Readable Code: https://www.amazon.com/Art-Readable-Code-Practical-Technique...

John Ousterhout, A Philosophy of Software Design: https://www.amazon.com/Philosophy-Software-Design-John-Ouste... This one looks particularly interesting, thanks AlexCoventry!

Kent Beck, Test Driven Development: https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/...

Dan Bader, Python Tricks: The Book: https://dbader.org/

Ian Sommerville, Software Engineering: https://www.amazon.com/Software-Engineering-10th-Ian-Sommerv...

Svilen Dobrev, various: http://www.svilendobrev.com/rabota/

Users get to see something early on.

Developers build a structure to work in.

You have an integration platform.

You have something to demonstrate.

You have a better feel for progress.

As a solo founder I need working code, that I can put out of mind, while I produce more.

https://news.ycombinator.com/item?id=22022599

https://news.ycombinator.com/item?id=22022842

https://news.ycombinator.com/item?id=22022896

https://news.ycombinator.com/item?id=22022836

The author of this piece was not engaging in a DRY activity even if he thought he was. He (perhaps unwittingly) admits to it himself:

> My code traded the ability to change requirements for reduced duplication, and it was not a good trade.

The acronym DRY was coined in The Pragmatic Programmer, and the author of that book makes it clear that DRY is about not repeating requirements in code. You definitely don't want to deduplicate similar code if it involves multiple requirements because then you entangle yourself, which is what the author of this piece did.

https://pragprog.com/book/tpp/the-pragmatic-programmer

At my work, our book club is (re)reading The Pragmatic Programmer. There's a section which advocates picking one text editor, mastering its arcane secrets, customizing it until it's perfect, and never using anything else. All my colleagues happily agreed with this, and I couldn't quite express why I didn't.

Then I did a bit of pair programming with a few different people. In every case there was a significant learning curve just to follow what the driver was doing in their comfortable editing environment, and in the most customized cases, it was nigh impossible for me to drive at all.

So we relocated to my desk instead. I have a standard qwerty keyboard with vim, emacs, and textmate - all completely un-customized and ready to go. I couldn't care less which editor we use as I've learnt the bare minimum to be proficient in all of them. And importantly, so have my colleagues. Sure they grumble at not having their own autocompleting magic, but we can get our work done at a good enough rate, and either of us can drive.

(My previous work took this one (enterprise management style) step further and forced everyone to use the exact same model laptop, operating system, and editor. As a youngster I hated this required conformity. As a cynical old bastard I can see the logic...)

I definitely sit in the middle of the two camps. Not 'The Best', not 'The Worst'; just 'The Satisficing'.

[1] https://en.wikipedia.org/wiki/Satisficing

Still a worthy topic, still worth your time. As was mentioned about 'The Pragmatic Programmer', I think reading this works best once you have a few years of experience.

http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master...

This blog post doesn't express things nearly so well as the book, but the argument has validity.

Any if you can't find mentoring at your current position, try some books. My first mentors were Andrew Hunt (The Pragmatic Programmer) and Martin Fowler. Start with them, or find your own.

Code mindfully, go deep to understand every little detail of the code you write or read. Ask questions. A lot. Don't stop at the first draft. Don't stop a the first pass of questions.

Keep at it for a while. That one day you'll wake up with the feeling that the code you write yesterday was good. And hell if it's not a beautiful day to make it even better!

Get some CS background if you feel you miss it. https://teachyourselfcs.com/ gets one Hacker News every now and then.

Work on architecture/design. Try to understand design patterns for example. Be critical. Try to understand architectural decisions of the code you read.

Don't understimate the efficiency that comes with really being fluent with a language but do not give fluency too much credit either.

This is a lifetime journey. Improve step by step, little by little, every day. But improve mindfully. Get a direction. Get learning goals.

It's not a "try harder" it's juste question of better orienting the energy maybe.

That's my 2cents.

Good luck, I'm sur you can get, better you just need guidance.

The Pragmatic Programmer
Meta-programming at it's finest. Be a better programmer.

Joel on software blog:
Here's an example post.
http://www.joelonsoftware.com/articles/fog0000000043.html

There's quite a bit to learn in there.

Many other books available free online. Primarily I suggest you read to an end, and as you get to a stagnation point you alternate between reading to learn new technologies or languages and reading to improve yourself as a programmer.

As to your point about whether they wrote any books on 'agile' I think it could be argued either way. More specifically, whether or not "The Pragmatic Programmer" (the book they made their name with) counts as a book about 'agile' is an interesting question, and one that throws some light on the wider debate.

Although they sometimes talk about "pragmatic programming" as if it were a thing, in the same way as XP and Scrum, their approach was more one of giving a smorgasbord of potentially useful techniques and practices rather than codifying a tightly defined set of best practices.

Editors seem to raise a lot of religious issues, and not to totally discount the distinctions that can be made between them, but I think it's more important to know your editor well than to worry about "the best editor." (If such a thing exists.) As Hunt & Thomas say in The Pragmatic Programmer: "use a single editor well."[1] You'll be most productive if you learn your editor from head to toe, than if you half-assedly know several. That takes some effort and conscious practice, sitting down and memorizing key combinations and the like. And a cursory glance at any editor might leave you unimpressed until you've gotten somewhat fluent with its features.

Just a couple of suggestions if you do use ST2:

+ get package control: http://wbond.net/sublime_packages/package_control/installati...

+ For rails, a couple of nice packages are RubyTest and SimpleRailsNav

+ Learn the multi-edit commands

+ Familiarize yourself with cmd-P/ctrl-P (osx/win)

+ Keyboard shortcuts: WIN: https://gist.github.com/1925069 OSX: https://gist.github.com/1207002, or look at Default (OS).sublime-keymap

[1] I would amend that to add "and also know vim at least a little" for stuff like sshing in to servers and whatnot.

Learn design patterns, approaches to getting requirements, and how to read/create diagrams.

Learn how to write unit tests.

Learn source control tools and how to use them. If it's a command line, know how to do this from the command line.

Learn best practices for your language and get really good at your editor/IDE. (For instance, I use VIM with syntastic and pylint to check PEP8 compliance).

Learn to type quickly and accurately. This helps with everything.

If you've done those, enjoy your Summer! It's the last one you'll ever have :).

Some other things that would be fun:

- Set up a Docker image

- Write a REST API server in Python on a Linux OS

- Build in authentication, authorization, documentation

- Have Docker build and run your REST API server

- Set up a load balancer container to distribute load between multiple Docker containers

- Set up a shared cache like Redis or Memcache with containers

- Set up a MySQL Database

- Write unit tests for API

- Have Docker container automatically build, test, and deploy when you check in code

That will bring up a lot of questions of how you design things and how everything is tied together. Maybe you will just be working on a small part of this, but then you might know why things are done a certain way or how to do them better. That's where you can make a difference and distinguish yourself. You can bring a fresh perspective. Don't take anything for granted. Ask questions when they need to be asked. Learn how things can be improved.

I reread Pragmatic Programmer every year.

The other two you mention I find pretty poor, to be honest. I may reference them once in a while, but to really understand the topics they cover I'll rely on a well written, colorful article over those books.

In general I've found books written by more than 2 authors to be quite boring, impersonal, and oftentimes misleading.

Code Complete and Pragmatic Programmer are two of my favorites alongside C, and the Practice of Programming.

Caveat: I'm not a developer, so my comments about learning how to program should be taken with considerable skepticism. But I have some opinions based my effort to learn.

For me, programming syntax is less a problem for me than poorly organized code, poor grasp of problems and poorly thought out solutions. Design is a subtle and important topic that does not lend itself to the shorter coverage typical of internet material. Book-length immersion in the concepts is only a beginning to an understanding. So I think your "internet only" restriction is a severe constraint.

But it isn't as if there are many design books for beginners. These generally target people who've mastered some languages and know the design-problem space. "Pragmatic Programmer" was a big help.

I have found test-driven development an enormous help. It feels cumbersome, but you always know what problem you're trying to solve. "Test Driven JavaScript Development", Johansen, is an excellent overview of the approach. I'm also trying to work through Beck's "Test Driven Development By Example" doing the exercises in Ruby, but it's a side project that hasn't gotten much attention.

I repeat: I'm not a developer. Hopefully this is thought-provoking, but I'm no authority.

Personally I find I still frequently write pretty atrocious code on the first draft, and it's only by stepping back from the problem after demonstrating to myself I understand it well enough to solve it at all that I can begin to write a more graceful solution. But deadlines and reality being what they are, I think the majority of us are embarrassed by our past code a majority of the time.

So don't be too hard on yourself, but also frankly don't worry about shoe-horning yourself into "A Career" either. They're kind of a recent invention and the whole concept might need a few more iterations. You could spend a few years as a Product Manager, an Engineering Manager, a Highschool Teacher, or a Business Analyst, leveraging your past experience to gain competency in a new niche.

I want to emphasize of self-awareness you have is commendable and not universally present: If you can realistically assess your own current skill level and then apply yourself to improving, you could be an above average software engineer before you know it. And right now it seems like so so many companies just can't get enough software engineers, so it's a pretty safe place to practice learning how to learn while also earning a decent income.

https://letterstoanewdeveloper.com/

There are some other books covering similar ground.

From my book proposal and other research, here's a set of books/sites I'd recommend:

   * https://medium.com/basecs
   * New Programmer’s Survival Manual: https://pragprog.com/book/jcdeg/new-programmer-s-survival-manual 
   * Your First Year in Code: https://leanpub.com/firstyearincode
   * Code Complete (long and some parts aren't very modern, but very in depth)
   * The Pragmatic Programmer
   * Don't Make Me Think
   * Badass: https://boingboing.net/2015/02/27/kathy-sierras-badass-how-to.html
   * The core docs of whatever language you are using (don't underestimate the power of understanding the core libraries!)

This book contains some of the deepest programming insights I've encountered, to be put on the same level as SICP or the Pragmatic Programmer.

The discussions on naming and abstraction are particularly illuminating, exposing some fundamental tradeoffs like synthetic vs natural names, or principled vs adaptable systems of abstractions. Were these notions more widespread, a lot of the pointless rants and debates we hear in programming circles would disappear.

I would not recommend this book to beginners - this book is most useful when you are experienced enough that your struggle is to make choices, not to get things to work.

For instance, reading The Pragmatic Programmer and JavaScript: The Good Parts early-on changed my professional life irrevocably, both in terms of programming and career.

I am sure there are various other books like those that truly are impactful, and it doesn't hurt to look up recommendations for those from people who are experts / polymaths.

The case against wikis (with the exception of design docs) and blog posts is that they are erratic, restricted, unedited, stale, and low on pedagogical focus. Some of the books are meticulously structured-- there's no comparison.

But like others in this post I would recommend CS unplugged.

And depending on how long he is in there for he might want to look at:

How to Design Programs - This is a good book, and although it's in Scheme, it teaches how to create appropriate levels of abstraction, which seems to be something many programmers struggle with.

Concepts, Techniques & Models of Computer Programs - Discusses the different paradigms and how they are inter-related.

Also something a bit more vocational like The Pragmatic Programmer or Clean Code / Clean Coder probably wouldn't hurt either.

If he can read all of those he will be very well prepared to do some actual programming when he gets out.

SICP not a bad shout either, although I've not got past the first chapter.

IBM's watson, the best thing we got going for artificial intelligence, is it written in lisp? NO, it's written in java. The link from lisp to artificial intelligence is a lie. Lisp is just a very poor language, it's designed to get eager novices working on things that are irrelevant so they will learn (the hard way) that being a good programmer means laughing at the people who promote lisp as "an epic language". Lisp had its day, somewhere back in the 1950's/1960's. That day is gone.

If I'm working on any sort of problem needing a programming solution, and someone suggests we use lisp, I buy that person a copy of "The pragmatic Programmer", and tell them to read it closely.

Fooled by Randomness, Taleb

Linchpin, Seth Godin

"Working Effectively with Legacy Code"^1 is usually what I recommend instead. It felt like a more up to date approach

More generally "The Pragmatic Programmer"^2 is a classic for a reason. But from you're comment you've probably already read it.

1. https://amzn.to/2I4rIWP
2. https://amzn.to/2GfxVTa

2.

I don't really think that the people who left perl all went to PHP.

Now if only there was a "Ruby lite" that ran more like Perl 5 (skipping the GC for reference counting and a few other performance shortcuts)

I'm sure my use of Scala would disappoint the first interviewee, but it was an effective use-case for me. Use the index on the book to scan for likely topics, then round things out with Google.

I found the IDE support a bit broken in NetBeans (6.9). I suspect that the Scala plugin was incompatible with my vi/vim plugin, but I'm not sure. (it would go into a mode where the editing keys would stop working)

Related question: do you guys have a similar system for research papers? I've tried reading them a lot but have successfully made it through only a few. At this point, I even question if the effort in getting through their drudgery is worth it.

Longer answer: Basically, you need to get away from the world of front-end web development, and from the echo chamber blog posts and conference talks by people who have only ever worked in that area. No-one is writing anything large, high-performance, high-reliability or long-lived there yet, so you need to look for experience from people who have had to do those things in other contexts instead.

Classic books like Code Complete and The Pragmatic Programmer, early "serious OO" books like Design Patterns, and practical advice books of a similar generation in the Effective <programming language> style all contain a wealth of knowledge and insightful commentary. Of course some of the technical details are quite dated today and some of the specific techniques discussed might no longer be considered good practice a decade or two later, but many of the underlying principles and the discussions around them are as relevant as ever. A bit more recently, there were interesting discussions about a broad range of programming issues in Beautiful Code and the related titles, and there have been some interesting case studies based on open source software too.

If you want to read some shorter pieces online, I recommend finding a few authors who work in fields like games or embedded software, where there are often significant performance and reliability constraints to deal with, not to mention hard deadlines that force difficult decisions and compromises. There are some healthy doses of reality in there that you won't find in less demanding environments.

Enterprise applications, while often considered bland, can also be large and some of the longest-lived software we develop, and much has been written about organising and maintaining them, including real-world pressures like changing operating environments and large development teams whose members come and go. Perhaps a little ironically, this now includes a fair bit of back-end web development. Some of the writing around this is well worth a read as well, but beware that this part of the industry is plagued by consultants who talk a good talk but don't have much of a track record or other evidence to back up their advice. Approach with caution, particularly anyone who uses words like "agile", "lean", "craftsmanship" and anything else on the buzzword scale.

I am currently listening Designing Data Intensive Applications and it's phenomenally done - the author clearly worked with the narrator to adapt the content to audio format, and the narrator seems to have experience or familiarity with the subject because he pronounces the technical jargon very naturally.

I hope to find other software related audiobooks as good as DDAI is.

I fell into programming by accident at about 21, and I remember what it was like, it's much as you described. Fun times!

All the advice here is good, but nobody has recommended you read "The Pragmatic Programmer", which I found to be a bit enlightening. I still go back to it years later to read and ponder.

Good luck! You sound like you wont need it. It's a damn good career for those who enjoy it and are willing to put in some effort.

EDIT: I never did a CS degree, but considered doing it many times (if work dried up, it never did). I believe though that the people you meet and work with is a major part of doing a degree, so that'd be why I would go. I get to work with good people anyway. This article was posted on HN recently and I think is relevant:

http://sheddingbikes.com/posts/1275258018.html

I admit there are CS-type stuff I can't do (but I know where and who to ask) because I never did a degree. Saying that though, I have worked with people who have had CS degrees and couldn't code themselves out of a paper bag. If I were to go back in time to when I was your age, I'd do the degree, though.

The implementers of the legacy code aren't stupid. It's very common for junior programmers, tossed into the swamp of some codebase that's been around for years through many different hands, think the code is junk and the original implementers were fools. Usually, it's just that the problem is much more complicated than the juniors understand, and that's how the code got that way.

New tools probably won't solve the problem. There's a tendency with junior programmers to whine about the antique tools in use, convinced that the new Foobaz framework or Language X will magically clear up the issues they encounter. But the problems with code usually aren't from the tools used to build the code - they're from failure to understand the requirements, and time/scope/resource constraints on development.

Perfect isn't as important as finished. It's easy to get caught up in perfectionism. It's a good excuse to avoid releasing something you find embarrassing into the world. But the more time you squander polishing that turd, the less time you have for the next tur... er, cool new project.

If you can't write a test for it, you don't understand it well enough. Writing good tests is hard. It's easy to fall into a trap of "That's too hard to test. I'll just sort of check manually to make sure it works". This will bite you in the ass later!

(1) My first really good bug as a junior programmer actually was a "SELECT is broken" kind of problem (technically, mmap() was broken). I went to a great deal of effort to prove to the senior programmers (and then IBM) that my code was actually correct and I had an OS bug. And if some junior programmer came to me today and said a deep system call like mmap() was broken, I'd laugh at her and tell her to check her code. So sometimes, SELECT actually is broken - just not as often as junior programmers think.

Write code first. Write code until your programs collapse under their own weight. Then go out and read what the masters have written. You'll understand it much better when you have personally faced the problems that they were facing.

If you're going to write commercial software for a living, it's useful stuff to know (or be reminded of).

All of that is a long-winded way of introducing the suggestion that you learn to program by programming. The second-best is understanding others' programs (select well-respected, progressively larger codebases). Books, suggestions of which I hope others will provide, may give you some good ideas and thought patterns. "Software design" is a vast field with tons of completely obsolete advice, and terrible amounts of overengineering. Perhaps something like an agile workflow book, "The Pragmatic Programmer" once you can construct programs.

I learned it reading Armstrong's book from Pragmatic Programmers. It was a joy. I'm also reading the OReilly book, and it seems good as well, though I can't tell how it would be if I didn't know the language already. As for the titles-- one is Programming Erlang, and the other is Erlang Programming!

Applying Domain-Driven Design and Patterns was the book that made me fall in love with software engineering. Perhaps a little dated now though.

Head First Design Patterns - I never grokked any of the patterns from the GoF book, but this one 'clicked' for me, if you can get past the cutesy presentation.

Peopleware - Shows importance of focusing on people, rather than the tech, as this is often the main cause of project failure in the software realm (and perhaps others).

Having read it a few times since I think it falls into the same group of books as Mythical Man Month, Peopleware, and the Pragmatic Programmer where the earlier in your career you read it, the more you'll get from it.

Reading these books after 20 years of programming I found that I really struggled to find anything useful to take away from them.

It's not that these books are bad, or out of date. It's more that they exposed some new ideas at the time that, to the books credit, have been picked up and made mainstream or basic/required knowledge for the working programmer

But the main one is about the need for urgency.

One basic way to read these changes is that it just looks like Medium getting savvier about what drives and grows their subscription business. There's been no pivot there. The challenge for them still is to get their subscription business over the hump.

And the hump they have been at for awhile is that the subscription has been growing despite being generally meh quality. It's just $5 and a lot of people like supporting authors that way. But what are the ways to go from meh to great?

What I think Medium found is that they were getting better value by spending in other places. For example, I was part of bringing the back catalog of The Pragmatic Programmers books onto Medium. That was a deal that was relatively economical and had a direct hypothesis related to growing the subscription. For programmers now, at least, they have a nice headline for why a programmer would spend $5.

So to see Medium focus more on what's working to actually tip the subscription over puts me at ease because I still see the company has being in a zero to one situation. It could succeed, but it hasn't yet.

A similar effect can be found with Grit, Fogg’s Behavior Model, Superforecasting, and most Gladwel books.

On the coding side, I’ve only noticed this with Pragmatic Programmer, Clean Code, and maybe Phoenix/Unicorn project. Could I don’t read enough of those or they’re too focused on specific technologies instead of broad ideas … or I get too much of my technical reading from blogs and twitter. Those do get repetitive and you quickly find common patterns, but no titles to refer to.

http://www.reddit.com/info/6mikl/comments/

but it looks like you've beaten me to it!

I did create a listing of the most popular books mentioned on the comment thread, if you're interested. The following were mentioned by 4 or more people:

14 The C Programming Language

11 Structure and Interpretation of Computer Programs

8 Introduction to Algorithms

7 Compilers: Principles, Techniques and Tools

6 Programming Erlang

5 The Mythical Man-Month

5 The Pragmatic Programmer

5 Applied Cryptography

4 Beautiful Code

4 The Little Schemer

4 Programming Perl

more here: http://www.reddit.com/info/6mikl/comments/c04abpy

Maik Schmidt is the author of this book.

> Maik Schmidt has worked as a software developer for nearly 20 years and makes a living creating complex solutions for large enterprises. Outside his day job, he writes book reviews and articles for computer science magazines. He is the author of Arduino: A Quick-Start Guide, Enterprise Recipes with Ruby and Rails, and Enterprise Integration with Ruby for Pragmatic Bookshelf.

I also appreciate being able to browse the small selection of fiction/non-fiction at our local branch. As with the bookstore, I often pick up things I wouldn't dream of searching for online and would therefore never have found.

I likewise wish my library system had more of a "long tail" stored somewhere.[1] Older books (no matter how popular and well-known they were at one time) are often simply not available.

I had practically written off libraries when I was in my 20s:

* The hours didn't mesh well with my work schedule

* I could afford to buy whatever I was interested in

* They never had the up-to-date programming books I wanted/needed

That has changed completely now that I'm a parent. And yes, I do think libraries need books. Communities need books. This stuff needs to be available, even if just in principle.

I was skeptical but surprised to find that my local library system has one copy each of:

* Introduction to Algorithms

* The Art of Computer Programming (vol 1)

* The Pragmatic Programmer

But the list of computer science classics they don't have is far larger. What they do have are a ton of of titles like _Teach Yourself Visual Basic.NET in 21 Days_ (real) and _Excel 14.2.32.rev13 for Boneheads_ (made up). No doubt it reflects what patrons are requesting...but I would personally wish for a collection that leans a little more heavily on the perennial classics.

[1] http://www.dlib.org/dlib/april06/dempsey/04dempsey.html

It talks about what to do, in your life as a programmer, and how to approach it.

EDIT: http://www.codinghorror.com/blog/2004/10/a-pragmatic-quick-r...

The other important difference, and the reason there is always strong pushback when this topic comes up, is that many of us believe there is a subtext that people who spend a lot of time outside work on side projects are better employees. (I mean, it isn't even really subtext, it is in the text of the OP, and I've been reading the new edition of The Pragmatic Programmer, and it's in the text there as well.) If that view wins out (and in many circles it already has), then what you see as harmless, fun, and enriching side projects are actually a job requirement, one that is extremely hard for many of us to satisfy. So we (reasonably, I think!) push back on this view because we think we're good programmers and good employees without needing to spend our evenings doing solitary work away from our friends and families.

- How to design programs (http://htdp.org)

- The Little/Seasoned/Reasoned Schemer.

- Code: The Hidden Language of Computer Hardware and Software by Petzold

- Coders at work by Peter Seibel

- The Pragmatic Programmer by Hunt and Thomas

- Code Complete by McConnell

For intermediate/experienced people:

- Structure and Interpretation of computer programs (http://mitpress.mit.edu/sicp/full-text/book/book.html)

- Software Tools in Pascal by Kernighan and Plauger.

- Programming Pearls by Bentley

- Smalltalk 80: The Language and Its Implementation by Adele Goldberg.

- Paradigms of Artificial Intelligence Programming by Norvig

- A Discipline of Programming by Dijkstra

While I've ommited some important language specific books, and ignored essential areas (algorithms, discrete math, hw arquitecture), I think this is a good starting point.

2. The Pragmatic Programmer -- a classic. Reminds me that I need to re-read it.

3. Effective Oracle by Design, by Tom Kyte -- Not that I use Oracle any more, thankfully, but really provided a lot of insight about how databases function and how it pays to deeply understand their internals when writing webapps.

I would recommend getting a copy of both of them, but you might want to check out the online version of the O'Reilly book before buying it:

http://programming-scala.labs.oreilly.com/

The Pragmatic Programmers book is not bad either, but it's only a short introduction to the language compared to the other two books mentioned.

All three books have nearly identical titles: Programming (in) Scala

Code Complete: http://cc2e.com/

Introduction to Algorithms (google that one, it's hard to find a good link)

Domain Driven Design: http://domaindrivendesign.org/books/evans_2003

Design Patterns: Elements of Reusable Object-Oriented Software

The term "web development" doesn't mean much. There is web design. There is application development. When the two mix, there is web application development. Any kind of application development is hard, and simply knowing a language or two isn't going to make you a good application developer any more than knowing english will make you Stephen King. (IMO)

You can get learn a lot building your own apps, but then you're forced to learn some lessons the hard way. Sometimes you can avoid making mistakes by learning from someone with years of experience. You don't need to take a course, but reading can help so much. Books like The Pragmatic Programmer, Code Complete or Literate Programming can set a good base for thinking about your code.

Also to address the how self taught programmers get jobs, it's worth pointing out that the first question was from a 17 year old. I'd say it would be tricky at that age to get given a chance by an employer. So with time and age their employ-ability should increase as a factor of age alone.

I immediately thought of his metaphor with the woodworker and his toolset, that needs skills build on it, as well as the working material.

Some books are references and some are read throughs. I read Code Complete while in college and thought it really helped my programming. Effective Java is another great book that I've read. The Pragmatic Programmer is another one that I've read that really is worth the time.

Many books are just good references though. Pick it up and read a chapter for example. I think the more experience a programmers gets the less they need to read right through a book. When looking at a book on a particular language I can usually skip the first half because I know the parts that are common across most languages. I only need to know what's different/cool/idiomatic in this particular language.

Algorithm books are another example that falls into mostly the reference category. I don't think I've read any entire algo book, but I have read many chapters from many different algo books that touched on what I needed to learn at the time.

Given this, there are some books you might add or remove depending on the area you are interested (e.g.: Knuth's "Art of Computer Programming", Martin Fowler's "Patterns of Enterprise Application Architecture", ...)

To finish, 2 books people recommend a lot for beginning programmers:

"The Pragmatic Programmer"- Hunt, Thomas: a very good book, with sound advice and very easy to read. The only bad side is that it became so influential that its ideas became vulgarized in thousands of blogs.

"Code Complete" - Steve McConnel : A very dangerous book. It does give have a lot of sound advice. But, IMO, it has some big problems. First is that it gives the false impression that there is a lot of empirical evidence on what works on software engineering. Second, it perpetuates some myths that don't have such evidence: the "orders of magnitude programmer's productivity" and "the cone of uncertainty" (see: https://leanpub.com/leprechauns).

A few classics that focus on improving "general code style" would be:

- "Clean Code" (https://www.oreilly.com/library/view/clean-code-a/9780136083...)

- "The Pragmatic Programmer" (https://pragprog.com/titles/tpp20/the-pragmatic-programmer-2...)

EDIT: Since you are talking about coding like at a top company, one book that has been sitting on my shelf for a while, but I haven't gotten around to reading yet is "Software Engineering at Google: Lessons Learned from Programming Over Time" (https://learning.oreilly.com/library/view/software-engineeri...)

The Pragmatic Programmer (Andrew Hunt)

Cashflow Quadrant (Robert T. Kiyosaki)

I think more people read those books and say, "yes, I agree with all of this already" than read them and think, "oh, here is a new thing I haven't thought before and will use from now on."

From a technology standpoint, "The Pragmatic Programmer" changed the way I looked at programming. When I read it the first time, I was a Visual Basic programmer, with only a passing familiarity with the world outside the Microsoft ecosystem. After reading that I began to explore Perl, then Python, and installed Linux and learned it. For my career as a developer, then team lead, and then manager, that book changed me more than any other book I've read in the field.

Is it worth reading JS based software engineering / design books, as compared to Code Complete or The Pragmatic Programmer?

double f( double x ) { return 1/ x; }

They pointed out that it is trivial to get 100% coverage in test cases but unless your tests include passing in 0 as the parameter you are going to miss an error case.

I started doing this after reading "The Pragmatic Programmer" where it's argued that the DRY principle should apply to everything including documentation.

It starts with the bug tracker. So when entering something in that I'll also add the text that I want to appear in the changelog for the user to see (these lines will have a // at the start).

When a bug/feature is completed a commit is made and the text in the bug tracker is the commit comment.
If the commit comment has a line starting with a // then that line will have another line inserted above it //Bug fix: or // Feature:

Finally on building the distributable the changelog is constructed entirely from the lines in the commit messages that start with //

Bowden, Mark (2011) Worm: The First Digital World War

Brooks, Frederick (1995) Mythical Man-Month, 2nd ed.

Christensen, Clayton (1997) Innovator's Dilemma: When New Technologies Cause Great Firms to Fail

Hafner, Katie and Matthew Lyon (1996) Where Wizards Stay Up Late: Origins of the Internet

Hunt, Andrew and David Thomas (1999) Pragmatic Programmer

MacCormick, John (2012) Nine Algorithms that Changed the Future

McConnell, Steve (2004) Code Complete, 2nd ed.

Mitnick, Kevin and William Simon (2002) Art of Deception

Poulsen, Kevin (2011) Kingpin: How One Hacker Took Over the Billion-Dollar Cyber-Crime Underworld

Raymond, Eric (2003) Art of Unix Programming

Stone, Brad (2013) The Everything Store: Jeff Bezos and the Age of Amazon

Torvalds, Linus and David Diamond (2001) Just for Fun: Story of an Accidental Revolutionary

Wallace, James and Jim Erickson (1992) Hard Drive: Bill Gates and Making of the Microsoft Empire

Williams, Sam (2002) Free as in Freedom: Richard Stallman's Crusade for Free Software

Wilson, Mike (1996) The Difference between God and Larry Ellison: Inside Oracle Corp

Saying that whoever recommends Code Complete made some wrong life choices is a bit rude and uncalled for. Books are just tools, the benefits they bring depend on whether the reader goes through them in a smart way or not.

Then again, but this is a matter of taste, I would suggest The Pragmatic Programmer as a first read. It's shorter, well-written and with laser-like focus on the topic at hand.

Lastly, since designing and writing software is as much of an art as it is science, what's really important is to avoid reading passively and blindly applying anything the knowledge one finds in a book, and instead strive to understand why, and going against the grain and see why certain practices are called "best".

I didn't get much out of The Pragmatic Programmer myself. Maybe if I'd read it ten years earlier, it would have been my Code Complete.

Code Complete is a fine book. The Pragmatic Programmer is okay. But neither book holds a candle to Introduction to Algorithms for career-long usefulness. For that matter, neither one holds a candle to Design Patterns for the ability to expand your mind and improve your ability to think about code (I read both at the same time, and Design Patterns is the only one whose lessons I remember distinctly, years later).

I think the main problem here is that the easy, mechanical reads get more votes than books that are harder, but more valuable. It's the technical equivalent of a lolcat photo.

Avoid pop finance books that is light on numbers. If you want to understand the qualitative aspects/culture/history, books like Flash Boys or Flash Boys: Not so fast are more than sufficient. Stay away from "technical" books that are designed for layman and non-technical readers. They will handwave Black Scholes and economic math and you will simply be going through the movements without truly understanding.

Books like Reminiscences of a Stock Operator are great secondary books to supplement your primary readings. You don't give a beginning programmer Pragmatic Programmers/Clean Code/Programmers at Work when he or she can barely write a hello world, let alone a quicksort. You want a intro to programming course followed by something like SICP to lay in the foundations of abstraction and computer science. It is the same for finance. Half of the books in this thread are either financial pop science or has little relevance to somebody who wants a rigorous understanding of how the stock market system works.

Also to note, Buffet and A Random Walk Down Wall Street are books that espouse certain schools of thought on managing portfolio. Judge them by their history and backtest their theories rigorously. It is like Object Oriented Programming, fads wax and wane with time and everyone has their opinion on how trading should work so take things with a grain of salt. Lastly, trading and managing a 10 billion dollar fund is quite different from e.g. 100k in your tax free social security account due to stuff like network effects and doors that can only be opened when you have enough zeroes on your spreadsheet so what's good for the goose is not always great for the gander.

Once you are done with stock markets, get a macroeconomics textbook to understand how it ties into the federal reserve (or central bank) and how government bonds affect liquidity, that sort of thing. Again, avoid pop science books which shows up way too often on HN (this is worse with biology, another subject that this forum has a poor grasp of).

If you'd like to learn best practices, check out Hunt & Thomas' 'The Pragmatic Programmer' (http://www.pragprog.com/the-pragmatic-programmer).

To get up to speed fairly quickly on what's going on under the hood, check out Petzold's 'Code' (http://www.charlespetzold.com/code/) and Nisan & Schocken's
'The Elements of Computing Systems' (http://www1.idc.ac.il/tecs/).

That said, I've still used it for my research ... although I can often find other sources that say things better, CC2 has made a good starting point for ideas on how to present ideas about code.

* good engineering practices (as all those described in books like "Pragmatic Programmer" and "Code Complete": code reviews, unit testing, continuous integration, coding standards)

* tools worth respect (e.g.: subversion, git or mercurial but not Visual Source Safe)

* a well defined development & project management methodology, agile or not (e.g.Scrum, RUP), instead of clueless project managers.

* a concrete problem/puzzle in the company website to filter out bad candidates

* respect for the developer private life; i.e: what to expect in overtime work

As I learned erlang and OTP I kept finding design choices I really appreciated.

The pragmatic programmers book on erlang was written by the creator of the language and I think is one of the better programming books ever. Clearly he's spent several decades teaching this language to perplexed students, cause he found the right way to illuminate it.

1) The Mythical Man month

3) The Pragmatic Programmer

3) Code Complete.

The thing about these books, well atleast 1 and 3 is that when they were written they broke new ground. Or if that phrase bother you, they were the first mainstream publications that brought their core ideas to developers.

Reading these books early in your career will help cement these best practices.

Reading these books after you've been a practicing programmer means,IMHO, that the return you get from reading them goes way way down.

You'll find that you've already learned all/most? of what they are trying to teach.

You'll find yourself getting frustrated that they are preaching what you already know as common sense and first principles.

Or put another way, I'm not sure there is much that someone who has programmed for 5-10 years can get out of those books that they haven't picked up somewhere else already or learned the hard way.

Here are a few portions of his method that I always come back to:

---

Understanding the problem:

- What is the unknown?

- Draw a figure. Introduce suitable notation.

- Separate the various parts. Can you write them down?

Devising a plan:

- Have you seen it before? Do you know a related problem?

---

You can see the whole method at this link: https://imgv2-1-f.scribdassets.com/img/document/68994766/ori...

I use this approach in conjunction with an A4 piece of paper, or a note program capable of "outlining" functionality (expandable nodes). The latter works great for containing and structuring lots of information, and you can selectively show and hide different parts depending on what you're focusing on. Again, helping with filtering out the "noise" factor.

Another good approach is falling back to a plain-text editor such as Notepad.exe when you want to write anything down. I got that tip from the Pragmatic Programmer book. You can easily extend this to Markdown if needed.

I realized there had to be a better way and so I went straight to the library and read up on the software engineering of the time ("structured programming").

Since then I've read a lot on the practice of programming and applied it to my programming. And kept reading and applying stuff; the key here is to never stop learning.

Studying good software was probably the other major way. Back then, it was learning the UNIX V6 kernel with Lions' Commentary on UNIX 6th Edition, with Source Code plus reading the sources of all sorts of things and working on some of them.

If you haven't read The Pragmatic Programmer, AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis, something by Gerald Weinberg and something by Tom DeMarco and Timothy Lister (Peopleware is pretty much required reading), and The Mythical Man Month I strongly recommend them.

The recent Coders At Work is really good, although at a somewhat higher level.

My other recommendation is to get serious knowledge of other domains that have useful ideas and metaphors; for me that would be science in general and biology in particular.

Hmmm, reading a lot of classic SF (from the '40s on) and studying nanotech also helped. You want to have a big bag of problem solving tricks.

It also helps to gain a top to bottom understanding of how it all works. There are many approaches and books for this, I like The Structure and Interpretation of Computer Programming (SICP) for the higher level stuff, but also be sure to study some EE, digital design and low level architecture. And operating systems.

And if you're at all good with your hands, build (assemble) yourself a computer and get UNIX/Linux running on it. Design and implement a network with routers and static IP addresses or something like that. Etc.

I find that these two books are in many recommended lists, but I found them entirely unforgettable, entirely too long, and without any "meat."

So much of the advice given is trivial things you'll just figure out in the first few months of coding professionally.
Code for more than a week and you'll figure out how to name classes, how to use variables, how scope works, etc.
The code examples are only in C++, Java, and Visual Basic (ha!). Completely ignoring non-OO and dynamic languages.
Some of the advice is just bad (like prefixing global variables with g_) or incredibly outdated (like, "avoid goto"? Thanks 1968!).

Work on a single software project, or any problem ever, and you'll know that you need to define the problem first. It's not exactly sage advice.

These are cherry-picked examples, but overall Code Complete manages to be too large, go into too specific detail in some areas, while giving vague advice in others.

All books are written in a time and a few become timeless. Software books have an especially short half-life. I think Code Complete was a book Software Engineering needed in 2004, but has since dropped in value.

I will say, that Code Complete does have utility as a way to prop up your monitor for increased ergonomics, which is something you should never ignore.

I have similar issues with Clean Code. One is better off just googling "SOLID Principles" and then just programming using small interfaces more often and use fewer subclasses.

A better alternative is (from above) The Pragmatic Programmer (2019), a good style guide, and/or get your code reviewed by literally anyone.

What I do find useful is listening to books on practice or management. Something like The Pragmatic Programmer, The Practice of Programming, and Clean Code. These are high on substance but (relatively) low on examples, so I feel I can still benefit from their insights without having to be in front of a screen.

If you think of orthogonality in geometry, you can describe any N-dimensional vector space through a set of N orthogonal vectors (say the unit vectors in X, Y, Z). "Orthogonal" in this case means that moving something along one of those (say the X axis) won't alter its position from any other base vector's perspective.

In the same way, "orthogonal implementations" is a way of saying that the things are independent from each other. You can find their explanation in the Google preview for the book [1].

So, say you write utility code for a couple of applications, for example: Message transmission and subscription management. Then, you should try and keep both as independent as possible from each other, so that as a downstream user I won't have to pull in or even "massage" both just to use one of them.

As I wrote before, that sounds totally obvious when said out loud; yet I constantly find new examples where someone found a way to unnecessarily "complect" [2] multiple things.

[1]: https://books.google.ch/books?id=LhOlDwAAQBAJ&pg=PT70&dq=ort...

[2]: If that word also seems strange to you, I highly recommend watching https://youtu.be/oytL881p-nQ

If changes to the implementation of String could cause issues for you, you really should be using a custom solution anyway. A quick and dirty option would be to write a wrapper class which uses all of your preferred String hacks in a central location, and using that in place of String throughout your code. When String's implementation changes, you can update your hacks all in one place.

Here is some relevant advice from The Pragmatic Programmer: https://pragprog.com/the-pragmatic-programmer/extracts/coinc...

Owning two types of cars (or a car and a motorcycle) maybe a more helpful metaphor than horse and buggy vs car. The Pragmatic Programmers release all their books as non drm-ed pdfs and you can buy both the electronic copy and the pdf if you choose. They seem to do well.

But yes, the kindle is very underwhelming, I'll for a better reader without DRM (or at least hackable DRM).

    The Pragmatic Programmer
    Clean Code
    The Clean Coder
    Domain-Driven Design
    Growing Object-Oriented Software, Guided by Tests
    Continuous Delivery

I've read The Pragmatic Programmer on a 10 hour flight and I fell asleep 2 or 3 times, because it was freaking boring. Beginners might get some value out of it, but it's all common sense stuff that you learn in the first couple of months on the job.

Everybody has some of these books in their bookshelf, including other classics such as the Art of Computer Programming. What I find interesting is that few people read these books, either because they are boring (the soft-skill ones) or because they are really hard to follow (AOCP), but keeping such books in your bookshelf is like a rite of passage. You can't call yourself a programmer if you don't have a couple of programming books in your bookshelf that you've never read :-)

To switch from framework learning to soft-skill books doesn't feel like much of an upgrade. If you want to learn something with long lasting value, learn actual computer science.

This means algorithms and math.

It also means exposure to paradigms like functional programming, or logic programming. I recommend Haskell, not because you need to learn yet another language, but because the knowledge ceiling in its ecosystem is really high and it's the current lingua franca for papers on functional programming.

Also some technologies are longer lasting than others. POSIX for example is still with us. The architecture of CPUs has evolved, but the basics of how a CPU processes instructions and accesses memory are the same. Frameworks and libraries come and go, but the fundamentals of concurrency, parallelism, asynchrony remain the same. Etc.

Some people are inevitably going to recommend The Art of Computer Programming, which hardly anyone has read and isn't that relevant to the work that 99% of us are doing.

Someone will probably recommend The C Programming Language, also called K&R after the authors, but again it's not very useful unless you're going to be using a lot of C and even then I personally don't think it provides anything you can't get from guides on the internet. (I have actually read this one, but it's been a while)

There are other classic textbooks that will probably be mentioned that are only useful to those in that domain. Many of us can get by without a deep understanding of algorithms and data structures, most people don't need to read a compiler book, etc, etc.

However, there are some generalized books that people often recommend like The Pragmatic Programmer and Code Complete. These are, in my opinion, good recommendations if you're looking for something to read but I wouldn't say that someone starting a career in software engineering should read them. Software engineering isn't really a field with seminal texts that should be read by everyone.

For example, every political scientist should have probably read The Republic by Plato and Politics by Aristotle among many other texts. I don't think software engineering has that equivalent, partially due to the relative newness of the field and partially because the primary output of our field is not written texts.

Another interesting question would be "What codebases should someone starting their career in software engineering look at?". Are there things that the average joe programmer can learn by poking around the Linux kernel or Firefox? Maybe. I don't know. I've never done it. I'd be interested in hearing from those who have, though. Maybe I'll do my own ask HN.

edit: I feel I should clarify that this is written from the perspective of a software engineer, not an academic in computer science. For all I know there could be seminal texts that those on the academic side should all have read.

I read Code Complete 2 after developing software for maybe 6-7 years in an environment like this. Much of it was obvious, but the rest was a revelation. Same with The Pragmatic Programmer.

Several years later I read a book called "The Passionate Programmer", which was like the book described in this article - soft, career development skills. That was probably the most important book I've ever read. In fact it's how I found out about Hacker News in addition to a whole bunch of different books. It lit a fire in me.

4 years later, I have a career that is so dramatically different I don't even know where to begin. On the same token, I reread that book (Passionate Programmer) recently and it does seem like common sense I would absorbed over time from things I read on HN.

All the "engineer"-ry things like constructing testing oracles or understanding code complexity this can all be found in Programming and Programming Languages https://papl.cs.brown.edu/2020/ that uses Pyret which has similar enough syntax to Python none of your bad engineers will be lost. There are lectures for it too: https://learnaifromscratch.github.io/software.html#org4eef4d... you could teach this class to them the lectures really teach you concepts like trees and graphs and how to reason about them.

Would you hire a graduate who wasn't inclined to spend their time learning about version control, bug tracking or release management systems (all of which are part of the ITIL standard) ?

A lot of ITIL isn't that much different from what you find in Code Complete or the Pragmatic Programmer books on deployment. Just because you prefer your buzzword to their buzzword, doesn't mean it's any more important.

If this advice is to be taken seriously the only editors you can learn is vim and Emacs.

Shiny editors like Sublime Text come and go every 2-3 years. And putting effort learning them, only brings you back to your statement: "You'll be most productive if you learn your editor from head to toe, than if you half-assedly know several."

These books will teach you how to think and approach coding in a way that will make Object Oriented programming simpler to comprehend.

I can't suggest a book that explains basic OOP principals, hopefully some other much smarter person here can. I learned basic OOP through practice and through my education/class - but to be honest the basics are dead simple. It's only when you start getting into the very abstract that OOP starts to get really complicated and that's where the above books will help you.

One I'd recommend is "Eloquent Javascript". It may be a tiny bit out of date now (I read it over 5 years ago maybe, and Javascript has improved a lot since then), but it's a solid book.

Other books you might like: Pragmatic Programmer, Pattern on the Stone, Clean Code, Mastering Regular Expressions.

Learn who you are, what you enjoy, and where you want to go with your career. Technology stacks change more often than I buy new shoes. Is that a reflection on the technology or the shoes?

I see Mobile development, web dev, FP, and devops technologies in your list. What excites you?

Instead of specific languages, what about learning new concepts? Learning about functional programming will change how you program in other languages. Studying algorithms will change how you think about efficiency. Reading books like "The Pragmatic Programmer" or the classic "Mythical Man Month" will give you a bit of a higher-level understanding of what it is we do.

This is only one of these "must-read book list", what you can do is search several of them and see which ones are quoted by almost everyone!

About "everything" I would rate the following books very highly, for their sheer usefulness:

- Thinking Fast and Slow (really do the exercises!)

- then Neuroleadership which describes the purpose of brain structures, it's somehow wider than kahneman

- A Mind for Numbers (include very useful data points for knowledge workers)

- Distinction: A Social Critique of the Judgement of Taste

- Cutting Through Spiritual Materialism

About programming I would rate the following books highly, but at the same time it seems a bit fruitless to me to read about programming, rather than spending more time reading about psychology or sociology:

- the Economics of Software Quality

- Peopleware

- Pragmatic programmer

- Mythical Man month

^you'll see that these books are hardly kept secret, it's just that people quote them but don't actually read them, or so it seems.

I figure out what needs to be done in order to get something to work reasonably well, and if I can’t do it myself I google it till I find snippets of code that mostly do what I need, then I modify them and hack around till I get something that works decently enough.

To me this is a much bigger problem than your ability to implement a linked list or describe big-O notation -- I'd be worried that I'd always be cleaning up after your messes.

The good news is that this is a solvable issue. Start collaborating with people, maybe via open source. Find a project of yours that's useful but maybe not profitable, open source it, and start handling requests for features and submissions. Learn how to deal with bad incoming code, and how to deal with your code being confusing to other people. Maybe read some of the classics on code as collaborative effort, like the Pragmatic Programmer or Clean Code.

Or maybe just decide that this isn't for you! There are lots of jobs oriented around achieving specific goals with throwaway code that you might be happier in than being a slave to the CI server, and they aren't less valuable. But if you want to be hireable in a code-oriented company, I think you have to change some things.

The books I enjoyed the most were Richard Stevens' Network Programming and Unix Programming books. Those books teach you a ton of things while helping you implement something useful. They were very hands on. I haven't been able to find anything similar in a long while.

Anyhow, I expect we'll get the usual round up here. Code Complete, of course; plus a smattering of rebels who think it was boring or irrelevant. The Pragmatic Programmer will receive universal praise, especially from those who didn't take the time to read Code Complete from cover to cover.

Some of the debate will be about whether Code Complete is "better" than Clean Code or not. A silly argument, they are complementary (though, really, is this even a debate worth having? Code Complete is clearly the better book).

Let's see, what else?

Structure and Interpretation of Computer Programs will get mentioned, which will spawn a fertile subthread arguing about whether computer science books really belong on a list for developers. That subthread will debate the merits of Introduction to Algorithms vs everything else, and someone will mention a lisp book that changed their life. Probably Paradigms of Artificial Programming or On Lisp.

The Gang of Four will get nodded at. Like the Bible, Homer, or Peopleware it will be the book everyone says they've read but which almost nobody has actually read.

The C Programming Language will be mentioned. These days that means Zed Shaw will be named and hilarity will ensue.

Myself? I'd definitely have Code Complete (I still have my first edition), perhaps A Discipline for Software Engineering and Software Estimation: Demystifying the Black Art. I've found pretty much everything from Dorset House to be worth my time, so to PeopleWare I'd add The Deadline and Adrenalin Junkies and Template Zombies.

What we don't do in this industry, however, is read more widely. Get out of your rut. Read about history, read some classics, read deeply in another field you pursue as your hobby. Everything illuminates everything. Get out there, see the intellectual sights (for which, get a copy of Dawn to Decadence by Jacques Barzun for a guided tour). You'll be a better developer and a better person for the trouble.

I feel like Pragmatic Programmer would be a good book to read before starting your first job, or maybe your undergraduate year of college.

I was going to start Code Complete next, but Pragmatic Programmer was so disappointing I decided to read fiction for the next few weeks instead.

So to answer your question, the best language agnostic development books I've read are:

1. Joel on Software: And on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and Managers, and to Those Who, Whether by Good Fortune or Ill Luck, Work with Them in Some Capacity

2. The Best Software Writing I

3. Hackers and Painters

I always wish Joel would come out with a second volume of #2, or to start his blog up again. I've yet to find something that equals his quality since he stopped writing.

I've read The Pragmatic Programmer, and early-on, it mentions "broken windows" principle -- fix errors as soon as you notice them, or else they'll get more difficult for you to fix as time goes by. And like broken windows are like a green-light for a neighborhood to decline, unfixed hacks similarly invite poor quality code.

In practice, do "working" and "working well" end up being sort of the same as suggested by the broken windows principle? Or Is "make it work" refer to making a quick prototype, and "make it right" refer to filling out substantial functionality?

Nearby shelf:
The Design of Everyday Things,
Maverick,
Founders at work,
A Brief History of Time,
A Pattern Language,
Peopleware,
Made to stick,
Web Standards Solutions,
Designing Interactions,
The Pragmatic Programmer,
The Mythical Man-Month,
Oh, the Places You'll Go!

Other good reads:
Blink,
Tipping Point,
Long Tail,
Freakonomics

Andy once worked on a large graphics application. Nearing release, the testers reported that the application crashed
every time they painted a stroke with a particular brush. The programmer responsible argued that there was nothing
wrong with it; he had tried painting with it, and it worked just fine. This dialog went back and forth for several days,
with tempers rapidly rising.
Finally, we got them together in the same room. The tester selected the brush tool and painted a stroke from the
upper right corner to the lower left corner. The application exploded. "Oh," said the programmer, in a small voice,
who then sheepishly admitted that he had made test strokes only from the lower left to the upper right, which did not
expose the bug.

Then I started reading books on skills I wanted to acquire (i.e. Traction for marketing and SPIN Selling for sales).

All of those books lead to recommendations into other books.

Listening to podcasts that recommend books increase the breadth of books I'm reading.

My wife brings home books from the library and I read whatever she reads (i.e. Hillbilly Elegy and The People vs Democracy), and those lead to other nonfiction books I become interested in. And then there are the "classic" novels I interleave from time to time (i.e. Siddhartha and Meditations).

It just starts with maybe a handful of books you are dying to read, try to read for 15 min before bed, and before you know it, you're 50 books into the year!

About a year later (summer 2007), I got a job working for a ticket search engine called Tickex, doing Rails. I was paid £9 per hour, and worked at a BBQ table and chair. It was a really enjoyable time. we were Seedcamp finalists and nearly got funding from Sequoia, but sadly the funding ran out and the business moved back to California and then shut down. Since then, I've worked at a few other startups, at a web agency called New Bamboo, at AOL, and now I work in a small business. I also had offers to interview at Square and Facebook, but a temporary lack of nationality/family circumstances meant that I couldn't move to California.

The decision to deviate from the path offered by my degree has been one of the best in my life. Before I had learnt to program, I had ideas but no ability to program, so they remained as ideas. Having learnt to program, I have the ability to have ideas and do something about them.

McConnell, Steve. Software Project Survival Guide. Redmond, WA: Microsoft Press, 1998.

Maguire, Steve. Writing Solid Code. Redmond, WA: Microsoft Press, 1993.

Ranade and Nash. The Elements of C Programming Style. New York: McGraw-Hill, 1992.

Kernighan and Plauger. The Elements of Programming Style. New York: McGraw-Hill, 1982.

Caner, Cem, et al. Testing Computer Software, Second Edition. New York: Wiley Computer Publishing, 1999.

Hunt, Andrew, et al. The Pragmatic Programmer. Reading, MA: Addison-Wesley, 2000.

Holub, Allen. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming. New York: McGraw-Hill, 1995.

- Link the name to a list with all the recommendations by that person, use the date for a link to the place where the recommendation was made (using the date for a permalink is convention).

- Link tags.

- Show everyone who recommended something and sort by how many people recommended it. (For instance The Pragmatic Programmer is recommended by Joel Spolsky, Steve Yegge and Jeff Atwood.)

- Use Amazon Affiliate links to make money.

1) You'll likely get better/more response if you prefix your post with "Ask HN: " (lots of folks have triggers for that type of thing)

2) You don't have to be a mathematician to be a good programmer. Tons of great programmers were not comp-sci majors so don't let that sort of thing get you down. If you've done "some basic noodling here and there... in a few languages" and you want to improve as a programmer, I'd advise you to:

   - Pick a language
   - Pick a pet project
   - Buy a few books or take a few online classes that are on your chosen language
   - Begin reading the book
   - Implement your project while reading the book
   - Find some sample apps written in your language and review how they did things differently
   - Finish your book and buy another book/class that is specific to your language
   - Pick a new pet project and implement it
   - Review some open source apps written in your language
   - Contribute to some open source apps

   * The Pragmatic Programmer
   * Code Complete
   * Head First Design Patterns
   * The Mythical Man-Month
   * Design Patterns: Elements of Reusable Object-Oriented Software

Next up: build a startup!

Notice there are no math books in my list. This is different from what others would propose but, given the scant description you wrote, I don't see any need for math except to satisfy a possible desire to learn.

I also don't think that the format matters more than it's use.

Reminds me of some good advice in The Pragmatic Programmer, should be
(simple) text-files for editing and (regardless if one or multiple files), a single source of truth (e.g. if multiple files, not the same time the same data to edit in). This is roughly as I remember it and I found it always useful to apply.

If I see duplication, it's about fighting the rot and remove it.

If configuration files are generated, they don't belong under version control (there are some exclusions to this rule, e.g. pinning dependency versions for example when shared with the repository).

Plus, with a digital version like epub, I could change font size and let it reflow, change the colour theme to sepia in Apple’s Books app or Calibre, and it would still be beautifully formatted.

I'm aware you expect some quick tips from HN though. Have a look at my old blog posts that summarize these books. While 3 years old and written in Polish, Google translated it very well. Direct links to the translations: https://bit.ly/1oZiidn and https://bit.ly/1w8ELhY.

Another big helper (which works well when you're already in Emacs), is to type in and test code examples, and force yourself to solve/work all the exercises/problems given.

A couple of last things to look up: the PQ4R strategy and SQ3R strategy. I've heard these are taught in England; I really wish they would teach it here in the states early in public school.

Already mentioned is Code Complete and The Pragmatic Programmer. I'd add The Mythical Man Month, still a classic, but note that's a relatively short book and may not last long enough. (A depressing read in some ways; decades have passed and what's in the book is arguably common wisdom, yet I still encounter the errors outlined in that book every year.)

Godel, Escher, Bach (mentioned by caffeine) is a love it or hate it book; check out a couple of summaries and see what you think.

Personally, I don't recommend the SICP unless you're actually working through the exercises to some extent, and without a computer it's too easy to think you understand it when you don't.

If you have already read all those, well, I'd suggest replying and saying so. :)

Off-topic: what books do you recommend on chemical engineering? What's the equivalent of The Art of Electronics for analog electronics, or HDL Chip Design for digital chip design, or Code Complete or Algorithms in C or CLRS or The Pragmatic Programmer or SICP or TAOCP for software?

The Pragmatic Programmer's ebooks, from their site, are all non-DRM, on the technical side (I think a number of other big technical publishers do non-DRM on direct-from-publisher ebooks).

(On the fiction side, I know Baen has included CDs of DRM-free ebooks -- mostly the all-but-most-recent books in major series -- with hardbacks, and also allowed them to distributed on the web.)

Business & Management

1. Innovator's Dilemma and Innovator's Solution by Clayton Christensen

2. Built to Last and Good to Great by Jim Collins. Built to Last is more applicable for startups.

3. Mythical Man Month by Fred Brooks. Anyone who has to manage a team of programmers and hasn't read this will fail utterly, unless they've already failed before (or been on a failing team). There's a lot that's counterintuitive about software project management.

4. Peter Drucker's work. Kinda long and repetitive, but some good insights.

Marketing

1. All Marketers are Liars by Seth Godin. I like this better than Purple Cow, Guerilla Marketer's Handbook, and The Big Red Fez. Most of those have fairly obvious stuff.

2. The Tipping Point by Malcolm Gladwell

3. Crossing the Chasm by Geoffrey Moore

Technical

1. Building Scalable Websites by Cal Henderson

2. High Performance MySQL by Jeremy Zawodny

3. Pragmatic Programmer by...well, it's mentioned elsewhere here.

There are lots of other technical books I like, but most of them aren't directly relevant to the startup I'm building

1. Neuromancer - William Gibson

2. Snow Crash - Neal Stephenson

3. Hackers - Heroes of the Computer Revolution - Steven Levy

4. How to Measure Anything - Douglas Hubbard

5. Godel, Escher, Bach - Douglas Hofstadter

6. The Pragmatic Programmer - Andy Hunt and Dave Thomas

7. The Soul of a New Machine - Tracy Kidder

8. Code - Charles Petzold

9. The Shockwave Rider - John Brunner

10. Ambient Findability: What We Find Changes Who We Become
Book - Peter Morville

11. Don't Make Me Think - Steve Krug

12. The Design of Everyday Things - Donald A. Norman

13. The Mythical Man-Month: Essays on Software Engineering - Fred Brooks

14. Decline and Fall of the American Programmer - Ed Yourdon

15. Cube Farm - Bill Blunden

16. The Philip K. Dick Reader

17. The Cuckoo's Egg - Clifford Stoll

18. The Prince - Niccolò Machiavelli

19. The 48 Laws of Power - Robert Greene

20. The Atrocity Archives - Charles Stross

21. Business @ the Speed of Thought: Using a Digital Nervous System - Bill Gates

 * GEB:EGB - Hofstader
 * The Pragmatic Programmer - Hunt / Thomas
 * Peopleware - DeMarco / Lister
 * The Mythical Man Month - Brooks
 * Paradigms of Artificial Intelligence Programming - Norvig
 * Nausicaa of the Valley of the Wind - Miyazaki

For what it's worth, it's the same imprint that gave us the pickaxe book (Programming Ruby), so perhaps that ought to be a point in it's favour.

Beyond that, off the top of my head the number one theory book for working programmers would be Introduction to Algorithms by Cormen, Leiserson, Rivest and the new guy.

I would point you to two other reference materials. One, is Andy Hunt's (of the Pragmatic Programmers) book: "Pragmatic Thinking and Learning" which I cannot recommend enough. Second is 37Signals "Rework", which I also heartily reccomend.

One thing Pragmatic Thinking & Learning touches on is S.M.A.R.T. See: http://en.wikipedia.org/wiki/S.M.A.R.T.

Also? I have A.D.H.D., too. I also struggle at times -- it's a bitch to admit you're both intelligent & disabled.
I don't have much practical advice on this topic, just be aware.

Finally, work on balance. Work on goals. And don't sweat the small stuff -- relax and work slowly. Change is hard.

Best of luck.

-N

P.S. Exercise helps everything (ditto sleep) -- cognition, bodily health, focus, etc. Even if you don't lose any weight (or gain slightly due to fat -> muscle) it's still worth it. Trust me.

Then I'd recommend you go back and read it closely yourself, because there's an entire chapter on domain-specific programming which includes tips on implementing mini-languages to write code close to the problem space, which is a very Lispy suggestion.

-Erica Sadun's iPhone Developers Cookbook: http://www.amazon.com/iPhone-Developers-Cookbook-Building-Ap...

-Apple's documentation.

-If you're really confused about ObjC, check out Steve Kochan's Programming in Objective C: http://www.amazon.com/Programming-Objective-C-Developers-Lib...

  * The Pragmatic Programmer
  * Coders at Work
  * Cocoa Programming for Mac OS X

Coders at Work takes a slightly different approach. Odds are you've heard about it from other users of HN, but in short: It's a selection of interviews with some of the most accomplished programmers around; Knuth, Simon Peyton Jones etc. I'd still recommend this book, but I would probably cut out around 15% of it.

C++ was never given enough time at my University (it was a Java school) and so I wasn't too tied to it when starting out with Cocoa Programming for Mac OS X. If you can understand basic pointer use in C, then this book will hold your hand through Objective-C and into using Interface Builder and XCode to build native Mac applications. It's not going to teach you how to build iPhone apps, but it will give you the correct core knowledge to go on and do so using the Apple docs should you wish.

I'm currently in the process of reading K&R (The C Programming Language book) and Thinking in Java, both of which are regarded quite highly. Although K&R is definitely seen as THE technical book to read.

  Fiction, English

Reading: The Dispossessed, Ursula Le Guin.

  Fiction, Spanish

  Non-fiction

I have other books started lying around the house, but these are the ones I’ve been actively engaged with in the last couple weeks. When I can type properly again (two to three weeks) I’ll resume Lisp in Small Pieces, Christian Queinnec. And at the office I have The Pragmatic Programmer, I’ll be back there next week and bring it home so I can continue with it.

The Pragmatic Programmer
The Mythical Man-Month: Essays on Software Engineering

And oh yeah,Dilbert & The Tao of Programming for philosophical contemplation.