(Part 2) Top products from r/ProgrammerHumor

Along with the advice from /u/perpetualwalnut the book "The C++ Programming Language" by Bjarne Stroustrup (the language creator). It's limited in being C++11 (we've had 14 as a minor update and now we're approaching the major update of 17) but it's a pretty solid reference for a large portion of the language (>1,000 pages). (Edit:)It's not a book that will teach you C++ directly, but it's a good reference and is pretty extensive while providing motivation and examples of the language features.

For free sources I suggest cppreference.com as a great online reference.

For videos this should give you a good idea of some language semantics that you may or may not be aware of (again by Bjarne).

This video by Sean Parent (former senior programmer/architect, I'm not sure which, of Adobe and worked directly on Photoshop) is a neat intro to how neat using STL can be.

And finally it may also be worth checking out r/cpp for C++ related stuff, they post good articles/videos relevant to the language from time to time.

Sorry for the info dump, this is just all stuff I would have loved to have when I started. C++ is a monolithic language, but you can do some pretty neat/fast things with it.

If I could make a recommendation based on time-tested experience, I'd recommend following the advice of 2 books, Refactoring: Improving The Design Of Existing Code and Growing Object-Oriented Software, Guided By Tests.

Basically, if you are committed to this codebase, you can rewrite bits and pieces of it (while covering them with tests to make sure you didn't break any functionality) and slowly migrate/transform the code to a point where it's more maintainable.

Of course, if you have a manager who you can't convince this is worth spending time on, you might point them to a resource like this about technical debt or perhaps this one to bring it down to dollars and cents (which every manager understands).

I'd also recommend reading this great piece by John Carmack (of id's DOOM fame, and now VR... He's a highly respected OO C programmer, I'm sure you've probably heard of him) about his excursion into 1 month of programming using a "functional style" (it's applicable to any language, actually, including PHP). It has great quotes like this one: "No matter what language you work in, programming in a functional style provides benefits. You should do it whenever it is convenient, and you should think hard about the decision when it isn't convenient."

I promise you that if you can follow some or all of the knowledge I've linked you to, your job will become both less frustrating and more enjoyable (down the line).

A good metric is by how expensive the object you're passing around is to make a copy of. In the case where you're passing by value, you're probably returning by value as well so two deep copies there. An alternative is references which are syntactically similar to pass by value but retain the memory niceties of pointers which don't require a full copy but rather just the passing of a memory address.

Typically my rule of thumb is bigger than a pointer use a const reference unless I need a fiddle with the bits in the object I'm passing then I'll go with a pointer. Given enough practice and seeing enough code you sort of get a feel for when it's best to use what, but you kind of need to understand the tradeoffs between how you throw around data.

Passing references everywhere is bad though because it makes it less obvious to person reading/using your code that the object you're passing in could potentially be different object than the one you passed in. If your function takes a pointer it tells the reader that you probably intend to do something with the object's data in the function to change it. Which comes to the second point of using 'const' everywhere which not only informs the reader that the object will not be changed but also binds your function to a contract to not be able to change the value.

For more stuff like this I highly recommend Effective C++ and More Effective C++

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.

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.
  

It reminds me of one of Raymond Chen's blog posts where he reminds you that the a NULL garbage collector is a perfectly valid implementation:

------------

Everybody thinks about garbage collection the wrong way
-----

When you ask somebody what garbage collection is, the answer you get is probably going to be something along the lines of "Garbage collection is when the operating environment automatically reclaims memory that is no longer being used by the program. It does this by tracing memory starting from roots to identify which objects are accessible."

This description confuses the mechanism with the goal. It's like saying the job of a firefighter is "driving a red truck and spraying water." That's a description of what a firefighter does, but it misses the point of the job (namely, putting out fires and, more generally, fire safety).

Garbage collection is simulating a computer with an infinite amount of memory. The rest is mechanism. And naturally, the mechanism is "reclaiming memory that the program wouldn't notice went missing." It's one giant application of the as-if rule.

Now, with this view of the true definition of garbage collection, one result immediately follows:

> If the amount of RAM available to the runtime is greater than the amount of memory required by a program, then a memory manager which employs the null garbage collector (which never collects anything) is a valid memory manager.

--------------------

Bonus Reading
------

MIT Press - Maintaining the Illusion of Infinite Memory, Chapter 5, pp. 540:

> If we can arrange to collect all the garbage periodically, and if this turns out to recycle memory at about the same rate at which we construct new pairs, we will have preserved the illusion that there is an infinite amount of memory.

I have it. Pretty heavy for my tiny brain.

But, anyway, Amazon has it for ~$56. In the world of expensive textbooks, this is a steal.


https://www.amazon.com/dp/0262035618/ref=cm_sw_r_cp_apa_i_G4DJDbH8JXJ71

An excellent and surprisingly complete book describing many lower level concepts would be Operating Systems: Design and Implementation (3rd ed. 2006) by Andrew Tanenbaum. It is about writing your own Linux-type OS called Minix complete with memory management, locks, scheduling, quantums, so much more. Even if not creating an OS the algorithms and hardware details it can teach you are bricks of gold for any programmer.

There's a lot of books written about good programming practices, some of which are more advanced than others. Search around on amazon and you'll find a few.

https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164/ref=sr_1_3?ie=UTF8&qid=1520137256&sr=8-3&keywords=clean+code

I cannot vouch for this specific book, but I read another book in the same series, which taught me a lot of things about software design that I had never even thought about.

He used the word "bounded context" using its meaning from Domain-Driven Design approach https://martinfowler.com/bliki/BoundedContext.html and that's what triggered Vernon who is the author of 2 books on this topic https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577 and https://www.amazon.com/Domain-Driven-Design-Distilled-Vaughn-Vernon/dp/0134434420/ . That's what makes this whole conversation funny.

> what is a good resource to learn about search functions?

Knuth vol. 3 is as canonical
an answer as you can get.

The first book I read that made C++ seem simple was Accelerated C++. You can easily find a PDF on Google if you're so inclined.

(It is a little out of date because C++11 brought about some important new features, but the basics are still fairly relevant)

It was at the local Kroger in the Halloween section. Going to buy one today and I'll update with the information on the tag and such!

EDIT: Here is a link to it on Amazon: https://www.amazon.com/Crazy-Bonez-W81243-Ducky/dp/B07STX538Y/

After about a 100 hours of cramming in as many days, I'm willing to bet my left testicle that it's Introduction to Algorithms!

The famous Tanenbaum circus, for those who haven't seen it:

http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639

http://www.amazon.com/Object-Oriented-COBOL-SIGS-Advances-Technology/dp/0132611406

Except that one's real.

That book still got nothing on this one