Top products from r/ProgrammerHumor

Oh god where to begin?

***

Well I Like to think there are level of programming understanding that are relatively tiered.

Tier 1 - How to Code

***
This one is tough as there is no real definitive best answer. My personal primer of choice is

• Sams Learn Java in 24 hours.
  
  > Fyi - , that is not "in one day" that is , in 24, 1 hour sessions equating to a hypothetical 4 college lectures a week lasting a month and a half of intensive training. A huge amount of homework is required to accompany that primer.
  
  so now you can write an app, what next? well. to finish the thought:
  
  
  

  Tier 2 - How to Code...
  

  so other programmers don't want to hit you over the head for each line in your longest function screaming CYCLOMATIC COMPLEXITYYYY
  
  **
  
  Here we talk about how to program properly* You want to be looking up Uncle Bob . Head over to
  
  

• www.cleancoders.com
  
  and check out his video form of his famous book:
  
  
• Clean Code....then buy that book.
  
  Now you should be writing code that doesn't make other programmers eyes bleed.
  
  

  Tier 3 - How to Code..To Solve Problems
  

  ***
  Here we talk about design patterns. Now, you will bump into a lot of debate over their value but...that is stupid. that is like some people saying all carpentry should be done with a saw and another group saying carpenters should never use a saw. Design patterns are names for recognised ways to solve problems you will hit every day in your programming. They may not always work in your case but at worst they will have you thinking around a problem better.
  
  For a primer, check out:
  
  

• Head First: Design Patterns
  
  In fact the entire head first series is great, It is like the For dummies series for programming principles. Great for morons like myself.
  
  With that read, get the real design pattern book:
  
  
• Elements of Reusable...
  
  Don't expect to actual understand almost any of this. I read that book cover to cover and it didn't actual click for me till it slapped me in the face when i was in the real world developing business tier applications. Although having read it so many times meant I new which pages to flip to when I was ready.
  
  

  Tier 4 - How to Code... For Users
  

  ***
  
  This is a whole different kettle of fish. Now you may have written the perfect app to do X with only two buttons, you will find quickly that users are adept at licking the buttons in just the correct order to cause your application to explode. You need to program applications so the cast of jersey shore can use it.
  
  I am a fan of the blog:
  
  

• Joel on Software.
  
  Joel (Co-founder of Trello) covers a lot regarding front facing applications and UX that is required reading...even if he a bit cavalier on his approach to testing.
  
  This is the next part. Testing. You are going to want to Learn about Defensive Programming andTesting. There is a wealth of tutorials over on pluralsight for these.
  
  

  Tier 5 - When NOT to Code
  

  
  **
  
  This is a hard step to get to. Realising that copy and pasting code is GREAT!..but for the right reasons. Once you jump over the initial Copy+paste = the greatest thing in the world barrier , most developers grow a level of defiance that borders on the absurd. Preferring to rewrite the wheel instead of using ...the wheel. When you can honestly say you could* program it from scratch, it is perfectly okay to use libraries and apis.
  
  This is where I go to:
  
  

• www.codeproject.com
  
  and hit up Sacha and others. They show you fairly feature complete and interesting implementations of problems, not just the one or two lines you get from Stack Overflow. Granted this is miles more complicated but it shows not only how to do it, but how to do it right and WHY to do it right. and github of course.
  
  

  Tier 6 - Learning From Mistakes
  

  ***
  
  Now that you have climbed code mountain and are absorbing the combined knowledge of all the internet geniuses, it is time to see where you went wrong.
  
  Head over to
  
  

• http://codereview.stackexchange.com/
  
  and post you functional applications. There a number of people will politely tell you not...how but how to do it better, general improvements in design, logic and reusability. take you through the solid principles and much more. Also..say hello to me if you like :P.
  
  You don't even have to learn exclusively from your own mistakes.
  
  check out:
  
  
• www.thedailywtf.com
  
  and cringe at some examples of real software....and if you don't understand why you should be cringing..learn.
  
  ***
  
  

  Tier 7 - How to think like a programmer
  

  
  Now things get a little bit meta. The best way to become a great programmer? don't JUST read programming. Read books like:
  
  

