Unity is the bee's knees.
I've been messing with it casually for several years, and got serious in the last 2-ish years. I like it because I get to use C#, and that's the language I know best. Only problem in it's using some weird limbo version of .NET 2, that's not actually 2.0 but is also 3.0 is some places? I think it's because it's using Mono 2.0, which is some subset of .NET. It's weird. They're moving to 4.5 soon anyways so I'm hype for that. I'ts been a lot of fun regardless, I get to apply a different knowledge and tool set from my day job. Not to mention it feels great when you actually get something to build and actually work.

So anyways here's a list of resources I've found over the years to be super helpful:

Things on Reddit

• r/Unity3D
  
  
• r/GameDev
  
  
• r/GameDesign
  
  
• r/Blender
  
  
• This comment on mathematic resources for games, by u/jozborn.
  
  Books
  
  
• C# in Depth. My favorite when it comes to C# knowledge. Written by one of the architects/designers of the C# language. (Companion site)
  
  
• The Art of Game Design: A Book of Lenses. Havent gotten too deep into this one, but I've been really liking it so far.
  
  
• Programming Game AI by Example. I've read quite a bit of this one, and it's been a great resource for AI stuff.
  
  
• Game Programming Patterns. This one is free if you read it online, but I suggest buying it. The examples are in C++, but the ideas can be applied in any language.
  
  
• Game Engine Architecture: 2^nd Edition. Probably something to look into down the line, but great to keep track of. Dives deep into the structure of a game engine, how it works, and some theory behind it. I've only gotten about half way, but it's my favorite book so far (for game dev).
  
  Videos
  
  
• Cooking with Unity. I went through basically all of these, and they helped me a lot when I was starting out.
  
  
• Pretty much anything this guy does is super great. I've used his videos a lot for ideas, inspiration, and tutorials.
  
  
• This guy is great too. Similar to the above in why I look to his works.
  
  
• This set of vids is for general C#, but he also has stuff for OpenGL. Plus I felt he has a great way of explaining and illustrating new ideas and concepts.
  
  Other Things
  
  
• Thu Unity3D Patch Notes. Great to see the new stuff the engine can do.
  
  
• An ton of (mostly) free books on github. General computer/programming stuff, but there is some good stuff in there for gamedev.
  
  
• This set of blog posts about memory/performance in Unity. Great general knowledge of things to watch out for.
  
  
• The Book of Shaders. More stuff for general graphics knowledge. Been looking through it a bit, and it's been really insightful.
  
  
  That's all I can think of right now. I know it's a lot, but hopefully you can take away at least one of these resources.
  
  Happy dev-ing!

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've posted this before but I'll repost it here:

Now in terms of the question that you ask in the title - this is what I recommend:

Job Interview Prep

1. Cracking the Coding Interview: 189 Programming Questions and Solutions
   
2. Programming Interviews Exposed: Coding Your Way Through the Interview
   
3. Introduction to Algorithms
   
4. The Algorithm Design Manual
   
5. Effective Java
   
6. Concurrent Programming in Java™: Design Principles and Pattern
   
7. Modern Operating Systems
   
8. Programming Pearls
   
9. Discrete Mathematics for Computer Scientists
   
   

   Junior Software Engineer Reading List
   

   
   

   Read This First
   

   
   

10. Pragmatic Thinking and Learning: Refactor Your Wetware
    
    

    Fundementals
    

    
    

11. Code Complete: A Practical Handbook of Software Construction
    
12. Software Estimation: Demystifying the Black Art
    
13. Software Engineering: A Practitioner's Approach
    
14. Refactoring: Improving the Design of Existing Code
    
15. Coder to Developer: Tools and Strategies for Delivering Your Software
    
16. Perfect Software: And Other Illusions about Testing
    
17. Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application
    
    

    Understanding Professional Software Environments
    

    
    

18. Agile Software Development: The Cooperative Game
    
19. Software Project Survival Guide
    
20. The Best Software Writing I: Selected and Introduced by Joel Spolsky
    
21. Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams
    
22. Rapid Development: Taming Wild Software Schedules
    
23. Peopleware: Productive Projects and Teams
    
    

    Mentality
    

    
    

24. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency
    
25. Against Method
    
26. The Passionate Programmer: Creating a Remarkable Career in Software Development
    
    

    History
    

    
    

27. The Mythical Man-Month: Essays on Software Engineering
    
28. Computing Calamities: Lessons Learned from Products, Projects, and Companies That Failed
    
29. The Deadline: A Novel About Project Management
    
    

    Mid Level Software Engineer Reading List
    

    
    

    Read This First
    

    
    

30. Personal Development for Smart People: The Conscious Pursuit of Personal Growth
    
    

    Fundementals
    

    
    

31. The Clean Coder: A Code of Conduct for Professional Programmers
    
32. Clean Code: A Handbook of Agile Software Craftsmanship
    
33. Solid Code
    
34. Code Craft: The Practice of Writing Excellent Code
    
35. Software Craftsmanship: The New Imperative
    
36. Writing Solid Code
    
    

    Software Design
    

    
    

37. Head First Design Patterns: A Brain-Friendly Guide
    
38. Design Patterns: Elements of Reusable Object-Oriented Software
    
39. Domain-Driven Design: Tackling Complexity in the Heart of Software
    
40. Domain-Driven Design Distilled
    
41. Design Patterns Explained: A New Perspective on Object-Oriented Design
    
42. Design Patterns in C# - Even though this is specific to C# the pattern can be used in any OO language.
    
43. Refactoring to Patterns
    
    

    Software Engineering Skill Sets
    

    
    

44. Building Microservices: Designing Fine-Grained Systems
    
45. Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools
    
46. NoEstimates: How To Measure Project Progress Without Estimating
    
47. Object-Oriented Software Construction
    
48. The Art of Software Testing
    
49. Release It!: Design and Deploy Production-Ready Software
    
50. Working Effectively with Legacy Code
    
51. Test Driven Development: By Example
    
    

    Databases
    

    
    

52. Database System Concepts
    
53. Database Management Systems
    
54. Foundation for Object / Relational Databases: The Third Manifesto
    
55. Refactoring Databases: Evolutionary Database Design
    
56. Data Access Patterns: Database Interactions in Object-Oriented Applications
    
    

    User Experience
    

    
    

57. Don't Make Me Think: A Common Sense Approach to Web Usability
    
58. The Design of Everyday Things
    
59. Programming Collective Intelligence: Building Smart Web 2.0 Applications
    
60. User Interface Design for Programmers
    
61. GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos
    
    

    Mentality
    

    
    

62. The Productive Programmer
    
63. Extreme Programming Explained: Embrace Change
    
64. Coders at Work: Reflections on the Craft of Programming
    
65. Facts and Fallacies of Software Engineering
    
    

    History
    

    
    

66. Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
    
67. New Turning Omnibus: 66 Excursions in Computer Science
    
68. Hacker's Delight
    
69. The Alchemist
    
70. Masterminds of Programming: Conversations with the Creators of Major Programming Languages
    
71. The Information: A History, A Theory, A Flood
    
    

    Specialist Skills
    

    
    In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.
    
    

72. Peter Norton's Assembly Language Book for the IBM PC
    
73. Expert C Programming: Deep C Secrets
    
74. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming
    
75. The C++ Programming Language
    
76. Effective C++: 55 Specific Ways to Improve Your Programs and Designs
    
77. More Effective C++: 35 New Ways to Improve Your Programs and Designs
    
78. More Effective C#: 50 Specific Ways to Improve Your C#
    
79. CLR via C#
    
80. Mr. Bunny's Big Cup o' Java
    
81. Thinking in Java
    
82. JUnit in Action
    
83. Functional Programming in Scala
    
84. The Art of Prolog: Advanced Programming Techniques
    
85. The Craft of Prolog
    
86. Programming Perl: Unmatched Power for Text Processing and Scripting
    
87. Dive into Python 3
    
88. why's (poignant) guide to Ruby

“Why is C# better than Python” is a tough question to answer, but the short answer is that all the features of C# were put there for a reason. And there are MANY features; C# has evolved over the years to support virtually all of the programming paradigms you can imagine, from procedural code to object-oriented to functional to low-level memory/hardware interaction to whatever. It’s dauntingly complex to dig into all of it, but you really only need a relatively shallow subset of those features to be productive, and you’ll only get better as you absorb more of the profile. What you find as you watch other languages like Python evolve is that they’re really playing catch-up, trying to patch in features that C# has had from its inception. Of course, trying to stick static type safety in after the fact is extremely difficult, but you’re seeing a lot of that in both Python and JavaScript. The lifecycle typically goes something like this: new developers get a whiff of the complexity of C# and are put off, then are pleasantly surprised by how easy and “flexible” JavaScript seems, spend years working with it, and then after hitting a wall with the limitations of those languages, they start down the rabbit hole of trying to monkey around with them to try to fix them up to be more like C#.

Just from the outset, static typing is a huge necessity for large software projects. You can’t afford to exist in an environment where every change of a property throws the stability of your codebase into question, with a host of problems that you can’t identify until runtime. Code clarity is, I would argue, the DEFINING feature of a stable, healthy project, and what you find with dynamically-typed languages is that people get to be afraid to refactor for clarity, because the code is brittle and can’t be changed with any reasonable
level of confidence.

Som people try to make assertions like “a good linter is just as powerful as a strongly-typed language”, but that just strikes me as nonsense. It’s only true if you can commit to using the language in a very basic, highly-conventional way, and once you’ve done that, what you’ve REALLY done is abandoned the flexibility that was the hallmark of the loosely-typed language in the first place, AND what you end up with is a very limited subset of the features a true statically-typed language gives you. It’s really tantamount to believing that most static-typing support is superfluous, which it is most definitely is not.

The thing about JavaScript in particular is that it received an enormous boost by being the only game in town. It’s still a pretty crappy language, but it used to be considerably worse; people tolerated it because it was the only game in town. Even then, it had its cadre of language evangelists who assured everybody that the overwhelmingly primitive nature of the language was really a great feature, and maybe in some abstract sense they were correct insofar as it was sufficient to become a building block for better transpiled iterations of it. But largely, as new features were introduced, developers embraced them wholeheartedly, which likely wouldn’t have been the case if there really was a ton of value in the extremely raw nature of early JavaScript.

These are a couple of really excellent resources for C#, which really dig into the design motivations of the language:

https://www.amazon.com/C-Depth-3rd-Jon-Skeet/dp/161729134X
https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650

It’s worth noting that they’re both enormous books, and ironically the “Nutshell” book is over a thousand pages! That’s the kind of scope that you’re dealing with to really get into what C# has to offer. But once you do, it can feel awkward to switch between that and less-powerful languages. For that reason, I think every developer in any language could stand to learn about C#, since it’s just a great case study in language design.

All of that said, I always think it’s important to remember that programming in most dynamically-typed languages is pretty much like writing every C# program using Dictionary(string, object) as your only data type.

What kind of jobs are you applying for? Low-level stuff is typically applicable for things like engine work, graphics, optimization, networking and audio. Okay, that covers a lot of the game development process, but there are certainly jobs that aren't deep into that, like peripheral tooling (making tools for developers to use) or working on stuff like the webservices that powers the online community.

However, if your goal really is core game development, then you need to be a lot more targeted in how you learn. I have interviewed for and was hired by a game company that worked in C++, and have also worked in distributed, networked military simulations (think of it like boring, more realistic Starcraft), so here is how I gained the various knowledge I had in getting through those types of interviews (including a 90-minute written test for the game company where I had to debug C++ code on paper, answer various gotchas, etc.).

I don't know how far you have covered, but this is how I would approach the learning now, were I to start over again.

• Become really good at C++ - During my first job, I mostly used Java with Python/C++/Perl/TCL on the side. I learned a lot of C++ in short order to prepare for interviews and move jobs (to simulation).
  
  
• Read Accelerated C++ and/or C++ Primer. These are probably the best books for getting introduced to C++ and starting off in a good place (as in, not learning C++ in the form of C), getting familiar with using the OO system of C++ and using the standard library. Also remember to do the exercises to really reinforce the concepts.
  
  
• Read Effective C++ SUPER COLLECTION - In honesty, you can make do with just Effective C++, Volume 1, but these cover good practices for using C++.
  
  
• Read the C++ FAQ - lots of gotchas there and corner cases of C++.
  
  
• If you want to go beyond those books and resources, there are Herb Sutter's Exceptional C++ books.
  
  
• Understand the machine - this covers the low level component. Helping you to understand the machine itself, how your code runs, how it's executed.
  
• Read Randall Hyde's Write Great Code - This is one of my favorite technical books, and is language agnostic.
  
  It covers low-level concepts like CPU pipelining, memory, and how code interacts with the machine. I read this years after I started my job building simulations, and it reinforced a lot of what I learned previously and in college. I also recommended this book to a friend of mine who credits it with giving him an edge over his fellow college grads (he's years younger than I am) in low-level knowledge. If you don't know concepts like cache locality, cache lines and how memory is allocated, this book will cover that and more.
  
  
• Read Randall Hyde's Art of Assembly Language - I have only briefly touched upon this book, but it takes a unique approach to introducing you to x86 ASM (by using a higher-level form of ASM).
  
  
  
• Understand the algorithms and data structures - I took multiple classes in this in college, as well as periodically read CLRS to refresh my knowledge. But CLRS is too mathematically rigorous and theoretical here if you just want to get familiar with algorithms.
  
  
• Skeina's Algorithm Design Manual is a more practical approach to refreshing yourself on algorithms and also learning complexity theory.
  
  
• Skeina's Data Structures Lectures are helpful for data structures. In general, though, know these (I include whatever C++ has as well):
  
  • Dynamic array - std::vector<T> in C++.
    
  • Associative structures - std::map and std::unordered_map
    
  • Sets - std::set and std::unordered_set
    
  • Linked List - std::list<T> and std::forward_list<T>
    
  • Stacks and Queues - std::stack and std::queue
    
  • std::deque - The C++ implementation of a double-ended queue.
    
  • Trees - binary trees, red-black, heaps, tries (no standard C++ implementations of these, though stuff like std::set is typically implemented with a red-black tree behind the scenes)
    
  • Graphs
    
    
  • Understand the complexities of actions on each data structure (insertion, deletion, modification, searching, etc.)
    
    
• Read the wiki on Pathfinding, because this class of algorithms is very important in game development, as well as network communication.
  
  -----
  
  The above covers the 'core' stuff you'd have to learn. If you wanted to get into stuff like network programming or graphics programming rather than just core gameplay development, I can expound further.
  

I got my start by taking AP CS in high school. However, I had already gone to college and that was a while ago, so I read some books on the commute to/from work.

Initially, I read Sams Teach Yourself PHP, Mysql and Apache all in one to learn PHP.

Immediately afterward, I read Murach's Java Se 6 and Beginning Java Objects to learn Java.

Most recently, I read a portion of C++ Primer Plus, but got very sick of it. I've read most of Accelerated C++

I have a few other books on C# to read when the time comes to actually write code.

By the time I had read all of the above, I felt pretty confident on how to structure a program, regardless of language. As such, I was able to pick up Python and JavaScript quite easily just by reading online documentation at Python.org and W3Schools. When I'm writing a web app, I'll rely pretty heavily on PHP's and MySQL's online documentation to help me with whatever syntax quibbles I may have.

I still want to read Game Coding Complete and I'll probably want to find a few resources on programming within XCode.

They all tend to follow the same programming paradigms, to be honest. Java did a good job in getting me into an OOP mindset and C/C++ did a good job at helping me think about how to program things without layer of abstraction. Once I learned these concepts, it was pretty easy to get started with a new language. Programming in PHP can be super sloppy, but taking what I learned from other languages, I'm usually able to write fairly clean code in PHP (especially when I learned how to use classes).

I wouldn't recommend all of the books above, to be honest. I didn't have much ability to do online training at the time and compiled lists of books weren't nearly as useful at the time, so I relied mostly on Amazon book reviews. I'm sure you can find a few choice books on each language you want to learn and go that way. If you were to read books, I think Accelerated C++ is a good book, but works best if you already have some experience programming. I remember like Beginning Java Objects more than Murach's, though both are great as references (which is why they're both still in my bookshelf). C++ Primer Plus spends too much time teaching C and not enough time teaching C++ (you spend pages upon pages learning about C-style strings, aka char arrays, rather than just using the String Class, but I digress).

