16 ms·

Ask HN: What books had the greatest effect on how you structure your code?

• nichochar 9y ago
  The pragmatic programmer
• rurban 9y ago
  SICP
• breck 9y ago
  Clean Code
• Jtsummers 9y ago
  Literate Programming, Knuth. My methods have evolved since I first read and started toying with the ideas here, but this is where it started. http://www-cs-faculty.stanford.edu/~uno/lp.html http://www-cs-faculty.stanford.edu/~uno/lp.html
• mhh__ 9y ago
  Alexandrescu's Modern C++ design taught me how to template properly. Also, Scott Meyers's books were very helpful. The design of the D standard library has also been very influential on my code (Mainly convincing me of the benefits of ranges over iterator)
• DanHulton 9y ago
  Code Complete, Steve McConnell. http://www.stevemcconnell.com/cc.htm http://www.stevemcconnell.com/cc.htm One of the best books on programming style and function, backed up with actual research for the recommendations.
  • darawk 9y ago
    I second this. I read this book in my teens after I had taught myself programming and just been hacking away for a little while. It had never occurred to me to even think about the issues this book was discussing. It really made me think about and appreciate design quality in software.
    • 4ndrewl 9y ago
      Ditto.
  • vram22 9y ago
    Same opinion. I always recommend it to my programming students. Also, The Pragmatic Programmer is good, for topics both about programming and beyond programming per se.
    • akprasad 9y ago
      Ditto for both books, though I prefer The Effective Engineer to The Pragmatic Programmer. I found that quite a bit of the tactical advice in TPP is already standard practice (e.g. "always use source control"). Comparatively, TEE has more of an emphasis on project planning and team/company health, and I found that more useful for my work.
      • vram22 9y ago
        Thanks for the tip.
    • arikrak 9y ago
      A lot if the advice in these books has become widely accepted, so if you might not find that much new in them if you've already worked at a tech company for a bit.
      • vram22 9y ago
        True, but it's likely some junior folks will be reading this thread, so it was worth mentioning, IMO.
• deleted 9y ago
  [deleted]