• Zen and the Art of Motorcycle Maintenance
  
  
• Don't Make Me Think
  
  Read anything and everything, exercise your mind. books on architecture, books on carpentry. any kind of design and problem solving with stretch your understanding of how to climb those brick walls you will hit.
  
  Read some of the more general programming blogs, like:
  
  
• http://blog.codinghorror.com/
  
  Read anything and everything.
  
  

  Final Thoughts
  

  ***
  
  Have fun.
  
  Check out:
  
  

• www.commitstrip.com
  
• www.xkcd.com
  
  and..well..here.
  
  I would also say as a personal suggestion, although i left it out of the mandatories up above as it is a bit controversial, I suggest going TDD. Test driven development. It is not for everyone, a hard ethos to get into but in the real world, in business applicable coding...a life saver. Uncle bob is the man for that again.
  
  Finally I am a fan of Rubber Ducking. Great way to work though problems.
  
  If you want some final reading, I left them out because everyone and their brother has these (and most of the above) in their top 50 programming book lists so it is a mite redundant:
  
  
• Code Complete
  
• The Mythical Man Month
  
• The Pragmatic Programmer
  
• Refactoring: Improving the Design of Existing Code
  
  ***
  Enjoy.
  
  
  
  

tl;dr
Step 1: http://craftinginterpreters.com

Step 2: https://www.amazon.com/Types-Programming-Languages-MIT-Press/dp/0262162091


There are a few good ones that I think are good depending what kind of language you're trying to build.

There's a series of blog posts called "Crafting interpreters"

http://craftinginterpreters.com

It's focused on dynamically typed scripting languages like Python and JavaScript but it covers some the basic stuff that you need in all compilers and then some. It's pretty beginner friendly.

On the other end of the spectrum, if you want to learn about implementing statically typed languages, then it's kind of harder to find resources that are not intimidating at first sight (they involve Greek letters and such :/). It's a deep rabbit hole of information and once you start digging, you'll be able to navigate it better. It's not actually that hard if you get used to the basic notation.

I would start by first learning languages with interesting type systems. Haskell is a good one and learn you a Haskell series of blog posts is a good starting point. The point of this exercise is to get familiar with a decent type system. You can't learn how to implement it if you don't know what to implement. Next, there's a good book for learning about type theory called "Types and programming languages" by Benjamin Peirce. If you want something less theoretical, there's also a paper called "Typing Haskell in Haskell" which is a tutorial-ish implementation of Haskell type system. It's what helped me the most in making things click because it showed a concrete implementation.


Also, shameless self plug, I wrote 2 blog posts about implementing basic type inference/checking which is more focused on the code rather than the theory. It's not expertly written but I tried to assume 0 knowledge about type systems. Also, it's written in typescript so it might be less alien than most type system related stuff that tends to be in Haskell.

https://medium.com/@dhruvrajvanshi/type-inference-for-beginners-part-1-3e0a5be98a4b

https://medium.com/@dhruvrajvanshi/type-inference-for-beginners-part-2-f39c33ca9513

Bear in mind that it's not the most clearly written tutorials out there and there are some mistakes which were corrected in edits but it should give you a basic idea.

I'll start by saying if you haven't read Clean Code, then it's a great place to see questions like your answered with examples. It gets a little too in the weeds for some people at the end, but the first several chapters are great for explaining how, why, and when to break things up.

What a lot of it comes down to for me (and there are different opinions on what "clean" code looks like or should look like, it's somewhat stylistic) is readability.

No matter what app you're writing, with a little bit of business/domain knowledge I should be able to look at your code without having seen it before and be able to understand what parts of the code are responsible for what logical operations so that if the requirements have changed or a bug was found I should know right where to go.

I made a small example while nomming some lunch (forgive me for typos or obvious errors lol). The example is a Cash Register app that is responsible for totaling the sale amount given a list of items.

___

Here is the orignal code | Here's the refactored Specifically looking at the CalculateTotalSale methods....

So in a small trivial program it's not as easy to see the benefits, but in the refactored version the total sale logic has been broken up into methods. This way, lets say there's a bug in how we're calculating taxes (in a small app like this they're probably wouldn't be, but in an enterprise POS app that's in an international market tax calculation can be a pain) we've made several ways to track down where taxes are being done. We can look at the usages of _taxes to see where it's being modified, and we can look at CalculateTaxes() method since that's where all the tax logic should be. If we find that tax logic is not there, we should either move there, or consider a small change in design to make it flow easier.