Ultimately, I could read a bunch about a language, but I never truly learned the language until I started writing in it. I've written a handful of programs just as proofs of concepts and I recommend you do the same while learning any language.

Rust is currently premature but that is only temporary. You don't have to restrict yourself to only a single language. Try it and see how it goes. Rustbyexample and the guide set the barrier pretty low as far as trying things out (although, windows support may currently only be mediocre). Rustbyexample in particular because everything can be run in place (without downloading anything). Concepts in one language extend to others so learning one helps with others.

---
Some of the following comments about Rust may also extend to other language like python. For example, python has a well organized and seemingly comprehensive documentation set on their main site which is a huge help. Other (newer) languages may also.

If you intend to learn it using the internet only (without printed books) then C++ may not be a good choice (in my experience). This C++ tutorial is pretty good but it is extremely brief compared to a book like Accelerated C++ which is compact, detailed, and covers much more material than the tutorial will (it may be difficult for a beginner though).

Rust doesn't currently have the luxury of referring to good books for instruction. So best practices and coding conventions are being baked directly into the compiler/guidelines pages (currently WIP)/the guide. This is really convenient compared to C++ where resources are much more scattered (aside from books).

Inevitably, if you try writing something though in either language, you will get confused/perplexed by something regardless of the quality of documentation. In those cases, having IRC for help is incredibly helpful. They can save you hours upon hours of mystification. The Rust IRC is extremely extremely helpful in that regard.

Rust has cargo which makes testing new things incredibly easy. My experience with C++ is you find a new repository you want to test, you download it and spend the next 2 hours trying to get dependencies in order so you can compile it. With cargo, you often run this and you're done:

git clone site:repository
cargo build

The C++ compiler is notoriously unhelpful also which extremely confusing especially to a beginner. It is commonly the case that it finds some issue on line 12. When you eventually find the error, it's on line 20 (the compiler points you to the wrong location). What kind of issue could it be...maybe you forgot a semicolon. In general, the rust compiler is much more helpful with regard to error messages. If there is a confusing error message, the compiler team would like to make it better. If you're still confused, there is always IRC.

C++ has a lot of IDE support which is very helpful for advanced projects. Rust currently doesn't (Python doesn't seem to either). This will probably improve in the future. Also, IDE support often costs money depending on the language.

First thing I noticed upon looking into your code, and I do apologize if it sounds a bit harsh, please forgive me: It's very disorganized, you have non-constant globals (nasty), and very sparse comments (not useful when trying to figure out code, try to at least have simple descriptions of what a function does), your map is hard coded in game (not bad for simple example, but try reading it from a file later on). I'm also curious why you're doing

struct inputstate curstate = {false, false, false, false, false, false, false};

within main, calling

inputstate curstate = //blah

should be sufficient. Calling struct will create a new structure, although maybe in this case it's making an inputstate. Either way, it's an odd line. Putting struct before inputstate is unnecessary.

I strongly suggest you learn more about C++ and Object Oriented programming, as it will solve these issues with organization and global variables you're having, if you use the ideas correctly. Since it seems like you do know some programming, I would suggest Accelerated C++.

Now, on to your questions:

> Is there a problem with using an IDE?

No way, and don't let anyone tell you there is. Visual Studio is an insanely powerful IDE, and I use it myself and absolutely love it. If you're comfortable with VS there's no need to switch because people say it isn't 'proper'. However, learning to use a simple text editor, g++ on command line and makefiles will be valuable, even if only as a learning exercise. That is why you should try to learn it. I know both, but prefer working with VS, intellisense is too good to deny hahaha.

> Do people only use vim/text/command line

It's personal preference really

> How to generate make files

Cmake can do it, and you may be able to do with an extension from VS, but I'm not sure

> Quickstart tutorial for vim/make

Look up the g++ compiler for linux (on windows minGW) and get vim running. Although I prefer Sublime Text 2 for text editing.

> Advantages of VS

Tons, if you learn the IDE it is another very powerful tool. My personal favorite thing in VS is the fantastic code completion, I've not found anything on par with it from any other editor.

> Can I do int a = b

Yes. I'm a bit confused with your wording though, if you're implying that a would equal b at all times, that is false. a = b at the time the expression is evaluated. If you want a to reference b you need a to be a pointer to b's address like so

int a = &b

Then doing

a

Will return the value of b at the time you've called *a

> Where can I get more help?

See the recommended book above, when you feel you've learned the concepts in there well, move on to a more advanced book listed on SO's C++ book list

I hope this covers your questions

Umm, I think Python is a good language to start with. It's forgiving and low on boilerplate code. I haven't read it but Learn Python the Hard Way by Zed Shaw is supposed to be decent (and it's free online). I didn't like Learning Python published by O'Reilly. I'd just read reviews on Amazon if Learn Python the Hard Way isn't working for you. Whichever you end up with, I recommend typing all examples from the book into the computer by hand. Something about doing this really helps make things stick in your head. You'll also make the occasional typo and have to debug your program which is something we programmers spend more time doing than any of us care to admit.

I think it is important to try to think of something you want to make and have it in mind while you are learning the language. It can be any software but I recommend a video game. They are really good for this because you can just think up a simple concept or implement your own version of an existing game. Having a goal makes it so you are constantly solving the problems you will encounter while trying to reach that goal which is the most important part of programming (more so than learning the syntax of the language). This is actually the highest rated Python book on Amazon and is all about gamedev with Python.

After you've learned Python to the point where you are comfortable (no need to master it), learn other languages to grow as a programmer. Once you've gotten a couple languages under your belt it's actually really easy to learn even more languages (unless it's a very odd language like Haskell, Lisp, or Brainfuck). The problem solving skills you've acquired often work in any language and you learn some new techniques as you learn new languages.

• Accelerated C++ is the go-to these days for C++.
  
• The C Programming Language is often recommended for learning C but it's pricey and there are dozens of good books on C to choose from.
  
• Head First Java gets recommended a lot for learning Java.
  
• C# In Depth is very highly rated and happens to be written by the guy with the largest score on StackOverflow (a kind of Q&A for programmers).
  
• The D Programming Language I really enjoyed.
  
• Programming Ruby 1.9 is often recommended but it felt more like a reference manual to me. There are higher rated books on Amazon.
  
  

Read these books to get to grips with the latest techniques and ways of working. As an employer I'd be extremely impressed if you'd read these books. They will give you a big head start when trying to move into the professional work environment. Most of them will apply to any programming language but they mainly use Java as the example language but it's very similar to C#. It's books like these that are the difference between a beginner and an expert, but don't forget when you start coding 9-5 with good developers you will very quickly pick things up. We were all in your position at one point, if you get these read it'll all be worth it in the end!

Coding

C# in depth - I've not read this one since I do Java but I've just had a quick glance. This should be pretty useful and it's a respected publisher. I think you should start with this one.

Clean Code - Great book which explains how to write clean concise code, this 1,000,000x. It doesn't matter what language you are using it should apply where ever you write code.

Cleaner Coder - Another Robert Martin book, this one is easy to read and quite short, it's all about conducting yourself in a professional manner when you are coding. Estimating time, working with co-workers, etc.. Another good read.

Growing Object-Oriented Software - This book is about writing code using test driven development. It explains the ideas and methodologies and then has a large example of a project that you build with TDD. I just read this recently and it is really good.

Head first design patterns - This book goes through essential design patterns when coding with an object orientated language. Another essential read. Very easy to read, lots of diagrams so no excuses to not read it!

Work Methodologys

Kanban

Succeeding with Agile


p.s

Start building stuff, get an account on linked in and state the languages you are working with. This will help as well because having something to show an employer is priceless.

I like this book for C++ if you want to learn C++. Python is easier though and most people start with Python. I like the book Learn Python the Hard Way (it's actually a pretty easy book lol) but there are quite a lot of books that are good for Python. (and I'm like 99% certain there are free versions of these books available on the web)

That's probably a good way to see if you like coding. Personally I love it 'cause it's a lot of problem solving, and then forcing a computer to do your evil bidding work.

Then for the chemistry part. I think everybody on the planet and their brother loves this book (it's also free on google). That will help you learn about the theory behind the software.

I also think you should talk to a professor who does computational work to let you toy around with it. I've had two advisors now in comp chem, and I get the feeling if a student came to either of them and said they wanted to play around with the software and see what comp chem is like, both of those professors would probably have been happy to set them up with an account to a supercomputer and show them a few tricks to setting up jobs, running simulations/calculations, viewing data, etc.

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.

Before anything, I want to ask if you're really going to work with C, whose support in visual studio is really poor, or if you're going to work with C++. My question is: are you sure you'll be working with C? Isn't it C++?

I've seen a lot of people say C when they mean C++. Given how bad is the C support in visual studio, I imagine this may be your case (i.e. someone told you that you'll be working with C programming using the Visual Studio IDE).

If this is really C, then I don't have much to give you, but if you'll be working with C++, then there are some to consider.

I know there are books targeted at teaching C++ together with the Visual Studio tooling. I don't know if they're any good though.

Microsoft has its channel9 website. It has several videos covering how to use Visual Studio and also several videos on C++. Here are some of their video series which seem good:

• https://channel9.msdn.com/Series/cplusplus-language-library (one of the teachers here seems to be Kate Gregory, who has given an interesting talk (IMO) at cppcon about teaching C++)
  
• https://channel9.msdn.com/Blogs/Sam/C-Language-Programming-with-Visual-Studio-2010-Ultimate-Pro-or-VC-Express - This one seems to be about C (not C++) on visual studio.
  
• https://channel9.msdn.com/Shows/The+Knowledge+Chamber/C-A-Language-for-Modern-Times - In there you'll also find some "isolated videos" like this one (like the previous one), which don't seem to be part of any series but are interesting anyway.
  
• https://channel9.msdn.com/Events/GoingNative/GoingNative-2012 - In here you can find videos about this GoingNative conference, which is pretty much about C++ and the importance of native code. This is fairly advanced, but that's the sort of thing you can find as well.
  
• https://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C- - This is a series of videos by one of the people at MS who is part of their C++ standard library team (Lavavej). It covers core C++, which is pretty much the C++ language (I've watched some of these lectures and found them really helpful).
  
• https://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Standard-Template-Library-STL- - Like above, by the same person, but this one is about the C++ standard library (whereas the previous one is about the core of the C++ language)
  
• https://www.youtube.com/user/CppCon - This is the youtube channel for the cppcon. You'll find tons of presentations in here. Several of them actually can be watched by a beginner C++ programmer (this is specially in your case given you're already a programmer) and be understood. Some of them can help you learn about C++ programming.
  
  A book I really liked is Accelerated C++, by Andrew Koenig and Barbara Moo (https://www.amazon.com/Accelerated-C-Practical-Programming-Example/dp/020170353X/). It's not very up to date considering how C++ changed since this book's publication date, but it's still good as an introduction IMO.
  
  For modern C++ introduction book, you can take Bjarne's A Tour of C++ (https://www.amazon.com/Tour-C--Depth-ebook/dp/B00F8CWGOS/).
  
  All of these materials I've posted in here are supposing you're interesting in getting up to speed fast. I believe Kate Gregory's course and Lavavej's two series will really helpful.

My own opinion is that it doesn't matter so much what books you use, especially with Google available to answer questions and provide supplementary examples. Some might be a bit clearer or a bit less, but you're going to get to the same place if you keep writing code and practicing those skills regardless of what you're reading.

If I wanted to learn to program in a given language these days, I'd probably just Google for "<language> tutorial" and start going...maybe bounce among a couple until I find one that's clear. The books I learned C and C++ with were written decades ago and are probably out-of-print.

I'm very dubious that college is the most effective way to learn a language. My experience with college classes is that a class will teach you general concepts, and you more-or-less pick up the language yourself (you'd need to to get the assignments done). Computer science courses will teach you things that are nice to know, like time analysis, but they aren't necessarily the best way to get someone up and running and writing code. I personally think that people tend to do better when they get to explore the things that they're unclear on. The professor might lead you to some important concepts that you might miss, but you don't need college classes to pick up programming, and I'd encourage people not to wait for said classes and hope that they just transform them into a programmer.

Note also that there are a lot of ways to program in C++, and these produce very different-looking programs.

• It can basically be used as C with an extra feature or two (a string class...back in the day, const...and using iostreams).
  
  
• It can be used in an OO fashion, where new and delete show up.
  
  
• It can be used in the currently-popular OO approach, with Boost and ideally no pointers showing up anywhere.
  
  Throw in templates and the STL showing up or not showing up, and you've got a fair number of "languages" that fall under "C++".
  
  My only recommendation is the one I use for trying to learn any new subject that I want to know well: get at least two books or sources on the subject and go through them one after the other, since you'll probably get a better idea of the material after having seen it in two different lights (and if one description of a particular point isn't clear, you have a second one to bounce to).
  
  There is one difference among books that I would say is meaningful, and that's that some books combine teaching C++ and learning to program and others deal just with C++ as a language and are intended for programmers (sometimes programmers that already know the language). If you want specific book recommendations, you might want to give a sort of idea of what background you're coming from (e.g. do you program at all yet?), because the sort of thing that, say, a junior C++ programmer would use to brush up on his C++ is a bit different from what I think would probably make a good "introduction to C++ for non-programmers" text.
  
  The last "brush-up" book I bought was Stroustrop's The C++ Programming Language, which taught me that I didn't know the language as well as I thought I had. This is probably behind-the-times enough now that something else is better for brush-up. If you want a "beginning programming" book, looking for something that has "learn" and "c++" in the title is probably a good heuristic.

I have to say linux profiling has seemed to me to be a fast-moving target, meaning you'll get scattered results if you search. But, there's this which seems up-to-date: http://en.wikipedia.org/wiki/Perf_%28Linux%29

Then there's Ulrich Drepper's 'What every programmer should know about memory' (long series, but worth skimming at least, if your code is memory intensive. At least read about cache-coherency and cache-lines): http://lwn.net/Articles/250967

But the biggest thing is to get the algorithms right. Sounds like you want image-processing books. Also, GPUs are just absolutely the right place to do this stuff, and there are probably libraries already out there for it; speaking of which, did you know about OpenCV? It even has some stuff implemented on the GPU (as CUDA). I root for OpenCL, but the fact is, almost everything out there, libraries, and books, is written for CUDA.

> All the software is written in C++: I am interested in unlearning bad habits and writing better and easier to maintain code.

I suggest Effective C++ if you haven't read it yet. Also, Herb Sutter's 'Exceptional C++' series (a 'digest' version is C++ Coding Standards: 101 Rules, Guidelines, and Best Practices).

Never read it myself, but I hear 'Code Complete' is good. Maybe, too, Martin Fowler's Refactoring book - it shows lots of little awkward, problematic patterns and what to do about them, with good discussion. Each cleanly separated out - it will refer back and forth, but you can read the bits one-at-a-time. Good bathroom reading :)

Re: algorithms: Ugh, I don't know. It sounds like you'll want some metric data structures, dealing with space as you do. There's http://www.amazon.com/Foundations-Multidimensional-Structures-Kaufmann-Computer/dp/0123694469, and I don't know what else, maybe some Knuth? But probably, you should learn undergraduate-level data structures and algorithms, Big O stuff. Any used CS Data Structures + Algorithms book should help with that.

