Reddit reviews Modern C++ Design: Generic Programming and Design Patterns Applied
We found 24 Reddit comments about Modern C++ Design: Generic Programming and Design Patterns Applied. Here are the top ones, ranked by their Reddit score.
You have a long journey ahead of you, but here goes :D
Beginner
C++ Primer: One of the better introductory books.
The C++ Standard Template Library: A Tutorial and Reference: Goes over the standard template library in fantastic detail, a must if you're going to be spending a lot of time writing C++.
The C++ Programming Language: Now that you have a good idea of how C++ is used, it's time to go over it again. TCPPL is written by the language's creator and is intended as an introductory book for experienced programmers. That said I think it's best read once you're already comfortable with the language so that you can full appreciate his nuggets of wisdom.
Intermediate
Modern C++ Design: Covers how to write reusable C++ code and common design patterns. You can definitely have started game programming by the time you read this book, however it's definitely something you should have on your reading list.
C++ Templates: Touches on some similar material as Modern C++ Design, but will help you get to grips with C++ Template programming and how to write reusable code.
Effective C++: Practical advise about C++ do's and dont's. Again, this isn't mandatory knowledge for gamedev, but it's advice is definitely invaluable.
Design Patterns: Teaches you commonly used design patterns. Especially useful if you're working as part of a team as it gives you a common set of names for design patterns.
Advanced
C++ Concurrency in Action: Don't be put off by the fact I've put this as an "advanced" topic, it's more that you will get more benefit out of knowing the other subjects first. Concurrency in C++11 is pretty easy and this book is a fantastic guide for learning how its done.
Graphics Programming
OpenGL: A surprisingly well written specification in that it's pretty easy to understand! While it's probably not the best resource for learning OpenGL, it's definitely worth looking at. [edit: Mix it in with Open.gl and arcsynthesis's tutorials for practical examples and you're off to a good start!]
OpenGL Superbible: The OpenGL superbible is one of the best ways to learn modern OpenGL. Sadly this isn't saying much, in fact the only other book appears to be the "Orange Book", however my sources indicate that is terrible. So you're just going to have suck it up and learn from the OGL Superbible![edit: in retrospect, just stick to free tutorials I've linked above. You'll learn more from them, and be less confused by what is 3rd party code supplied by the book. Substitute the "rendering" techniques you would learn from a 3d book with a good 3d math book and realtime rendering (links below)]Essential Mathematics for Game Programmers or 3D Math Primer for Graphics and Game Development: 3D programming involves a lot of math, these books cover topics that OpenGL/DirectX books tend to rush over.
Realtime Rendering: A graphics library independent explanation of a number of modern graphical techniques, very useful with teaching you inventive ways to use your newly found 3d graphical talents!
I don't have any experience with Clay and have a vested interest in D, so take the following with a grain of salt.
Here are my impressions on Clay vs D2 after having read the brief docs on the wiki:
[S] SizedSequence?(static S) = Sequence?(S) and CallDefined?(size, S);
whereas you do the same thing in D like this:
template hasLength(R) {
enum hasLength = isInputRange!R && is(typeof(R.init.length) == size_t);
}
I don't know how to enforce in Clay that the type of "size" is size_t; I'm sure there must be a way. And indeed the Clay version is shorter.
import myownlib.test.*;
Overall Clay's current offering (judging only by the docs) is very scarce compared to D2's. I found nothing in Clay that's sorely missing in D2, and conversely there's plenty in D2 that I'd sorely miss in Clay.
Clay looks a lot like the toy language I was working on before deciding to build on D: long on hope, short on bread and butter. In hindsight, I am happy with the decision to start with a language (D1) in which I could take for granted a lot of stuff.
Andrei Alexandrescu's "Modern C++ Design". It was so mind-expanding and well-written, not to mention useful, I was reading it for 2-3 hours a day until I finished it.
Grab a book, find a project. Bunker down and nail it out.
I have a simular background; I learnt AS3, went onto JS/HTML, c#, java, python, c/c++. For my C, I picked up unix networking and for c++ I picked up modern c++ design.
From there, it's just a matter of getting dirty.
"Modern C++ Design" by https://www.reddit.com/user/andralex might not be quite so modern anymore, but it does a good job of presenting the basic building blocks for TMP, especially if you want to do complex stuff with types. Many of the things presented there have since gone into the standard, but it's good to know what goes on in the background.
I have not made anything up. I've described the long-standing accepted definition of the term. You don't just get to claim I'm making stuff up as if it were fact, sir.
> "smart pointer" is not a catch-all for any object with pointer-like behavior.
And that's not the way I described it. A smart pointer is an object that behaves like a regular pointer but is smarter in some way.
> Smart pointer (as opposed to a "dumb" or "raw" pointer) is a C++ structure that behaves almost identically to a common C pointer but it also includes some other capabilities, e.g. throws an exception when it's NULL and someone tries to dereference it, or it destroys its contents automatically when it goes out of scope.
http://www.csc.lsu.edu/~kosmas/smartPointers.html
> In computer science, a smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic memory management or bounds checking.
http://en.wikipedia.org/wiki/Smart_pointer
> Smart pointers are objects that look and feel like pointers, but are smarter. What does this mean?
> To look and feel like pointers, smart pointers need to have the same interface that pointers do: they need to support pointer operations like dereferencing (operator *) and indirection (operator ->). An object that looks and feels like something else is called a proxy object, or just proxy. The proxy pattern and its many uses are described in the books Design Patterns and Pattern Oriented Software Architecture.
http://ootips.org/yonat/4dev/smart-pointers.html
> So what's a smart pointer? A smart pointer is a C++ class that mimics a regular pointer in syntax and some semantics, but it does more.
>...
> This is the mantra of smart pointers: You can replace pointer definitions with smart pointer definitions without incurring major changes to your application's code. You thus get extra goodies with ease.
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
And finally http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Smart_Pointer
Although I don't agree with most of the intent and motivation sections in that one and would never implement handle/body in that manner.
First, be prepared to write code that sucks and is unmaintainable for a while. (This could be months or years.)
If you only know Java, then you'll need some C concepts. In particular, you need to become familiar with pointer arithmetic, avoiding buffer overruns, and manual memory management. (C++ has ways (RAII) to make manual memory management less error-prone, but you still need to understand what's going on.)
To learn the basics of the language, read The C++ Programming Language, Special Edition, by Bjarne Stroustrup.
Read a lot of things by Herb Sutter and Andrei Alexandrescu. I particularly recommend Modern C++ Design and Exceptional C++; I'm sure others in this thread can give you some good suggestions.
Finally, start writing code, and get it critically reviewed by someone who really knows C++. (I've known 2 or 3 such people in my career; they exist but are the exception, not the rule. Look for people who can explain all the things I listed, and more.)
(Edited to add The C++ Programming Language.)
Well, in that case I would recommend using C++ to do it, if you can compile using a recent~ish version of clang or gcc for your environment and using the standard library (aka the std or the stl) as much as possible, it's a very OO library so by using it you will understand how OO can be helpful and you can look at it's design to understand how to write things similar to it.
If you want books I would recommend Scott Mayer's Effective Modern C++ (if you are familiar with C and/or older C++) or Brine Startrooper's A Tour of C++ if you are not that familiar with programming in general.
Alternatively, if you want a book about OOP design patterns, there are tow classics that come to mind:
Gang of four (http://wiki.c2.com/?DesignPatternsBook)
Modern C++ Design(https://www.amazon.co.uk/Modern-Design-Generic-Programming-Patterns/dp/0201704315)
For more up to date stuff, watch talks, look at code or look for less popular "up and coming" books.
Keep in mind that your goal shouldn't be to use OOP because you want to use OOP but to use OOP because it helps you reason about things.
OOP can easily result in slow code (similar sized data will not be localized, resulting in inefficient access), horrible design patterns (most beginners will make the mistake of writing large objects that have two many responsabilites) and hard to read code and change code (due to, sometimes useless, coupling between data an algorithms).
If you want to see some interesting takes on OOP check out Scala and Akka's actor library, actors are a thought provoking distributed design pattern that is fun to write and Scala is arguably "the purest OO" language that is widely used today.
Overall write code that works and is easy to modify, use a lot of language and libraries to familiarize yourself with as many aspects of technology as possible.
And remember "objects are burritos", they are simply an abstraction that is used by a wide array of programmer and as such they mean different things from different people.
The problem here is that of the three "overrides" of
colideWithObjectthat you defined, onlybool collideWithObject(Object* obj)is actually an override. If you put theoverridekeyword at the end of each statement function in Circle (Assuming c++11), you will see the problem. see hereWhat you are trying to achieve is called multiple dispatch (aka multimethods), which requires some legwork in C++. I remember a good method of doing this described in chapter 11 of Modern C++ Design.
Starting this off as saying that I work primarily in iOS and mac environments. I think PCs are great and apple is overpriced but I really enjoy it and I love Swift so whatever.
If you're building applications in Windows most people seem to start with Visual Studio. There's a ton of resources, frameworks, libraries, and a large community for it. At the very least it's probably a good place to start. For C++ development maybe start here: https://msdn.microsoft.com/en-us/windows/uwp/get-started/create-a-basic-windows-10-app-in-cpp
Now for your broader question of application development, I would start with the Gang Of Four for code design. These aren't easy concepts to get right off the bat, it's putting in some reps before it becomes natural. You'll never use just one either, most projects become a mesh of different design concepts and there's way more than 4. I recommend coming up with a simple project to build on your own and then attempting to architect that from a high level before coding. Then actually building it. It's really the only way to learn. For C++ reading maybe check this out (not 100% on this, I don't do much with C++, but seems recommended as an update for the original Gang of Four): http://www.amazon.com/dp/0201704315/
Another book: http://www.amazon.com/dp/0735619670/
it's from this list: http://blog.codinghorror.com/recommended-reading-for-developers/
This all said, don't get bogged down in books. Read enough to feel comfortable starting something then start it.
Someone who doesn't really know C++ can do things in C++ and be productive, but keep them away from writing templates, macros, and/or doing anything with pointers. The right library can protect amateurs from shooting themselves in the foot, at least too often; that's why people talk about using a "subset of the language."
I'm a game developer. It's still the case that most serious game developers demand C++, and for good reason.
For reference: I've interviewed dozens of developers applying for a C++ game development job. Most rate themselves 9 to 10/10 in C++, and yet most also choke when I start asking them even slightly interesting questions about the language. Not even the standard (or any other) libraries -- just about the core language. This is all stuff I know like the back of my hand -- and I know that there are things in C++ that I couldn't just get right the first time (see Modern C++ Design for a few examples).
I would also suggest to follow these up with Modern C++ Design by Andrei Alexandrescu, which really opens your eyes to the power of C++ templates and template meta programming.
Well, this is what most people understand by "modern C++": https://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315; it was published 2001.
Actually Qt offered an equal or even better solution for most features introduced with C++11 alread long before 2011. At least for me C++11 brought little benefit.
Senior Level Software Engineer Reading List
Read This First
Fundamentals
Development Theory
Philosophy of Programming
Mentality
Software Engineering Skill Sets
Design
History
Specialist Skills
DevOps Reading List
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315 - amazing book, completely changed the way I write C++ code
Vecchia edizione, ma in italiano.
http://www.amazon.it/Linguaggio-libreria-standard-principi-programmazione/dp/8871920783
Completa con (in inglese):
http://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/0321334876
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
Kind of dated now but still mind expanding: Modern C++ Design by Alexandrescu. Templates can get pretty intense and let you choose what gets done at compile time.
Programming is language agnostic; it sounds like you're looking for breadth rather than depth, so:
Those are the only books I ever used, and I've had no problem programming in any (serious) language I've come across.
Scala, Mozart, etc. cover more "programming paradigms" than C++, but there are more resources for C++ than those languages, so it is a good balance between breadth and support. If you would rather learn a few languages than one language then I would suggest the combination of an ML, C, Python, XSLT, and Scheme. Spend two weeks in each language and make sure you've implemented something nontrivial in each, and make sure that implementation is idiomatic.
First note that Career/Job/Market is quite different from Knowledge/Intellectual satisfaction. So you have to keep "earning money" separate from "gaining knowledge" but do both parallely. If you are one of the lucky few who has both aligned in a particular job, you have got it made. Mostly that is never the case and hence you have to work on your Motivation/Enthusiasm and keep hammering away at the difficult subjects. There are no shortcuts :-)
I prefer Books to the Internet for study since they are more coherent and less distracting, allowing you to focus better on a subject. Unless newer editions are reqd. buy used/older editions to save money and build a large library. So here is a selection from my library (in no particular order);
Could you post a link to the negative response you received? I would be curious to judge it for myself.
There was a fairly strong anti-OO backlash that I would place in the early 00's up to about 2008. The furor has since died down (or at least I'm no longer seeing anti-OO blog posts like I used to). If you're interested I could probably dig up some more, but off the top of my head:
Personally, I'm not a huge fan of OOP. It models some problems very well, such as GUI widgets and simulations. But in most domains it tends to result in a bunch of scaffolding that becomes a permanent part of your code base. It is a crutch for when you poorly understand your problem - objects give you something "concrete" to grasp and this is fine for a first pass - but ultimately you should prefer cleaner and simpler abstractions that more closely map to the problem domain.
I also think that C++ is a horrible language for OOP. It's not flexible enough and thus requires a great deal of biolerplate to achieve object-like behavior. For OO-tasks I prefer to work in Smalltalk-inspired languages like Python or Ruby. In particular, characteristics of "real" OO languages would be: late-bound, dynamically typed, and introspective.
Instead, when I work in C++ I prefer to use (what I think of as) "modern style" which was first defined (to the best of my knowledge) in Alexandrescu's book, and is perhaps best embodied by the Boost C++ library style. I realize that this is not everyone's cup of tea. But I think that this is the one area that C++ legitimately shines. It is what I call the "no compromise" style of programming - with the help of template meta-programming libraries you can write your code at a very high level of abstraction, and yet compile it down to extremely efficient code as if it were hand-coded in C to do that specific task. It can be pretty amazing, although it can also be (and probably is) a Turing Tarpit.
EDIT: Not sure why it really matters but: mid-30's, and I work on automotive infotainment systems. C & C++ are the only languages officially supported on the platform, so despite my dislike of C++, I write a lot of it and it is probably my strongest language.
Yeah there was nothing in the talk about it.
As far as I can tell, it's a somewhat silly reference to the fact that the influential book "Modern C++ Design" was written in the C++ 98 era.
This 2001 book advocated a clean break from the C heritage in C++:
https://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
It's heavy on template metaprogramming. I actually prefer "C with classes" for many problems, but it's it's clear that C++11, 14, 17 are going further in this direction.
And I believe that Immer relies on many features from C++11 and 14. Those features enable C++ the language to delegate all its data structures to libraries, rather than being part of the language.
-----
For a completely different and more useful application of the word "postmodern" in programming, I recommend this paper:
http://www.mcs.vuw.ac.nz/comp/Publications/CS-TR-02-9.abs.html
It's very insightful, fun, and in the 15 years since it was written has become more relevant. I haven't blogged about this, but this kind of thinking underlies the shell and the design of the Oil shell in particular. In particular, in large systems, there is "no grand narrative", and it makes sense to opportunistically use models when they are useful, but throw them out when they are not.
There is a tendency among programming language designers to assume that they are at the center of the universe. A big part of shell is about making existing pieces written in different languages work together.
And that includes the operating system. To me, it's obvious that runtime is more important compile time, and too many programming languages are ignorant of the other enormous piece of code that runs when your program runs -- the operating system.
>Classes without template parameters are not in a different type system then those with them.
Many people very strongly metaprogram in C++, using templates to make abstract types that bear no resemblance to traditional C++ classes, doing polymorphism, data hiding and various other cannonical aspects of classes without a class keyword in site. It quite clearly is a different type system, much more esoterically different than the one in ObjC, being compile time. We're not talking "classes with template parameters". It's a second, wholecloth type system. Interfaces (as java would call them) without the interface declaration.
>Also what the hell are "new style" vs "old style" template classes.
An old style template class is a class that works on a datatype or two which is templatized. A new style template class is something out of http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315 a very popular style in some shops.
>And what the hell are you even talking about with your "weird extra encapsulated ways"?
Class 1 has a private member variable to a second class called a Class1_impl which is a completely different class which implements the internals of Class1. This is an attempt to enforce data hiding from friending.
The reason I listed more than 2 type systems, is because I doubt you can say ALL the listed type systems I have are the same one. If even 2 of them are, C++ has "at least as many" as objective C does (or Java for that matter). If you've NOT encountered these esoterica, I just think you need to work in 2-4 more C++ shops and you definitely will. They're pretty common in my experience.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
http://www.amazon.com/Coding-Standards-Rules-Guidelines-Practices/dp/0321113586
Also if you want something really challenging:
http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043
http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
Free below:
https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html