Also we've left the CalculateTotalSale method open for extension as well. Noted by the comments, if the business wanted us to write coupon logic we could put it in it's own method and go from there. We've left a pattern for the next person to follow, they'd be able to get into this code and get to work pretty quickly. Patterns do change though, but since we've followed some fairly fundamental designs of class structure it'd be easy for someone to change the pattern if they needed to. They won't have to look all over the code for pieces of logic if we've grouped it well.

All that being said, the first example still works fine and gets the job done, the discussion above is more of engineering vs programming. Just my two cents though! Sorry if I've made any obvious errors or didn't explain this well!

Depends what you want to learn. Some of my favorites are

• Code by Charles Petzold if you want to know how your computer works under the hood.
  
  
• Peopleware if you want to learn how to manage knowledge workers.
  
  
• Clean Code by Uncle Bob if you want to learn about good practices and program structure. Impressive content, covers much more than I expected.
  
  
• Don't Make Me Think if you want to learn about usability.
  
  
• Algorithms by Robert Sedgewick if you want to learn about DS & algorithms.
  
  
• The Art of UNIX Programming by Eric S. Raymond if you want to learn about the unix philosophy. Lots of hidden gems in there. Have you ever heard: write programs that do one thing and do it well; don't tune for speed until you've measured; imagine all this knowledge distilled to you in one book.
  
  This a good list to get you started :) most of my favorite books are not language specific.

Don't Make Me Think is a great book on usability, I'd start with that. If you try to make your interface easy to use you'll often end up making it look better. Beyond that my best advice would be analysing things other people have made and trying to work out which techniques you can appropriate for yourself.

Oh, and whitespace is your friend. Give stuff room to breathe, even if it means you end up needing more space.

So, there are tons of opinions on this.

Mine is that you write what makes the code easiest to reason about, read, extend, test, and maintain.

The "performance gains" you might gain for writing terse and cryptic "one liners" and non descript variable names are not even detectable unless you are talking about 100,000 lines of JavaScript and are negligible even at that scale as you should be minifying your code anyway, which makes your code terse and cryptic automatically, meaning that you should write your code so it can be easily understood rather than obsessing over microseconds of performance gain at the cost of ease of development.

There is a Zen to this, you can write too much so that the point of what you are trying to achieve is just as lost as if you crammed everything into one line.

Basically, ask your self what can I extract, is this code doing too much, can I break it down into single responsibility functions and orchestrate them in a delegator function, do my variable name's make sense, should this be refactored, what is using this code, is is this duplicated elsewhere, does this code belong in this file or in a service/repository/on the class/centralized configuration file/ etc.