Do not fear spending money, as a former boss said, "books are free" ie they pay for themselves if they save you an hour's debugging later. Good luck!

I am actually going to try to be helpful, in stark contrast to the rest of the comments. You actually want to learn two things C++ and the C++ STL, because the STL is the way to actually get work done with C++ these days.

The vast majority of my college classes were in C++, so I have read several computer science textbooks aimed at C++. The least bad of all the ones I have personally used was Understanding Program Design and Data Structures with C++ by Lambert and Naps. It is the textbook that My Introduction to Computer Science I class used back in the day. It is a serviceable into to computer science book; if you new to computer science it isn't too bad, if you are familiar with comp sci then the book should all be trivial but a good way to learn the language. It is kind of old but the basics of computer science haven't really changed since the 1970's anyway so it doesn't matter [Amazon link]. Lambert and Naps seems to have a newer C++ book out, I don't know anything about it; if it is a newer edition or a different approach or what [Amazon link]. The nice thing about the older one is I can vouch that it is okay, and you can get it really cheap used through Amazon.

Bjarne Stroustroup is the original creator of C++. His book, The C++ Programming Language, is a very good and very thorough overview of the language. Be warned though, it reads like a dense college textbook, mostly because it is a dense college textbook [Amazon link].

The other really essential one is The C++ Standard Template Library by Plauger. Stepanov, et al.; Stepanov is the creator of the STL [Amazon link].

My favorite STL book is actually The C++ Standard Template Library: A Tutorial and Referenceby Josuttis. It is a lot more readable [Amazon link].

Remember, the STL is there to be used, and it hasn't sucked since the late 90's, so don't go around making your own string classes and stack classes, except when you are playing around to learn C++.

Also the Boost libraries are really good now too, but it didn't really exist when I was doing C++, so I don't have any idea what is a good book for that.

Good luck! I just gave you about a year's worth of reading material, but at the end you will be a well-qualified C++ newbie.

The correct answer to:

Q. Should I learn C or C++ first?

Is:

A. Yes.

WARNING: Highly Opinionated Analysis of C vs C++

I see a lot of people recommending one way but no one offering an analysis of BOTH the Pro's & Con's.

I've been using C++ since ~1990. I've briefly worked on a PS3 C++ compiler when I worked for Sony. I've seen 2 major problems over the years with C++ programmers:

1. People don't exercise discipline and restraint in K.I.S.S.

They use (and abuse) every language feature because they can. There is this tendency to over-engineer even the simplest things. Take a look at this complete clusterfuck of CRC in the Boost library.

1109 lines of over-engineered C++ crap for a simple CRC32 function instead of a mere 25 lines of code!?!?! The C version would:

• do the same thing,
  
• be simpler to write, and
  
• be simpler to debug, and
  
• more importantly solve the problem at hand, not abstracted to the point of being over-engineered.
  
  The trade-off would be is that it is less flexible, but WHEN was the last time you needed to use a custom CRC polynomial!?!? One would instead use a different algorithm such as MD5, SHA, etc. that:
  
  
• has better better error-rate detection,
  
• less collisions,
  
• is multi-core.
  
  This excellent SO on hashing is but one example of focusing on the big picture.
  
  2. People lack a basic understanding of the cost let alone the implementation of C++ expressions.
  
  I've seen people stick a virtual function inside an inner loop and wonder why their performance is crap. I've seen people fail to grasp a basic understanding of pointers. I've seen people not understand memory management and how to guarantee zero memory leaks. I've seen people spend more time on writing an "über" template and waste hours debugging that instead of just writing something in 1/10 of the time and move on.
  
  IMO, due to the bloated, over-excessive verbose nature of C++ it is for these reason that I strongly recommend a beginner learn C first and then learn C++. You'll have a better understanding of why C++ is designed the way it is, what the design trade-offs are/were, what C++ hacks are, and how to best use the languages to their potential.
  
  However, this is ignoring the benefits and disadvantages of the Pro's/Con's of why one would learn C++ or C first.
  
  

  Learn C++ first
  

  
  

• C++ Pro
  
• C++ really is a better C then C in so many ways, too numerous to enumerate
  
• In the ways it is worse the smart people / companies use a sub-set of the language: Ubisoft avoid Templates, Exception Handling, and Run-Time Type Identification. When even a C++ committee member admits he writes in a sub-set of C++ himself you know the language is b-l-o-a-t-e-d.
  
• You won't have to unlearn certain "bad habits" of C
  
• Your skills will up-to-date
  
• Your code will be textually smaller (See note about Con)
  
• Job Security -- that is half joking, half serious. Seriously.
  
• You can enjoy the time exploring the different nooks and crannies of the language. You will see a different way to solve the same old problems. This can be both good and bad.
  
• Eventually you'll be able to enjoy deep technical C++ comedy such as Hitler on C++
  
• OOP (Object Orientated Programming) makes it almost easy to quickly write bigger scale programs
  
• Is multi-paradigm: Procedural, OOP, Functional, Generic. You have the freedom to pick and choose the parts of the language that fits your needs.
  
• For every problem you're trying to solve there is probably language support. Threads, and Atomics are finally part of the language.
  
  
• C++ Con
  
• You won't understand some of the C idioms used in practice
  
• The language is HUGE -- it will take you a decade to properly learn the language
  
• Debugging C++ is a PITA
  
• While people write crap code in any language, it is harder to read bad C++ code then C code.
  
• Compiler Support for the latest standards is a constantly moving target. Translation: Microsoft's Visual C++ has traditionally had crap support for the latest C and C++ standards. The good news is that MSVC 2015 finally supports a nice section of the language.
  
• While C++ can be textually smaller, one's code can easily be "bloated" if not careful (such as templates and partial template specialization)
  
• You really won't understand the run-time costs, nor be motivated to understand the underlying assembly language generated, by a "simple" C++ expression.
  
• Expect L-O-N-G compile times for any significant code base unless you use a "Bulk / Unity" build (you compile one .cpp file that includes EVERYTHING)
  
• It will be hard to resist over-engineering, over-complicating even the most basic tasks
  
• iostreams is a complete clusterfuck. Even the C++ committee recognizes there are many problems with C++ iostreams but sadly nothing is being done towards performance at the cost of type safety.
  
• It is far easier to blow your cache. Even Bjarne Stroustrup, the language designer, until 2012 didn't have a clue in understanding why Doubly Linked Lists were so slow compared to Arrays. HINT: The L1 Cache usage is critical for performance sensitive code.
  
• People tend to over-use the OOP paradigm even when they shouldn't. People make dogma and religion of "Design Patterns", failing to think if the model applies or not.
  
• The OOP paradigm is slow and bloated compared to Data-Orientated-Design. See Sony's Pitfalls of Object Orientated Programming
  
• Reflection STILL isn't standardized -- everyone has their own "home grown" approach. Maybe in C++17 ?
  
  
  

  Learn C first
  

  
  

• C Pro
  
• The language is tiny and easy to learn. Learn C the Hard Way is a great tutorial.
  
• No operator overloading
  
• No function overloading
  
• No lambas
  
• Has no reflection
  
• Has no exceptions
  
• Has no RTTI (Run-Time Type Identification)
  
• Has no STL (Standard Template Library)
  
• You will have a better understanding of the run-time "cost" or performance of code instead of a single line hiding "hidden" behaviour.
  
• You'll be a better programmer for understanding more of the lower-level implementation. If you don't know how to write itoa() or atoi() you're a noob programmer.
  
• You'll be forced to keep things simple
  
• You'll understand how to implement OOP in a non-OOP-native language, and better appreciate C++'s syntax sugar of OOP.
  
• You'll appreciate how C++ templates solve some but not all "textual replacement" problems and why #define macro's suck for debugging.
  
• Is ubiquitous, runs everywhere, and easy to get a C compiler for everything under the sun. Matz's Ruby Interpreter (MRI) was written in C, the Java VM was originally implemented in C, Perl is implemented in C, Linux is written in C. Anything popular and older then 10 years was probably written in C.
  