• gt_ 9y ago
  As a programmer in training who has both Clean Code and Code Complete in a queue on the edge of my desk, I'm following this thread to decide which goes first, or if they both get sold in mint condition.
  • gt_ 9y ago
    Slightly kidding ofc. I have already skimmed sections of each.
  • newlog 9y ago
    Go for Clean Code!
  • blub 9y ago
    Code complete is a classic. Clean code will teach you how writing 3 line functions is a best practice. It's an overhyped, overrated book which is more damaging than helpful and one of the very few I couldn't stand to read until the end due to the authors' dogmatic views.
    • cocoa19 9y ago
      Care to elaborate what bits of Clean Code are damaging? I've read it and I thought it has some good ideas. It's the #3 most discussed book on StackOverflow. However, I've been downvoted on HN for recommending something the book talks about (comments are usually misused) Maybe I'm missing something more experienced developers know.
    • Denzel 9y ago
      That's interesting, I had the complete opposite reaction to clean code. As a person that recommends this book, with full heart, to every developer, I'd like to hear any details you could spare re: why you believe it's damaging? Maybe you can provide some examples of well-written codebases and why you believe they're such? And maybe you could comment on why you feel Clean Code's principles harm readability with some examples? I find it painful working with codebases that don't use most of the principles re: - Write code like good stories: Code should read like a story, methodically descending the call graph method by method; each working at one level of abstraction. For example, why is string manipulation littered all over this function that's supposed to be dealing with consolidating reports? Ugh. I like when one function stays at one level of abstraction - Factor out conditions into descriptive methods: I shouldn't have to sit and read through 5 logical operators, some arithmetic, and method calls in 1 'if' conditional, to understand why we're doing all this. Once again, this goes back to having your code read like a story. Factor it out into a descriptive function, so that I can understand at a glance and deep dive if necessary. - Comments are a failure: This applies 99.99% of the time. It's almost comical when someone leaves behind a comment that could be eliminated by factoring something out into a descriptive method call instead. There's a lot of other great stuff in Clean Code that I'm forgetting off the top of my head. (It's been awhile since I last looked over it.) I've come across very few code bases that are a literal pleasure to read. https://github.com/jekyll/jekyll https://github.com/jekyll/jekyll is one of the cleanest codebases that comes to mind immediately. And on the other side of the coin, https://github.com/kubernetes/kubernetes https://github.com/kubernetes/kubernetes is one of the dirtiest. If anyone wants more details/expansion, let me know and I'll reloop. (On my phone right now.)
• lj3 9y ago
  Practical UML Statecharts in C/C++: Event-Driven Programming for Embedded Systems by Miro Samek. https://www.amazon.com/Practical-UML-Statecharts-Event-Driven-Programming/dp/0750687061/ https://www.amazon.com/Practical-UML-Statecharts-Event-Drive...
• marvel_boy 9y ago
  Programming using GNU Smalltalk http://stephane.ducasse.free.fr/FreeBooks/Gnu/ProgrammingUsingGnuSmalltalk.pdf http://stephane.ducasse.free.fr/FreeBooks/Gnu/ProgrammingUsi...
• oneeyedpigeon 9y ago
  The Art of Unix Programming, Eric S. Raymond. http://www.catb.org/esr/writings/taoup/html/ http://www.catb.org/esr/writings/taoup/html/ I'm still trying to achieve everything he advocates, but what I've managed so far has been extremely beneficial.
• abecedarius 9y ago
  Thinking Forth; Software Tools; SICP; Abstraction and Specification in Program Development; Essentials of Programming Languages; Paradigms of AI Programming; I'd like to list something about OO too, but no book I know really measures up to learning from other programmers. But there's Mark S. Miller's thesis Robust Composition. (in roughly chronological order. As you can see from the chronology, it took me a long time to start to like OOP.)
  • kod 9y ago
    What I wouldn't give for 5 more books of equal quality to PAIP...
    • aerique 9y ago
      Came here to mention PAIP as well. A lot of Peter Norvig's stuff is good. He makes it all look so beautiful and simple.
  • mikekchar 9y ago
    Here I was thinking, "I was never really influenced by books. I just read and wrote a lot of code." But you've reminded me that it's just wrong. Thinking Forth. Nearly 35 years later it still probably dominates my approach. Edit: Just realised that it is available under a CC license: http://thinking-forth.sourceforge.net/ http://thinking-forth.sourceforge.net/
    • vram22 9y ago
      >Thinking Forth. Nearly 35 years later it still probably dominates my approach. That's interesting. Can you elaborate on why you think it dominates your approach? I'm interested because I had read a good amount of Starting Forth by Leo Brodie some years ago, and liked the language, and had played around with it a bit (only got access to a Forth system for a short time, so could not go deeply into it, on the practical side). But I remember liking the language. I don't think I have read Thinking Forth.
      • 9y ago
• doubleunplussed 9y ago
  Not a book, but the game spacechem [1] made all my code start being more influenced by the actor model [2] without me really realising it. [1] https://en.wikipedia.org/wiki/SpaceChem https://en.wikipedia.org/wiki/SpaceChem [2] https://en.wikipedia.org/wiki/Actor_model https://en.wikipedia.org/wiki/Actor_model
• jcmoscon 9y ago
  On LISP, by Paul Graham. LISP was the second language I learned in college, but only after 6 years programming Java and C# that I came back and really learned LISP. It was when I realized that I was doing everything wrong. For example design patterns exists because OO has serious problems that we don't find in a functional programming language and you only see this when you understand both paradigms.
  • gnaritas 9y ago
    Design patterns exist because common solutions to problems exist, not because OO has serious problems. I understand both paradigms and Lisp is hardly free of design patterns. Every time you pass a lambda to a higher order function you're using a strategy pattern. If you only see design patterns as problems with OO, you're missing the point of design patterns. All languages have design patterns. Common design pattern in Lisp, with-X macros to deal with scoped resource cleanup.
    • sideshowb 9y ago
      Are Design Patterns really so out of fashion with the youth of today that nobody here mentions Design Patterns as their answer? Because it is mine, for better or worse. It took me from understanding OO to understanding how to build large systems with OO, writing maintainable code and using proper encapsulation. A much deeper work than Code Complete (though the latter is worth reading too). I have used functional languages as well (ML, Lisp; not Haskell yet though I think I get what monads are; plus I write a lot of Python, C++, JS in functional style) but I have yet to use them for any project as big. I hope I get the chance to one day. But for now Design Patterns gets my vote.
      • gnaritas 9y ago
        > Are Design Patterns really so out of fashion with the youth of today that nobody here mentions Design Patterns as their answer? Apparently so; sad.
        • deleted 9y ago
• InclinedPlane 9y ago
  Refactoring. If I could shove that book down every coder's throat in the world I would. Or, if I could even just get them to use extract method like ... half the times they should I'd consider that to be a major historical achievement.
• butlersean 9y ago
  Refactoring: Improving the Design of Existing Code After reading I began to think about programming as an algebraic transformation from one system to another, in doing so radically reduced the amount of errors I made.
  • keithnz 9y ago
    I got this when it first came out, I was kind of doing it in a "gut feeling" kind of way, but this made me think of it more as a discipline, and solidified the idea of micro improvements and let me drop the idea of trying to get it exactly right the first time.
• danso 9y ago
  Of lesser-known books, Avdi Grimm's "Confident Ruby": http://www.confidentruby.com/ http://www.confidentruby.com/ Learning Ruby itself was a huge influence to me; hadn't considered that a language should be designed to make programmers "happy", as Matz said. "Confident Ruby" was one of several books that had this human-happiness focus. "Confident" is broken down into patterns, many of which can be found in books like Sandi Metz's POODR, but as a semi-experienced programmer, Grimm's way of writing really appealed to me. Even the title of the book itself was revelatory to me. The idea that the functions and methods and conventions we create should be rooted in a "confident" mentality (such as the old adage of being promiscuous in what a function accepts, and strict in what it returns) really improved the way I designed code. Not just in terms of technical proficiency, but with less cognitive burden, which ultimately leads to the elegant simplicity we desire in our work.
  • artursapek 9y ago
    Ruby makes programmers happy while they're writing their sexy new code base. It makes them cry when it's time to refactor it.
    • caseysoftware 9y ago
      I don't know why you're being voted down.. even Avdi Grimm supports that: http://www.virtuouscode.com/2015/08/11/what-its-like-to-come-back-to-a-ruby-project-after-6-months/ http://www.virtuouscode.com/2015/08/11/what-its-like-to-come...
      • danso 9y ago
        I didn't downvote but I suspect whoever did saw the GP comment as bashing Ruby and being off-topic, even though some of my comment talked about Ruby's philosophy as a whole (though I felt it was important to include the context in which Grimm's philosophy is grounded). FWIW, I almost never use Ruby today, having switched to Python for both teaching and development purposes. That doesn't mean that learning Ruby didn't influence me. For starters, it taught me the dangers of giving programmers too much syntactic freedom :).
• gnaritas 9y ago
  Smalltalk Best Practice Patterns by Kent Beck. Refactoring by Martin Fowler. Design Patterns by the Gang of Four. Domain Driven Design by Eric Evans.
• cutler 9y ago
  Clojure Applied by Ben Vandergrift and Alex Miller. That and Rich Hickey's Greatest Hits (https://changelog.com/posts/rich-hickeys-greatest-hits https://changelog.com/posts/rich-hickeys-greatest-hits).
  • zimablue 9y ago
    I haven't read that many coding textbooks not specific to a language but the Joy of Clojure probably slapped me with the most ideas I'd never seen before. Not sure it made me a better developer in the short run, but I'd like to think that it will in the long run.
• __s 9y ago
  Fountainhead
• davidmoffatt 9y ago
  The Little Lisper by Dan Friedman. It is probably 30 years out of publication but I pulled it off of my shelf the other day, reread it, and the next day I noticed that my code had improved. It is a quick read, nothing earth shattering, but you will be amazed by what you have forgotten.
• ztjio 9y ago
  It surprised me just how huge the impact was of reading about Flow-based Programming years ago (J Paul Morrison's book, though, his site is probably a sufficient substitute http://www.jpaulmorrison.com/fbp/ http://www.jpaulmorrison.com/fbp/) Of course, in recent times, it has become all that much more relevant to me as I began working in data science/engineering space. Even though it's not specifically about code structure for a particular language, it addresses a common flaw in most programming approaches that seem to treat all functionality as a servant of the current context which is strange and silly and not how anything works in physical information processing so why do it in code? A somewhat common pattern that maps well to FBP is "Railway Oriented Programming." Though FBP in full takes this well beyond simply shooting errors along in sideband to the happy path.
• jjjjjosh 9y ago
  Hands-down, Practical Object-Oriented Design in Ruby (http://www.poodr.com/ http://www.poodr.com/) - some of it I don't agree with but it's all wonderfully put-together: clear and concise, with wonderful examples. Much more about OO design than Ruby, non-Rubyists will get 98% of the value out of it that Rubyists would.
  • censhin 9y ago
    I'm glad to see someone posted this book. I think it's far undervalued. Definitely a must read. The Ruby written could be completely replaced by pseudo code, and it wouldn't change the lessons taught.
  • rimliu 9y ago
    And there is another book by Sandi, released this year. https://www.sandimetz.com/99bottles/ https://www.sandimetz.com/99bottles/ Her books and her talks had the biggest influence on me regarding code design. At least influenced to think a lot more about it.
• chrismealy 9y ago
  Kent Beck'a Smalltalk book. I've never used Smalltalk but it transfers to any dynamic OOP language. (It also used to be $25, yikes what happened?)
• d0m 9y ago
  SICP made the biggest difference; it really changed the way I approach mutability and state management in everything I write (To name just this).
• Kenji 9y ago
  Digital Design and Computer Architecture (Harris & Harris) Why? Because we software engineers can learn a lot from the hardware guys. Almost every piece of software I write these days contains some finite state machines (technically, every program is a finite state machine, where the binary string that makes up all your variables at a given point in time is one state, that insight alone is valuable, but I mean with explicit states in the code) - in fact, they often make up the core structure and uphold some strong invariants that make reasoning about the code simpler. And if one finite state machine does not do it, then you can nest them and keep all the benefits.
• miguelrochefort 9y ago
  Are books still state of the art in 2017? I would assume all the best knowledge could be found online for free by now.
  • vinylkey 9y ago
    Many people prefer books to screen reading. Many people also learn better from reading.
  • pjmorris 9y ago
    A book can be coherent and curated in a way that a collection of posts by different authors cannot be.
  • csnewb 9y ago
    Online resources are often shallow in content. I prefer to deep dive into a topic and truly learn it inside and out by reading a good book. Blogs and tutorials don't give you that deep insight.
  • tnecniv 9y ago
    There's only so much you can put in a blog or lecture series. Most college courses don't even cover a whole book (in STEM subjects).
  • justin66 9y ago
    Do you read enough books to have an informed opinion on that?
  • zimablue 9y ago
    For me, the best way to absorb knowledge is text. Video makes it much harder to skip parts (you can jump forwards but you can't quickly skim to make sure you have a vague idea what you're skipping. You can speed up and slow down videos but it's far, far more clunky to me than varying between skim reading vs deep reading. I've spend literally decades now doing that every day when you think about it, varying digestion speed by orders of magnitude without thinking about it, no chipmonk voice involved. Hyperlinked text might be better, so that you have a graph of knowledge not a searchable seq(book with chapters and an index), but there's a natural order to learning things, the teacher hopefully has an idea what order it makes sense to put the concepts in front of you in. tldr; books are hard to beat, if something was going to beat it for me it would be a well designed, portable wiki of the book's contents, maybe with some interactive exercises. Definitely not the video lectures and homework of most online courses.
• deleted 9y ago
  [deleted]
• hardlianotion 9y ago
  Scott Meyers Effective C++
• fusiongyro 9y ago
  A Mentoring Course in Smalltalk[0]. I was really surprised, after reading and really loving Design Patterns, that there was still so much to say about OO design. I did love Design Patterns a lot though. Purely Functional Data Structures by Chris Okasaki was also really useful for Haskell, as was Real World Haskell. Programming Prolog probably had a bigger influence on my Prolog than the other books, even though I read Art of Prolog and Prolog Programming in Depth first. Especially the latest edition, it's a really beautiful book. [0]: http://www.lulu.com/us/en/shop/andres-valloud/a-mentoring-course-on-smalltalk/paperback/product-3788890.html http://www.lulu.com/us/en/shop/andres-valloud/a-mentoring-co...
• Adamantcheese 9y ago
  How To Write Unmaintainable Code by Roedy Green. The best way to write better code is to avoid writing it badly in the first place. But you need to know how to write bad code to write code better than it. Definitely a different way of learning how to write good code, also a good laugh for anyone in industry.
  • teemo91 9y ago
    I am almost tempted to bring it into work and frighten my manager with it :)
• dcw303 9y ago
  For C#, Framework Design Guidelines by Cwalina & Abrams. Very clear and concise pointers for well structured and easy to read code. It's a little out of date now though, wish they'd update it to a third edition.
  • arwhatever 9y ago
    A lot of the design guidelines in that book carry forward many other technologies. A really great read.
  • neppo 9y ago
    thanks for mentioning the programming language
• _Codemonkeyism 9y ago
  "Implementation Patterns"
• e12e 9y ago
  Probably the book that surprised me the most, was "Designing Active Server Pages" by Scott Mitchell[1] - bought for next to nothing in a sale clearing out old titles. I don't really program in VBscript or on the .net platform - but the book demonstrates how much improvement it is possible to get in a server-side template language (eg: like PHP, ColdFusion) with a bit of mindfulness to how code is structured. I'm not sure I would recommend it today, but at the time I read it, in the mid 2000s, it did change my view on these "unmaintainable" technology stacks. I later came across the fusebox architecture/pattern, originally from ColdFusion - and realized that many PHP programmers had skipped some history, ending up reinventing code structure, sometimes badly. Note that fusebox has grown and changed, I'm mostly talking about the fundamental ideas, and I don't think the later "port" to using XML was a very elegant or good idea. For those interested, see: https://en.wikipedia.org/wiki/Fusebox_(programming)#Fusebox_.28version_1.29 https://en.wikipedia.org/wiki/Fusebox_(programming)#Fusebox_... and most of the rest of that page. [1] http://shop.oreilly.com/product/9780596000448.do http://shop.oreilly.com/product/9780596000448.do
• nlawalker 9y ago
  Dependency Injection in .NET by Mark Seemann was the trigger that started my transition from someone basically writing "script spaghetti" in an OO language to someone that could actually decompose a conceptual set of processes into decoupled parts and assemble a software system from them. It came along at just the right moment in my career, when I was struggling to understand how I could build things in a more elegant way. I picked up the book thinking I was going to learn about some esoteric design pattern, and came away with a much better understanding of the languages I was using and all of the other design patterns I thought I had learned about previously. It's clear, concise, and focuses on concepts over specific tools and libraries, but most importantly it's practical - it has real, practical code examples and explains how to actually build an object-oriented system. It's such a stark contrast with most presentations I've seen of the Gang of Four patterns and of SOLID, which usually come with really weak examples that aren't helpful or motivational. Everything snowballed from there. I started using composition a lot more than inheritance, I started identifying problems with side effects and eliminating them, I started writing real unit tests, I was able to better critique other peoples' code. I felt like I was finally using the tools available to me in the way they were supposed to be used. What's funny and satisfying to me is following the author's blog and seeing that he has since moved on to focus primarily on F# and functional programming, which I naturally started to do myself after more practice with the concepts in his book. Once you start decoupling things well, and you've built a few systems big enough that you have trouble finding the actual implementation of your IWhatever and an AbstractSingletonProxyFactoryBean actually does solve your problem pretty well even as you realize the insanity of it, the encapsulating borders of classes and the need to assign everything to a noun start to feel more like a hindrance rather than a guide. That said, I still think that most of the world's code written in object-oriented languages would be better off if everyone using them had brief, practical training to understand the value of specifying the behavior of an object through the interfaces it depends on, giving it other objects that implement those interfaces right when you create it, and doing all that creation up front (or specifying other objects that can defer that creation to later). I still see so much C# code from developers at all levels who clearly create classes only because the language offers it and it seems like the right thing to do, randomly jamming methods and fields into classes with names vaguely related to the domain, calling static methods to access databases and external services, and proudly adding unit tests for their one loose little function that mushes strings together. I push this book as hard as I can on junior devs.
• fernly 9y ago
  Jon Bentley, _Writing Efficient Programs_ and Kernighan & Ritchie's _C Programming Language_.
• MithrilTuxedo 9y ago
  Clean Code by Robert C. Martin This helped me break my analysis paralysis when it came to figuring out how to organize my code.
  • nip 9y ago
    Excellent recommendation. The examples are written in Java but it doesn't matter too much as most concepts covered in the book are language agnostic.
• leksak 9y ago
  Game Programming Patterns - without a doubt. Own it in print, but usually only read it online. To me it's a more exciting read than the GoF book http://gameprogrammingpatterns.com/contents.html http://gameprogrammingpatterns.com/contents.html
  • gauravhp 9y ago
    Thanks for providing online version. Where I am staying I cannot purchase most of these books mentioned in this thread.
• tomjakubowski 9y ago
  "The Practice of Programming" by Kernighan & Pike, especially chapters 3, 4, 8 and 9. http://www.cs.princeton.edu/~bwk/tpop.webpage/ http://www.cs.princeton.edu/~bwk/tpop.webpage/
• frik 9y ago
  JavaScript, the Good Parts
• weishigoname 9y ago
  for me, there is no special book effect my code style, the greatest effect is read source code of projects I am interested in.
• troels 9y ago
  "Patterns of Enterprise Application Architecture" by Martin Fowler made a big difference for me at the time. Also, "Domain Driven Design" by Eric Evans. Both have a focus on high level architecture. Of books that are more on the craft of programming, "Refactoring" (Also Fowler) is good. And I enjoyed "Practical Common Lisp" by Peter Seibel too. In general, I suspect that the value of a book has more to do with where the reader is, than where the book is.
• oulu2006 9y ago
  The Art of the Metaobject Protocol https://mitpress.mit.edu/books/art-metaobject-protocol https://mitpress.mit.edu/books/art-metaobject-protocol
• chvid 9y ago
  The Life-Changing Magic of Tidying Up by Marie Kondo
• pjc50 9y ago
  Very old, but "C traps and pitfalls": http://www.goodreads.com/book/show/706807.C_Traps_and_Pitfalls http://www.goodreads.com/book/show/706807.C_Traps_and_Pitfal... It's essentially a list of anti-patterns to avoid. But crucial to it is the idea of clarity and avoiding misinterpretation by either human or compiler.
• CalRobert 9y ago
  Javascript: The Good Parts
• gaius 9y ago
  Alice in Wonderland
• robinphilip1989 9y ago
  Head First Design Patterns by Eric Freeman Design patterns by GoF Code Complete by Steve McConnel
• ertucetin 9y ago
  Joy Of Clojure
• enriquto 9y ago
  all modern programming books are footnotes to Kernighan and Ritchie
• BJanecke 9y ago
  * Douglas Hofstadter - Gödel, Escher, Bach: an Eternal Golden Braid * Fred Brooks - Design Of Design * Fred Brooks - The Mythical Man month * Eric J. Evans - Domain Driven Design * Design Patterns: Elements of Reusable Object-Oriented Software * Kent Beck - Extreme Programming Explained * Kent Beck - Planning Extreme Programming * Michael C. Feathers - Working Effectively with Legacy Code * Daniel Kahneman - Thinking, Fast and Slow [EDIT] Correct the author for legacy code
  • waterlink 9y ago
    > * Bob Martin - Working Effectively with Legacy Code Author is Michael C. Feathers
    • BJanecke 9y ago
      Nice catch, thanks :)
  • gkamal 9y ago
    correction Working Effectively with Legacy Code is by Michael Feathers
  • vldx 9y ago
    I've just recently bought "Gödel, Escher, Bach" -- looking shortly to start it. Curious, how did it influenced you in connection to programming?
    • BJanecke 9y ago
      Just like the other non programming book on the list(Thinking Fast and Slow) GEB is a lot about perception to me. Understanding that nothing is purely logical nor is it purely expressionistic; by pigeonholing your perception of any design whether it be Code, Math or Art to either Logic xor Expression you are blinding yourself The other angle for GEB is design I read GEB along with Design of Design years ago following my mentor at the times suggestion, I would highly recommend doing this. Think of it as the Gödel, Escher, Bach, Brooks (Although Brook's writing style can be laborious at times) Recognizing patterns in all design work helped my understand my own design process better.
• numbsafari 9y ago
  Writing Basic Adventure Programs for the TRS-80. [1] It contains this gem [2], which is pretty much how every program works. I occasionally riff off this diagram for work as an inside joke with myself. 1: http://www.trs-80.org/writing-basic-adventure-programs-for-the-trs-80/ http://www.trs-80.org/writing-basic-adventure-programs-for-t... 2: https://imgur.com/gallery/Vz63D https://imgur.com/gallery/Vz63D
• ransom1538 9y ago
  Classic essay on unmaintainable-code. https://github.com/Droogans/unmaintainable-code https://github.com/Droogans/unmaintainable-code
• anentropic 9y ago
  Does anyone else here never read programming books?
  • josmar 9y ago
    They are a great ladder for when one wishes to climb up the shoulders of giants. Much can be learned in blogs, but long-form text is not that easily replaced. That said, my books-to-read list is ever growing as well...
  • psyc 9y ago
    I think I've read fewer than 5 programming books in 30 years. For the most part, I don't read about programming. For certain specific problems, I'll read articles or watch talks by people in my field who I respect a lot. Mostly, I just write a lot of code, observe what I don't like aesthetically, and think about how to make it better.
• skytreader 9y ago
  SICP (w/ Brian Harvey's CS61A lectures) influenced how I approach abstraction _a lot_. Its "baby brother" _How to Design Programs_, with its design recipe approach, ingrained testing and iterative refinement in me early on. _Head First Design Patterns_ is a great influence too when it comes to OO-abstraction, for good and bad.
  • sevensor 9y ago
    I'll second HTDP. A close read of the preface is worth your time even if the deliberate pace of the rest of the book isn't your cup of tea. The data-first approach to design is a breath of fresh air.
• wallstprog 9y ago
  At the risk of being labeled a dinosaur, this is still prob. the best book I ever read on structuring code: https://www.amazon.com/Reliable-Software-Through-Composite-Design/dp/0884052842/ref=asap_bc?ie=UTF8 https://www.amazon.com/Reliable-Software-Through-Composite-D...
• PJ_Lau 9y ago
  work effectively with legacy code
• blain_the_train 9y ago
  For a modern look at systems design i highly recommend "Designing Data-Intensive Applications (DDIA)" By Martin Kleppmann. Not really about structuring code, but I think stepping back and realizing your code is part of a larger system is very illuminating and influence how you write code. http://dataintensive.net/ http://dataintensive.net/
• beagle3 9y ago
  Essays, not books, but ... everything Ken Iverson wrote: The Description of Finite Sequential Processes http://www.jsoftware.com/papers/DFSP.htm http://www.jsoftware.com/papers/DFSP.htm (see e.g. the concrete implementation of the Simplex algorithm , the hamming code corrector). It shows that, with the right primitives and notation, a lot of things are simple and elegant. It's not an necessarily an easy read (depending on your math level and background), but it is a very rewarding one. Notation as a tool of thought http://www.jsoftware.com/papers/tot.htm http://www.jsoftware.com/papers/tot.htm - a longer introduction. Bottom line: a different take on abstraction. It makes a huge difference when you peel most abstraction layers.