Learn how to write clean code and whether other coders like it or not (usually if they don't it's because they are not disciplined and don't want to be bothered learning the proper way of avoiding common pitfalls and mistakes or following best practices in general)

Do this and I believe you will be a welcome member to almost any dev team.

https://www.amazon.com/dp/0201633612/?tag=stackoverflow17-20

https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

And you could check stack overflow for question on general programming books. I would always go for a general concept functional programming over how to functional programming in haskell.

But I'll be perfectly honest, I'm a victim of the curse of knowledge so I honestly don't know how one should start. What I do remember is that I had huge problems with syntax (how do I tell language X to do a for (Employee e in employeeList), how do you write a switch and stuff, why would I ever need a ternary operator, and like that.

But once you master the basics of how to write x, y and z in your preferred language, you absolutely need to understand design patterns, you absolutely need to understand how code is supposed to be written, you absolutely need to understand data structures, you absolutely need to understand inheritance and polymorphism, you absolutely need to understand lambdas and functional programming.

Then you can get to the more "neat" stuff like the benefits of having immutables, and "job specific stuff" like how to solve race conditions in threading; sockets and web communication, etc.

Hey, no problem man. The source for this particular script is kind of mediocre, but it is here. Note that I included a file called "wow," to get the shell to respond when I typed "wow, real mature, shell".

I want to also mention that when I was learning shell scripting, I made a shell script with a ton of comments to help me understand stuff better. That is located here. And also, for fun, here is a shell script I wrote to make the mouse pointer touch every pixel on your screen. For further learning, I really can't reccommend Mark Sobell's "A Practical Guide to Linux Commands, Editors, and Shell Programming (3rd Edition)" highly enough. It really brought my practical Linux knowledge to a much higher level. I think you can Google that book and get the 2nd edition in pdf form somewhere.

+1, don't just circle jerk and pretend you're above learning patterns before you even understand why they exist. They can be abused, but they exist for good reasons.

I strongly recommend going over Head First Design Patterns to anyone interested.

Please see my edited post.

You are overthinking it. There is nothing called "modern way of doing C". Unlike a lot of modern languages which have been conflated with their libraries/APIs and which keep on growing, C is a small and minimal language and has not changed much through its revisions. So you will be good whichever book you start from and as you build up knowledge you will figure out the nuances and internalize "best practices". It really is that simple.

Here are some books to get you started;

• The C Primer My gold standard for absolute beginners.
  
• The C Programming Language The bible.
  
• Computer Systems: A programmer's perspective A textbook bringing language, tools, systems together to give you the full picture.
  

Ok, I was just giving my opinion. If you want to be a better developer read about it: https://en.m.wikipedia.org/wiki/Test-driven_development

It’s simply the idea of writing a test for the desired behaviour before writing the code (let the tests ‘drive’ the development).

For reading on how to write clean code: https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 it has a whole chapter on TDD

I agree with the Amazon review. Unless you need for a class, or learn an advanced topic not available in other places, I wouldn't touch this book ever. There are much easier algorithms books to read such as https://www.amazon.com/gp/product/032157351X/ This book isn't introductory at all as mentioned on Quora by multiple people https://www.quora.com/What-are-the-best-books-on-algorithms-and-data-structures

And if you've bought this for algorithms interviews preparation, it's better to buy cracking the code interview or similar which has explicit instructions for interview questions.

One more thing to add to the review was the algorithms are written in pseudocode, array indices start with 1 instead of 0, some lines refer to other pages in the book so you can never read a code inside this book sanely.

It's a pretty big topic: Algorithms and data structures. Introduction to Algorithms is a pretty good book.

Sounds like you need this.

Good luck!

https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=mp_s_a_1_3?keywords=Code+language+of+machines&qid=1574705522&sr=8-3

One of my favorite books

Starts with Morse code (light on/off) and then logic. Great for non tech folks too

I know right?! I was like that as well, until I had been enlightened.

Here is my new bible: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

If you have more than two levels of indentation you should break it into multiple methods. If you want to know more I would recommend reading clean code.

Edit: Before you downvote you should know that this isnt my idea, the Clean Code book is even more restrictive and is one of the most recommended books among programmers and companies out there.

This book changed the way I did things massively and may help you:

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) https://www.amazon.co.uk/dp/0132350882/ref=cm_sw_r_cp_apa_i_lxCwCb8S1W5DZ

That's exactly how you should code. Uncle Bob taught us that.

Uncle Bob is love, Uncle Bob is life.

Read his book

Try Sam's teach yourself C++ in 21 days. The book eases you into programming and expresses concepts in a way easy to understand. It also gives you lots of code examples you can type out and compile and reviews material with questions and exercises that reinforce the material.

https://www.amazon.com/Sams-Teach-Yourself-Days-5th/dp/0672327112

