If you are completely new to programming, don't worry, it's definitely not as hard as people believe it is.

The first important thing when you are learning any programming language is to be goal oriented, because this is what is going to keep you engaged and make you more likely to actually gain something from anything you read.

Think of the most tedious and repetitive task that can save you some time - that is going to be your best place to start. For instance, some formatting always has to be updated and it's time consuming, or you need to create a letter from information on a speadsheet every day etc. That's where you'll see your work pay off immediately, and that rush of having it work for you every day will really inspire you to keep going. For me, it was taking a bunch of files and porting the information to one place initially.

Once you know what your end goal is and what you want it to do, google it in every variation you can find. YouTube tutorials are actually where I started, just to see if what I was thinking of was possible. They have a lot of great resources for how to do certain things and you can find out if the concept is achievable this way really easily. Try to "steal" code or try examples that you find. (Just put a url in a comment or some indicator of where you found it from because you will forget later, and having the page it came from can significantly help when you are troubleshooting. This is attribution etiquette for programming, anyway.) Don't get discouraged if the code doesn’t work the way you imagined, this is going to allow you to see why it behaved the way it did later on and is a really important step to learning how things worked. Besides, with anything you do, you will likely have to mold it so much to your project, it will end up being more your work than anyone else's in the end either way.

[Wise Owl Tutorials] (https://www.youtube.com/watch?v=KHO5NIcZAc4&list=PLNIs-AWhQzckr8Dgmgb3akx_gFMnpxTN5) are some of the most thorough and logically laid out tutorials I have seen for VBA and I heartily recommend this if you learn better through video - he's pretty much made a full course of it.

Then, I would say dive in and find out how the language itself works for a little bit. Read about variables, if statements (and variations of these), and loops.

Variables are the placeholders for your data, and using the right ones in VBA means that you can make your program run faster or slower, so it definitely helps to get an understanding of these and what they do early.

If statements and operators and their variations are the parameters that determine what happens. (If dog does not = fed, then feed dog.) These are the logic that everything runs on. You would be surprised how much coding comes down to statements like the dog example.

Loops are how your program is able to do a few things to a large data set in very little time in a structured way. (For each dog, if dog is not fed, then feed dog, then move onto the next dog.) These are also ubiquitous in all programming languages, but the syntax varies between language. This is how those if statements become really powerful.

If you are like me, and learn well from books, these two have been the best ones I've found:

[Excel 2016 Power Programming with VBA (Mr. Spreadsheet's Bookshelf)] (https://www.amazon.com/Excel-Power-Programming-Spreadsheets-Bookshelf/dp/1119067723/ref=sr_1_1?ie=UTF8&qid=1539050489&sr=8-1&keywords=john+walkenbach+excel+2016+vba)
This book is great for learning from the very beginning, especially if you don't have any previous programming knowledge. It will walk you through everything in a very easy to read way and get you dreaming about the possibilities with VBA. It also shows you why you may end up wanting to get detailed in the ways you think about variables etc with timed examples. I used the 2013 edition of this book and I was very pleased. This is a great choice as your first book covering the basics.

Mastering VBA for Microsoft Office 2016:
This book is the one I used the most out of all of the books that I bought on the subject. It has some really excellent examples of things you may not have even imagined could be done in VBA that give the language a lot of power and usefulness. I still refer to it, even though I outgrew all of my other books. It spells out a lot of the basics as well, and if I had to refer to VBA on a desert island, this would be the only book I would bring. (Although the idea of having to refer to VBA on a desert island is a special kind of nightmare, even for someone like me who loves it.)

If you can only afford one of these, definitely get this one - the first one is great for baby steps but becomes outgrown quickly. I recommend it mostly because it does an excellent job of explaining programming if you have never done it before.

The Spreadsheet Guru has some really basic things ranging to some more advanced concepts and is not a bad place to start learning some quick fixes.

Excel Macro Mastery is great for getting to know how the moving parts work, especially with some of the complex data types that it can be a little hard to wrap your head around as a newcomer. This site has some times when it will try to sell you on his program, but it's worth a little annoyance for the truly good advice:

Excel Virtuoso is excellent for advanced program structures and how to make VBA act more like an object oriented programming language. It may be good for some of the earlier stuff, but this is when I found ways to do things that most people don't seem to know it can, including ways to make custom classes for data do things that are not very well known and only glossed over in most VBA programming books. It's been a godsend for me, and is the cornerstone that a lot of my work actually hinges on as the project I took on was far more complex than the scope of most macros, which are quick and simple maneuvers primarily.

But don't limit yourself to these resources. Look everywhere when you are trying to learn and don't fret overly with whether you are doing something right or wrong. Make it, test it, troubleshoot it, and improve.

The computer will not explode if you do something wrong. VBA is meant to be like a fisher price language because the intent of providing it is more for office workers than full blown programmers. At worst, your program will shut down and you may have to end the task in task manager or reboot your computer. This is rare. Most times, the compiler will remind you that you missed some part of syntax, which is a quick and easy fix that even advanced programmers have to deal with all of the time.

Feel free to look at places like stack overflow, but take all of this advice with a grain of salt, because there are normally at least 20 ways to do something (and that is on the low end) and everyone can get a little protective of their way. I use this as more of a brainstorming effort.

And if you have any questions, feel free to reach out to you. If I haven't dealt with it already, I may be able to point you in the right direction. :)

Also, if you're interested in learning programming in general, this is an awesome list of coding courses and where to find free coding courses that freecodecamp sent out this summer:
https://medium.freecodecamp.org/500-free-online-programming-computer-science-courses-you-can-start-in-august-bc1bcac1af5e

> I think if I learn how to program with an aim to work as a software developer and make games on the side, is this viable after just turning 20?


There's nothing wrong with the age of 20. I started school at 20, graduated in four years, and found work as a software engineer right out school.


What you have to figure out is how to make the best of your time left in school: should you take a class or two on programming and graduate on time, or (more dramatically) change your field of study to computer science and spend a few more years in school? That's something only you can decide. If you want to finish your architecture program and graduate in a reasonable amount of time, I can assure you that your math and physics background will be enough to get you work as a software engineer, but only if you can actually program.


Part of working as a software engineer means being able to program in multiple languages. That's because it's not really about the language, it's about the logic. All languages follow certain patterns and while syntax or wording may change, they all share ways to implement the same logic.


It also means knowing what data structures to use for what scenarios. The phrase "There's no such thing as a free lunch" comes to mind. All data structures have advantages and weaknesses and no data structure is perfect for every occasion. Know the differences, know the performance impact, and be able to speak to them. This won't just help you write better code, it will help you land a job. Interviewers love to ask questions about data structures.


As a corollary to data structures, you also need to know your algorithms. You need to know the performance impact of different ways to search and sort, traverse graphs, and find the shortest path (particularly relevant for game programming).


You said you're learning Python and that's great. Python is a great way to learn how to program. It's dynamic, it's friendly, and it has a rich library. Learn Python inside and out, then pick another language and figure out how to do the same things. C++, Java, and C# are all pretty popular in the industry, pick one of those. Once you know how to program in a few languages, you focus less on minute implementation details specific to one language and more on high level abstraction shared across multiple languages. By that point, you'll no longer be speaking in code, you'll be speaking in plain English, and that's the goal.


I don't know many good free online resources for learning languages, I learned mostly out of textbooks and lecture slides (along with lots of practice). There are some links in the sidebar to some tutorials that are worth checking out. Beyond that, I can recommend some books you may want to read.

• Algorithms in a Nutshell - one of the best quick references on algorithms you can read
  
• C# 5.0 in a Nutshell - excellent language reference, aimed more at advanced programmers, though it's comprehensive in scope, covering everything from language syntax and structure of a program to more complex tasks like threading, multiprocessing, and networking
  
• Learning XNA 4.0 - a great game programming book, teaches 2D and 3D game development using Microsoft's C# and XNA framework
  
• Java in a Nutshell - another great language reference
  
• Starting Out with Java - introductory programming text, has end-of-chapter problems for reinforcement, a little pricey so see if you can find a used older edition
  
• Starting Out with C++ - another good introductory programming text from Tony Gaddis
  
• Python in a Nutshell - I can't speak to this one as I haven't read it, but I have been extremely happy with O'Reilly's "... in a Nutshell" series so I suspect it's as good as the others
  
• Learn Python the Hard Way - free online book about learning Python, begins with simple examples then teaches you how to break it so you know both sides of the story, wasn't as comprehensive as I'd hoped but it taught me the basics of Python
  
• Programming Interviews Exposed - sort an all-in-one book covering lots of different topics and giving an insight into what to expect for that first interview
  
  EDIT: I added Programming Interviews Exposed because it's a good reference for data structures, algorithms, and interview questions

> My other question is if F# good for some scientific applications?

Yes. I started out using F# for such things. I ended up writing the book on it.

F#'s ML core is extremely simple. I think you would find it very easy to learn. Let me get you started:

There is a type called unit that has a single value in it called () that can be used to convey no information, a bit like void in other languages but you can use the value () of the type unit anywhere.

The bool type has values true and false.

Integers are written 1, 2, 3 and so on. Integer arithmetic is 1+2*3. The int function converts a value (e.g. float or string) into an int.

Floating point numbers are written 1.2, 2.3, 3.4 and so on. Floating point arithmetic is written 1.2+2.3*3.4. The float function converts a value (e.g. int or string) to a float.

Characters are of the type char and are written 'a'. Strings are of the type string and are written "foo". You can append strings with "foo"+"bar". The string function tries to convert a value of another type (e.g. int or float) into a string.

Lists are written [1;2;3]. You can prepend onto the front in constant time with 1::[2;3].

Arrays are written [|1;2;3|]. You can read and write elements with random access in constant time with arr.[i] and arr.[i] <- 3.

ML has sum types and product types. The simplest product type is the tuple. Tuples are written (2, 3) and (2, 3, 4). The types of those tuples are written int * int and int * int * int. Tuples can have as many elements as you like (greater than one, of course). Note F# uses OCaml-style syntax which lets you drop many brackets when dealing with tuples, so you can often just write 1, 2.

F# also has record types which are product types where the fields have names. Record types are defined as type MyRecord = {FirstName: string; LastName: string}. Values of record types are written {FirstName="Jon"; LastName="Harrop"}. Given a value r you can get a field with the syntax r.FirstName. As a product type, a value of type MyRecord must have a FirstName and a LastName.

Algebraic datatypes (ADTs) are a combination of sum types and product types. A sum type allows a value to be one of several different options. The simplest example is to define your own boolean:

type MyBoolean = True | False

The values True and False are then values of the type MyBoolean. Like an enum in other languages. But the really cool thing about ADTs in MLs is that those union cases can have an argument of any type you want. For example, we can define an ADT:

type Glyph =
| Digit of int
| Letter of char

The values Digit 3 and Letter 'x' are values of this type Glyph.

The value () of type unit was a minor diversion from other programming languages. Now comes the first major diversion: pattern matching is the only way to destructure ADTs. So the only way to extract those values 3 and 'x' from the value of type Glyph is using pattern matching. In ML there are patterns all over the place. The most obvious place you see patterns in on the left hand side of the -> in each match case of a match expression. Here is a pattern match that will keep digits the same but redact all letters to 'x':

match Digit 3 with
| Digit n -> Digit n
| Letter c -> Letter 'x'

In this case the Digit n and Letter c are patterns. In particular, these have the effect of binding the variable n to the value conveyed in the Digit case (so it can be used on the right hand side of that match expression) or c to the value conveyed in the Letter case.

You can match int, float, char, string and other types such as tuples, records and ADTs using the same literal syntax that you do in expressions.

When you need to match a value but you don't care about its value you can use _ to match any value of any type and not bind it to any variable name.

If you want your pattern to match either something or something else you can write an or-pattern: patt1 | patt2.

If you want to name part of a value that you're matching you can use patt as myVar to call it myVar. For example, we could have written:

match Digit 3 with
| Digit as glyph -> glyph
| Letter c -> Letter 'x'

You can define variables with let:

let x = 3

This looks mundane but that x is actually a pattern so you can also do:

let (x, (y, z)) = (1, (2, 3))

to destructure the int * (int * int) pair on the right and define x, y and z.

You can also define functions with let:

let redact glyph =
match glyph with
| Digit -> glyph
| Letter c -> Letter 'x'

In ML, function application is written f x rather than f(x), e.g. redact (Digit 3).

Here we come to our second massive departure from conventional languages: when you have tuples you don't need multi-argument functions so every function in ML accepts one argument and returns one value! Furthermore, like OCaml, F# typically writes functions in Curried form. So a function to add two numbers is written let add x y = x+y which has the type int -> int -> int rather than int * int -> int so this is a function that takes x and returns another function that takes y and returns x+y.

Oh look, you've learned enough F# to understand this computer algebra system that can differentiate any symbolic mathematical expression composed of integers, variables, addition, multiplication, power and logarithm:

type Expr =
| Int of int
| Var of string
| Add of Expr Expr
| Mul of Expr Expr
| Pow of Expr * Expr
| Ln of Expr

let rec d x e =
match e with
| Var y when x=y -> Int 1
| Int | Var -> Int 0
| Add(f, g) -> Add(d x f, d x g)
| Mul(f, g) -> Add(Mul(f, d x g), Mul(g, d x f))
| Pow(f, g) -> Mul(Pow(f, g), Add(Mul(Mul(g, d x f), Pow(f, Int -1)), Mul(Ln f, d x g)))
| Ln f -> Mul(d x f, Pow(f, Int -1))

For example, the symbolic derivative of x^x computed in F# Interactive (e.g. in Visual Studio) is given as:

> d "x" (Pow(Var "x", Var "x"));;
val it : expr =
Mul
(Pow (Var "x",Var "x"),
Add
(Mul (Mul (Var "x",Int 1),Pow (Var "x",Int -1)),
Mul (Ln (Var "x"),Int 1)))

Probably the next thing to understand is that map f [a;b;c;...] = [f a; f b; f c; ...] and fold f a [b;c;d;...] = f (f (f a b) c) d) .... For example, if you represent 2D coordinates as a pair you can write:

let translate (x0, y0) ps = Array.map (fun (x1, y1) -> x0+x1, y0+y1) ps

To sum a list of integers you can write:

let sum xs = Array.fold (fun x a -> x+a) 0 xs

So given a file containing a list of integers on separate lines you can add them all up with:

Seq.fold (fun total line -> int line + total) 0 (System.IO.File.ReadAllLines @"Data/Numbers.txt")

F# has a handy pipeline operator |> so you can write f x as x |> f instead. For example:

System.IO.File.ReadAllLines @"Data/Numbers.txt"
|> Seq.fold (fun total line -> int line + total) 0

Another mind-blowing thing you'll come to love is purely functional data structures. When you add an element to a list, set or map (dictionary) in F# you get a new collection in O(log n) time but the old collection is still perfectly valid and can be reused.

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

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.

Buy The Pragmatic Programmer, read it from cover to cover. Let it change your life. It's not a specific language reference but it's pretty much required reading for any new programmer. It's about creating maintainable code, which is more of a mindset than anything, it's also a really really EASY and relatively entertaining read.

https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?ie=UTF8&qid=1520232423&sr=8-1&keywords=the+pragmatic+programmer&dpID=41BKx1AxQWL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch

Another more specific book to use as reference is the Effective C#:
https://www.amazon.com/Effective-Covers-Content-Update-Program/dp/0672337878/ref=sr_1_1?s=books&ie=UTF8&qid=1520232641&sr=1-1&keywords=effective+c+sharp&dpID=51ga39m0W5L&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch

They make "Effective" books for nearly all popular languages, and they really are great references. If you don't understand everything in it like co-variance and contravariance google as a lot of good examples of these concepts in practice, as well as definitions. Believe me I understand that these things can get really confusing and frustrating coming from a non-academic background and trying to bridge that gap. But utilizing this book and understanding the lingo will also help you to find more answers to run on your own.

Now, as with anything in programming, the point is not to have to remember everything all the time in these books(despite what try-hard programmers on the internet will tell you). That comes with experience and you're human so don't set yourself up with that expectation. Read them once so you know what is in them, and keep them at your desk for reference.

When you need to construct an interface pull out the book go to the interfaces and give it a glance over to give you an idea on where to go.

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!

I started with C++, its easy enough to learn but tough to master. Java or C++ would be the best, a tip would be find a school you like find the intro to programming class where the teacher posts the notes and assignments on his campus website. Download it all and buy the book and do it at the same pace.

C++ and Java are pretty much a toss up until you get to pointers so either one really. Also avoid using some of the advanced libraries and coding it out for the extra practice. I learned VB later and it works well enough and VB.NET is a huge step forward, but it is a bit finicky with ASP.NET VB pages so I would suggest the C++ route as C# didn't give me as many issues.

Also in my opinion C++ is easier than C, also find a page on coding standards a university posts online. Coding standards are important but the some of them are extremely complex and over the top. Once you learn one language its easy enough to pick up more. But after you learn a language its more about learning programming concepts that apply to problem solving like sorting, memory management, MVC, algorithms, etc. That is where you get the difference between someone who know how to program and someone who is a developer.

Also I used this book
http://www.amazon.com/Absolute-C-Walter-Savitch/dp/0201709279/ref=sr_1_sc_2?ie=UTF8&qid=1374738681&sr=8-2-spell&keywords=savidge+c%2B%2B

\> Would it transpile ALL of my code into JS? Wouldn’t that degrade performance?

​

If you implemented your numerical computations in the Fable app, yes, most likely. Although JavaScript can be used to write performant desktop applications - for instance, Visual Studio Code - I don't think it would be a good fit for scientific computing. The use case for Fable is in having behaviorally-sophisticated UIs without having to run through the dynamically/weakly-typed mess that is JavaScript. That said, JavaScript is not a terribly slow language - the Node.js JavaScript runtime is typically faster than Python. And Fable has Electron bindings for creating desktop apps. It could be worth trying. But I imagine a transpiled F# program would be noticeably slower than having one run in the .NET Framework or .NET Core runtime.

​

You really want to think of this as a UI layer on top of a computation layer. For a web application, the UI is typically run client-side in JavaScript (the browser sends .JS code to its JavaScript runtime, or in the very simplest case is only an HTML renderer), while the server code is some other language (F#, C++, PHP, etc) that sends user-facing data to the JavaScript. For a .NET desktop application, it'll all be bundled and run in the same place, but typically with a separate frontend project and a backend project. Unfortunately, either way it'll be a bit of work. And I think we'd need a bit more information about your code to give a good answer - for starters, is this Windows, or Linux? .NET Framework or .NET Core?

• Honestly, using Windows.Forms or Eto Forms is the easiest way to solve the problem of "add a GUI to my F#." Compile your numerical code to a class library and create a separate project for the UI which references that library, then call the numeric functions you need from the UI.
  
  • /u/Mischala suggested the standard way F# devs add user interfaces to their desktop applications: in Visual Studio, C# desktop UIs can be built visually using the Forms designer, which is a tool that F# unfortunately lacks. The designer automates what would be extremely ugly and tedious code and lets you drag things around on a screen to build out your UI. Since C# and F# interoperate fairly nicely, you can reference your F# project from C# and call your functions directly. I imagine this would be the fastest way to add pictures and buttons.
    
  • If you don't want to get your hands dirty with C# - who would blame you :) - then it's really not that hard to write a forms application purely in F#. I am assuming, given your userbase, that aesthetics are a low priority, so you wouldn't need to learn anything fancy or play too much with resizing.etc. Here are some tutorials to get you started:
    
    • The book F# For Scientists has an excellent introduction to using Windows.Forms in Chapter 7. Unfortunately it is out of print, but I snagged a copy fairly cheap on Amazon.
      
    • Expert F# 4.0 has a chapter using Eto. I have not played around with this but it looks more F# friendly than Windows.Forms - plus, there are tutorials in F#. It's also cross-platform
      
    • https://www.c-sharpcorner.com/uploadfile/f5b919/windows-form-application-in-fsharp/
      
    • https://emmorrisonjr.wordpress.com/code-tutorials/f-tutorials/creating-a-simple-f-windows-forms-application-using-visual-studio-2010/
      
• Like /u/Mischala said, turning your existing F# code into a webserver isn't a bad option.
  
  • Note that it doesn't actually have to be a real webserver hosted externally; an ASP.NET Core app is just a console application, and you can use the (amazing) Fable.Remoting library to have a webpage-based UI talk to the CLI console application.
    
  • Unfortunately you'll have a lot of useless boilerplate and overhead. Still, I think this would be the easiest way to use Fable for a high-performance desktop application. The Giraffe framework is both relatively easy to use and a lot of fun, and Visual Studio has an ASP.NET Core F# template out-of-the-box.
    
• You could try forking Fable.Remoting and modify it to have it chat to a desktop application directly. This might be easy, but I don't know enough about JS to endorse it.

Let's look at it from another angle. What are you going to be doing with Excel?

My experience is that it's all about the Data Process. You have to clean it up. Check the minimum values, maximum values, date ranges, see that different fields are what you want. Half your SSNs are text and half are numbers? How do you deal with that?

Do you have all the information needed for the statistical analysis you want to do?

Your client claims this list of people have been paid out this much. Here's a list of actual benefit payments from their bank trust. Compare them and explain the differences.

For added fun, the bank trust gave you benefit payment information as pdf files. Turn them into excel and find some way to connect them to each participant.

May be worthwhile to simply research the data process and build from there. Much of the actual learning comes from working with others and paying attention to the tricks and hotkeys they're using. Every single candidate puts 'proficient in Excel' on their resume. Telling a story about something done with it is usually better.

Hell. Research Beersheets for fantasy football, rip it apart and see how it ticks. Apply lessons learned to another sport.

Burning through this there are certain things you run into often.

VLOOKUPS. COUNTIF. Filters. DATE. TEXT. MATCH. Grouping. VALUE. General practices such as color-code inputs. Center Across Area rather than Merge Cells.

alt+e+s in sequence to bring up special paste options. (alt+e+s+v for paste values and alt+e+s+t for paste formats are super common. paste transpose exists.)

There's got to be some online site to offer services for pay. I'd be shocked if there's not someplace to offer data cleanup.

Really want to go to the next level? Dive into VBA. The go to is Excel 2010 Power Programming with VBA. Read through a section, do all the examples, come back then try to do them all again without guidance. This gives insight into a lot of what goes on behind the scenes in Excel, teaches many hotkeys you wouldn't otherwise pick up on. The moment I discovered how to access the Immediate window (ctrl+G) then learned to throw a Print command or two into my coding to test values in the VBA editor was the key moment I connected my programming in VBA to what I had done in R, Matlab, C, or Python.

In college is an excellent time, because you have time. It doesn't seem like it now, but time is hard to find afterward as well.

C++ was my first language, followed closely by Assembly and then Java. While I agree with you on the most part, I think it's better to learn something seemingly more "complex". Once you get into the flow of things, other languages seem easier.

OP, I started programming back in high school as well. While my instructor was fairly decent, I would still recommend you take the "sucky" teachers' c++ courses. That could help with getting started. YouTube tutorials and buying a relatively cheap book off of amazon worked wonders for me. Programming is "perfected" through practice, practice. A whole lot of the things (most of them, anyway) you're going to learn on your own, but having a teacher around could help a bit. Best of luck!

This is the book I most recently got (well, received from a friend) about a year ago. This is the one I used back in high school.

Join Stack Overflow to ask questions/learn from previous questions asked, and github to share your code.

Edit: Added links.

I'd recommend Programming in C for a beginner. It goes through all the basic stuff in great detail with plenty of good exercises, and it's well written and easy to read too.

Honorable mention to Pointers on C, a little more advanced, but definitely the most useful C book imo. Can be hard to find a reasonably priced copy but well worth it if you can.

K&R (The C Programming Language) is oft recommended but I found it impenetrable when I was starting out. There are better options these days for more or less all experience levels.

Right. But don't be so quick to judge. =)

The issue is that there isn't anything much better out there. A lot of the issues with teaching C is C itself.

C it a very simple language, maybe too simple. A lot of the safety in C is difficult because C doesn't give you anything to get that right. The solution to this is being very good at it, know what you're doing and avoid the problems. Modularity barely is possible in C (it is only through simple means). Dynamicity is a pain. All of these things that other languages simply support out of the box, you have to go through major hops in C so you get them.

From what I understand, most uses of C today only exist when nothing else is applicable. That is, when they really need the sort of benefits you get from using C, because the language itself isn't that great.

You could write whole books on getting modularity right in C, on getting dynamicity right in C, on getting security right in C, and so forth. And in fact there are:

• http://www.amazon.com/Interfaces-Implementations-Techniques-Creating-Reusable/dp/0201498413/ - on modularity
  
• http://www.amazon.com/Secure-Coding-Edition-Software-Engineering/dp/0321822137/ - on secure C programming
  
• http://www.amazon.com/Secure-Programming-Cookbook-Cryptography-Authentication/dp/0596003943/ - On secure C (also for C++), but touches stuff which goes beyond security within the language, like cryptography.
  
• http://www.amazon.com/CERT-Coding-Standard-Second-Edition/dp/0321984048/ - on secure C programming
  
• http://www.amazon.com/The-Puzzle-Book-Alan-Feuer/dp/0201604612/ - on C crazyness (which is highly related with insecure C programming)
  
• http://www.amazon.com/Expert-Programming-Peter-van-Linden/dp/0131774298/ - like above
  
• http://www.amazon.com/C-Traps-Pitfalls-Andrew-Koenig/dp/0201179288/ - like above
  
  It goes on and on and on. The C standard library is extremely thin (in comparison to everything out there). How can K&R2 teach you how to write highly sophisticated programs if the most advanced stuff in the standard library is sorting? I'm being a bit simplistic in this argument, but it's not so much distant from the truth.

You can try just googling python for physics pdf files to help get you started. I found these two places which look like a good start. Python is a fairly simple language I would say and most of the research I did with python I learned pretty much on the spot since the application of python to physics is so varied. There are also a lot of really good textbooks out there not just for python, but I feel once you know C or something you can easily figure out python.

Also the bible when it comes to physics computations is this book. It's written in C, I believe there is one for Java, but like I said if you learn C picking up Python should be pretty simple. You might find it online somewhere. I should also add that this is a bible in helping you write pseudo-code algorithms for solving multiple types of mathematical expressions - translating the pseudo-code into actual code is where the learning process coding comes into play.

Google is your friend.

https://www.google.com/search?q=9780132990448&sugexp=chrome,mod=12&sourceid=chrome&ie=UTF-8

Also here is a review I stumbled upon:

"The authors must believe that the date is due for a new edition, without actually having anything new content-wise to show for it, and the result is again, another edition that deals with the same problems that have plagued the earlier editions. You should read the reviews of the previous editions of this book and you'll get more information that might save you from wasting your time and money. Not much has changed in the new editions, other than the abundant use of colors in vain attempts to revitalize the overall poor quality of the content, but most importantly, there are much better alternatives, if you want to spend on a book to learn C and enjoy yourself while you're at it. I highly recommend the very best one out of my stack of C books: C Programming A modern approach by K. N. King.

It's obvious that new editions bring in more money to the authors and it keeps their books proudly filed under "new" on the store bookshelves, but without enough valid material to make it a worthy investment for students and programming enthusiasts, it is very difficult to recommend this book. I regret buying a copy of the latest edition and i compared it to an older 4th edition from a friend. The content is about the same, retaining its poor structure but some paragraphs of text were extended to meaningless conclusions, which are completely lost into the pages of text that are used to describe simple examples. Really, there was no need for the new edition. It's just not worth it, at least, from the point of view of the buyer/reader."

Here is the 5th edition (only $5!!): http://www.amazon.com/gp/offer-listing/0132404168/ref=sr_1_3_up_1_main_olp?s=books&ie=UTF8&qid=1345193151&sr=1-3&condition=used

Edit: Cheapest-
http://www.amazon.com/gp/offer-listing/013299044X/?tag=wwwcampusboocom-20&condition=used

Second Cheapest: http://www.alibris.com/booksearch.detail?invid=11365280428&cart=1&cm_sp=cart-_-listing-_-title

Since you are a practicing engieer with plenty of experience, I will suggest the right way to learn rather than the speed-of-the-internet , show-me-a-web-page way to acquire jargon.

Buy and read textbooks.

Start with Numerical Recipes by Press et al (Link 1). It has a couple of chapters on optimization and some very VERY excellent discussion. It will teach you the way academics formulate these problems, and how they solve them today.

Then read Gill, Murray, and Wright "Practical Optimization" (Link 2).

Next comes Roger Fletcher, "Practical Methods of Optimization". This book has been published two different ways: as a single volume, and also split into two volumes. Since Amazon Used Books sells the two volumes for considerably less money, I recommend that path: (Link 3) and (Link 4) .

After you have read those books, you will be able to appreciate the following paragraph:

I myself have found, in practice, that some of the old 1960's approaches to optimization work DELIGHTFULLY WELL on 2015 real world engineering problems, using 2015 computer power. In fifty years the problems have become 10,000 times more difficult and the computers have become 2^(50/3) times more powerful. The computers are winning the tug of war.

Make an honest try to solve your problem using no-derivative unconstrained optimizers, plus penalty functions or barrier functions for the constraints. I think you will be very pleasantly surprised. If you have honestly done your best and tried your hardest to get this to work, and failed, then your fallback is to implement the full stochastic miasma. Start with the TOMS paper by Corana, Marchesi, Martini, and Ridella. It is the most engineering-results oriented discussion I know of. If you are a masochist, try (just try!) to read the various publications and white papers by Lester Ingber. You will regret it.

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.
  

Here are my favorite books for sharpening your C saw. The great news is that all of these are less than 300 pages each.

The C Programming Language (Kernighan, Ritchie)

An essential for all C programmers. It's short but dense and it's packed full of great exercises.

Data Structures in C (Kalicharan)

This book offers a practical look at data structures and a few algorithms. It has a bunch of exercises to help you retain what you're learning.

The C Puzzle Book (Feuer)

A tiny book packed with a bunch of C puzzles, the pointers chapter is especially helpful.

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.

My General Thought

I find it is best to learn and get exposure from several book/media sources coupled with actual application of things learned.

----

Introductory Texts/Links

Short Intro
http://heather.cs.ucdavis.edu/~matloff/unix.html

C Programming: A Modern Approach
http://knking.com/books/c2/index.html

Head First C (Different Presentation Style, check amazon preview)
http://www.amazon.com/Head-First-C-David-Griffiths/dp/1449399916/

Programming in C
http://www.amazon.com/Programming-C-4th-Developers-Library/dp/0321776410/

PDF Tutorial
http://phy.ntnu.edu.tw/~cchen/pdf/ctutor.pdf
Original Here > http://www.tutorialspoint.com/cprogramming/index.htm

C The HardWay (Mostly complete)
http://c.learncodethehardway.org/book/

Zed's K&R Critique
http://c.learncodethehardway.org/book/krcritique.html

Practical C Programming
http://shop.oreilly.com/product/9781565923065.do

Ben Klemens Modeling with Data book has a short C introductory section.
http://ben.klemens.org/pdfs/gsl_stats.pdf

-----

Reference
Harbison and Steele C Reference Manual
http://www.careferencemanual.com/

Plan on developing on Linux?
The Linux Programming Interface: A Linux and UNIX System Programming Handbook
http://www.amazon.com/dp/1593272200/

Didn't get Pointers?
http://www.amazon.com/dp/1449344186/

21st Century C, This book got dogged a lot, but I think its a nice text.
http://www.amazon.com/21st-Century-Tips-New-School/dp/1449327141

K&R Scan (If you want an idea what's inside K&R)
http://www.iups.org/media/meeting_minutes/C.pdf

-----

Need an Editor?
VIM Book
ftp://ftp.vim.org/pub/vim/doc/book/vimbook-OPL.pdf

Vim Video Tutorials
http://derekwyatt.org/vim/

-----

Back in the Day
I used these books years ago. They're somewhat dated, but still useful and cheap.
Programming in ANSI C
http://www.amazon.com/Programming-ANSI-Hayden-Books-library/dp/0672484080
Advanced C: Tips and Techniques (Hayden Books C Library)
http://www.amazon.com/Advanced-Techniques-Hayden-Books-Library/dp/067248417X/

----

C Language Basics
How do I read/write files
How things are implemented at a lower level
Compiler Options and Functionality
What is a make file?
Debugging... How to do it... How do I use a standard debugger like GDB?

The best thing to do would be to pick up a book on general programming principles, something that will teach you the basics about control statements (booleans, conditionals, loops), variable types, and data structures.

Python (or Ruby) is probably the easiest language to get started with because there isn't a lot of strange syntax or archaic symbols, and you're relieved of the burden of doing low-level stuff like memory management (for the most part). Also, you'll be able to read other people's example code pretty quickly, because it is a lot like English.

C++ was my first language, but Dive Into Python by Mark Pilgrim was what I learned python from. You can read it for free here. I'd recommend learning the abstract concepts from a good beginners' c++ book if possible.

Advanced C++ Programming Styles and Idioms is pretty unconventional: the author assumes you are already familiar with programming concepts and C++ syntax, and presents a plethora of C++ idioms, at least half of which are... let's say unconventional applications of C++'s power of abstraction, that make you think outside the box. Amazon's synopsis and the reviewers there do a better job at describing it though, so give that a read.

You should read an intermediate-level C++ book or two before diving into this one in order to truly appreciate its eccentricity (which should open your eyes considerably). It is a rather strange book: it reads more like a novel than a desktop reference.

+1 for mentioning malwareunicorns Reverse Engineering Malware 101 course. I'm pretty excited about starting that after I'm done with some Powershell stuff.

Books for: /u/Kreator333 and /u/curiousdoggo

C/C++:

• The C Programming Language (2nd Edition) - K&R is fine for fundementals.
  
  
• Pointers on C the sections on pointers are phenomenal. The author explains them in great depth with lots of examples.
  
  
• TBH I haven't learned C++ yet but this definitive guide/list looks promising.
  
  Assembly/C:
  
  
• Hacking The Art of Exploitation 2nd Edition. Mainly the chapter on programming which pretty much has everything you need. It can get you started with C and ASM and how they compare by stepping through examples using GDB, etc.. Read this if you really want to hit the ground running and then jump into those other books you mentioned OP.
  
  Also OP while your learning the basics here do as many examples as you can. Don't just read it and assume you know everything. For C you can try coding a bunch of classical ciphers and for ASM, debug the assembly of simple programs in gdb. (check out godbolt) or try coding a echo client/server in Nasm.
  

As someone who actually did go the route of learning C/C++ as my first language, let me say DON'T.

Python would have to be the best, as the punctuation is very minimal, and lets face it, missing that all important semi-colon is something that's best not worried about while trying to wrap your head around the concepts.

Once you do have an understanding of basic Python, and you're certain you want to learn C++, start with C, specifically, this book. Once you've got your head around pointers, pointer pointers, function pointers, and all the fun ways C allows you to shoot yourself, then aim for C++ (which introduces many many ways to shoot yourself, ontop of the methods C allows).

While it's generally agreed that "The C Programming Language" is the best book to learn C from (it's written by the folks who made C, and it's quite short), I'm not aware of a strong consensus about which book is best to learn about C++, although you could do worse than going straight to the source, Bjarn Stroustrup, the creator of C++, wrote "The C++ Programming Language", link.

Somewhere in there, if you want to write C and or C++, you have no choice but to learn Assembly Language. It's a long running joke that C is simply a high level assembler. The funny thing is though, it's true. If you don't have at least a rudimentary understanding of Assembly, your C/C++ is going to be shit.

Some physical book recommendations:

• 21st Century C
  
• C Programming: A Modern Approach
  
• Understanding and Using C Pointers
  
  List of free ebooks: https://github.com/EbookFoundation/free-programming-books/blob/master/free-programming-books.md#c
  
  I highly recommend reading up on assembly as well, since understanding assembly is invaluable for understanding C. You might also enjoy reverse engineering as a topic, especially since it teaches a lot about lower-level architecture.
  
  Physical books:
  
  
• Assembly Programming and Computer Architecture for Software Engineers
  
• Practical Malware Analysis (malware is a good subject for reverse engineering because the only difference between it and other software is intent and they're real non-contrived examples that people won't sue you over for breaking)
  
  Some more (free) e-books:
  
  
• PC Assembly Language
  
• Programming From The Ground Up
  
• Reverse Engineering For Beginners (Understanding Assembly Language)
  
  Other resources: (will add more when I remember/find them)
  
  
• LiveOverflow YouTube Channel
  
• nand2tetris

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.

I started my summer semester with no experience whatsoever. Right now, I'm about halfway through Programming 1 (C++). I'm able to write basic programs (word counter, "day of the week" program, and other simple stuff).

As for doing something useful: I build a simple little robot recently. I did all of the mechanical and electrical work, and I had no idea how to do the programming side of it. I used a program that some people had suggested, so that kind of worked for the time being. My goal by the end of the semester is to write my own program for my robot!

I would really recommend a book like Starting Out With C++ - From Control Structures through Objects - 6th Edition by Tony Gaddis. I think it has a lot of well explained examples.

I hope that helps!

Of course! References can be your best friend. There are even some books specifically meant as a reference material, like Stroustrop's giant textbook ( http://www.amazon.com/Programming-Language-3rd-Bjarne-Stroustrup/dp/0201889544 ) They can really help out if you're stuck on something.

Not sure about C, but for C++ this book is pretty awesome. It's written by the guy who designed C++, so yeah.

If you want something a little more general, and you've already got a handle on how the language (and framework) work in a general sense, then I'd highly recommend Effective C# by Bill Wagner. It really helped me understand some of the idiosyncrasies of both C# and .NET in general, as well as some features I'd never before discovered. It'll really help you make anything you'd create more stable, legible, and maintainable.

I've always found the Deitel & Deitel books to be of great value when you want to learn how to use a programming language in the practice. The one for C is this one:

http://www.amazon.com/C-How-Program-5th/dp/0132404168/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1219748403&sr=8-1

But still, if you are an absolute beginner, The C Programming Language is the way to go. Small, concise, a pleasure to read, and even shows you how many of the standard library functions are written.

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.

I made the transition by essentially rewriting a C game engine, piece by piece in C++. I don't know if you are a programming novice or just a C++ novice, but either way working within an existing code base can be a great help.

Most of my reference came from:
"C++ For Game Programmers" - http://www.amazon.com/dp/1584502274
And of course, the C++ bible - http://www.amazon.com/dp/0201889544

The latter isn't really so much of a "read it through" as an invaluable reference for how things work.

This is also quite handy: http://www.parashift.com/c++-faq-lite/

If your primary goal for learning C is performance, then I would stop and back up. Matlab is going to be able to do matrix operations faster than your hand written C, because it knows tons of tricks to get performance out of hardware. Scipy as well will give you access to libraries like LAPACK and BLAS that are already highly optimized for those specialized types of computations and run at native speed. And implementing a solver/algorithm in Matlab or Python is going to be much easier and require less programmer time than doing the equivalent in bare C. Turning to C should be a reactive decision ("I have a working model in Matlab but it takes too long to execute") and not pro-active ("I heard C was the fastest, so I'll start there.")

If you really want books on C, then try Numerical Recipes in C: The Art of Scientific Computing. But I must warn you, most of the code in this book and others like it is simply ghastly. It is written by and for scientists, not programmers, with an emphasis on getting things done without regard for "code smell" or modern programming practice. It is the last thing you want to learn C or any other language from.

Since folks already answered your question, I'm a newby as well, and amongst many books, I found these 4 of particularly great help:

Read this first:
https://www.amazon.com/Starting-Out-Early-Objects-9th/dp/0134400240

https://www.amazon.com/C-Primer-Stanley-B-Lippman-ebook/dp/B0091I7FEQ

https://www.amazon.com/Engineers-Scientists-Gary-J-Bronson/dp/1133187846

https://www.amazon.com/Understanding-Using-Pointers-Techniques-Management/dp/1449344186

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
  

It makes every list because it's a decent book and presents the basics of OO in a cohearent manner?

http://www.amazon.com/Thinking-Introduction-Standard-One-2nd/dp/0139798099

85 customer reviews agree?

I'm not saying that it's a magical book that will turn you into a guru of C++, but with that book, some dedication, and some googling, it really is a great place to start in C++. Understanding the C-roots of C++ is intensely important for problem solving. I'm not sure why you have a problem with that, can you please explain?

C Traps and Pitfalls is good book and much shorter than Expert C Programming. It's based on a paper of the same name that you can get for free. But, the book cover more topics - worthwhile if you can find it at a reasonable price.

Almost certainly not. Those "Learn x in y days/weeks" books are usually not worth the hundreds and hundreds of pages of paper that they're written on. My advice would be to steer clear of them and pick up something better like Thinking in C++.

There are a handful of books out there, but this one is generally considered the definitive text. David Abrahams and Aleksey Gurtovoy are way smarter than I could ever hope to be, so I had to do a lot of work to get through this book and grasp the basic concepts.

I don't think you don't need to use Visual Studio. This is certainly a job which VBA was created for within MS Word and will do everything that you want.
You can use the Document object that can load in a file and pull out what you need.
Ultimately, learn Office Word 365 thoroughly and VBA to extend rather than Visual Studio. Visual Studio is an IDE for programming languages, and as such you will need to learn the programming language to use and how to package and deliver the software.
Office has VBA to extend functionality in Office Applications, and as such is more suited to what you wish to do.

See : https://docs.microsoft.com/en-us/office/vba/word/concepts/working-with-word/working-with-document-objects
https://www.amazon.co.uk/Mastering-VBA-Microsoft-Office-2016/dp/1119225388/
https://mva.microsoft.com/en-US/training-courses/office-365-developer-overview-13986

Regarding

> ” I am confused about why this is a copy constructor and not just a normal function:

> class Core {
> friend class Student_info;
> protected:
> virtual Core clone() const { return new Core(this); }
>
> private:
> Core cp; //sorry I think this is how it was declared, but I hope it is close enough
>
> // bunch of other code
> };

The clone function is a normal member function, and is not a copy constructor.

However, the implementation (function body) of that function uses the class' copy constructor.

At one point the term virtual constructor was used about a clone function. I think but I'm not sure that that term was introduced or popularized in ¹a book by Coplien. Today that term is not much used, if it's used at all: I've never seen it used except in comments about terminology for clone functions. :)

---

Regarding

> ” First of all, I thought a copy constructor was in the form
>
> classname (const classname &obj) {
> // body of constructor
> }

That's one of the 4 forms a copy constructor can have.

The other three forms have formal argument types T&, volatile T&, and volatile const T&.

Formal argument type T, passing by value, is not a copy constructor, because you need a copy constructor to pass that argument, and a class can have just one copy constructor.

---

Regarding

> ” Did the act of copying those two cp pointers bring us to this statement?:
>
> virtual Core clone() const { return new Core(this); }
>
> Or was it just calling clone()?

The Student_info copy constructor is executed as a result of an attempt to copy an instance. Usually it's an implicit call, e.g. via = initialization syntax, or passing an argument by value.

The Student_info copy constructor calls Core::clone, via the explicit call in theStudent_info copy constructor function body. Since the clone function is an ordinary member function, nothing special about it, in particular, it isn't a conversion function, it can't be called implicitly. So it will not be called out of the blue.

In the Core::clone function there is an explicit call of the Core copy constructor.

---

Note that the terminology I use here, talking about an explicit constructor call, is contested. It beats me why, but some quite competent people have insisted that constructors can't be called by user code, even after being pointed to e.g. the C++03 definition of default constructor (one that can be called without arguments). I only convinced one of them that that choice of terminology, not using the terms “call” or “explicit” about constructor calls, was impractical, and that was after several years, and via an argument that is a well known logical fallacy, namely, an appeal to authority: I finally found an article by the language creator Bjarne Stroustrup where he used these words.

---

Notes:*
¹ Googling indicates that the book by Coplien was “Advanced C++ Programming Styles and Idioms” published in 1991. That predates the first C++ standard by 7 years.

• OOP with C
  
• C Interfaces and Implementations
  
• 21st Century C
  
• The C Puzzle Book
  
• Expert C Programming: Deep C Secrets - Very advanced book
  
  Exceptional C++ and Effective C++ (and the More ** versions) are also actually pretty damn useful in the C world.
  
  Since you didn't mention C knowledge, you'll still need to either start with K&R OR C Programming: A Modern Approach by King.

Programming C# 4.0 is great for learning and starting out.

Once you're comfortable with the language, go through CLR via C#. This will teach you how things work in detail.

Im currently in the class now. I agree with the previous posts in that reviewing C is a great idea. The whole class is entirely in C. I also recommend to get a supplemental book on C. The book in the link below really saved my ass.

Understanding C Pointers

Once done reading both K&R C and Deep C Secrets (definitely two of my favorite books), go through the C Puzzle Book. An excellent way to test your knowledge.

Agreed, C Programming A Modern Approach, 2dn edition is the textbook I would recommend if you want to learn C, K&R is classic , but it lacks a lot details in C which are coverd in books like Pointers on C and C Traps and Pitfalls, C Programming A Modern Approach, 2dn edition covers most, if not all, of them.

> How the heck am I supposed to learn STL, when and how to use it?

Books are good! They can cover the material more efficiently than video can, and it's easy to adapt if the material is being covered too quickly or too slowly. I don't have a personal recommendation, but a quick Amazon search came up with The C++ Standard Library: A Tutorial and Reference (2nd Edition) which seems to be well-regarded. Too expensive? A used copy of the 1st edition is only a few bucks.

Also, if you like this sort of C mindfuck, buy The C Puzzle Book. Even if you're an experienced developer I bet at some point during the book you go "Oh, wow, I didn't know that." And of course lots of "Who in their right mind would EVER write code that stupid?"

With VBA, I think it would be very boring and hard to learn out of a book. Really the best way to learn is to have a simple task in Excel that you can automate with VBA. Then as you do more and more your knowledge grows organically. If that's not possible, I learned a lot from this book. Or you can get the updated 2016 version.

For SQL, I mostly use W3Schools when I forget some syntax, so that might be a good place to start.

I disagree somewhat with that distinction. The reason I say this is that a few of the patterns in GoF where actually documented as idioms in Advanced C++ Programming Styles and Idioms and recast as patterns. On the other hand, some purists argue that the GoF patterns are not even real patterns in the Alexandrian sense, therefore they would all be idioms.

So if you are sticking to the GoF definition of patterns, they aren't much more than idioms. If you look at the Alexandrian patterns, then I might agree with you. A good distinction would be to limit idioms to language specific solutions and real patterns to solutions that arise independent of the language. I edited my reply above to reflect this.

Programming C# 4.0 is really excellent in my opinion. I came to it with a teenager's programming experience and still found it easy to follow. The book is huge, totaling at over 800 pages. It is mostly focused on C# itself, but in later chapters branches off into a lot of the subsets of .NET such as ASP.NET, WPF, WF, Silverlight, etc.

It does take a little understanding for boost code. I remember looking at it many years ago when I was student and not understanding it at all. But some things that really helped me was dave abrahams C++ template metaprogramming book, and More C++ Idioms wiki page. I understand boost code a lot better(except the compiler workarounds they have for esoteric compilers). Its actually rather simple a lot of it. Its just different.

I can't recommend this book enough: The C Puzzle Book

It goes over all this kind of stuff in great detail. Must-have for anyone studying or working in C/C++

Java and C# are very very similar.

> How do you more experienced developers go about teaching yourself a new language?

Google and books. This book is pretty decent.

For c++ at least http://www.amazon.com/The-Design-Evolution-Bjarne-Stroustrup/dp/0201543303 this goes over pretty much all the early design desisions, including why they picked that idiom.

Since you're studying Mathematics, you might be better off looking at functional programming,rather then OOP. F# from Microsoft offers both functional and OOP. A good introduction is F# for Scientists . As for performance, there are a number of benchmarks showing F# matching or beating equivalent C++ programs.

Koenig, "C traps and Pitfalls"

http://www.amazon.com/C-Traps-Pitfalls-Andrew-Koenig/dp/0201179288/

from 1989, still valuable as a periodic refresher

Thinking in c++ by Bruce Eckel. Good one I've used to learn the langage while being students.

http://www.amazon.com/Thinking-Introduction-Standard-One-2nd/dp/0139798099/ref=pd_sim_b_1/190-9785840-9713239

Check out Bjarne's book:
(https://www.amazon.com/Design-Evolution-C-Bjarne-Stroustrup/dp/0201543303)

For a book-length rationale/apology for why C++ is the way it is. I think C++ language is shooting off it's feet bit by bit with the way they design things: in a couple standards the language will be so complex developers will be cargo-cult-copying-boiler-plate over most things like this.

I would highly recommend power programming with vba. Exceptional reference. http://www.amazon.com/gp/aw/d/0470475358/ref=s9_simh_gw_d0_g14_i1?pf_rd_m=ATVPDKIKX0DER&pf_rd_s=mobile-1&pf_rd_r=09S70XW4XDWY2BC2JT9K&pf_rd_t=36701&pf_rd_p=2068141862&pf_rd_i=mobile.

I think a lot of it is subjective; one book is not going to destroy you as a programmer unless you rely on only one book. Most of the developers I deal with have a library of books. For C++ they have at least Stroustrup's C++ and the STL Library. They are both pending for new editions for C++11 so you might want to wait a bit.

personally, i've really enjoyed Power Programming with VBA by John Walkenbach. It is very elementary, with lots of examples and a disc included. If you are a total noob (like me) and want to speed up repetitive BS at work, this isn't a bad one to pick up.

I highly recommend The Design and Evolution of C++ if you want to learn about the original design decisions behind C++ that the current ISO committee seems to not care about in the slightest.

It's a bit dated but offers a tremendous amount of insight into why the language was made as it is.

PowerShell in Action is apparently quite good. I read somewhere if you wanted a more in depth read on what/how powershell is doing, more so than in 'A month of lunches' then this is the one you want. I haven't read it myself, but I have the 3rd edition on order and its due in May

Seconded. At the risk of being branded as a shameless O'Reilly plugger, I recommend this book for OP. It was immensely helpful when I was learning C; I found that K&R's description of them was complete, but lacked the tutorial aspect.

Check out this book: Understanding and Using C Pointers: Core Techniques for Memory Management https://www.amazon.com/dp/1449344186/ref=cm_sw_r_cp_apa_i_Eb-tDb8FMT3Y0

Other than that, I had trouble with pointers to arrays and the concept of "array decaying". You should take a look at them to better grasp pointers.

Well there this book I used to learn C++ that takes a similar approach (building up from C): Thinking in C++ there was a free version of it online but link is broken on www.bruceeckel.com

I think it's worth the read even if you never did much C and just want C++. And it does a better job than the linked article I think. (I know it's unfair to compare a blog post to a full book).

Actually, I thought you were referring to: Pointers on C by Kenneth Reek.

I'll check yours, too.

You could take a look at The Design and Evolution of C++.

These are my monitor stand in work;

http://www.amazon.com/Thinking-Introduction-Standard-Volume-Edition/dp/0139798099

http://books.google.ie/books/about/UNIX_Network_Programming.html?id=ptSC4LpwGA0C&redir_esc=y

https://www.amazon.com/Windows-PowerShell-Action-Bruce-Payette/dp/1633430294/ref=sr_1_1?ie=UTF8&qid=1505822784&sr=8-1&keywords=powershell+in+action

• graphics gems series
  http://www.amazon.com/gp/aw/d/0122861655
  
  
• numerical recipes in C
  http://www.amazon.com/gp/aw/d/0521431085
  
  
• anything by Jim Blinn

The book that changed my life is called: The C++ Programming Language, the author's name is Bjarne Stroustrup and he is the inventor of the C++ language.

This book is about the C++ programming language, the syntax, and the uses.
At first I wanted to learn about computers but when I picked up this book I became so interested in software developing that it got me reading other books about other programming languages and now I know 4 of them. It helped me make a choice in my major and now I'm studying software development in college.

Once these were called idioms:

http://www.amazon.com/Advanced-C-Programming-Styles-Idioms/dp/0201548550/ref=sr_1_1?ie=UTF8&qid=1310699439&sr=8-1

The idea of specifying dimensional information in code is not a new one, and I think a lot of work on that was done in Ada decades ago.

In C++, I seem to recall the work done in Scientific and Engineering C++ and, more recently, in C++ Template Metaprogramming.

Incidentally, the latter book has the chapter dealing with dimensional analysis available as a sample chapter.

In Common Lisp, I know of the Measures package, part of LOOM.

For VBA, I cannot recommend any of the books by Walkenbach highly enough, such as: http://www.amazon.co.uk/Excel-Power-Programming-Spreadsheets-Bookshelf/dp/0470475358/ref=la_B000APG96Y_1_5?s=books&ie=UTF8&qid=1406291315&sr=1-5

Yeah, no worries; just emphasizing. I wasn't programming when it was introduced either. ;-) I had to dig out my D&E to try to track it down.

I like Josuttis as a standard library reference. It might not be your traditional "Learn how to program" book, but it will remain on your shelf long after you've tossed out the rest of your beginners books. (I also notice that he seems to have a C++11 book coming out soon.)

http://www.amazon.com/Standard-Library-Tutorial-Reference/dp/0201379260/ref=sr_1_1?s=books&ie=UTF8&qid=1324964906&sr=1-1

I learned C++ from Dietel & Dietel 1st Edition, but I noticed that by the 4th edition the book had gotten a bit obnoxious. Maybe they've corrected some of that now that they are on their 8th edition? If nothing else, at least they have been doing the C++ book thing for well over a decade.

http://www.amazon.com/How-Program-8th-Paul-Deitel/dp/0132662361/ref=sr_1_1?ie=UTF8&qid=1324965103&sr=8-1

Code Complete

Big Java Late Objects

The Pragmatic Programmer: From Journeyman to Master

The Mythical Man-Month

Android Programming: The Big Nerd Ranch Guide

cracking the coding Interview

Introduction to Algorithms

Thinking in C++

I too started with C as my first language using K&R and "learn C the hard way" but i abandoned both halfway. I've started from beginning with "A modern approach to C" as my main source and C: A Reference Manual as, well reference manual when i wanted more in depth knowledge about particular subject. After you're done with Modern approach you should go back to K&R and finish it in order to have your foundation properly rounded.

Edit: I should add few more resources that generally helped me a lot when I started:

http://c-faq.com/

C Traps and Pitfalls

C Standard Library

Things you should avoid in C

A Guide to Undefined Behavior in C and C++

> It's you little hipstor who're trying to prove the outrageous idea that what people do now is somehow the best possible

Nope I haven't once tried to argue that. I'm arguing against your stupid idea, not that what we have is perfect. But again your inability to grasp basic knowledge doesn't really surprise me.

> Even that useless wikipedia does not say anything about

I pulled several literal direct quotes out. Were you unable to read those? Was it too hard? Should we check and see if there's a simple english version of that wikipedia page for you?

> What for? Wikipedia is for idiots. Why would anyone at all care about the idiots?

Okay so can you provide a list of sources you consider valid? Since anybody who's made a compiler that's actually used is stupid and idiotic, the entire world is stupid and idiotic, wikipedia with sources is idiotic and stupid. Who besides you do you consider not stupid and idiotic?

Would the creator of Parser Expression Grammar be a valid source? Because Bryan Ford says

> Parsing Expression Grammars (PEGs) provide an alternative, recognition-based formal foundation for describing machine-oriented syntax, which solves the ambiguity problem by not introducing ambiguity in the first place. Where CFGs express nondeterministic choice between alternatives, PEGs instead use prioritized choice.

I assume that if his scientific paper isn't a good enough source then MIT itself is just full of stupid idiots too?

What about lambda the ultimate?

What about the MIT mailing list for PEG who reference this site that advocates for users to read the wikipedia entry on it. You know why it advocates that? Because Bryan Ford wrote the wikipedia page on it.

I could literally go all day finding more and more sources that directly contradict you, or reaffirm that the wikipedia entry is indeed correct. Could you find a single source besides yourself?

> Since when C++ is mainstream?

Since pretty much it's creation. Usage isn't even significantly dropping as it's doing a fairly good job of adding more and more features.

> And nobody would dare to call it a "general purpose"

Yeah nobody except for, you know the literal standard which has it as the first sentence of the second paragraph.

> designed explicitly for building eDSLs.

Where the hell did you get this idea? Seriously who told you this?

Because Bjarne Strousrup says that it

> was designed to provide Simula's facilities for program organization together with C's efficiency and flexibility for systems programming. It was intended to deliver that to real projects within half a year of the idea.

But he's probably an idiot too right? What would he possibly know about the reason why C++ was created?

> Objective fact is an implementation of error recovery operator. Which you claim is somehow "impossible" in PEG.

Nope never claimed that. Again you fail to be able to read.

What I claimed is that the naive trivial implementations where you auto-generate stuff does not support this well. You have to go very far out of your way to get decent error messages out of a parser generator. Which is why nobody making a widely used language uses them. And certainly even you can agree that adding the error recovery operator does mean you do more work than not having it.

> I demonstrated a PEG-based extensible parser generator that integrates with IDEs and literate programming tools automatically.

I didn't say it didn't do that. Just that it's rather shitty. You can get the barest minimum of features that are expected out of every IDE extension.

> What the fuck did you just say? It does not even mean anything.

I'm sorry, were those words too complicated for you? You wanted a single example because in your mind it was impossible to find a single example. I gave you one. You can't even understand literally the world's easiest set of requirements? Would you like a more thorough spec for the 5 minute task?

Or do you need another example because you're going to change your mind again and say something like "well actually the web is stupid and nobody uses websites".