• Variables must be placed at top of a brace {
  
  
• C Con
  
• Compared to C++, you'll hate how primitive the language is such as typedefs for structs, no local functions, const is only "half" useful in C -- it can't be used in array declarations (See: http://stackoverflow.com/questions/5248571/is-there-const-in-c ), etc.
  
• No operator overloading
  
• No function overloading
  
• No lambas
  
• Has no reflection
  
• Has no exceptions
  
• Has no RTTI (Run-Time Type Identification)
  
• Has no STL (Standard Template Library)
  
• Simple algorithms can be tedious to write
  
• Variables must be placed at top of a brace {
  
  With that said there are numerous C++ books I would recommend to ALL C++ programmers. They are sorted from beginner to expert:
  
  
• The Design and Evolution of C++, Bjarne Stroustrup -- another ancient but fundamental to understanding all the kludges in C++
  
• The C++ Programming Language, 4th Edition <-- "Mandatory"
  
• ALL the books by Scott Meyer
  
• Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14
  
• Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition)
  
• Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library -- ancient but good
  
• Modern C++ Design: Generic Programming and Design Patterns Applied by Andrei Alexandrescu -- another ancient but it blew the doors open for C++ Meta-Programming. IT is interesting that he hates C++ -- he now works on the D language.
  
  If you can get only one book, get the The C++ Programming Language.
  
  Even though Bruce's book is ancient he keeps it simple and is a fun easy read. Remember this is before C++98 where the language is much simpler.
  
  
• Thinking in C++, Bruce Eckel
  
  You can find it online for free
  
  Lastly, just because you can, doesn't imply you should. Use balanced C++ and you'll be fine.

Well, you first need to ask yourself what you want to accomplish with it. Do you want to write stuff for the web ("web-apps" etc.), fully fledged system software, "utility scripts", games... or what? For the web, I'll let someone else answer (you'll be looking at learning HTML/CSS first, (technically not programming languages), then PHP, MySQL, some web framework, but I have very limited experience with those).

For systems programming, you'll want to learn something like C, C++ or Java eventually but they really aren't particularly beginner friendly (if you do go for C++, Stroustrup's "Principles" book is a decent place to start). I don't know anything about Java and very little about C, but really these are all probably not the place to start, just where you might want to go in the future.

Realistically, I'd recommend you learn something like Python. I love it, it's just awesome. It's fairly easy to learn and very flexible, there's even good support for web apps (Django framework etc). I believe the MIT OCW course linked in other comments are based around Python, I've heard good things about them but not used them personally.

Some other resources for Python:

http://www.reddit.com/r/learnpython

Learn Python the Hard Way

A Byte of Python

Good luck!

Books are still the best way to learn C++! C++ Primer, 5th Ed. covers all the basics of C++11 from functions and standard library usage to OOP and templates. Effective C++ reinforces good practices and idiomatic C++ that, despite being written for C++98, is just as relevent today as it was then, some of its contents even more so than ever before. Then Effective Modern C++ then does the same for C++11 and C++14 features, building on top of what C++ Primer covers about C++11 and introducing the subtle changes brought about by C++14. This is my primary recommendation for learning modern C++ from the ground up.

But we live in the internet age! Best make use of it! So many wonderful talks from conferences such as CppCon, C++Now, Meeting C++, ACCU and Code::Dive are all available for public viewing. With regards to modern C++, Herb Sutter's CppCon 2014 Back to the Basics! Essentials of Modern C++ Style and CppCon 2016 Leak-Freedom in C++... By Default are great videos to watch. For more specific topics, here is a list of videos that I've seen and personally found engaging, educational, and worth my time to watch (multiple times!):

• The Exception Situation for exception handling,
  
• rand() Considered Harmful and What C++ Programmers Need to Know about Header <random> for random number generation,
  
• Everything You Ever Wanted to Know About Move Semantic (and then some) for move semantics (by one of the authors of the proposal that introduced it!),
  
• Modern Template Metaprogramming: A Compendium for template metaprogramming,
  
• Lambdas from First Principles: A Whirlwind Tour of C++ for lambda expressions (this one is very good!), and
  
• Type Deduction and Why You Care for auto and decltype(auto) (I miss Scott :'( ).
  
  There are also shows such as CppChat and CppCast where interesting events, projects, papers, and people related to C++ are brought up and discussed. There are so many interesting blogs to read!
  
  And there is always people on IRC (##c++, ##c++-basic, and ##c++-general) and the Cpplang Slack Channel for live updates, discussions, debates, questions, answers, and/or just plain fun with a group of people that ranges from complete noobs who are learning the basics, to committee members and library authors whose names are known across the community. If you ever have a question or need help, these are the places to go and ask (/r/cpp_questions is nice too! :P ).
  
  And finally, links to videos, blog posts, articles, papers, interesting Stack Overflow questions, almost everything mentioned above is constantly being shared at isocpp.org and on /r/cpp. Subscribe to both to get a constant stream of links to anything and everything about C++.
  
  Edit: as for C++17 material, the standard is not technically completed/published yet, but that hasn't stopped the community from creating material about it! This paper lists all the changes from C++14 to C++17, with links to relevant papers, and this Git repo provides a simple "then, and now" comparisons of the major changes to the language. Talks describing the changes in breadth and in depth have been given at conferences, and blog posts have been written for a more textual description of the changes. C++17 is not a major update like C++11 was to C++98, but full of fixes, conveniences, more language flexibility and utility, and new toys to play with! If you have a solid foundation in C++11, C++14 and in turn C++17 should be relatively easy to pick up compared to the shift from classic (C++98) to modern C++.
  
  TL;DR Learn C++11 the best you can. Once you are comfortable with C++11, the transition to C++14 will feel natural, and C++17 will be waiting just around the corner.

When I started, the most memorable three resources I know I had were the following:

• Bjarne's book - I don't think any C++ developer can truly call themselves even intermediate until they have absorbed at least half the content in the book. I started off with his 3rd edition, which is way less intimidating and shorter, but I subsequently ran through this entire book after it came out. There are no shortcuts on here - you need to read it.
  
• Effective C++ 3rd Edition - I would almost require this one as it prevents any new C++ developer from getting caught in C++ gotchas. You should ideally follow this book up with his 4th edition afterwords. The reason why I recommended the 3rd first is because that book is much more newbie friendly. The 4th edition is targeted towards experienced C++ developers that already have had their feet wet with C++11/14 and want to figure out some best practices. Note the 3rd edition is for C++98 while the 4th is for C++11/14.
  
  After you're done with the two above required books, here are some useful readings:
  
  
• What Every Programmer Should Know About Memory - This is an absolutely essential reading whether or not you've taken any systems courses. It's the foundation of what you will be programming towards (optimizing CPU cache usage).
  
• 1024cores - I believe this guy works/worked at Google at one point, but his site is essential to understanding multi-threaded programming (which is essential in the field). Browse through his site and learn what you can.
  
• Linux Kernel Development - Robert Love (who also works at Google) has probably written the most concise and understandable book on the Linux kernel I've ever read, and I've run through the Daniel Bovet's book and Michael Kirrisk's. For one thing, they're 1,000 and 1,500+ pages, respectively. Secondly, all I've found in those two books that I didn't find in Robert Love's is the implementation details in some areas as well as the details on the scheduler. Robert Love's incredible descriptions on the bottom-half/tasklets were already more than effective for normal understanding. I believe the latter books were more detailed in the networking areas as well, but in that case, you're better off with Understanding Linux Network Internals.
  
  The above readings will probably be a solid 6-12 months to read and absorb assuming you spend a couple hours a day, but I think it'll be well worth it in the long run since this type of stuff sticks with you for a long time. I read the above around 2013, and I can still talk about the CFS/other schedulers, software interrupts, and how the CPU cache works. It'll also make converting to other languages even more of a breeze because you'll know how everything works underneath the hood.

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:

• Execution In The Kingdom of Nouns
  
  
• Why Arc Isn't Especially Object Oriented - and in particular "the smartest programmers [Graham knows] are some of the least excited about [Object Oriented Programming]".
  
  
  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.

You only need one book: The C Programming Language, 2nd Edition.

However, I would also recommend you own C: A Reference Manual, Fifth Edition, especially for the C99 coverage. Not needed immediately, by any means, but well worth having - the reference section of K&R will serve you well for quite a while for any C89/C90 coding.

A fine supplemental book is C Programming FAQs. Much of it is available online as the comp.lang.c Frequently Asked Questions, but the book adds material and polish.

Once you're ready for advanced C knowledge (I'd guess after at least a year of substantial C programming, but only you know when you're ready and interested enough), you really want to read Expert C Programming: Deep C Secrets, by Peter van der Linden.

There are some other very good books that have more or less direct applicability to C programming. The two I would call out are The Practice of Programming and Programming Pearls. Both worth far in excess of the asking price.

Good luck, and welcome to the deep end of the pool. The water's fine.

There's OO design, and there's particulars as to how to implement things in C++. I'm totally with unapersson as to, that the Os you make are as often conveniences or design helpers as representing real world objects. Ie that it's implementation objects. I don't remember how much OO design advice Effective C++ has, but it's a good book to get someone to intermediate C++ programmer. C++ Coding Standards by Herb Sutter and Andrei Alexandrescu talks at a fast clip about a lot of taste and design issues; I haven't looked at the 3rd edition of Eff. C++ but, from earlier editions, the difference is that Coding Standards is more dense, and sophisticated; Eff. C++ more basic (from what I can see, Coding Standards does cover the same material as Eff C++, but in a very compressed form, only the most minimal discussion; maybe not what you want when you're seeing the material for the first time.

As for pure OO design, I've heard that straight-up Grady Booch is still the best, but I have no experience of it.

I will say, if you want to be good at C++, you'll have to spend money on books (but get your company to buy them perhaps - compared to programmer time, books are free), and time on reading them; there are a lot of best-practices, technicalities and real pitfalls that are not immediately obvious.

edit:

> Also, should I be studying data structures/algorithms in unison with OOP?

Definitely. Have you learned the basics, stack, tree, queue, hash tables (or set, map, vector, unordered_set, unordered_map)? You /must/ know these. (priority_queue and list too, less so maybe.) If you can though I'd read (somehow) about other data structures, spatial ones especially in your case; they can really make your program more efficient and thus able to do more.

edit edit:

I have to say, the above books are for long-lasting code; probably for games your best bet is to look at how other programmers write their games (smaller, simpler, even in other languages - it can be hard to understand large, sophisticated codebases) and, just the necessary experience you gain from writing your own.

I think the first confusion here is that the language is a entity in the construction of a program. Does the type of a house that is built depend on what type of hammer the carpenter used to put up the walls? Or what kind of wrench a plumber used to put together the piping? Sure, the carpenter or plumber could've used a crowbar to do their job, but was it the right tool for the right job?

The right tool to build an Android app is Java. If you need better performance, and you don't need Google APIs, you can include C or C++ to further improve performance at the cost of added complexity.

There are a lot of different abstractions to add the ability to use other languages on the platform, but this comes at the cost of performance, and added potential points of failure (more abstractions = more potential bugs not caused by the coder.)

Heavy number crunching (especially on a RISC architecture) may push the device to its limits. Do yourself a favor and learn how to use the right tool for the right job. This book is both entertaining and informative, and this book will get you started in on C++ in a short amount of time.

C++ is the inspiration for Java, and the creation of Java is what caused C# into being. As such, the syntax for all of these languages are tightly woven between each other. I wouldn't doubt that within 15 minutes of light reading on Java you'll be up and running in its entirety.

C++, while being a slightly more complicated beast, isn't inherently an overly complicated one. The Object-Oriented concepts are all there to be leveraged.

While you say you're not a professional programmer; I think you'll find that broadening the languages you do learn will improve your ability to convey your thoughts and concisely implement them.

Best of luck!

These are books I actually own and would recommend. Of course there are other great/better books out there, but I'm going to stick with what I've actually bought and read or "read".

I say "read" because several books are NOT meant to be read cover-to-cover. These typically have about 1/3 that you should read like normal, and then skim the rest and know what's in the rest so that you can quickly reference it. These books are no less important, and often even more important. I've marked these kind of books as #ref for "read for reference". Normal books that should be read cover-to-cover are marked #read


For learning your first language: This is really the hardest part and unfortunately I don't have any books here I can vouch for. I started with "C++ for Dummies" and am not including a link because it's bad. Your best bet is probably "Learning <language>" by Oreily. I also love the Oreily pocket books because you can carry them and skim while on the bus or the john, but you can just do the same with your smartphone. Pocket Python, Pocket Java, Pocket C++

Top Recommendations:

Accelerated C++ #read Made for people who already know another language and want to pickup C++. Also great for people who need a refresher on C++. I really like how it doesn't start with OOP but gets you familiar with the imperative parts of C++ before diving into OOP.

The Algorithm Design Manual #ref This is my new favorite book and the first I would send back in time to myself if I could. Each algorithm & data structure is given a mathematical breakdown, pseudocode, implementation in very readable C, a picture (very helpful), and an interesting war story of how it Saved The Day.


Cracking the Coding Interview #read I originally avoided this book like the plague because it represented everything I hate about coding interviews, but many interviewers pull questions straight from this book so this book can equal getting a job. Put that way, it's ROI is insane.

The Pragmatic Programmer #read Must-have for any profressional software engineer that covers best-practices for code and your growth. You can also find the raw tips list here

Head First Design Patterns #read Many prefer the "GoF/Gang of Four" Design Patterns which is more iconic, but Head First is a modern-version using Java to cover actual design patterns used day-to-day by programmers.

For Intermediates:

Effective Java or Effective C++ and Effective Modern C++ #read When you're ready to go deep into one language, these books will give you a huge boost to writing good Java and C++.

Design Patterns #ref You'll want to get this at some point, but early on it's too much for a beginner and many of the patterns are obsolete.

The Art of Computer Programming #ref The programming "bible" but like Design Patterns you should hold off on this iconic book until you've got your basics covered. It would make for a great purchase with your first paycheck or first promotion :)

I'll start off with some titles that might not be so apparent:

Unexpected Fundamentals

These 2 books provide much needed information about making reusable patterns and objects. These are life saving things! They are not language dependent. You need to know how to do these patterns, and it shouldn't be too hard to figure out how to implement them in your chosen language.

• Design Patterns: Elements of Reusable Object-Oriented Software
  
  
• Game Programming Paterns
  
   
  
  Good General book
  
  
• Effective C++: 55 Specific Ways to Improve Your Programs and Designs
  
   
  
  This book is great if you're going to make a browser based game
  
  
• HTML5 Canvas Cookbook
  
   
  
  General Knowledge books
  
  
• Pro HTML5 Games (Expert's Voice in Web Development)
  
   
  
  Provide a working moveable 3D model with C++ and DirectX, Very cool.
  
  
• Character Animation With Direct3D
  
   
  
  More general game base building
  
  
• Game Engine Architecture, Second Edition
  
  
• Programming Game AI By Example
  
   
  
  Working product results books, little if any modification needed
  
  Releasing in a couple months (hopefully) 2 Very good books using C++ to develop by.
  
  
• Introduction to 3D Game Programming with DirectX 12
  
  
• Introduction to 3D Game Programming with DirectX 11
  
   
  
  Not presented in the best manner but still noteworthy:
  
  
• DirectX 11.1 Game Programming
  
   
  
  I used to love XNA...but now it's not feasible for commercial development. If you're a beginner to game design...starting out with XNA might actually be useful. It's easy to pickup and put out a working product. XNA is C#
  
   
  
  
• Learning XNA 4.0: Game Development for the PC, Xbox 360, and Windows Phone 7
  
  
• XNA Game Studio 4.0 Programming: Developing for Windows Phone 7 and Xbox 360
  
  
• XNA 4.0 Game Development by Example: Beginners Guide
  
  
• Beginning XNA 3.0 Game Programming: From Novice to Professional (Expert's Voice in XNA)
  
  
• XNA 3.0 Game Programming Recipes: A Problem-Solution Approach (Expert's Voice in XNA)
  
  
• Building XNA 2.0 Games: A Practical Guide for Independent Game Development (Books for Professionals by Professionals)
  
   
  
  Working product books, modification needed to make run on current systems
  
  
  Provides a working FPS game in C++ on DirectX 9. Good for some starting out knowledge for an FPS
  
  
• Programming Mutliplayer FPS Direct X
  
   
  
  Good for 3D Terrain rendering in DX9...however much of this is outdated...some concepts still apply, and it's not the worst idea to see a working example.
  
  
• Real-Time 3D Terrain Engines Using C++ and DirectX9 (Charles River Media Game Development)
  
   
  
  TLDR: Click links starting at top, buy, read, profit

These are good, but I would say they're actually better for learning C++ rather than branching to higher level concepts. C++ is one of the easiest languages to implement best practices with and it's intuitive if you're a good programmer. The language and standard itself promotes cleverness and conciseness.

Some books I would suggest for branching to higher level C++ would be Effective C++ and More Effective C++.

Both are wonderfully written and relevant across standards. It focuses on bigger picture C++ rather than exactly current standards.

• Redis is a very popular key:value store written entirely in very readable C. However if you were to expand your list to just "popular software written in C" (such as MariaDB) it would probably be very long, and not too useful. I would advise you to not do this, and focus on C specific stuff.
  
  
• ZeroMQ is a pretty nice networking library for high performance message passing.
  
  
• Jannson is apparently pretty popular for working with JSON. I haven't used it myself.
  
  
• Ragel is a DSL for finite state machines that compiles to C amongst other languages. You can also use it to parse text, by describing your tokens with regex like syntax, and wiring token detection to state transitions. It sounds complex, but its actually really straightforward, and I have found it to output parsing code much faster and safer than I could write it, and it worked fine in embedded too. Zed Shaw sings its praises here.
  
  
• Expert C Programming: Deep C Secrets is a very good book, which should certainly not be your first or maybe second C book, but really digs into the innards in a very interesting and entertaining way.
  
  

C++ has been around for exactly 30, what i mean by that is that it's still widely used in production until this day, and doesn't look like it's gonna change any time soon. it's more then any other language out there, with C as an exception. I'm not sure C# would be valid in 10 or 20 years, but C++ would.

Your best resource for learning C++ would be good books. Like i mentioned, i highly recommend The C++ Programming Language, 4th Edition, it's updated and very complete reference to the language. there's also Effective C++ - it's not for beginners.

There's right, you won't find too much resources about C++ at first glance, but you will if you will dig a bit deeper.

Here's few sites that you should use:

• C++ reference
  
• The C++ Resources Network
  
• Boost
  
  You also might find some useful stuff and links in the Google+ C++ Community
  
  
  Other people and myself have mentioned learning C++ is not easy, partly is because the lake of documentation on the web. but once you know the language well, you will enjoy it's benefits. It's not for everyone though. I also recommend looking into new technologies like emscripten, it allows to compile C++ code into JavaScript, understand the implications of that, and maybe you will also have my POV.

Another "lunches" book to read after the first is Powershell Toolmaking in a month of lunches there's another book coming out on the matter of Scripting later this year.

Also, for reference see if you can get Powershell in Action

It was written by the man who architected and designed the bloody thing, so you're in good hands. I've not read it cover to cover, but it's certainly the definitive reference on the subject.

All above books rated 5/5 stars on amazon by a lot of people.

If you're so bogged down, stitched up and scared to even think about automating anything, then I'd absolutely recommend The Phoenix Project this is the paradigm shift IT has gone through over the past decade. Essentially, IT has taken on board efficiency and best practices that have been standard in the manufacturing industry for decades, to incredible success.

Seriously, "Bag of Nails" IT shops are on their way out. If they're that unwilling to take a step back and do things the smart way, they're a shit company to work for. Learn about technical debt and why it's critical to pay it off.

DevOps and Site Reliability are in essence the latest buzzwords in IT service management, but there's a lot of positive change going on in the industry off the back of it. There's a sort of productivity Gold Rush.

If you're bogged down your current job sounds like the perfect place to cut your teeth and leapfrog off the back of it to move into a better organisation who wants to work smart.

Have fun!

Hi PizzaPartify,
I believe that different companies/teams will place emphasis on different skills. When I was helping to hire software engineers for EA's motion capture studio, I liked to see candidates who showed a strong aptitude for engineering code to be maintainable. For me, this meant a familiarity with design patterns and software development processes (like Test Driven Development or Extreme Programming). In my department, much of our code was in C++ and Python. However, other departments would use languages like Java, C# or ActionScript - depending on the project.

It would be helpful to know what role you are applying to.

To answer your specific questions:

1. If you're already familiar with C++, I would highly recommend reading Effective C++ by Scott Meyers (http://www.amazon.ca/Effective-Specific-Improve-Programs-Designs/dp/0321334876). Every C++ developer should read this.
   
   Regardless of the language you're working in, I would also recommend Design Patterns by the gang of four (http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612).
   
   A game-specific recommendation is Game Engine Architecture by Jason Gregory (http://www.amazon.ca/Game-Engine-Architecture-Jason-Gregory/dp/1568814135). It doesn't matter if you intend to write an engine or not, it is immensely helpful to understand how they work.
   
   I own all of the Game Programming Gems books but use them more as a reference library. The books above will be more helpful right now.
   
   
2. I worked with Unity only briefly to prototype a game, so I can't really comment here.
   
   
3. This is tricky. I think you will need to find a passion project in C++ so that you will just naturally learn more about the language. And speaking of passion: you need to really want the job you are applying for. I have seen qualified developers miss out on jobs because you could tell they were just looking for anything (rather than really being enthusiastic about the position).
   
   I hope that helps.

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.

For starters: http://c.learncodethehardway.org/book/

Then for some advanced material (Books, sorry they cost $ but they are written by a king C++ con$ultant) : Everything this guy writes. Namely his "...Tips for Effective C++" series, of which he has several. He released one very recently, actually.

• for modern C++
  
  
• for older C++ 03.
  
  He's got other books, although these are his true gems.
  
  Lastly, I think it's valueable to find read blogs of C++ industry programmers-- using C++ in an effective matter is not trivial, and requires a nontrivial commitment. By the time I started realizing the benefit of blogs, I started moving away from C++ to other languages (Because HEY! You can actually get stuff done in other languages!!) The main one I (did) read is this Casey Muratori's blog posts - link is to the start of a really good series of about 3 of his blog posts. He talks about specifically, "how to give birth" to objects. and it's great.

If you're mainly interested in Java, I would recommend Effective Java by Joshua Bloch. It's a great guide with recommendations for best practices in the language.

For C, the best book is The C Programming Language by Kernighan and Ritchie. I would recommend that you read that before ever looking at C++ because C++ is based on C. In fact, it's such a great book that I would recommend reading it before you read anything else on any language. You can skip the file system and Unix stuff though.

For C++, I have never found a good beginner book, so my suggestion would be that after you read the above C book, read the stuff in this tutorial and then read Effective C++ by Scott Meyers. It's another best practices book.

For Python, I've heard good things about Learning Python but I don't really know. I actually found it more useful to just go through the Python tutorial and then start making fun little scripts.

Hope that helps!

This is really cool! Thank you.

>A common question is whether the book is still relevant. After all it's over ten years old

I find that some old(ish) books can really hold some great significance, for example: Effective C++ and Clean code have both given me some brilliant tips on making better code. I'm also readingWrite Great Code. If you have any more books i'd love to see them :) Thank you, again.

I'll give this one a shot, since I've read through all your comments on here.

It seems as though you're interested in 'programming linux' in the literal sense that you wish to program an operating system similar to linux?

Now below you mentioned creating your own compilers, codebase, etc. So assuming that you're going to at LEAST start with the linux kernel (if not, writing your own kernel is something only a handful of people in the world know how to do, I can't even begin to instruct you on that.)

You're going to want to learn something to introduce you to programming in general to start with, Python is incredibly popular since it's 'easy' due to the minimal amount of syntax. If you don't have much experience, this would be a good place to start.

If you plan on making your own compilers, you're going to need to understand how C/C++ breaks into ASM, and further breaks into machine code / binary. This will be an extremely in-depth process, and you will generate a LOT of code in VERY low-level languages, which is why there are only a handful of compilers out there.

Now, continuing onto the actual linux OS itself, assuming you were editing the actual behaviors of the OS, you'll need to know a HUGE amount of C, as that's what a large amount of the native Linux code is programmed in. C, unlike python is a LOT of Syntax. C++ is like a less syntax intensive version of C that supports many of the same design ideology as C with some simplifications. It's not AS well suited at dealing with the lowest levels of computing that you'll be getting into with OS programming.

Now, next you're going to have to get into the hardware side of C, and that's where things get really hard. There are a set of tutorials here: http://www.learn-c.com/ that will give you a good place to start off. I cannot urge you enough to focus intently on the hardware aspects of things, as hardware support generally makes / breaks an OS.

Lastly, and perhaps most importantly. Make sure you understand design paradigms. Picking up a copy of:
http://www.amazon.com/Coding-Standards-Rules-Guidelines-Practices/dp/0321113586 might do you some good. Although it focuses on C++ there is a lot of generally good practices that you can take away from it. Chances are damn good you'll need C++ for this as well, and despite Linus talking out against C++ every now and again, it's a VERY robust language. Not suited for EVERY situation, but extremely well suited for others.

Hopefully this has made some sense. Good luck in your endeavors.

Introduction to Algorithms by CLRS

TAOCP is a waste of time and money; it's more for adorning your bookshelf than for actually reading. Pretty much anyone who suggests TAOCP and is less than 55 years old is just parroting Standard Wisdom™.

Godel, Escher, Bach is a nice book, but it's not as intellectually deep in today's world as it was when first published; a lot of the memes in GEB have been thoroughly absorbed into nerd culture at this point and the book should be enjoyed more as a work of art than expecting it to be particularly informative (IMO).

If you're interested in compilers, I recommend Engineering a Compiler by Cooper & Torczon. Same thing as TAOCP applies to people who suggest the Dragon Book. The Dragon Book is still good, but it focuses too much on parser generators and doesn't really cover enough of the other modern good stuff. (Yes, even the new edition.)

As far as real programming goes, K&R's The C Programming Language is still unmatched for its quality of exposition and brevity, but these days I'd strongly suggest picking up some Python or something before diving into C. And as a practical matter, I'd suggest learning some C++ from Koenig & Moo's Accelerated C++ before learning straight C.

Sipser's Introduction to the Theory of Computation is a good theory book, but I'd really suggest getting CLRS before Sipser. CLRS is way more interesting IMHO.

I think you partially need to decide what area you want to focus on. Generally if you're going to delve into more advanced materials they should also be geared towards the in depth aspects of a specific technology, methodology, or problem.

I'll add a +1 for the design patterns suggestion. The Head First book is an option, but here is the book that I've got that is quite good. There's always the gang of 4 book, and although it is the "design patterns bible" its also a bit dry.

I'm also going to suggest Mark Seemann's Dependency Injection book. Although it is about DI and inversion of control containers, he also really focuses on SOLID design that makes DI more effective.

If you don't know what SOLID design principles are, then I'd brush up on that.

Turning specifically to C#, there's Jon Skeet's C# in Depth and also Jeremy Richter's CLR via C#. Both are great books are focused on roughly the same thing, understanding some of the inner workings of of the C# language, but they each approach it in a slightly different way. Although the CLR book came out before, C# in Depth seems to be a bit more highly regarded. I'd take a look at the TOC of each and see which one interests you more.

Outside of that, I'd say make sure that you really understand concepts like generics, reflection, and maybe even dive into understanding some MSIL.

Hey, I highly recommend checking out the code academy courses on programming. At the level you're at, pretty much starting with any language will be beneficial since most of the beginning concepts are universal.

https://www.codecademy.com/

C++ has a larger learning curve past the beginner stage than other languages (in my opinion). It's a wonderful and extremely powerful language but memory management concepts can be challenging for a large majority of learners.

If that doesn't deter you, then you may find this book useful. I've used quite a few C++ books in college and this one was my favorite. Once you feel comfortable with object oriented design with class building, dynamic memory allocation, basic generic programming and basic data structure then I cannot recommend enough:

effective C++

You can definitely find a PDF of that if you just google the ISBN number and "pdf"

Coding is so much and it can really take a lot of time to finally make anything practical so patience is also incredibly important. Also, you must acknowledge and accept that you will NEVER know everything you want to know. You will learn new things all the time and you will work with people who think they know everything. Those are the ones who know the least, trust me.

Given your understanding of the problem with Js/React, I'd dive right in to C#/.NetCore. You're aware of potential pitfalls and confusion of language vs framework, but there's probably not a lot of avoiding it anyway. C# is fairly straight forward for the most part. .NetCore is fairly dominant now so starting with it makes sense.

You could start with this book if you wanted:

https://www.amazon.com/Programming-Language-Covering-Microsoft-Development/dp/0321741765

Its starting to show some age, but it is where I started. It does do a good job covering stuff like value vs reference types, nulls, basic operators, special types like string, structured exception handling, etc. that could be valuable, but you can probably infer most of it if you have learned any sort of OO before. There's some stuff in there that's simply out of date, and glaringly no coverage of async/await. There are a bunch of newer language features such as string interpolation that may be better or more accepted ways to handle things these days.

edit: this is also popular, but still only up to date on C# 5.0:
https://www.amazon.com/C-Depth-3rd-Jon-Skeet/dp/161729134X

7-zip uses a mix of C, C++ and assembly. Unless you have experience with any of these languages, I would highly recommend starting with something much simpler.

I would say if you're trying to learn programming, you need to strip away all the extra 'stuff' that gets packaged up to make a production system. Don't worry about the GUI, and put WPF and C# to the side (for the time being). Start with something simple that will allow you to learn variables, functions, types, control flow, etc. A lot of people recommend Python, and that's a fine place to start. Any language where you can open a new file, write a few lines of code, and see a result would be ideal (Lua, Ruby, Javascript, etc).

More to the point of your question, GUI design is hard. There are all kinds of issues that have to be taken into account: event callbacks from the 'worker' code to let the interface know something changed, threading issues (does the interface lock up while the backend is working?), does the 7z file format even lend itself to parsing just a directory listing without decompressing the entire file?... There is a lot there, and it's not a good starting point. It's something that you can move toward as you learn the basics, though. And I always like looking through other codebases looking for good ideas.

If you're really serious about specifically working with 7-zip, the code is available at their website. You'll need to download the source code from 7-zip.org, then you'll need C Primer Plus and C++ Primer Plus. These are the best 'intro to...' books that I've found for C and C++. You're looking at a few months of reading and experimenting, and a lot of frustration. You're not only going to learn the languages, but also the Windows API that will allow you to interact with the folder views. These are somewhat stubbed out in the 7-zip source, but the specific view you're talking about would need to be written from scratch.

Regardless, it sounds like a fun project and if you put in the time I'm sure you'll get some benefit from it. Just be aware that this is trying to paddle against the current, and it is easier to take a step by step approach (in my opinion).

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:

• Clay seems to have no take on concurrency whatsoever. In fact even googling for Clay concurrency is quite difficult. D2 tackles concurrency issues directly with a no-default-sharing model.
  
• I like Clay's syntax desugaring (what I call "lowering"), but it assigned a name for each operator, which I believe is adverse to generic programming. D2 lowers operators by passing the operator as a compile-time string into the function, which enables further generic processing.
  
• Clay's iterators and coordinates seem to be similar to D's ranges. I'm unclear from the documentation provided about the pervasiveness of related entities and idioms in Clay. D2's ranges turned out to be wildly successful. Both use compile-time introspection to assess membership of a type to a concept. For example, in Clay you assess the presence of a member "size" like this:
  
  [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.
  
  
• Clay mentions multiple dispatch as a major feature. Based on extensive experience in the topic I believe that that's a waste of time. Modern C++ Design has an extensive chapter on multiple dispatch, and I can vouch next to nobody uses it in the real world. Sure, it's nice to have, but its actual applicability is limited to shape collision testing and a few toy examples.
  
• The docs offer very little on Clay's module system (which is rock solid in D2). The use of an antipattern in Clay's docs worries me though:
  
  import myownlib.test.*;
  
  
• Both languages seem to pay attention to linking with C and assembling applications out of separate modules.
  
• D2 is aggressively geared towards allowing its users to write correct code. Clay seems to have nothing else to say beyond a run-of-the-mill exception model.
  
• Clay lacks object-oriented programming support, although it does offer a number of palliatives (discriminated unions, for which D2 has powerful library offerings). This design choice seems odd to me because I believe straight OOP is much more important than supporting the obscure multiple dispatch.
  
  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.

The assembly is rather light at the beginning. In your first year you have to write some assembly to control a little car with infrared sensors, but it's really easy. Later on though, there are pretty interesting classes on assembly which are pre-reqs for classes on optimizing/debugging. Also it never hurts to learn more. But this definitely isn't something I'd be too worried about coming in.

After K.N. King's book, we don't really cover many more C books. But Kernighan and Ritchie's C Programming Language is a good thing to read.

In terms of C++ books we cover, it's a little weird. For one class, we needed C++ Primer and another we needed C++ Primer Plus. We've also needed Algorithms in C++ by Robert Sedgewick and a couple others. However, most of our classes don't have "required" textbooks, just recommended ones. If you send me a message I can compile a list of the recommended ones from my courses this far.

Personally, I'd highly recommend all of Scott Meyers' books, such as Effective C++, More Effective C++, and Effective STL.

It's a form of metaprogramming — writing programs that run at compile time rather than runtime. Metaprogramming in C++ is a little strange at first because operations don't primarily occur on values, but on types. A metafunction might take a type as an input and generate a result type as an output, for instance. The type system of the language is the execution environment for metaprograms, and hence templates factor into it heavily. A template type parameter can stand for any type, which makes it sort of the equivalent of a variable in metaprogramming.

SFINAE is a very powerful tool used extensively in C++ template metaprogramming. It stands for Substitution Failure Is Not An Error. (The term was coined by the authors of the book C++ Templates: The Complete Guide. It's not an official term in the standard, although the standard of course mandates the behavior that the acronym is describing.) To understand what that means, you need to understand how overload resolution works.

In very broad terms, whenever you call a function, there might be multiple functions with that name. This includes very straightforward overloading:

void f(int x)
{
// ...
}

void f(long x)
{
// ...
}

But it can also include more complicated things, such as:

template <typename T>
void g(T x)
{
// ...
}

void g(double x)
{
// ...
}

The first g() is a template function that can be instantiated with any type for T. So what happens when you call g(3.5)? The standard lays out a series of steps that happen, called overload resolution.

The first thing that happens is to build a list of candidate functions. This can be trickier than you might imagine, because of things like implicit conversions. If there's a function with signature void f(Widget w) and I call f(42), there might be an implicit conversion that allows constructing a Widget from an int, for example. So the compiler chugs through all possible functions, using criteria like the number of arguments (which is of course affected by things like default arguments and variadic functions), and the types of arguments to arrive at a list of viable functions.

It's entirely possible that there is more than one viable function. In the g(3.5) example, both are viable. The standard specifies a series of criteria used to rank viable functions. One function can be more viable than another, for example if calling it involves fewer implicit conversions, and a bunch of other details like that. (In the example above, void g(double) is more viable than the template function, because it's an exact match for the argument 3.5.) Anyway, there is a long and complicated series of things that are considered but in the end a most viable function is chosen.

Finally, if the most viable function is a template function, then the template arguments are deduced, and the deduced values are substituted into the declaration. For example, if I called g(12), then T would be deduced as int. int will be substituted for T in the declaration, forming void g(int x). That's legal, so everything is fine. The template function is instantiated (T is substituted in the definition) and called, and everything is fine.

But what if the result of that substitution of T into the function's declaration results in something that's invalid? Consider:

struct Foo {
typedef int fonzie;
...
}

template <typename T>
typename T::fonzie h(T x);

In order for this declaration to be valid, T::fonzie has to be a valid expression. (typename is necessary here to tell the compiler that fonzie is a member type. See this page for an explanation.) Clearly if I try to pass an instance of Foo, that will be the case, but not otherwise. For example, if I try to call h(42), the type int::fonzie is nonsense.

That's the "substitution failure" part of SFINAE. The "is not an error" part means that this does not halt compilation. Rather, this overload is merely removed from the list of viable functions and the next best match is tried. (If there is no next best match, then that really is an error.)

We can harness this, by intentionally causing substitution failures. That allows us to say "don't consider this for overload resolution", which is in effect a way of steering things, of specifying some logic which is executed at compile time that decides which function is called based on certain criteria.

Here's how std::enable_if is implemented. Start with a template class:

template<bool B, typename T = void>
struct enable_if {};

This has two template parameters. The first, B is a non-type parameter, whereas the second one, T is a type parameter. It has a default value of void. Now we provide a partial specialization:

template<typename T>
struct enable_if<true, T> { typedef T type; };

If I try to instantiate enable_if with the first template parameter equal to true, then the result is the above specialization, which is a class that defines a single member type named type. Otherwise, we get the non-specialized class above which is just the empty class. Is it beginning to click?

enable_if<true, T>::type evaluates to T. enable_if<false, T>::type is a substitution failure, because there is no such member named type. If this is used as part of the declaration of a function, we can cause that function to not participate in overload resolution based on some true or false condition.

This is meant to be combined with other metafunctions, such as type traits. For instance, std::is_integral<T>::value is a static member that's true if T is an integer type (char, short, int, long, long long, etc.), otherwise it's false.

template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type func(T x);

If func() is called with an integral type, then std::is_integral<T>::value is true, which means we have:

template <typename T>
typename std::enable_if<true, void>::type func(T x);

We said earlier that if the first parameter to enable_if is true, then the second parameter is passed through to the member typedef ::type, so this is equivalent to

template <typename T>
void func(T x);

This is a plain old function returning void as long as T is deduced as an integer type. If it's not, then this is a substitution failure and this function becomes non-viable and does not participate in overload resolution. We could supply another overload that would apply in that case; it could either apply universally, or it could have conditions of its own, such as only accepting types that meet some other condition. This is the equivalent of an if/else or if/else if — we've written a meta-program that says "if the type is such and such, call this, otherwise call this."

I hope it's obvious that this is extremely powerful. It's used extensively in the implementation of the standard library, as well as numerous third party libraries like Boost.

If you want to learn more about C++ template metaprogramming, there was recently a talk at CppCon by Walter E. Brown titled Modern Template Metaprogramming - A Compendium. Here's part I, here's part II, and here are the slides (PDF). You can also read the book mentioned above, which is the definitive reference for this stuff, although it has not yet been updated to cover the new goodies in C++11 and C++14 such as variadic templates.

which books exactly, please guide me.

these ones?

Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition)

Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14 1st Edition

More Effective C++: 35 New Ways to Improve Your Programs and Designs 1st Edition

What is the difference between them? It seems effective cpp 3 is from 2005 and more effective cpp is from 1996. Is there a point in reading more effective cpp after reading the third edition of effective cpp?

Also, what do you think about C++ How to Program?

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.

For a quick reference, I like this list of 101 LINQ samples. For something more extensive, Pro LINQ is a little old but still pretty good. Also, C# in Depth is a great all-around C# book and has a few chapters devoted to LINQ.

I haven't read any real thorough comparisons between LINQ methods and their corresponding SQL keywords, but, most of the important methods are named identically to their SQL counterparts (with a few exceptions like Take() instead of TOP). I tend to stick with the standard method syntax and lambda expressions over query syntax most of the time, although the query syntax is sometimes more readable for groupings.

I use LINQ to Objects all the time, and LINQ to XML has come in handy on more than one occasion. If your intention is to use LINQ as a replacement for ADO.NET (i.e. accessing a relational database), then you'll probably want to look into Entity Framework and LINQ to Entities (the LINQ to SQL approach has been deprecated for a few years). Whether or not you should actually do this is debatable, but that's a whole other conversation.

>My only problem is that every book assumes i know nothing about Programming but i know(kinda)...

They're almost all like that. You'll want to find a book that covers a lot of material, and sort of skim through the "this is a variable, this is an if-statement" parts. Don't skip them altogether, as there will be differences, and special cases. C++ Primer is a good book for learning C++ IMHO.

It sounds like you don't really have your heart set on C++ though, which is cool too. Python is certainly used by big companies though, especially Google.

Give the guy a break. He's clearly learning and the last thing someone who is learning needs is to be ridiculed for trying. I get that he's being a bit cocky, but maybe he's coming from a different language, where he was strong, or something and doesn't quite the get the idiosyncrasies of C++. If you put yourself, someone who has some, moderate, maybe even decades of experience in his shoes, you might think twice about being so blatantly disrespectful. You followed it up with good instruction, but why put the guy down? You don't have to be an asshole to help the guy.

As for /u/roflmaohaxorz, you might want to check out some beginner books like Programming: Principle and Practice using C++. Maybe, take a look at using std::string, instead of trying to manage your strings raw. Then I'd suggest reading up on how the standard input and output streams work. Maybe some investigation into primitive data types to understand the difference between arrays, pointers and values. Keep trying, but be modest. Try to understand likely you don't know, what you don't know. Lastly, have fun!

I'd recommend C Primer Plus, though to be honest it would be a much better investment to study C++ with C++ Primer Plus from the same author.

Do you have to go with C? C++ is better for beginners while still maintaining all the C things. If you absolutely have to go with C (which I'm assuming you are studying for coding systems - most likely embedded, or to maintain legacy code), the book I pointed out should start you out nicely.

If it is programming you want to learn, I'd recommend trying your hands at Java or Python or any interpreted OOP-focused language first. Java has very nice IDEs (Eclipse, NetBeans, etc.); it has its roots in C/C++ so it should help making the transition back and forth. C/C++ can be a mess to get the build environment set up correctly if you are not using an IDE like Visual Studio.

If you are in college, a lot of these technical books are free through your online library.

I read "Professional ASP.NET MVC 3" about 3 years ago but it seems liek there is a MVC 5 version out now.

To your question about why is asp.net webforms becoming outdata. While there are many reasons I think the biggest is that MVC as a design pattern works really well web appplication development. Webforms is a great technology but it tries to enforce a stateful design pattern on web development which can make development harder. Stateful design patterns are better for desktop applications where as stateless applications are better for web applications. Lastly with MVC works better with a lot of the javascript frameworks out there that webforms really struggled to ingrate well with but a lot has been improved to fix this.

As others have mentioned, writing code is the best way to get exposure. But if you're a book guy like me then there are a lot of option out there that'll accelerate the process. You'd be insane to read all the following--these are just starting points that can accommodate different interests/tastes.

Having said that, I'll start with the one book that I think every C# developer should own:

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries

... it's a good read, and it includes a lot of direct input from the designers of the C# and the .NET Framework. Microsoft has been really good about sticking to those guidelines, so you'll immediately get a leg up on the Framework libraries if you work through this book. (Also, you'll win a lot of arguments with your coworkers about how APIs should be designed.)

General knowledge books (tons to pick from, but here are some winners):

• Cookbook-style factoids: C# 6.0 Cookbook, 4th Edition
  
• But since you're coming from a lower level language, you might appreciate more details: C# in Depth by Jon Skeet (the Chuck Norris of C#)
  
• Scott Meyers-style content with good discussions of idiomatic C#: Effective C#: 50 Specific Ways to Improve Your C#
  
• CLR via C# goes deep into the guts of the language.
  
  Deep dives into specific features that'll serve you well:
  
  
• Concurrency in C# Cookbook is a good starting point to get productive with the TPL quickly, but I actually learned a lot more from the more prosaic Pro Asynchronous Programming with .NET.
  
• C# generics aren't as powerful as C++ templates, but Metaprogramming in .NET may provide some decent (though clumsy) workarounds.
  
  Note: I've never found a good LINQ book that supported how I actually use the feature. Coming from C++, you can probably just start off by thinking of the extension methods on Enumerable as a C# version of std <algorithm>... a good way to avoid writing raw loops. But if you're a performance-obsessed game dev then you'll probably want to use LINQ sparingly--it does have some overhead.
  

The Pragmatic Programmer is about the discipline of Software Engineering. It focuses on treating Software Engineering like a craft, just like any other craft. Turning the focus of "just producing code" into an apprenticeship.

Clean Code is about how to write your code as cleanly as possible. Clean Code allows for better productivity, better maintenance, clearer understanding of your code, and makes communication with your peers easier.

Neither book is focused on .NET or any type of specific tech, they are more about how to approach the discipline of Software Engineering. Having that kind of mentality will help you conquer any Software Engineering hurdles you may be having.

If you feel you need to learn more about how .NET/C# works. These books might be best saved for later. But they will come in handy in the long run. It sounds to me like you have a grasp of being able to do your day-to-day job now. So maybe some general knowledge about Software Engineering would help.

If you are looking for something to read that is C# specific I cannot recommend C# in Depth enough. It is a rather dry read, but it completely covers all aspects of the language. It even does it in a chronological way so you can see the language grow and develop over time. If you have ever thought "Why does C# do it that way?" this book will answer that question. I found it fascinating to see the language grow over time and realize why the language is what it is today. Make sure to get the latest version of the book which I believe is currently the 3rd Edition.

And if that is what you want to do then there will always be jobs that require you to write code, but those aren't the only jobs available to people with a CS degree. I got my degree with no intent of writing code in the long term, I've always loved the analytics side of things and the systems integrations; the actual use between client, employee and system. And CS degrees teach more than how to program, they teach how to think logically like a programmer which is a huge boost to everything else you'll do later on.

Personally haven't used the Harvard site before but if you want to learn it yourself try and pick up Stroustrup's book on C++ programming.. One of my favorite books I have ever used, cheap, and written by the guy who literally invented modern day C++. If you can successfully implement the first half of his book, and understand why it all works, you'll be way ahead of most CS students. After that it's just applying OOP to other languages and practicing with bigger personal projects that use new languages/tech until you've sampled a ton of stuff and built a few multilayered projects.

Powershell in a month of lunches (as you've already seen), Powershell Toolmaking in a month of Lunches as a follow up looks good. Check out the sidebar of /r/PowerShell, Master-PowerShell was helpful for me, but ymmv. There's also the Hey, Scripting Guy! blog.

The things that always help me out when I'm just getting started is how do I find help, and how do I find commands/functions.

Finding commands

get-command [verb]

and

get-help [command]

also, check out get-help get-help, there are quite a few useful flags attached with get-help like -examples, which is really nice when you're just learning PowerShell.

It's pretty early for me, so this is just kind of a quick brain dump and I'm not entirely sure the coffee has hit my brain, yet, so I hope this helps.

Well, this is usually because C++ is not really a beginner friendly language. You need to understand the architecture/fundamentals of a computer system at times to understand certain concepts and are often difficult to understand ex: pointers, dynamic memory allocation etc. and with C++ you never finish learning!

Yes, you are very correct about understanding basics before doing actual game-based programming, C++ Primer is pretty old but it's definitely a golden book alongside it though for someone like you I will suggest some of the books I read a couple years back and some that I believe are better for beginners:

Accelerated C++: Practical Programming by Example

Programming: Principles and Practice Using C++

The C++ Programming Language, 4th Edition- Very big book, read this after you've read the rest.

And a book that I've heard is pretty good for game development with c++: https://www.amazon.com/Mastering-Game-Development-professional-realistic/dp/1788629221

I guess I'm going to go ahead and be "that guy".

Don't aim to work with a specific language.

I feel you should reframe your goal to be a "problem solver" that knows how to pick and use various tools to solve a problem. C++ may be one of those tools. Maybe C. Maybe Python. Maybe Java. You want to develop your skill set to be flexible enough to adopt the right tool for a job. Now, that's not to say you can't be a language expert. Language experts are very valuable and becoming one is a perfectly reasonable goal. That said, I think you'll find that you have many more opportunities when you remain flexible.

With that out of the way, I would say good next steps for continued C++ mastery are to read and understand Scott Meyers' excellent books:

• Effective C++
  
• More Effective C++
  
• Effective STL
  
• Effective Modern C++
  
  Also go through the CppCoreGuidelines.
  
  Beyond the language, make sure you know your standard data structures and algorithms.

As long as you understand that VBA would be less efficient, and you'd be doing it for the experience.

I like to get fully immersed in topics so I'd recommend this book. It helped me get a solid introduction of most topics without getting too complex. You can get by with just googling functions but long term you'll want a more thorough introduction either with this book or an online resource. Also the contextuals (spelling?) and mrexcel sites are good iirc. And definitely stackoverflow.

With that being said, this is a pretty straight forward script, so it shouldn't give you that much trouble. If you have trouble feel free to post your sample script and I can make some suggestions. The best method to learning VBA is to just go at it and see what work. Google and stackoverflow are your friend.

Jumping into C++ as a first programming language, especially with the kind of impatience that you seem to feel. I might characterize a few programming languages in this way (It's an old joke to talk about how to shoot yourself in the foot in various languages):

C will allow you to aim the gun at your foot and pull the trigger with no complaints. C++ will let you aim the gun and fire, without telling you that it was aimed at your foot the whole time. Java will warn you repeatedly as you aim the gun, warn you as you pull the trigger, and shoot you in a single toe.

C++ is a complicated language. Yes, it's powerful, but it's powerful in ways that you may not need, writing business apps. Python isn't a bad idea, if you want to work more on the web side, or write automation scripts. Java and C# would both be good options if you want to develop applications (C# especially, provided you want to do development on Windows).

If you're determined to jump in the deep end, consider this book. It's written by the original designer of C++, and it's written as a programming primer for beginners. It doesn't include the C++11 features (the most recent update to the language), but it ought to cover everything before that.

But, seriously: Slow down. You can learn the basic syntax of a language in a few weeks, and you can start feeling reasonably comfortable within a few months. You won't be as competent of a programmer as you feel like you are for a long time, though, and rushing through things isn't the way to get good.

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++

To date, the best programming book that I've read is C Programming Language by K&R. It's a pretty complete text on the C language. It is more than sufficient to enable the reader to be a good C programmer, yet it is still entirely digestable by new programmers. It is 274 pages. There are some recent gems, like Programming Clojure (304 pages). However, these days the norm seems to be more like Applying Domain-Driven Design and Patterns: With Examples in C# and .NET (576 pages), Real World Haskell (710 pages), and The C++ Programming Language (1030 pages). These books are all good. They just are hard to carry around and hard to hold while reading for long periods. I'm looking for good programming books that are short; an upper limit of roughly 325 pages. Post links to your favorites!

As a beginner, the resources you use to learn are much more important than the programming language you end up learning with them. C++ may be more complex than C#, but they're both incredibly complex for a beginner, and so your effectiveness starting out relies an incredible amount on which books you choose to go through. When I was learning C++, I really enjoyed the book Accelerated C++ by Koeing and Moo. It eschews the "learn c, then c++" attitude some other books have, and believes that C++ is significantly different enough from C to warrant a different approach. And you learn C++ one piece at a time, so it's never overwhelming. I heartily recommend it if you decide to learn C++.

I don't own any C# books for beginners, so you'll have to ask someone else for a recommendation :P.

Just a quick note: programming is incredibly difficult when you're just starting out, but it's 10x as rewarding, and is one of the most fun skills you can pick up. Good luck on your journey!

This doesn't sound like 'advanced C', this just sounds like having low level knowledge of certain things. You'll probably have better luck searching for books on kernel development if you want to know about the linux kernel for example, or compiler dev for compiler dev, or machine learning for machine learning etc.

Doesn't get much simpler than C, past the basics programming better C just involves expanding your mental model of the cpu - i.e. understanding that memory isn't just RAM, but also your CPU has caches helps when optimising code.

That being said, I picked up this from the library and read the first couple chapters. Seemed quite good, and gave you a nice overview of some of the idiosyncracies of C! https://www.amazon.co.uk/d/Books/Expert-C-Programming-Peter-van-Linden/0131774298

It might not fit your specific goals exactly but I am really enjoying C# in Depth.

It's not a 'learn to program' book so he starts with the assumption that the reader has a degree of background knowledge. He focuses on features that make C# unique as a language and explains concepts well. I also find the examples he works to be clear and interesting.

I'm using it as a supplement to a second year programming class and so far it's filling the gaps very nicely.

Hello,
Based on the comments until now i understand that you trying to learn asp.net core 2.
When i started my journey on asp.net i started with Professional ASP.NET MVC 5 great book.

For Asp.net Core i started with: Pro ASP.NET Core MVC its a nice book for asp.net core 1.

for asp.net core 2 i would suggest the Pro ASP.NET Core MVC 2 but with a slight hesitation because asp.net core 2 at the time of the publishing was still new.

Also this MVA course could help you.

If you need more info and tutorials - courses. Comment bellow and i will try to help you find the best courses for you.


Thanks.

Sorry but there's no cheat sheet and no reasonable way of making one. C++ is a rather large and complex language laid atop C, which is effectively laid atop an assembly language, which is compiler manufacturer and target platform dependant.

The best way to learn C++, or any programming language for that matter, is to use it, learn from your mistakes, and of course researching and reading everything you can. And of course, have fun with it!


Many popular books exist covering C++ things. Here are a couple good starter ones, in my opinion:

• Effective C++
  
• Design Patterns
  
  A couple popular C++ sites:
  
  
• http://www.cplusplus.com/
  
• http://en.cppreference.com/w/
  
  
  If you're simply starting to learn programming, start small. I suggest beginning with an object-oriented scripting language like Ruby, Python or Javascript. Most concepts will transfer to C++, but beware that the syntax will not - you will quickly see the difference!

I've found this book to be quite a good book and is quite complete. It may be a bit of a jump into the deep end, but I feel as though they explain things simply enough, piece by piece.

http://www.amazon.com/C-Primer-Plus-5th-Edition/dp/0672326973/ref=sr_1_1?ie=UTF8&qid=1333572620&sr=8-1

Also, C/C++ are GREAT first languages to learn. You have the opportunity to really understand how the computer itself functions with these languages, whereas with higher level languages, this type of understanding is quite easily lost as it becomes less important. It really depends on why you're learning it as to if it's a good first language or not.

I really like the books /u/joerod suggested.

Links:

PowerShell in a Month of lunches

Learn PowerShell Toolmaking in a Month of Lunches


For the MVA PowerShell courses:

MVA PowerShell - A plethora of good resources


Good luck! PowerShell is incredibly helpful and fun in both work and every day life!

Edit: Other recommendations from my old self

> even some "old but gold" ones are fine

The Scott Meyers book you mentioned, Effective C++, is just that: old but gold.

I'd also suggest you read his other books, Effective STL and More Effective C++.

These 3 books stand out amongst many for me, for their accessibility and effectiveness. It is worthwhile reading them now and getting a solid understanding on pre C++11 design principles etc.

Once his Effective C++11 book comes out, read that too!

Following these, but now moving from intermediate to expert level, the single biggest influence on how I designed and wrote C++ was Modern C++ Design by Andrei Alexandrescu.

It's pre C++11, but the insights into generic algorithm design using templates are just incredible.

Excerpt from the description on Amazon:

> Alexandrescu offers a cutting-edge approach to software design that unites design patterns, generic programming, and C++, enabling programmers to achieve expressive, flexible, and highly reusable code.

If there is ever one book I recommend people to read, it's this one.

|will I ever have to use ArrayList again?

You are correct, no you wouldn't have to at least in the vast majority of cases. As an aside, If you use a generic List<T> with object as the type (List<object>) it will work the same way as ArrayList - but normally you'll rarely have to use object as the generic type parameter.

|How can I make it work, then?

The scenario I provided is kind of unlikely, and you won't be able to completely escape type restrictions. But there are ways to make that example code work, however I doubt you'd every have to or want to use them. If you must know, I was thinking of the implicit conversion operator - User could convert itself to and from int (if that made sense to do!). Also, C# as of .NET has the 'dynamic' keyword, which could help accomplish similar semantics.

I was just thinking, if you want the soup-to-nuts of the .NET type system, delegates, generics, LINQ, lambdas and everything else, you might want to look into some of the books that cover things both in breadth and depth. I would personally recommend Jon Skeet's C# in Depth and Jeffery Richter's CLR Via C# both of which are flat out amazing, IMHO.

If you're fairly new, I think you should start something like Learn Windows PowerShell in a Month of Lunches. You'll find this recommendation everywhere and for good reason. I personally was an peer reviewer of the 3rd edition and read it page-for-page slowly and provided a lot of feedback. It's a good book to get started with.

After that then move into the advanced tool making books like Learn PowerShell Toolmaking in a Month of Lunches.

Of course this just help get you started. You'll need to get a lot of practice with realistic projects to become familiar with how to build tools. I would highly recommend becoming very familiar with Git. There are a TON of tutorials out there (both web pages and YouTube videos).

Honestly to become a good toolmaker you'll need a lot of practice, but in terms of material these are a good source to get you started. Be patient and try to find small projects that you can grab onto. I would also recommend Windows PowerShell in Action for a more under-the-hood kind of view of how things work.

Before teaching myself C++, I was terrified of the language too. Everyone said it's such a big language with many dark corners, and for the most part they're right. Then I /had/ to learn it for some coursework. I found the book C++ Primer to be very good. I abused all sorts of features of the language at the start, wrote tens of thousands of lines of code, and now I actually enjoy using the language for some tasks.

By analogy, cars and driving are scary too, but a healthy respect for the rules and best practices will usually get you to your destination safely.

I'd learn ASPNET MVC. This gives you a clear progression and also touches on CSS, HTML & JavaScript. If you're going to be a professional programmer, you're going to need this whole party. Why not look into that and make like a movie site? Or a project site where you can put topics you want to learn and rate them, add comments etc.

Be careful with learning for learnings sake.. I did that for too long and it's only when you're actually solving problems that things really start to stick..

Oh and this is THE book on C#.. I've read so many and this is by far the best; https://www.amazon.co.uk/Adaptive-Code-via-Interface-Principles/dp/0735683204

Good luck! Send me a message if you get stuck or need any more help.

Not sure about Qt, but the book Accelerated C++ is often recommended for people with a programming background who want to learn C++ (such as in this Stack Overflow question about book recommendations.)

I'm currently working through this book and I can personally recommend it. On the upside:

• It only spends a small amount of time going through the basics like variables and such.
  
• As the Stack Overflow description mentions, it is relatively compact at 300 pages, so you won't have to wade through some two-volume behemoth before becoming familiar with the language.
  
• It teaches the language in a "modern" style - unlike many C++ resources it does NOT take the approach of teaching C first (ie pointers and arrays, etc) - you'll be using Vectors and Strings and and other standard library classes quickly.
  
  On the downside it was released before C++11, so it doesn't cover any of the more modern features like auto, range-based for loops, lambda expressions etc. But you can always learn that stuff from some other resource - this book is still a great place to start in my opinion.

I recommend starting by teaching some version control basics. Focus on git and quickly cover others like TFS and subversion. You can read Pro Git for free.

If you teach a hardware/software course, CODE is an excellent book.

I also recommend C# in Depth. I would also think it'd be cool to offer points for contributing to StackOverflow or the new open source .NET projects on GitHub.

If you teach design/analysis or other classes focused on architecture, Adaptive Code via C# is pretty good. I'm only a few chapters in, but it discusses Scrum methodology, layering and tiers, as well as how to follow practices for writing great code.

I would also suggest a course on JavaScript. I have had to train too many Junior and Senior developers on how to write JavaScript. It's scary that many web developers don't even understand fundamentals.

What did it for me was to start with architecture lectures by Uncle Bob (Robert C Martin). You can google "Clean Architecture Uncle Bob" and start there. If you are developing on mobile platforms, I suggest reading on the VIPER architecture. Getting yourself accustomed with known architectural patterns helps a lot. There is no magic to it, it's a bunch of standard patterns all hooked up together, and they each help you solve a specific problem in a clean fashion. With good architecture, there is usually no ambiguity on "where should I put my code for this feature?"

This is also a pretty good book explaining the SOLID principles, it's mainly targeting C# but it's concepts that you can reuse in languages like Java. This book is really good IMO.

Accelerated C++ is an excellent recommendation. I would suggest quite the same thing, learn the basics before jumping into Boost. Accelerated C++ offers good, in-depth explanations of what's going on in the code, but not too mind numbingly deep that you get bored or can't understand it.

Boost::Asio is pretty good as far as a fairly mature socket and I/O library goes.

Sure it's in K&R, and that's the original source for a rule retold in many forms.

There were several very good books from the 80's that might have mentioned it - if could have been Harbison & Steele that he recalled.

If you're actively coding in C and like books, H&S is the best reference outside of the actual ANSI standard.

If you're serious about C++ programming and using the STL intelligently, I highly recommend getting a copy of Scott Meyers' Effective STL. He discusses exactly what you're asking about, e.g. when is a std::list better (or worse) than a std::vector, or how is a std::vector<bool> different than a std::bitset.

Actually all three of his books (Effective C++ and More Effective C++) are great reading if you haven't done so.

As for your question, if you need a thing to hold an array of something, std::vector is usually the go-to container for that.

A proper infix calculator program that can read something like 5*(3.5-1.2)/15+2.9 and give the correct answer isn't simple at all. It requires the creation of a parser, and to write a parser you'll need to know what grammar you're working with. The type of thinking needed to write a calculator is a step up from something simpler like a temperature converter, Tic Tac Toe or even Minesweeper even if it may not seem so.

Bjarne Stroustrup's Programming: Principles and Practice Using C++ devotes two chapters to making a complete console-based calculator with proper error checking and recovery in Chapters 6 and 7, which also happens to be where the difficulty of the book spikes considerably. He doesn't use a stack, which would be conventional for a calculator program, because stacks have not been covered at that point. Instead, he chooses to use repeated pushing and getting from a custom token stream to solve the problem.

If you're looking for a book that teaches you how to program and runs you through the thought process of a programmer as he builds a program, I recommend Stroustrup's book. It's not that suitable for an absolute beginner and his chapter organization seems slightly haphazard, but that doesn't take it away from being an excellent guide. It happens to use C++, but it teaches programming and does not teach a programming language. I suspect a book like that is what you want.

His (deliberately bug-filled as an exercise) solution at the end of Chapter 6 can be found here. Yes, it's hard to understand.

So, here's my advice and basically how I learned what I did. I got a major in Finance in college, but I took Python and C++ classes (I also took a discrete class and an "IT" class that gave me some additional insight, but probably unnecessary). With that being said, I would learn basic Python first because debugging and learning algorithms is an absolute bitch in VBA. You don't need to learn additional libraries etc, just go through a basic online course and get through learning about Object Oriented Programming. From there it is much easier to transfer to VBA and learn the Excel object library. This guy: http://amzn.com/1118490398 is the best VBA programmer and is very well known. I mainly use the book as a reference when I'm going into an entirely new area and I search google for smaller questions Also, stop by /r/excel and feel free to PM me with any additional questions!

You seem to be mixing a lot of stuff here.

In no particular order:

• I'm pretty sure Java is far more used for the server-side of web (or intranet) applications than for desktop apps.
  
  
• IIRC, you can use C# for desktop apps, and for both sides of web apps (client with Silverlight, and server).
  
  
• Assembly is not a language. ARM-assembly and x86-assembly are two different languages, since the two architectures are so different.
  
  
• If you really want to learn C++ (I won't comment on that choice), buy Accelerated C++. There are lots of other resources for beginners, but pretty much all of them are either bad or abysmal.
  Stroustrup's latest book might be good, but I haven't had a look at it, and I'm not very motivated for reading 1272 pages of Stroustrup's prose.
  
  
• "Fairly competent Web programmer": you do understand all the basics of the Javascript language, right? Likewise, you probably know Python well, so if you want to make desktop apps, Qt-Python bindings might be a good start.
  
  
  
  

Also Effective C++, because it's full of gotchas and important but subtle language features that are ideal for interview questions. A lot of it will be too advanced for a jr. level interview, but you should read it anyway because it's a great book.

excellent post, thanks, it's always enlightening to get historical perspective like this

in a similar vein I recommend Deep C Secrets which is overflowing with historical anecdotes about the evolution of C and Unix systems

Actually I think the book he's referring to may be Programming Principles and Pratice written by the original designer of C++. Many consider it one of the best books for beginners to learn programming principles and the C++ language. The author also explicitly says it is not a reference book and that it is best to go through chapter by chapter.

Of course, I could also be assigning meaning to nothing. I'm just going off the fact that the book is like 1300 pages and is popular for people trying to learn C++.

But the answer to this would still be no. You would need to code a lot in addition to reading the 1300 page tome.

I was also first a C programmer and only started learning cpp later. I have found this book to be excellent:

Accelerated Cpp book

it is intended to complete novices, which you are not. However I think it is still perfect for you because I think that it introduces Cpp the way it should be and not as a C extension. After you are comfortable with the std I would suggest you move to good practices books (effective c++ etc) and/or design patterns books

That is great for getting you comfy with the language but if you're like me you need to use it a lot / have a practical purpose in mind to help focus you so with that in mine, the follow-up book may be quite useful

Programming is language agnostic; it sounds like you're looking for breadth rather than depth, so:

• these books are free; they will teach you C++, including basic imperative and procedural programming, structured programming, pointer manipulation, and recursion;
  
  
• once you've got those down, this book will introduce you to higher order programming and macros, as implemented in C++; and,
  
  
• after you're familiar with those, this book will teach you the mathematics behind the design of the standard library for C++.
  
  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.

Thank you! Yes I have heard only good things about that book.
Does it matter that it is C and not C++? Because I have been told Accelerated C++ is also a very good book and things are seen at a faster pace. But again, if you believe the K&R is a better approach I will by all means look into that one. I mentioned Accelerated C++ because of the time constraint I have.

I'm currently learning MVC as well, and I went with the just-released Professional ASP.NET MVC 5 [1].

Reading the Amazon reviews, the Freeman book uses dependency injection via the open source library Ninject. That may be a common development approach for all I know, but I wanted to focus on learning MVC without any third party library requirements.

If anyone has thoughts on Freeman's approach, I'd be interested.

If you like video tutorials, another resource is a MVC 4 video tutorial offered free by Pluralsight. [2] They have subscription plan that looks reasonably priced, and it covers MVC 5. (The Pluralsight videos are narrated by K. Scott Allen, who is also one of the co-authors of the Galloway book.)

[1] http://www.amazon.com/Professional-ASP-NET-MVC-Jon-Galloway/dp/1118794753/ref=pd_cp_b_0

[2] http://pluralsight.com/training/Player?author=scott-allen&name=mvc4-building-m1-intro&mode=live&clip=0&course=mvc4-building

I'm starting to learn C++ and a good text is difficult to come by, some I find fall into "C with <vector>" while others read like reference documentation without sufficient information. I don't even particularly like Bjarne's own "Programming: Principles and Practice Using C++" as his examples tend to be convoluted.

My current strategy is to go through Discovering Modern C++ which appears compact, concise and modern. Probably complementing this with Effective C++ for good practice. Most importantly having a good linter keeping my code looking nice and proper.

By chance, I was reading yesterday the introduction of http://www.amazon.com/Accelerated-C-Practical-Programming-Example/dp/020170353X - what I like in that style, is that you see some code, have it in your mind, and get a discussion of concepts based on that example. Writing about programming is very difficult (as I experience myself), but I start liking the idea, that actual code examples early help the reader to get a better feeling what is going on.

There isn't a 4th ed./C# 6 version out yet for this, but C# in Depth (http://www.amazon.com/Depth-3rd-Edition-Jon-Skeet/dp/161729134X) is basically all advanced C#/.NET topics, and extremely well written.

If you're looking to up your C# knowledge, definitely would recommend this book. (Also a lot of the C# 6 features are syntactic sugar, so you're not missing too much you can't get from an online source such as https://msdn.microsoft.com/en-us/magazine/dn879355.aspx)

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.)

These are books I read many years ago, they can be helpful but may be dated and will not include newer features. But as an introduction they worked well.

Thinking in C++ Voume 1 and 2 by Bruce Eckel

https://www.amazon.com/Thinking-Vol-Introduction-Standard-2nd/dp/0139798099/ref=dp_ob_title_bk

https://www.amazon.com/Thinking-C-2-Practical-Programming/dp/0130353132/ref=pd_sbs_14_1

And Scott Meyers

Effective C++ - https://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/0321334876/ref=pd_sbs_14_2

Effective STL - https://www.amazon.com/Effective-STL-Specific-Standard-Template/dp/0201749629

Actually a more up to date book is C++ Template Metaprogramming by David Abrahams of Boost fame and Aleksey Gurtovoy. It uses the MPL extensively which implements quit a bit of the article if not all. It also describes FC++, Blitz++ and a few others. It implements a basic expression template system and even has an appendix on the Boost Preprocessor library.

I don't recommend starting out with that one though.

Also a good book, is C++ Templates . It's a little bit easier to start off with.

These are my standard recommendations to anyone who wants to learn the C language these days:

https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504/ref=sr_1_1?ie=UTF8&qid=1537025256&sr=8-1&keywords=king+c+language&dpID=41%252BbFKtFHjL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch

https://www.amazon.com/Reference-Manual-Samuel-P-Harbison/dp/013089592X/ref=sr_1_sc_1?ie=UTF8&qid=1537025419&sr=8-1-spell&keywords=herbison+steele

The first one is a great book to learn C from the basics to the details of the standard library, and it's updated to cover the C99 Standard. The second is more of a reference that is very useful once you get more experienced, it covers C99 as well, it is basically the C Standard document rewritten for humans : ) My students find the first one very complete and full of good exercises and explanations. Not everyone has bought the second, those who have find it invaluable.

And that is exactly why I recommend reading these books to people. Information online can often be misleading, wrong, old, or all of the above, at least in a book which is praised by so many people, you know that the info which you are getting is top value. I know that learing C++ can be a bit difficult, but remember that you do not need to know all of it at once (heck - nobody knows all of C++, and even Template Metaprogramming was kind of discovered by accident ). I hear that Accelerated C++ is a good book to start from if you already know some programming in another language. C++ Primer Plus is huge, but also good.

There's a good course by Google on Udacity at the moment - https://www.udacity.com/course/ud853 - which guides you through developing an app using their souped up version of Eclipse (Android Studio).

The nice thing about Android is you can run an emulator without XCode -- i.e. a Mac.

Depending on where your skills are at the moment, programming gis programming and the fundamentals are always important. You have to cut your teeth on something, but don't get caught in whatever framework/stack/paradigm you're working in. C# (Xamerin) is a great language, and it's what I started off with.

I'd say start off with something you want -- like the widget app. See if there's source code for some of the current Android reddit apps so you can get an idea of what's going on.

I cannot emphasize enough, however that you should eventually return to the meaty books/reading -- e.g. C# in Depth for C#. It's GOOD to try something and get frustrated; you'll see the value of good design and understanding in a way that being "told" cannot do.

S.O. has a list of books:
http://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list

Both options appear to be well-received.

Personally, I learned C++ initially with this book as it was the class textbook:

http://www.amazon.com/How-Program-Early-Objects-Version/dp/0133378713?ie=UTF8&keywords=deitel%20c%2B%2B&qid=1465331530&ref_=sr_1_2&sr=8-2


Maybe you can pick from the list for the introductory stuff, and pick up Effective C++ by Scott Meyers for recommendations and best practices after you are more comfortable with C++.

http://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/0321334876?ie=UTF8&keywords=effective%20c%2B%2B&qid=1465332161&ref_=sr_1_2&sr=8-2

Huh. After reading this thread, I'm pretty happy that Stack Overflow did not exist when I started programming in the early 2000s. All I found were sketchy pay-for-answers sites, which I did not trust (I was also a broke 13 year old), so I was forced to go buy a giant book on C++ and read it all the way through. this one

That gave me a great base of patterns to work with and I was able to not pay any attention in college because I already learned most of the material.

I do love Stack Overflow for shit like "How do I fix this obscure OpenGL error?" though, it has become an irreplaceable tool in my toolset.

So this is what I would consider the "Core" reading list for anyone interested in programming games. None of this is really game specific though. These are just the fundamentals you need in order to be an effective Software Engineer.

Learn about...

C++ syntax: Programming: Principles and Practice Using C++ by Bjarne Stroustrup

Software Engineering: Code Complete by Steve McConnell

C++ gems: Effective C++ by Scott Meyer

Software Teams: The Mythical Man-Month by Frederick P. Brooks Jr.

Why we love Joel: Joel on Software by Joel Spolsky

Problem Solving: The Pragmatic Programmer by Andrew Hunt

Common Code Solutions: Head First Design Patterns by Eric Freeman

Pearls!: Programming Pearls by Jon Bentley

I'll do a supplemental on this in a few days that dives into specific topics related to engine development. All of this is generic enough that it will help you regardless of what you do. You'll notice that very little here is actually language specific. Almost all of this is about the art of making software and process of working with a team. These 8 books alone will make you think about making software in a whole new way.

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.

Ignore the people who are stating that learning c++ is some daunting, difficult task. It isn't. If you have learned mathematics, you will be able to learn c++. Both are languages used to convey reasoning. Mathematics and C++ both have grammar to follow and rules for turning some statement into another -- you won't find things very foreign if you look at it from this perspective.

Also, you should avoid videos and such, and just go start writing and compiling C++. You need a good starting point for the language of course, and the core material usually recommended is The C++ Programming Language by Bjarne Stroustrup.

The rest of your reading material should be reading well formed c++ code. Read the source code of popular, well documented projects. Read the Boost libraries, read the source of Qt, read as much C++ as you can get your hands on. Try to understand it. If you find something you don't understand, go look it up. Ask other programmers about it.

Take things in small chunks and if you get overwhelmed just take a step back a bit and write something simple that you can grasp. Create small programming problems for yourself to solve and play with them -- do the same things you did while you learned mathematics.

There's a pretty comprehensive list over at Stack Overflow.

• Accelerated C++ is recommended often.
  
• Thinking in C++, with HTML version freely distributed
  
  
• This Wikibook might also be useful.

Ah. This is the explanation I was looking for. Thank you.

I understand your lack of confidence in the book. The other book I was using is Lippman's C++ Primer. The actual code presentation in the Primer was simple and beautiful, but Stroustrup's book seems to follow a more logical sequence of topics. I'm a math major and BS's text reads like a good math book.

First of all, ask yourself why it is you want to do C++. It isn't the easiest or most convenient language; unless there's some specific reason you want to focus on it, there's a pretty good chance that you should (first) learn something else. If you're not sure, try this page.

As for where to learn it, the only worthwhile resources available at this moment are good books. If you have little experience with programming, I'd recommend starting with C++ Primer or Programming: Principles and Practice using C++.

Read books. It might be boring, but a lot more informational than watching a youtube video.

If you already know how to program in another (preferably OOP) language there's The C++ Programming Language or C++ Primer if you want to learn C++11 (not to be confused with C++ Primer Plus, which is a different book 'series')

If you don't know how to program and you want to learn C++ for game development there's Beginning C++ Game Programming, which starts at the beginning (variables are one of the first things explained). After that book you should read up Introduction to Algorithms to make sure you're not writing horrible inefficient programs. Then there's Design Patterns: Elements of Reusable Object-Oriented Software to teach you more about certain patterns used in programs design (needed when using Ogre3D for example. Ogre3D was 90% magic to me until I read about Design Patterns. :p As alternative to DP:EoROOS there's Head First Design Patterns, but it's Java-centric which is a whole other beast than C++.

After those books there's this Stackoverflow thread. Read the first answer (the gigantic list of books). The thread used to be a ton of comments (with the most votes comments on top), but all anwers got copied to the first comment, so it's all sorted on votes. Code Complete (2nd edition) was the most upvoted one, The Pragmatic Programmer was the 2nd most upvoted one, etc.

Then there's this Stackoverflow thread, which is more C++ centric.

I hope this helps :)

I would recommend saving the money and learn from books. As said before most employers don't care about certifications and if they do, you probably don't want to work there.

The C++ Programming Language is written by the inventor of C++ Bjarne Stroustrup and arguably the best introductary book out there.

If you already know core programming principles by heart i would recommend Accelerated C++ .

I can highly recommend C#in Depth. It does not start with programming basics, instead it walks you through the evolution of the language version by version, which means not only that the more advanced topics are further down the road, but also gives you a very broad understanding about why the language has developed the way it has.

Edit: also +1 for Unity. It really gives you the freedom to focus on the important parts of game development.

I just looked through all my books. It's actually hard to find a book with large segments of good code. This is probably the worst book when it comes to good c++:

http://www.amazon.com/Numerical-Recipes-The-Scientific-Computing/dp/0521750334/ref=pd_sim_sbs_b_15

The best is probably scott meyer's effective c++. It gives small sections of good code and all 55 tips are gold (or silver)

http://www.amazon.com/dp/0321334876/ref=rdr_ext_tmb

I bought the C++ Primer, 4th edition a week ago on advice from this subreddit, and I can't recommend it more. It goes into the perfect amount of detail and uses the right amount of jargon. It's chapters are distinguished very well from one another, and there are full glossaries of all the key words met at the end of each of them. Those along with relevant exercises (some that can be done in your head, others that need to be coded) throughout help you learn much more effectively.

http://www.amazon.com/Primer-4th-Edition-Stanley-Lippman/dp/0201721481

1. If you think that C++ isn't harder to learn than C, then you don't really know C++. Read Modern C++ Design, and a few dozen pages of the C++ FAQ, and if your head doesn't explode, tell me again that C++ isn't harder to really learn than C.
   
2. I know the Linus article. I know he's competent. But I still don't agree; I think he's so steeped in his kernel code world that he doesn't see the advantages, at least for application software.
   
3. Anyone who writes code in C++ but who doesn't know pointers, can't concat strings, etc., is someone who also really doesn't know C++.
   
   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).

Hi there, fellow EE.

We should make a club :)

I believe you can do a crash course into software development and catch up later when it comes to be a better software developer, since you've already been in the market for 4 years I'm sure you know exactly what I'm talking about (job has nothing to do with education, and you can learn as you go), and I know its the same in CS, a lot of companies just want you to do specific thing, and they don't really care about your theoretical knowledge or your full knowledge with software development life cycle.


Since you are an EE graduate I think you can relatively easily land a c++ software development job, but the problem with c++ is that there is a lot of theoretical knowledge is expected from you.

Still I believe if you set aside 3 months of your lifetime and study the following:

Programming: Principles and Practice Using C++

Code Complete

introduction to algorithms

Optional:

Software Engineering

Java Heads first

C# in a nutshell

Note, half of these books will bore you to death, but you have to power through.
Also there will come times where you don't understand what you are reading, I find it best is just to keep going, eventually things will make sense.

I personally find books is the fastest way to learn, and give you the deepest knowledge and always access to awesome tips and tricks that you can't learn at class or from a video.

If you pick those books, you can read from them in parallel, make a habit of finishing a chapter per 24/48 hour and practice 1-2 hours of programming (of what you've learned) I'm sure by the end of the 3 months you will be better than a lot of CS graduates

Definitely Accelerated C++ by Andrew Koenig and Barbara E. Moo.

It's not a video or online, but definitely aimed at people who already know another language. You'll breeze through it and be very comfortable with C++ at the end.

This kind of stuff is available in painful detail in Josuttis' book, but there is a fair bit of "other stuff" in there.

That said, better than the fish book for someone who wants just the good stuff would be Effective STL and/or Standard C++ IOStreams & Locales.

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.

up

dammit. Thanks for taking the time to explain that to me.


This

>is a valid URL. The code doesn't limit the protocol to just "http", anything before a "://" will be accepted.



and that


>getline(inFile, sentence); will discard the ending newline,


are really good to know.


> paragraph.assign(std::istreambuf_iterator<char>{inFile},
std::istreambuf_iterator<char>{});

thx.


This book is like Jesus to those people at learnprogramming however I think I may pick up a different one.

How's this one book

Highly recommend this book: https://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/0321334876

Once Scott meyers has you hooked, checkout his modern effective c++ book. He's a great writer and teacher

What is your programming background? Do you have any experience in other languages/frameworks?

I haven't used the book you mentioned, but these have been pretty helpful (listed in order of brain-melting complexity):

1. https://www.amazon.com/Microsoft-Visual-Step-Developer-Reference/dp/1509307761/ref=pd_lpo_sbs_14_t_1?_encoding=UTF8&psc=1&refRID=WBZV8Q8BWT8APSVY7YPY
   
   
2. https://www.amazon.com/Adaptive-Code-via-principles-Developer/dp/0735683204/ref=sr_1_43?s=books&ie=UTF8&qid=1540568110&sr=1-43&keywords=C%23
   
   
3. https://www.amazon.com/gp/product/0735685355/ref=oh_aui_search_detailpage?ie=UTF8&psc=1

Thinking in C++ is good and available online, great for getting started.

Once you've got the syntax, OO concepts, and enough of the standard library down enough to be conmfortable, get a copy of Effective C++. It's basically the bible of how C++ programs should be written.

Other online references
cplusplus.com a good quick reference
C++ FAQ quick, thorough explanations of how random things work in C++

C++ Primer is excellent.

(NOT C++ PRIMER PLUS OH DEAR GOD STAY AWAY)

Read some easy beginner's book like Head First C# to get initial grasp of a language and after you finished with it read C# in Depth. If you really want to understand what is happening pick up CLR via C#.
Also always follow Code complete religiously and you will be better than most.

It does seem like MVC > WebForms. I'm trying to get better at it by following this book http://www.amazon.com/Professional-ASP-NET-MVC-Jon-Galloway/dp/1118794753/ref=pd_cp_b_0 . But I feel like it assumes you know WebForms or previous MVC's to be able to follow it. Do you have any advice where I could start as a beginner approach? Thanks

C++ is hard to practice at since any useful application in C++ is huge and done by multiple people. I would recommend reading Effective C++ if you haven't already to brush up on how C++ is really different under the hood from other languages.

As for 3D math I thought 3D Math Primer for Graphics and Game Development was a pretty solid review for me at least after being out of college for awhile. But I'm not sure how it would feel to introduce the concepts new.

Bjarne Stroustrup - Programming: Principles and Practice Using C++ (Amazon Link) would be my first recommendation.

It gives clear and detailed instruction right from the start. It's a lot of work, but it's well worth it. Buy a physical copy if you can; it's far better to work from a book.

Once you finish that, you will be ready to program in C++. The next step is to get a deep understanding of C++. For that Bjarne Stroustrup's "The C++ Programming Language" is the best. These are the only 2 books you will need... a quick-start book and a get-deep-understanding book.

Of course, after reading those 2, there are plenty of other good books that you can read to hone your C++ skills, learn more about STLs, etc.

Look at this.
I put together this guide for web dev newcomers.
If you don't want to go through the whole guide, this video is really good at delivering an overview of a web application's different parts.

On another hand, if you pick a big good book (400+ pages)about a web framework (Rails for Ruby, Django for Python, ASP MVC for .NET,...), the authors will mention Angular, Auth, DB connections, Rest Api, as side or main topics.
Exemple of such books.

I read an interview a long time ago where one of the K&R guys said something to the effect of "Yeah, we got some of the operator precedence rules wrong. We noticed it after awhile but we didn't change it because by that time there were hundreds of kilobytes of code written in C and it didn't seem fair to change it."

I don't remember where I read that; it might have been in this book. Incidentally the fish on the cover is a coelacanth, pronounced "C-le-kanth" and it remained undiscovered until the 20th century, making it a "Deep C secret". I love the double pun and the book was quite good.

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);

• Digital Design and Computer Architecture
  
  
• Foundations of Analog and Digital Electronic Circuits
  
  
• Introduction to Embedded Systems
  
  
• Code: The Hidden Language of Computer Hardware and Software
  
  
• The Elements of Computing Systems
  
  
• Foundations of Multithreaded, Parallel and Distributed Programming
  
  
• The Practice of Programming
  
  
• The C programming language
  
  
• The C Companion
  
  
• Expert C Programming
  
  
• C Interfaces and Implementation
  
  
• Data Structures and Program Design in C
  
  
• The Unix Programming Environment
  
  
• Computer Systems: A Programmer's Perspective 3rd edition is 64-bit, 2nd edition is mostly 32-bit and a little 64-bit while 1st edition is all 32-bit.
  
  
• The C++ Programming Language 4th edition
  
  
• Discovering Modern C++
  
  
• C++ Templates: The complete guide
  
  
• Modern C++ design
  
  
• Scientific and Engineering C++
  
  
• Advanced C++ programming styles and idioms
  
  
• Design Patterns
  

For those that code in C++, I highly recommend the book "Effective C++".

There are a ton of good books out there that teach you how to write maintainable, well designed code, and I recommend doing some reading, especially if you're an indie developer or haven't taken upper level Computer Science courses.

Heh, I don't know really. I usually recommend Accelerated C++, but it's a bit dated now with C++11. Perhaps we can help each other? :)

Don't be too hard on yourself, C++ is a tough language. Its a good sign that you are struggling, it means that you are human. You might want to take a look at Programming: Principles and Practice Using C++. It was written by the creator of the language and its good for beginners.

Good luck!

Would you recommend C# In Depth?

Someone said it's a masterpiece. Another person said it's for someone who already knows a bit of C#.

I am ready to do what you said.

The best book on plain C is "C: A Reference Manual" by Harbison and Steele. The K&R book is too ambiguous and out-of-date.
[See here:] (https://smile.amazon.com/Reference-Manual-Samuel-P-Harbison/dp/013089592X)

That said, Go is powerful, easy-to-learn, and easy-to-use. Highly recommended.

I picked up Accelerated C++ and it's, by far, one of the best books I've read. It's terse and provides an amazing amount of detail for its size.

Amazon

I feel like the book Adaptive Code via C# was a great resource for me to advance to the next level as a developer. It covers all the topics you mentioned and helped me understand how to write more maintainable, well architected code.

Adaptive Code via C#