Read The C Programming Language by Brian W. Kernighan and Dennis M. Ritchie front to back. It was published in 1988 and is still phenomenal at teaching the fundamentals of CS: primitives, branching, structures, etc. C programming is daunting at first, but future you will appreciate learning CS from its basics as C is about as barebones as you'll want to get. After finishing it you'll learn the majority of what you need to know to begin learning other languages quickly. Run every example in an environment of your choice to see for yourself whats going on in them. I recommend using this online compiler to run the examples as figuring out what programs to use to actually run the code is difficult for a beginner.

Working Effectively with Legacy Code by Michael Feathers

From wikipedia, and I highly recommend this book as reference material.

If you're interested, check out Clean Code. There is a chapter on just this. Put simply, you shouldn't be afraid to add length to your variable names, so long as they can concisely describe their function. I know, easier said than done, but it's helped steer me away from using acronym and single-letter variable names.

Eh... documentation should be an overview of the process. Specifics need to be within the code itself. Self-commenting code + coding standards is a real thing.

I would recommend any developer to pick up Clean Code and learn some of the basics on self-commenting code and how to write easy-to-read code.

I blame autoincorrect and typing nugs. I was going to find some amusing bug shaped mugs or something... but cafe press has ruined shopping for coffee mugs that have bugs.

Seriously, how many different cafe presses are selling the "My code never has bugs, it just develops random unexpected features" slogan mug?

https://amzn.com/B01A9LY9Q0 isn't a mug...

True story... back when the Atkins diet craze was going, I got the variety pack of larvets and put them in the break room with the sign "free carb free snacks". I think I got a few people to quit that diet.

Understanding ecmascript 6 just came out a couple days ago print. There is an online version on GitHub (although I think it is worth the $$).

Instead of making meowing ducks Amazon should get on this bug and fix it. Reported it a year ago. Scroll to 'about author'

Fred Brooks wrote The Mythical Man Month, one of the classics of IT literature. In it he describes being a software engineering product manager at IBM and the development of OS/360. If you haven't read it yet do so ASAP. https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959

I had PTSD from your class and I wasn't even in attendance.

Obligatory mention of Code book that explains logic gates and some other stuff.

Differential Equations for Dummies

I'd recognize that simuduck reference anywhere. it's Head First Design Patterns. We used this book in a class.

https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628

Whether or not they have read Code Complete.

http://www.amazon.com/dp/0735619670/ref=cm_sw_r_tw_awdm_ZlAbvb1GP04MC

source: https://www.osnews.com/story/19266/wtfsm/

book: https://www.amazon.es/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

I had that book!

Here you go: http://www.amazon.com/Types-Programming-Languages-Benjamin-Pierce/dp/0262162091/

Clean Code

First result after googling "Differential Equations for Dummies"

Required reading: The Mythical Man-Month

Every Preschooler needs to have read and studied this!

Here is the desktop version of your link

About The Author, for those using find

This is our SO before we invented the Internet

The C Programming Language (2nd Edition)

Found it!

https://www.amazon.com/Engineer-Definition-Funny-Coffee-Tea/dp/B01I461CVC

Amazon

Kernighan and Ritchie

I can highly recommend the book Code: The Hidden Language of Computer Hardware and Software, it helped me overcome my fear of hardware.

For less messy amazon links you can extract the part after "/dp/" in

https://www.amazon.com/Cricket-Flour-2-pack-100-protein/dp/B01A9LY9Q0/

and make it:

https://amzn.com/B01A9LY9Q0

BEEP BOP

Plz send any recommendations via PM

This can solve your problems.

Please consider reading this 😉

I know you are the sole developer but still...that is just confusing.

If the concept of magic numbers is foreign to you, then you should probably read this. Magic numbers are just the tip of the iceberg of bad practices...

> Are we talking about the book by Sedgwick?

CLRS
I tend to agree that the 1 based indexing is annoying but the book is ridiculously comprehensive and anyone in CS would be a fool not to have a copy.

No one would ever do that though...

Have you not read Clean code?
https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

A function that needs two lines to declare it is a bad function.
Encapsulate and follow single responsibility.

Any other examples where you need to mix them? Lets not waste time of you posting one example then I show you why its incorrect. Just list me all the instances you believe that you cant use tabs, and ill just correct them all in one post.