Game Engine:

Game Engine Architecture by Jason Gregory, best you can get.

Game Coding Complete by Mike McShaffry. The book goes over the whole of making a game from start to finish, so it's a great way to learn the interaction the engine has with the gameplay code. Though, I admit I also am not a particular fan of his coding style, but have found ways around it. The boost library adds some complexity that makes the code more terse. The 4th edition made a point of not using it after many met with some difficulty with it in the 3rd edition. The book also uses DXUT to abstract the DirectX functionality necessary to render things on screen. Although that is one approach, I found that getting DXUT set up properly can be somewhat of a pain, and the abstraction hides really interesting details about the whole task of 3D rendering. You have a strong background in graphics, so you will probably be better served by more direct access to the DirectX API calls. This leads into my suggestion for Introduction to 3D Game Programming with DirectX10 (or DirectX11).



C++:

C++ Pocket Reference by Kyle Loudon
I remember reading that it takes years if not decades to become a master at C++. You have a lot of C++ experience, so you might be better served by a small reference book than a large textbook. I like having this around to reference the features that I use less often. Example:

namespace
{
//code here
}

is an unnamed namespace, which is a preferred method for declaring functions or variables with file scope. You don't see this too often in sample textbook code, but it will crop up from time to time in samples from other programmers on the web. It's $10 or so, and I find it faster and handier than standard online documentation.



Math:

You have a solid graphics background, but just in case you need good references for math:
3D Math Primer
Mathematics for 3D Game Programming

Also, really advanced lighting techniques stretch into the field of Multivariate Calculus. Calculus: Early Transcendentals Chapters >= 11 fall in that field.



Rendering:

Introduction to 3D Game Programming with DirectX10 by Frank. D. Luna.
You should probably get the DirectX11 version when it is available, not because it's newer, not because DirectX10 is obsolete (it's not yet), but because the new DirectX11 book has a chapter on animation. The directX 10 book sorely lacks it. But your solid graphics background may make this obsolete for you.

3D Game Engine Architecture (with Wild Magic) by David H. Eberly is a good book with a lot of parallels to Game Engine Architecture, but focuses much more on the 3D rendering portion of the engine, so you get a better depth of knowledge for rendering in the context of a game engine. I haven't had a chance to read much of this one, so I can't be sure of how useful it is just yet. I also haven't had the pleasure of obtaining its sister book 3D Game Engine Design.

Given your strong graphics background, you will probably want to go past the basics and get to the really nifty stuff. Real-Time Rendering, Third Edition by Tomas Akenine-Moller, Eric Haines, Naty Hoffman is a good book of the more advanced techniques, so you might look there for material to push your graphics knowledge boundaries.



Software Engineering:

I don't have a good book to suggest for this topic, so hopefully another redditor will follow up on this.

If you haven't already, be sure to read about software engineering. It teaches you how to design a process for development, the stages involved, effective methodologies for making and tracking progress, and all sorts of information on things that make programming and software development easier. Not all of it will be useful if you are a one man team, because software engineering is a discipline created around teams, but much of it still applies and will help you stay on track, know when you've been derailed, and help you make decisions that get you back on. Also, patterns. Patterns are great.

Note: I would not suggest Software Engineering for Game Developers. It's an ok book, but I've seen better, the structure doesn't seem to flow well (for me at least), and it seems to be missing some important topics, like user stories, Rational Unified Process, or Feature-Driven Development (I think Mojang does this, but I don't know for sure). Maybe those topics aren't very important for game development directly, but I've always found user stories to be useful.

Software Engineering in general will prove to be a useful field when you are developing your engine, and even more so if you have a team. Take a look at This article to get small taste of what Software Engineering is about.


Why so many books?
Game Engines are a collection of different systems and subsystems used in making games. Each system has its own background, perspective, concepts, and can be referred to from multiple angles. I like Game Engine Architecture's structure for showing an engine as a whole. Luna's DirectX10 book has a better Timer class. The DirectX book also has better explanations of the low-level rendering processes than Coding Complete or Engine Architecture. Engine Architecture and Game Coding Complete touch on Software Engineering, but not in great depth, which is important for team development. So I find that Game Coding Complete and Game Engine Architecture are your go to books, but in some cases only provide a surface layer understanding of some system, which isn't enough to implement your own engine on. The other books are listed here because I feel they provide a valuable supplement and more in depth explanations that will be useful when developing your engine.

tldr: What Valken and SpooderW said.

On the topic of XNA, anyone know a good XNA book? I have XNA Unleashed 3.0, but it's somewhat out of date to the new XNA 4.0. The best looking up-to-date one seems to be Learning XNA 4.0: Game Development for the PC, Xbox 360, and Windows Phone 7 . I have the 3.0 version of this book, and it's well done.

*****
Source: Doing an Independent Study in Game Engine Development. I asked this same question months ago, did my research, got most of the books listed here, and omitted ones that didn't have much usefulness. Thought I would share my research, hope you find it useful.

Hi RandomNumber37,

So here's a little bit about me first; I don't want to misrepresent myself. My background is in economics and political science, where I was interested in statistical models that predict rare international events like war and state failure. It's here I became obsessed with statistics, machine learning, etc. Also, I've been programming in many languages since I was a kid, so after my undergraduate work in the social sciences and statistics, I took a job with a bioinformatics group doing coding. I thought this would be a temporary job until graduate school in economics or quantitative political science.

However working with large-scale biological and sequencing data was way more awesome than I expected. This caused me to shift focus. I also did a fair amount of work on computational statistics, i.e. ways of trying to make R better, understanding compiler technologies, etc. So after, I became more purely interested in statistics and computational biology, and I thought I would go to graduate school for pure statistics so I could also devote some time to computational statistics. However, now I work in a plant breeding lab (which I absolutely love). I will do this about another 2-3 years before I transition into a graduate program. This would mean I've worked in the field about 6 years before applying to graduate programs.

So, with that out of the way here are answers to your questions and some advice I offer:

1. How much of your time is spent working with the plants themselves vs with computer-organized data?
   
   Being that my background isn't in biology, I don't currently work with plants much. However, this is why I moved towards plant biology. Before getting obsessed about social science methods, I loved plants. I worked at an orchid greenhouse, and actually went to UC Davis thinking I'd study plant biology (until an awesome political science professor got me excited about science applied to political data). However, the scientists I work with are often not doing too much work with plants: many grow the plants, do the wet lab work, then spend more than half the time (sometimes up to 90%) analyzing the huge amount of data. I spend my full day in front of a computer, except when a colleague wants me to check out something cool in the lab, etc.
   
   
2. With what kind of operations does your computer aid you?
   
   Everything. We get raw sequencing data, I have to analyze it from start to finish. Or, from raw sequencing files until the point where the numbers behind it tell a story. I also spend a huge amount of my time writing programs that do certain things for biologists in our group. Everything — protein prediction, data quality analysis, statistical modeling, etc.
   
   
3. Do you see a full cycle... from plant, to data, to application of knowledge to your specimens (and back to data)?
   
   Yes, at this current position I am starting to (which I why I sought work in plant biology). It depends on what plant you work with (Arabidopsis = short life cycle, you can do lots of stuff, vs citrus tree = long life cycle, you can't do lots of stuff). But some of the more awesome longer term projects will take 4 years to fully materialize.
   
   So now, what steps were more important? I will tell you the three things that have helped me the most. As a point of how much they've helped me, I'll just mention that despite that not having a Phd (yet), or much of a background in biology other than what I've taught myself or learned on the job (which is actually quite a lot after 4 years in the field), I've had (and continue to receive) really nice job offers.
   
   
4. Learn programming really, really, really well. If you want to be a step above the rest, learn python and R. Perl is huge in bioinformatics, but it's a disgusting ugly language that's dying out in my opinion. It sucks for reproducibility; no one can read anyone else's code. It was great when everyone was racing to get the human genome sequenced and had to write quick scripts constantly. Now, we have larger software platforms for that stuff, and what will count most in the future is the distribution of your scientific code. Reproducibility problems will soon be primarily dry lab, not wet lab. If you doubt that, read the "Forensic Bioinformatics" paper (http://projecteuclid.org/euclid.aoas/1267453942) which was a game changer for me. I've always been passionate about open science and reproducibility, but that made me realize that we'll have a huge problem in a few years if we're not careful.
   
   Anyways, I'd recommend learning:
   
   

• Python (with BioPython). Also, with Django if you're building web apps to interface with scientific databases.
  
• R (with Bioconductor).
  
• Unix command line (sed/awk, bash)
  
• Know your editor. I use emacs. Even if it takes you 80 hours to learn emacs or your editor well, you will regain that time over a year of work. I promise. People watch me use emacs and they say it makes them dizzy because they can't keep up. That's dozens of hours saved each week.
  
  Now, optionally (but highly, highly recommended):
  
  
• C. Absolutely necessary to debug compiling programs or writing high-usage programs that need to be fast.
  
• SQL. You'll be storing biological data in databases. SQL is important. Use SQLite a lot. People like huge PostgreSQL or MySQL databases for even small things, but this is a waste of time IMO if you're just going to be the one accessing it. Bioconductor leverages huge amount of SQLite because it's so easy and awesome.
  
  Now, even more optionally:
  
  
• Lisp. Lisp will change the way you think about programming. It's also used with AraCyc, MetaCyc, and PlantCyc data. I've used it extensively in these applications. The ratio of how Lisp has changed my thinking to how much I use it in production code is HUGE. Learn functional programming concepts; then concepts like map/reduce will fall easily into place. Know object orientation too.
  
  
• Javascript. I love JS. It's doing amazing things too. And part of being a very effective bioinformatician/statistician is being able to easily convey your data. There is no easier and more interactive medium than a browser. Check out d3.js. Even old scientists can click a link and interact with data via Javascript. In contrast, they wouldn't want to install some old dusty Java application. Of course, with this comes HTML, XML, JSON, etc, etc. so learn those too.
  
  

1. Learn statistics REALLY WELL. Honestly, try to pick up a statistics minor (over a CS minor IMO). Lots of brilliant programmers buy the Cormen algorithm book and are set for data structures and algorithms. But understanding statistics at a deeper level — that takes intimate study via courses. I would recommend taking courses on probability theory and mathematical statistics. I took two courses as part of our mathematical statistics series and I cannot even begin to emphasize how helpful they were. I hear a quote once: at Google they use Bayes theorem like other programmers use "if" statements. Same thing in bioinformatics. Look at the best SNP callers, software, etc, and they're using population genetics models and Bayes approaches. Know math stats early, and it will permeate your thinking in the best ways.
   
   Another quick story: I had a statistics graduate student come tell me he was working for a rather well known genomics professor on campus. He asked me how to analyze RNA-seq data. He said he wanted to use ANOVA. Even though he was a statistics graduate student, he went immediately to normality-assuming models, which was definitely not the case with this data the case. So know your Poisson, negative binomial, gamma, etc distributions. A probability course should introduce them all to you. It will also means when you start learning more theoretical population genetics, you'll be set.
   
   Also, buy a book on machine learning (Elements of Statistical Learning II is good, and a free PDF is available). ESL II is good, but dense; don't let it discourage you. I also like this book. But again, this is dense stuff, don't let it discourage you.
   
   
2. Learn data structures and algorithms well. I think a single course, or doing this on your own is sufficient. However, if you want to do what Heng Li does (author of BWA, samtools, and fermi assembler) you need much, much more. Compression-based data structures are huge in bioinformatics now. I love this stuff, but it's too removed from the biology to be very interesting to me. But if that's the direction you want to move into, hang around CS department more.
   
   
3. Learn to code well. This is vastly underemphasized in the sciences. Learn about test-driven development. Get the habit of writing unit tests early, and writing good documentation. Learn Git too — this is a must.
   
   

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

"Introduction to Graph Theory (Dover Books on Mathematics)" by Richard J. Trudeau. I've been looking at this book recently and I think it's a fairly good primer for graph theory. It's written more as a math textbook, but I think it's quite useful for computer science.

"Turing's Vision: The Birth of Computer Science (MIT Press)" by Chris Bernhardt. I quite like learning about the origins of computer science (from Turing on), and this book is my favorite of the ones I've read on the subject.

"Quantum Computing since Democritus" by Scott Aaronson. I'm currently reading this book, and I've liked it so far. He also has a blog that I've been skimming. It's very interesting work. I'm likely to begin work on quantum computing with my (soon to be) advisor, so I'm planning or seeing what else he has to say on the subject.

"Elements of Mathematics: From Euclid to Godel" by John Stillwell. I'm a sucker for math history, and I like this book pretty well. It was used to teach a series of lectures on math history at UNSW (available on YouTube). Some of the lectures are quite useful for computer science. I also enjoyed "Mathematics and Its History (Undergraduate Texts in Mathematics)" by John Stillwell, which is similar.

"Categories for the Working Mathematician (Graduate Texts in Mathematics)" by Saunders Mac Lane. It's a bit of a heavy read, but I think category theory is quite interesting and could be very useful if you were to look in to e.g. Haskell.

"Types and Programming Languages (MIT Press)" by Benjamin C. Pierce. This is the best introduction to type theory that I'm familiar with, and it came with high praise from my advisor.

"Hidden Figures: The American Dream and the Untold Story of the Black Women Mathematicians Who Helped Win the Space Race" by Margot Lee Shetterly. This is more of a "for fun" read, but it's a pleasant book about a couple of little-recognized historical figures. Plus, the upcoming movie looks pretty good.

Finally, I would definitely recommend the dragon book. I've seen it in a couple places in the comments already.

Okay I came in to school like you with very little programming experience. Probably even less than you since I only messed around on my TI. I am going to assume you're only taking ECE110 first semester. If not I recommend getting in as soon as you can. They may give you some crap about it depends on last names, but it doesn't really matter. After a certain point its open to everyone.

Either way, programming in ECE doesn't really start until you take ECE190 which is all C programming and a very simplified assembly language for educational purposes. Like I said I went into the class with practically zero programming experience and still did very well in the class, so don't let anyone scare you on that. If you put the time aside to read the book (really helpful in 190) and doing your MPs/ask the TAs questions you will do fine.

I wouldn't fret too much over the summer with learning stuff, but I would definitely recommend C over Python. Python is pretty easy to pick up, but its also very high level. If you need an introductory language to get familiar you can try python for a bit, but I'd go with C after that. It is worth noting that the other two required programming class you have to take (CS 225 and ECE 391) are C++ and C/x86 respectively. So learning C should definitely be your focus.

I recommend the book written by the creators of the language. The book the school requires is pretty good too actually and would give you a better idea of what to expect. They're kind of pricey, so its your call how you want to get them. As a heads up, codecademy does have Python, but not C as far as I recall. I've never used lynda do I can't comment on them C Book ECE 190 Book

I honestly wouldn't fret too much about it all. Enjoy your summer, depending on how busy your schedule is next semester you can probably set aside some time now and then to study some languages. If you have any more questions I'd be happy to answer.

As someone who has gone through the rigors of learning assembly programming for various architectures, I believe I can offer a bit of insight to the situation.

The Art of Assembly Programming (AoA) is great for going right into the x86 architecture, however it very complicated and there may be a bit of a learning curve when going straight into it from the get-go.

Patt & Patel have a great book that starts from how gates are organized to form basic components, and moves into assembly programming for an artificial processor called the LC-3. It then goes into developing a C compiler for this processor.

After going through the previous book, I started AoA and got into x86 programming, which even after a solid understanding of the basic fundamentals of computer organization still had quite a learning curve.

If you are ok with your education taking a bit longer, you might look into working up through a few different processors. It will give you a very robust knowledge base, and will give you insight to assembly programming on other processors, as well as give you a few more "tools" for playing around with.

Here are some fun things to learn:

-LC-3: Incredibly basic, and has no "real-life" applications, but exists solely to teach basic computer organization. Great for starting out.

-PIC 16-series: Very simple and cheap microcontroller, but it has a lot of "higher-level" functionality. These are great for playing around with basic robotics and making fun toy projects, plus it uses the Harvard-architecture, which is very interesting and quite different than the "standard" processors we find in modern computers.

-6502: This was mentioned in this thread and its great. The 6502 was very popular back in the day (Apple II, Atari 2600) and learning it can lead to some fun projects. I wrote an Atari 2600 emulator back in the day in Java, and it was a lot of fun.

Structured Computer Organization by Andrew Tannenbaum (creator of Minix) is really good for learning some more complex computer organization topics such as pipelining, and it goes into detail about how the JVM works.

Once I had a solid base understanding of x86 programming, I started getting into Malware Analysis & Reverse engineering. This is a hot topic right now and there are a ton of resources out there from beginning to advanced.

There are two books I recommend to everyone who is frustrated and/or saddened by the state of the world and has lost hope for a better future.

The first is The Better Angels of Our Nature by Stephen Pinker. It lays out how violence in human societies has been decreasing for centuries and is still declining.

Despite the prevalence of war and crime in our media, human beings are less likely to suffer violence today than at any point in our prior history. The west suffered an upswing in social violence from the 1970s -1990s, which has since been linked to lead levels, but violence in the west has been declining since the early 90s.

Put simply the world is a better place than most media coverage would have you believe and it's getting better year by year.

The second book I recomend is The Singularity is Near by Ray Kurzweil. It explains how technology has been improving at an accelerating rate.

Technological advances have already had major positive impacts on society, and those effects will become increasingly powerful over the next few decades. Artificial intelligence is already revolutionizing our economy. The average human life span is increasing every year. Advances in medicine are offering hope for previously untreatable diseases.

Basically, there is a lot of good tech coming which will significantly improve our quality of life, if we can just hang on long enough.

Between those two forces, decreasing violence and rapidly advancing technology, the future looks pretty bright for humanity. We just don't hear that message often, because doom-saying gets better ratings.

I don't know what disability you're struggling with but most people have some marketable skills, i.e. they aren't "worthless". Based on your post, you clearly have good writing/communicating skills. That's a rare and valuable trait. You could look into a career leveraging those skills (e.g. as a technical writer or transcriptionist) which your disability wouldn't interfere with to badly (or which an employer would be willing to accommodate).

As for being powerless to change the world, many people feel that way because most of us are fairly powerless on an individual level. We are all in the grip of powerful forces (social, political, historical, environmental, etc.) which exert far more influence over our lives than our own desires and dreams.

The books I recommended post convincing arguments that those forces have us on a positive trend line, so a little optimism is not unreasonable. We may just be dust on the wind, but the wind is blowing in the right direction. That means the best move may simply be to relax and enjoy the ride as best we can.

Not sure what your budget is (buy used books or South Asia editions), but you may find the following useful :-)

Also, unless required, avoid programming in assembly but use C/C++ exclusively. This allows you to carry over much of your acquired knowledge across various MCU families.

• Make: AVR Programming This will teach you programming directly-to-the-metal on AVR using C. If you have the Arduino IDE installed, you already have the "avr-gcc" compiler toolchain as part of the package and hence you just need to setup your path and use the the toolchain in your Makefile. The book takes you by hand and shows you everything. Note that you can use the same Arduino board to do both "Arduino language" programming and "AVR C" programming.
  
  
• Designing Embedded Hardware Excellent overview of the hardware aspects of Embedded Systems. As a Software guy, this book is the one which clarified hardware for me.
  
  
• Building Embedded Systems: Programmable Hardware A very good book on all practical aspects of embedded programming. Hard-won knowledge which will make you a "professional" embedded engineer.
  
  
• Introduction to Embedded Systems: Using Microcontrollers and the MSP430 Excellent and comprehensive textbook detailing the hardware and software aspects of embedded systems. Every topic starts with an illustrated overview of the hardware and then shows you how to program for it.
  
  
• Embedded C Introductory book on C programming for 8051. The example code is simple and direct thus enabling you to grasp the concepts clearly.
  
  
• Patterns for Time-Triggered Embedded Systems Comprehensive and full of C code showing how to program all standard peripherals for an 8051. You can translate the code to your favourite MCU family. The book is available for free from the author's company website.
  
  
• ARM System Developer's Guide An oldie but still the best for firmware programming on the ARM microprocessor.
  
  
• Practical Microcontroller Engineering with ARM technology An exhaustive book on programming the Tiva version of the ARM Cortex-M4 MCU. The book reads like a manual but the ARM Cortex is complex enough that there is no easy way to learn it.
  
  
• The Engineering of Reliable Embedded Systems Advanced book showing how to implement industrial quality embedded software on various ARM platforms. The 1st edition of the book was available for free on the web.
  
  and finally;
  
  
• Computer Systems: A Programmer's Perspective A must-read textbook to understand the low-level details for a x86/x86-64 system. Many of these details are similar for MCUs and hence you will understand them better.

If you already have an engineering degree then you already know how to study. What experience do you have with embedded? If you don't have any then you should be sure it's what you want before you commit to anything huge.

I think the best way to get a job in embedded systems is to build embedded systems, and not bother with language certifcations. I might be going against the grain here a bit but I would suggest starting to dip your toes into embedded systems by buying an arduino and messing around with it.

Arduino gets a lot of flack for being "not real" embedded systems, and while it's true nobody is going to hire you because you can make an impressive arduino project, IMHO it's a great introduction to what embedded is about. The hardware equivalent of "hello world" is blinking an LED. If you are serious about learning then you will quickly outgrow the arduino, but you can always throw away the bootloader and try to program the ATmega with bare metal gcc and avrdude.

I don't know what you already know nor how you feel about math, but things you will want to learn include:

• Analog electrical theory, DC and AC, resistance/capacitance/inductance. Understand basic circuit networks and input vs output impedance. Hopefully you remember complex numbers and frequency response. You don't need a lot of circuit theory but you will need to understand what a pull-up resistor is and why it's necessary. Depending on your math background you can get into filters, frequency response, fourier analysis. A good introduction here might be www.allaboutcircuits.com
  
  
• Digital theory, starting with boolean algebra, logic gates, adders/multiplexers/flip-flops, all the way up to computer architecture. I like this book because it has a very holistic approach to this area https://www.amazon.com/Digital-Design-Computer-Architecture-Second/dp/0123944244/ref=sr_1_1?ie=UTF8&qid=1494262358&sr=8-1&keywords=harris+digital+design
  
  
• Linux, C. Linux and C. You need to understand pointers, and the best way to understand C is to understand computer architecture. If you're not already running Linux, install linux, as well as gcc and build-essential. Start learning how to manipulate memory with C. Learning about computer architecture will help here. My favourite book on C is one of the classics: https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=sr_1_1?ie=UTF8&qid=1494262721&sr=8-1&keywords=the+c+programming+language
  
  If you get this far and still want to become an embedded systems engineer then you're doing pretty well. I would say just try to build projects that utilize these skills. Maybe you can use your mech background to build a robot and then design the software to support it. Get used to reading datasheets for parts, and imagining what the digital logic inside looks like. Get used to searching google for answers to your questions.

Bishop's book Pattern Recognition and Machine Learning is pretty great IMHO, and is considered to be the Bible in ML - although, apparently, it is in competition with Murphy's book Machine Learning: A Probabilistic Approach. Murphy's book is also supposed to be a gentler intro. With an ECE background the math shouldn't be too difficult to get into in either of these books. Depending on your background (i.e. if you've done a bunch of information theory) you might also like MacKay's book Information Theory, Inference and Learning Algorithms. MacKay's book has a free digital version and MacKay's 16 part lecture series based on the books is also available online.

While those books are great, I wouldn't actually recommend just reading through them, but rather using them as references when trying to understand something in particular. I think you're better off watching some lectures to get your toes wet before jumping in the deep end with the books. MacKay's lectures (liked with the book) are great. As are Andrew Ng's that @CatZach mentioned. As @CatZach mentioned Deep Learning has had a big impact on CV so if you find that you need to go that route then you might also want to do Ng's DL course, though unlike the courses this one isn't free :(.

Finally, all of the above recommendations (with the exception of Ng's ML course) are pretty theory driven, so if you are more of a practical person, you might like Fast.AI's free deep learning courses which have very little theory but still manage to give a pretty good intuition for why and how things work! You probably don't need to bother with part 2 since it is more advanced stuff (and will be updated soon anyways so I would try wait for that if you do want to do it :))

Good luck! I am also happy to help with more specific questions!

Ok then, I'm going to assume that you're comfortable with linear algebra, basic probability/statistics and have some experience with optimization.

• Check out Hastie, Tibshirani, & Friedman - Elements of Statistical Learning (ESLII): it's basically the data science bible, and it's free to read online or download.
  
• Andrew Gelman - Data Analysis Using Regression and Multilevel/Hierarchical Models has a narrower scope on GLMs and hierarchical models, but it does an amazing treatment and discusses model interpretation really well and also includes R and stan code examples (this book ain't free).
  
• Max Kuhn - Applied Predictive Modeling is also supposed to be really good and should strike a middle ground between those two books: it will discuss a lot of different modeling techniques and also show you how to apply them in R (this book is essentially a companion book for the caret package in R, but is also supposed to be a great textbook for modeling in general).
  
  I'd start with one of those three books. If you're feeling really ambitious, pick up a copy of either:
  
  
• Christopher Bishop - Pattern Recognition and Machine Learning - Bayes all the things.
  
• Kevin Murphy - Machine Learning: A Probabilistic Perspective - Also fairly bayesian perspective, but that's the direction the industry is moving lately. This book has (basically) EVERYTHING.
  
  Or get both of those books. They're both amazing, but they're not particularly easy reads.
  
  If these book recommendations are a bit intense for you:
  
  
• Pang Ning Tan - Introduction to Data Mining - This book is, as it's title suggests, a great and accessible introduction to data mining. The focus in this book is much less on constructing statistical models than it is on various classification and clustering techniques. Still a good book to get your feet wet. Not free
  
• James, Witten, Hastie & Tibshirani - Introduction to Statistical Learning - This book is supposed to be the more accessible version (i.e. less theoretical) version of ESLII. Comes with R code examples, also free.
  Additionally:
  
  
• If you don't already know SQL, learn it.
  
• If you don't already know python, R or SAS, learn one of those (I'd start with R or python). If you're proficient in some other programming language like java or C or fortran you'll probably be fine, but you'd find R/python in particular to be very useful.

C is worth learning in my opinion. I'm a CS student so certainly not an authority on languages, but everything that's really cool I want to work on, and the problems that really interest me, tend to be in C. If you ever wanted to study operating systems then C is vital. You can go download the entire linux kernel and read it's internals, study how it works and try to wrap your head around why certain things were done in certain ways.

If you want to study algorithms and data structures, c is wonderful. Have you ever wondered how queues are actually structured in memory while you were using Java? Or lists, or strings, or objects in general?

Memory management, how the stack works when a function gets called, how the memory alignment of certain structures can decrease cache misses... There's so many cool topics that you can really dig into with C that you don't have the freedom to really mess with in higher level languages. The downside being you have plenty of rope to hang yourself with, but man the problems you run into can be so much fun.

Embedded systems are cool. Being able to take an Atmel or TI microcontroller and cobble together beautiful useful systems. This is what really invigorated me with regards to C when I was starting out. Snag yourself a cheap ATtiny AVR, a couple data sheets, a programmer and some tutorials and dive in.

As far as an IDE, I really wouldn't recommend one. Just use a text editor of some sort. For instance I do a lot of my coding right now in Sublime Text. All I really use it for is the highlighting. Everything else is done in the terminal. gcc is free and works fairly well, and in regards to referencing I generally just use the man pages or google when I want to get a quick idea on how to use something.

From what I've seen, and what I've heard from friends who are already working, if you can write good clean C it will help you in any other language you pick up. The language doesn't hold your hand.

K&R is one of those books you certainly want to have, but it isn't really what I'd start out with at first. I'm a little embarrased to admit it but I started with "Absolute Beginners Guide to C" by Perry. I didn't have any type of programming background though so you might be more inclined to something like "Programming in C" by Kochan.

No worries, glad to help. I bet you must be overwhelmed. It's hard to me to give you a clear path because I was "lucky" enough to start programming from an early age, an indirect influence from my father - the first programming language I learned was dBase when I was 12 years old and since then I never stopped (while my father still programs in Clipper to this day). Then I learned Clipper, Perl, PHP, JS, Python, C, Go. One side effect of my self-taught days is that I also skipped the CS fundamentals which I came to learn only much later - which in a way helped me appreciate their importance.

There's no way around it, if you want to be a great developer, not just someone looking for a quick easy buck, you'll need to learn the fundamentals. One book I greatly recommend is Computer Systems: A Programmer's Perspective - there's a cheaper "international version" of lesser quality (black and white and cheaper paper). It is such a great book that I recommend buying the hardcover version because you will be referencing it forever. (as a side note, I bought the hardcover 2nd edition a long time ago and cheapend out with the "international version" for the 3rd version and I would go back and invest on the hardcover version if I could).

Anyways, that's a great book that you give you a good grasp of some fundamentals - it will go from the basics of logic to how processors work (even creating your own 64-bit CPU) and then to assembly and C and the Operating System. Knowing how the CPU actually works and execute code will help you learn lower level languages (C, C++, Go, etc) and how to be good at it (by knowing what is happening behind the scenes). It will take you a while to digest this book.

You'll leave this book knowing how to program in assembly and C. With that you could already get a job working with embedded programming or working with C, or invest another year to learn C++ - the second most used language out there (only behind Java). Alternatively, instead of C++, you can focus on Java - although the marketplace competition will be greater with Java because every school teaches it so the market is saturated.

In the short term, if your focus is to hit the ground running and get hired as a programmer (and then buy time to learn the stuff I mentioned before), Java is probably the quickest/surest way. It is easy enough that it is the language of choice on Computer Science courses and there are a lot of jobs out there looking for Java (most popular language). The learning curve to master it will be steep because it has a pretty rich and complex ecosystem, but it would be your best bet in the short run. Just go to "Indeed" and do a search for "title:python" versus "title:java" where you live and you'll see.

If you dedicate 2h-3h religiously everyday, and you feel that you have a knack for programming (in other words, it interests you even if you're not good at it, or at the very least you don't hate it), I think you could learn Java well in a year, enough to get an entry-level job. What you'll have to keep in mind though is that you're gonna be studying 2h-3h everyday for the next 10 years if you want to be a good engineer - there's no way around it, but if you really like it, it won't feel like work, it will be fun. Even today, after been programming for almost 20 years, I still study 2h-3h everyday, recap stuff I have long forgotten, keep up with newer stuff, etc. So you'll never really stop studying, because in this field, if you stop, you deprecate quickly.

So yeah, by all means, learn HTML, CSS, JavaScript and Python, they're basic staples nowadays and every job expects you to know them (and JS and/or Python). Then look into Java if your short-term focus (and by short-term I mean, a year, a year and a half) is on getting an entry-level paid job. Keep in mind too that you'll never just learn Java - you'll have to learn about databases (at least MySQL or PostgreSQL and maybe something like MongoDB), you'll certainly be expected to know HTML/CSS/JS if you're gonna be involved with a web company (even if doing backend work and not frontend), etc... but you can learn these "extras" as you go by marginally including them in your projects.

I would guess that career prospects are a little worse than CS for undergrad degrees, but since my main concern is where a phd in math will take me, you should get a second opinion on that.

Something to keep in mind is that "higher" math (the kind most students start to see around junior level) is in many ways very different from the stuff before. I hated calculus and doing calculations in general, and was pursuing a math minor because I thought it might help with job prospects, but when I got to the more abstract stuff, I loved it. It's easily possible that you'll enjoy both, I'm just pointing out that enjoying one doesn't necessarily imply enjoying the other. It's also worth noting that making the transition is not easy for most of us, and that if you struggle a lot when you first have to focus a lot of time on proving things, it shouldn't be taken as a signal to give up if you enjoy the material.

This wouldn't be necessary, but if you like, here are some books on abstract math topics that are aimed towards beginners you could look into to get a basic idea of what more abstract math is like:

• theoretical computer science (essentially a math text)
  
  
• set theory
  
  
• linear algebra
  
  
• algebra
  
  
• predicate calculus
  
  Different mathematicians gravitate towards different subjects, so it's not easy to predict which you would enjoy more. I'm recommending these five because they were personally helpful to me a few years ago and I've read them in full, not because I don't think anyone can suggest better. And of course, you could just jump right into coursework like how most of us start. Best of luck!
  
  (edit: can't count and thought five was four)

Three esxi servers, each with more than one NIC, and one separate vcenter server is a great starting point. This allows you to tune DRS, HA, and even fault tolerance. Once you get that down, you'll want to be able to tune VMs properly to run most effectively in a virtual environment.

I enjoyed reading these books, though some are "dated" now, the contents are still very relevant. They won't get you anywhere in particular by themselves, but when you combine them with the self-teaching nature of sysadmins I've previously described, these will generously add to your toolset.

HA and DRS deepdive
Sed & Awk

Mastering Regular Expressions. I use rubular.com often.

Pro Puppet

Anything by Bruce Schneier is usually worth your time.

Though I no longer administer a large number of Windows machines, I am a huge fan of Mark Minasi. The Server 2003 book was super helpful in building and maintaining Windows Domains.

I have an old edition of the DNS and Bind book kicking around somewhere.

Understanding the Linux Kernel has largely been useful to me when doing anything "close to the kernel". Not a good beginner's book.

I've never used an apache book, but I enjoyed the Varnish book. This definitely helped me.

Of course, these books don't cover everything, and those listed are relevant to my interests so your mileage may vary. You'll never go wrong teaching yourself new skills though!

EDIT: I forgot about the latest book I've read. I used tmux for a little over a year before purchasing a book on it, and it has improved my use of the program.

As other mentionned, your question is pretty hard to answer on a post, even if it is pretty interesting. But having done a bit of research in discrete math & algorithm design and being a math lover myself, I'll try to talk about why I find my area interesting.

Being a software developper, you should pretty much know what an algorithm is. Given a problem, an algorithm is a recipe/step-by-step set of instructions that, if followed exactly, solves your problem. Algorithms can be classified in a lot of categories: deterministic algorithms (given some input, you always get the same right answer), probabilistic algorithms (you get the right answer 'on average'), approximation algorithms (you get an answer that is within some (provable) factor of the optimal answer) and so on. The main measure (there are multiple others) for the performance of an algorithm is the time it takes to find an answer with respect to the size of the input you are giving it. For example, if your problem is to search through an unordered list of n items for a given item, then the trivial solution (look at every item) takes time n. This is what we call linear in n, but algorithms can run logarithmic in n (takes time log(n) ) (very fast), exponential in n (c^n for some c) (very slow) or polynomial in n (n^k for some k) (efficient).

So the fun part is to find THE best algorithm for your problem. For a particular problem, one may ask how fast can the best algorithm run. Well surprisingly, it turns out that some problems will never admit an efficient EXACT solution. I'll give an example of such problem, and then come to the main point of my discussion.

Consider a graph/network (we love these things in discrete math), which is basically a set of points/nodes/vertices that are connected by links/edges, and its size is usually the number of nodes (the maximum number of edges of a (simple) graph is n^2 - the maximum number of pairs you can make with n elements). The Internet is the best example : nodes are webpages and edges are hyperlinks between theses pages. We say that two nodes are neighbors if they are connected by an edge. A fundamental problem of discrete mathematics goes as follows: what is the minimum number k such that you can color the nodes of a graph with k colors such that not two neighboring nodes share the same color? (http://en.wikipedia.org/wiki/Graph_coloring). It turns out that this problem can be proven to be inherently hard - if we can find an efficient deterministic algorithm (we strongly believe we can't) to solve this problem, than there is an efficient (=fast) algorithm to solve many "hard" problems (ex.: proving a theorem, or solving a sudoku ! - probably not going to happen). Such hard problems are said to be NP-complete. It also turn out that most real life (interesting) problems are also that kind of hard (http://en.wikipedia.org/wiki/List_of_NP-complete_problems).

This sounds quite desperate. However, here is where the research starts. It is said that these NP-complete problems cannot have efficient DETERMINISTIC and EXACT algorithms. Nothing prevents us from producing randomized and approximate solutions. So with some clever analysis, input from other areas (read algebra, geometry, probability, ...) and other tricks, some algorithms are built to find solutions that are usually within a good factor of the optimal. Hell, some NP-complete problems (i.e. Knapsack Problem) even admit an arbitrarly precise efficient algorithm. How is this possible? Reading required!

I don't know of non-scholar books that covered this subject, but if you are motivated, here are the books I suggest:

• http://www.amazon.com/Introduction-Algorithms-Second-Thomas-Cormen/dp/0262032937
  
• http://www.amazon.com/Algorithm-Design-Jon-Kleinberg/dp/0321295358/ref=sr_1_1?ie=UTF8&s=books&qid=1277946555&sr=1-1
  
• http://www.amazon.com/Approximation-Algorithms-Vijay-V-Vazirani/dp/3642084699/ref=sr_1_1?ie=UTF8&s=books&qid=1277946570&sr=1-1
  
  I guess there wasn't at lot of fireworks, but the goal was really to show an area of math that is not often brought up in 'mainstream math discussions'. So feel free to ask questions, I'll try to answer them as far as my knowledge goes.
  
  P.S. I guess I've have put down the foundations for the discrete math/ algorithm design fortress, so every knowledgeable person should add his/her own comment!

Reading some books would be a good idea.

• Superintelligence: Paths, Dangers, Strategies by Nick Bostrom is a good introduction to some philosophy and general tech behind AI. It's really a lovely read.
  
  The following are textbooks:
  
  General AI
  
  
• Artificial Intelligence: A Modern Approach by Russell and Norvig is a conical book on AI. It has an AMAZING companion site ran by UC Berkeley
  
  
• Artifical Intelligence for Humans by Heaton has some overlap with Artificial Intelligence: A Modern Approach, but is also a good overview
  
  Machine Learning
  
  
• Deep Learning by Goodfellow, Bengio, and Courville is a great book on deep learning
  
  
• Introduction to the Math of Neural Networks by Heaton is a great book on the math behind neural networks
  
  
• Make Your Own Neural Network by Rashid is a good guide to making your own neural network
  
  
• Reinforcement Learning: An Introduction by Sutton and Barto
  
  Statistics for Machine Learning
  
  
• Machine Learning: A Probabilistic Perspective by Murphy
  
  
• The Elements of Statistical Learning by Hastie, Tibshirani, and Friedman
  
  There are many other topics within AI which none of these books focus on, such as Natural Language Processing, Computer Vision, AI Alignment/Control/Ethics, and Philosophy of AI. libgen.io may be of great help to you.

Oi. Disclaimer: I haven't bought a book in the field in a while, so there might be some new greats that I'm not familiar with. Also, I'm old and have no memory, so I may very well have forgotten some greats. But here is what I can recommend.

I got my start with Koblitz's Course in Number Theory and Cryptography and Schneier's Applied Cryptography. Schneier's is a bit basic, outdated, and erroneous in spots, and the guy is annoying as fuck, but it's still a pretty darned good intro to the field.

If you're strong at math (and computation and complexity theory) then Oded Goldreich's Foundations of Cryptography Volume 1 and Volume 2 are outstanding. If you're not so strong in those areas, you may want to come up to speed with the help of Sipser and Moret first.

Also, if you need to shore up your number theory and algebra, Victor Shoup is the man.

At this point, you ought to have a pretty good base for building on by reading research papers.

One other note, two books that I've not looked at but are written by people I really respect Introduction to Modern Cryptography by Katz and Lindell and Computational Complexity: A Modern Approach by Arora and Barak.

Hope that helps.

The most fundamental math understanding for computer graphics is linear algebra. You'll want to learn about Vectors and matrices, trigonometry and geometry. I want to answer your questions to the best of my ability, but I would rather direct you to some really great resources which can probably do a better job, because this is exactly what they are for. I think if you follow through these in order, you'll be well on your way.

Great book for the math you're looking for. You might be able to find this as a pdf online somewhere. Vector math and trigonometry are used everywhere in graphics programming. Absolutely everywhere. In my opinion this is the most important subject to understand.
https://www.amazon.com/Primer-Graphics-Development-Wordware-Library/dp/1556229119

This site teaches the fundamentals of graphics programming from the ground up, with samples. I haven't been on it in a while but from the looks of it it's even better than the last time I used it.
https://www.scratchapixel.com

Once you feel comfortable with the basics, try experimenting with opengl. This is where you'll really start doing gpu programming, and probably write your first shaders.
http://www.opengl-tutorial.org

Good luck

I did this and just got offered a position as a "Software Engineer"

I'd recommend starting in Java or C# even though a lot of places are starting people on JavaScript. From what I've seen, JavaScript is being taught in a way that you will never conventially use it for, and it has a LOT of quirks (== type conversions etc.). Though the internet has all the resources you need to teach yourself, I would really really recommend using books as your main source of education, as they provide thorough and (the most important part) LINEAR explanations to whatever you want to learn. Tutorials are great, but a lot will be left out, and the amount of hand holding involved will give you no confidence as a programmer. To be effective, you need to be able to sit down at your computer and build a program without having something giving you tips every step of the way.

Start with this book to teach you the basics of Object Oriented programming:
http://www.amazon.com/Introduction-Java-Programming-Comprehensive-Edition/dp/0132130807/ref=sr_1_3?ie=UTF8&qid=1345145435&sr=8-3&keywords=y+daniel+liang

You should read this next. It is a very thorough and easy to understand explanation of data structures and algorithms:
http://www.amazon.com/Data-Structures-Algorithms-Java-2nd/dp/0672324539/ref=sr_1_2?s=books&ie=UTF8&qid=1345145623&sr=1-2&keywords=data+structures+and+algorithms+in+java

I personally read a textbook chapter a day on a book covering whatever it is I want to learn at the time. To prepare for my current job, I've read an 800 page book on ASP.NET in two weeks by just reading and following examples one chapter a day. You can do the same thing. Start at chapter one and just run straight through, one day at a time. Make sure you do a few of the programming exercises at the end of each chapter as well. Really visualize it as, "With each chapter I finish, I am becoming a better programmer." If you look at it with this mindset, it really starts to become fun.

You CAN find whatever you need on the internet, but there is so much information out there that it makes it hard to know which direction to go in. To most people this is paralyzing. You need concrete short and long term goals to maximize your education, and setting a goal of x amount of pages, or x amount of chapters a day/week is a very tangible and satisfying goal. Once you complete these two books, you'll be at a level where you can start specializing into whatever area you want.

Sure I really enjoy these podcasts.

• .NET Rocks. Even if you don't do .NET they talk about high level concepts and talk to a lot of smart people on various things. on a recent podcast, they mentioned KataCoda which is an amazing site for learning docker. I had never heard of it.
  
  
• Hanselminutes. Great technology podcast.
  
  
• JavaScript Jabber
  
  
• Ruby Rogues
  
  As for books , here are some tech books I have read and enjoyed:
  
  
• Clean Code Amazing book on how to write good, maintainable code. It's language agnostic.
  
  
• The Clean Coder Same author as ^ but instead of code, focuses on being a professional developer and the skills needed to succeed in the industry.
  
  
• [Site Reliability Engineering: How Google Runs Production Systems] (https://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X) I'm reading this book now and it's a great look into how you maintain high scale web applications.
  
  
• Notes to a Software Team Leader: Growing Self Organizing Teams . Even if you're still learning, it's a good book to see what a good lead is like and hopefully one day you can grow into that role.
  
  
• Head First Design Patterns
  
  
• Code: The Hidden Language of Computer Hardware and Software
  
  There's obviously a ton of other books, but those immediately come to mind.

I found myself in a similar circumstance years ago.

I would recommend learning C first. Programming in C is a very friendly intro.

After that I'd recommend Advanced C and Data Structures in C.

These 3 books will teach you the basics of programming, recursion, sorting, stacks, queues, graphs, hashing, etc...

After you can do that in C, everything else will be much easier.

I know a lot of people recommend Java or other OOP languages but in my opinion it's best to start out in C and then transition to an OOP language.

I recommend installing ubuntu and using vi as a text editor. Compile using gcc.

If you decide to go with another language The New Boston has lots of video tutorials in various languages. Personally I don't care too much for his tutorials, although I know some people do like them, but one thing that is helpful is that the first few videos in any particular language series shows you how to install a compiler or IDE and get it up and running. If you're not too computer savvy these can be helpful.

If you go the python route I recommend these free sources:

Learn Python the Hardway

Think Python (this book is used with MIT's intro to CS course)

MIT's intro CS course

Think Stats (use python to do statistics)

Tons of other sources:

http://freevideolectures.com/

http://academicearth.org/

(note: at academic earth you can find programming courses from Stanford University. Their intro course is in Java. So if you want to learn Java that could be a good way to go.)

Hey, I just started a class about this subject! Let me share what's in the first chapter of my book.

One of the main principles behind the architecture of a computer is called abstraction, which means more or less that each layer is separated from the next. When someone drives a car, they know what the dashboard lights mean and what the pedals do, but they might not necessarily know how the internal combustion engine works -- and, as long as it's working they don't need to. This lets different people work on different "layers" of the computer in different ways.

Think of a computer program as solving a problem. You need to do math? There's a calculator to solve that problem. You need to read an email? There's an email client to solve that program. So, at the top layer, you have something you want to accomplish, and you need to tell the computer how to do it.

The next layer is one of algorithms -- giving the computer step-by-step instructions to accomplish the task. We design ways for computers to sort lots of data quickly, or to ask another computer for specific data.

To implement those algorithms, you need to use a programming language. Sometimes they're called mechanical languages because where a natural language like English or Spanish can be ambiguous, mechanical languages are never ambiguous -- they always mean exactly what they say. Some examples of a programming language are C++, Java, Fortran, COBOL, or Pascal. Here, you can teach the computer, for example, IF a button is clicked, THEN a window should open.

But, how does a computer understand a programming language? Programming languages are often translated by a compiler, which turns the language into instructions that are understood by the computer's ISA, or "instruction set architecture." The most common ISA is the x86, from Intel. PowerPC is another ISA, that Mac computers used to use. The ISA contains the instructions, data types, and addressing modes that a computer can understand.

The ISA is implemented in the next layer by a detailed organization called a microarchitecture. If an ISA is a type of chip, a microarchitecture is a specific chip, like a Pentium IV or a PowerPC 750FX. It communicates directly with the chip hardware.

The next layer is the logic circuit - I think (but I'm not 100% sure) that this has to do with the path operations take on the chip itself. Different operations will be performed in different ways, depending on the speed or power requirements of the operation.

The last layer is the device itself - my book gives examples of CMOS circuits, NMOS circuits, and gallium arsenide circuits, but it doesn't go into more detail than that. This is the physical layer, where transistors and diodes live.

I hope this helps give you a little more perspective! I'm still learning about this stuff too, and I think it's pretty neat.

I had an internship with Amazon during my Sophomore to Junior summer. I also received offers from Microsoft and Google to intern this upcoming summer (Junior to Senior), but instead took an offer from Fog Creek Software. I have friends that have interned or are full time at Microsoft, Google, and Amazon, all from Rutgers University.

My advice is to anyone looking to get one of these positions is:

1. Start early, companies have only so many positions, and once they are taken, they stop looking. Generally this means you need to apply by November.
   
   
2. Data Structures and Algorithms, know them inside and out, know their complexity, know how to implement them, know their tradeoffs, and know when to use them. A great book for someone who has never done any data structure stuff is Data Structures and Algorithms in Java. I took CS111 and read this book and was able to get through the Amazon interview.
   
   
3. Read and do the exercises in Cracking the Coding Interview. Also use the author's resume template for making your resume.
   
   
4. Interview every chance you get. Seriously, I interviewed at about 15 places before I interviewed with Amazon, by the time that I got to the Amazon interview, I was fairly comfortable with the process. I was still nervous about the interview, but I knew generally what to expect and didn't get hung up on their curveball questions.
   
   
5. Pick a single club, whether it be IEEE, USACS, RUMad, etc. and be deeply involved with it. You can be a member of more than one, but you should be really involved with one.
   
   
6. Pick a language and know it. You aren't going to lose points because you don't know Python, or Ruby, or whatever else is the hot language this month. Java, C, C++, you should know one of these languages, and preferably two, C and then either Java or C++.
   
   
7. And finally, the only way to really know a programming language is to use it, so program, program, program, and then program some more. While you're doing all this programming, you should take a few minutes out of your day to learn about source control (git or git, there are no other options :) ). Then put the cool stuff you make on github or some other source control website.
   
   This may seem like a lot because well frankly it is. But if you actually enjoy programming and computer science, than this is pretty straight forward and easy. And finally, don't get discouraged. Just because you didn't make it into one of these companies the first time you apply, doesn't mean you'll never make it. Some people don't interview well(it is its own skill, hence #4), some people just can't build out a good resume(seriously use the template that I provided and read cracking the coding interview from front to back), and other people just aren't ready(you really need to program a lot). But that doesn't mean that you will never make it with them, just give it another year, identify your weakness, and work on it.

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

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


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

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

http://craftinginterpreters.com

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

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

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


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

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

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

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

>There have been some excellent trading opportunities with returns as high as 30% to your overall portfolio! Crypto is providing big returns that are uncommon in traditional markets.

I guess you have a good intention, Mr. Hustle, but I'd hate to see the kind shibes here being taken advantage of again. You should be more objective and also warn people that they can as easily lose that much of money when trading, especially when they don't know what they are doing initially.

And the effectiveness of technical 'analysis' is a highly debatable issue. I'd just leave this quote from Wikipedia:

> Technical analysis is widely used among traders and financial professionals and is very often used by active day traders, market makers and pit traders. In the 1960s and 1970s it was widely dismissed by academics. In a recent review, Irwin and Park[13] reported that 56 of 95 modern studies found that it produces positive results but noted that many of the positive results were rendered dubious by issues such as data snooping, so that the evidence in support of technical analysis was inconclusive; it is still considered by many academics to be pseudoscience.[14] Academics such as Eugene Fama say the evidence for technical analysis is sparse and is inconsistent with the weak form of the efficient-market hypothesis.[15][16] Users hold that even if technical analysis cannot predict the future, it helps to identify trading opportunities.[17]

...

> Whether technical analysis actually works is a matter of controversy. Methods vary greatly, and different technical analysts can sometimes make contradictory predictions from the same data. Many investors claim that they experience positive returns, but academic appraisals often find that it has little predictive power.[51] Of 95 modern studies, 56 concluded that technical analysis had positive results, although data-snooping bias and other problems make the analysis difficult.[13] Nonlinear prediction using neural networks occasionally produces statistically significant prediction results.[52] A Federal Reserve working paper[21] regarding support and resistance levels in short-term foreign exchange rates "offers strong evidence that the levels help to predict intraday trend interruptions," although the "predictive power" of those levels was "found to vary across the exchange rates and firms examined".

I'm not saying not to take coaching from DogeHustle, just that if people want to do it, be aware of its 'limitation' too and have fun doing it with your disposable money only. As an alternative, I strongly suggest shibes who want to try predicting the future based on pattern analysis to do it in a principled manner and learn math, stats and machine learning. It won't be easy, but it will have a wide application beyond trading (so-called data 'science' is the hot job nowadays). It will also teach you the limitation of such methods, and when it might fail, especially in such a manipulated market like crypto. This is a good book to start with:

http://www.amazon.co.uk/Machine-Learning-Probabilistic-Perspective-Computation/dp/0262018020

Might be biased, but I'm a big fan of Jeff Erickson's Algorithm Notes, which I think are better than a lot of textbooks.

If you really want a book, CLR Algorithms and The Art of Computer Programming both get recommended a lot, with good reason.

If you're interested in computational theory, the New Turing Omnibus and Spiser's Theory of Computation are two good choices.

Finally, I'd check out Hacker's Delight. It's a lot more on the electrical/computer engineering side of things, which might interest you, and it's very detailed while still being quite excellent.

I was in your shoes not long ago, though a much diff background and job situation.

> I guess maybe my question boils down to do I need to at some point go to grad school?

Yes but don't worry about grad school right now. It's expensive and you'll do better with it once you've been working in the real world. Try and get work to pay for it too.

>I'm not against it, but would rather learn on my own and make it that way, is that feasible?

Yes you can start using ML techniques at work without formal training. Don't let it stop you. Get a good book - I use Kevin Murphy's and also have a copy of EoSL on my desk from the work library (its free online pdf though).

ML is a somewhat broad and growing field. So if you have the mindset that you need to cover it all before you start using it you'll be sticking thumbs up your ass for a few years.

A better approach will be what is your specific data. Just like you're probably familiar with from using SQL, standard textbook techniques or something in a research paper rarely applies exactly to you what you're working with. So it's almost better to approach your problem directly. Explore the data, look at the data, study the data (in a stats fashion) and then look into what could an intelligent program do to better analyze it. And then in the meantime you can study more general ML topics after work.

If you're taking a Computer Science class anywhere, this is an amazing resource for you.

OpenLearning also has a free course, similar, but very different at the same time. A link here if you wish to check it out. The lecturer is hilarious, intelligent, and excited 99% of the time. He is super easy to watch.

Lastly, get a hold of C Programming by Kochan. It's a recommended reading by the CS50 course. Here is it if you are so inclined.

wow, yeah, 10 years is closer than 50 that's for sure. If you are right, that is something to be very excited about for sure. Just think of the possibilities. Can I ask where you get the estimate of 10 years? I am fairly uneducated on the subject, and admittedly I haven't even read the book about it therefore I am hesitant to even mention it, but I am familiar with Ray Kurzweil and his theories about The Singularity (basically when man and machine combine, hence "redefining" what it means to be human). I found his recent comments on nano-bots in our brains making us "God-like" intriguing to say the least, and if ever we will be able lay back, close our eyes, and experience some sort of virtual reality, it just makes sense to me that the most likely time when that will happen is when we have super intelligent nano-bots inside of our brains manipulating the way they work. I, personally, can't wait for this to happen, but I also know that I will be very apprehensive when it will come down to willfully injecting into my body millions and millions of nano-bots that have been specially designed to 'hijack' my brain, and make it work better. I think I will probably wait 10 years or so after people start doing it, maybe longer.

Here is Ray Kurzweil's book I was referring to that I really want to read: The Singularity Is Near: When Humans Transcend Biology

EDIT: I forgot to mention why I really brought up the singularity-- Mr. Kurzweil initially predicted that the singularity would occur sometime before 2030 (aka in the 2020's), but I believe he has now modified that to say that it will occur in the 2030's. Either way, that is not far away, and, being a pretty tech-savvy person myself (I pay attention to a thing or two) I think the 2030's is a reasonable estimate for something like this, but, as I mentioned earlier, I think it is the ethics of such a thing that will slow down true VR development (see: how the world responded to cloning)

double EDIT: just another thought (albeit quite a tangent)-- once a true singularity has been achieved (if ever?), 'transplanting' our consciousnesses into another body all of a sudden becomes quite a bit less sci-fi and altogether a more realistic possibility...

Basically any SRE advice for a normal service but replace/compliment HAproxy / nginx / ingress controller / ELB with the Tor daemon / OnionBalance.

I run Ablative Hosting and we have a few people who value uptime over anonymity etc and so we follow the usual processes for keeping stuff online.

Have multiples of everything (especially stuff that doesn't keep state), ensure you have monitoring of everything from connections, memory pressure, open files, free RAM etc etc.

Just think of the Tor daemon onion service as just a TCP reverse proxy, with load-balancing capability and then follow any other advice when it comes to building reliable infrastructure;

• https://www.amazon.co.uk/Site-Reliability-Engineering-Production-Systems/dp/149192912X/
  
• https://www.amazon.co.uk/Infrastructure-Code-Managing-Servers-Cloud/dp/1491924357/
  
• https://www.amazon.co.uk/Architecting-Scale-Lee-Atchinson/dp/1491943394/
  
• https://www.amazon.co.uk/Building-Microservices-Sam-Newman/dp/1491950358/
  
• https://www.amazon.co.uk/Practical-Monitoring-Mike-Julian/dp/1491957352/
  
• https://www.amazon.co.uk/Cloud-Native-Infrastructure-Justin-Garrison/dp/1491984309/
  
• https://www.amazon.co.uk/Designing-Distributed-Systems-Brendan-Burns/dp/1491983647/
  
• https://www.amazon.co.uk/Databases-at-Scale-Operations-Engineering/dp/1491925949/
  
  
  Once you've got to grips with running a reliable service then you can start layering your Onion reverse proxy / load balancing on top.
  
  
• Isolate your daemons from the clearnet (clearnet example; CloudFlare 'Access' suggests you only allow CloudFlare's IPs through your firewall guaranteeing that only traffic scrubbed by them reaches your servers)
  
• Configure Onionbalance (clearnet example; using keepalive-d / CARP / F5 LTMs to have redundancy for the ingress controller)
  
• Harden your software Unlike the clearnet examples of security you'll want to ensure that your software can't be 'tricked' into making a call to a hostile server (e.g. "Please fetch and attach content at this URL") - you can do this with tricks like Ablative's "QuadHop" setup or simply ensure that your software doesn't have such functionality.
  
  
  All of this aside, check /u/alecmuffett's "Onions that don't suck" repo for examples that are both well setup and stable.
  
  
  TL;DR; Tor is just a TCP reverse proxy with load balancer capabilities go learn some DevOps dodads
  
  Edit: As per Alec's comment - clarify that Tor is technically a reverse proxy with load-balancing capabilities rather than a straight up TCP load balancer.

Since you know Java I would suggest that you a read one of the best programming books ever written: [K&R The C Programming language] (http://www.amazon.com/The-Programming-Language-Brian-Kernighan/dp/0131103628/), this book was written by the people who made the C language and it's one of the best books ever written. It is a must read for every C programmer. [Computer Systems: A Programmer's Perspective (3rd Edition)] (http://www.amazon.com/Computer-Systems-Programmers-Perspective-Edition/dp/013409266X/) is a great book to learn about computer systems. But I would recommend [Operating Systems Design and Implementation (3rd Edition)] (http://www.amazon.com/Operating-Systems-Design-Implementation-Edition/dp/0131429388) because it has some minix source code which will go really well with learning C.

Best of luck buddy :)

If you want to save money on books for college here's better advice:

1. Don't buy the books
   
2. Organize study sessions for your classes
   
3. Get free homework help along with free book usage
   
4. At the end of the semester if the book is worth keeping, poach it from people looking to sell it back
   
   I can honestly say it saved me at least a few hundred dollars. The only books I ended up keeping were the literary books (looks good on bookshelves) and the reference-type books (any c.s. grads out there?). Then save the extra $200 and use it on a mini-fridge.

Here's my list of the classics:

General Computing

• But How Do It Know? - The Basic Principles of Computers for Everyone
  
  
• The Elements of Computing Systems: Building a Modern Computer from First Principles
  
  
• Code: The Hidden Language of Computer Hardware and Software
  
  
• Gödel, Escher, Bach: An Eternal Golden Braid
  
  Computer Science
  
  
• The New Turing Omnibus: Sixty-Six Excursions in Computer Science
  
  
• Compilers: Principles, Techniques, and Tools, 2nd Edition (aka The Dragon Book)
  
  
• The Art of Computer Programming
  
  
• Algorithms, 4th Edition
  
  
• Introduction to Algorithms, 3rd Edition (aka CLRS)
  
  
• Essential Algorithms: A Practical Approach to Computer Algorithms Using Python and C#, 2nd Edition
  
  
• Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People
  
  
• Structure and Interpretation of Computer Programs, 2nd Edition (aka SICP, available for free on the MIT website)
  
  
• Discrete Mathematics with Applications, 4th Edition
  
  Software Development
  
  
• Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems by Martin Kleppmann
  
  
• Design Patterns: Elements of Reusable Object-Oriented Software (aka The Gang of Four)
  
  
• Think Like a Programmer: An Introduction to Creative Problem Solving
  
  
• The Pragmatic Programmer: your journey to mastery, 20th Anniversary Edition, 2nd Edition
  
  
• The Mythical Man-Month: Essays on Software Engineering
  
  
• Code Complete: A Practical Handbook of Software Construction, 2nd Edition
  
  
• The Design of Everyday Things
  
  
• Clean Code: A Handbook of Agile Software Craftsmanship
  
  
• Programming Pearls, 2nd Edition
  
  
• Soft Skills: The Software Developer's Life Manual
  
  
• Hello, Startup: A Programmer's Guide to Building Products, Technologies, and Teams
  
  
• Hacker's Delight, 2nd Edition
  
  
• Peopleware: Productive Projects and Teams, 3rd Edition
  
  Case Studies
  
  
• The Soul of a New Machine
  
  
• Masters of Doom: How Two Guys Created an Empire and Transformed Pop Culture
  
  
• Hackers: Heroes of the Computer Revolution
  
  
• Where Wizards Stay Up Late: The Origins Of The Internet
  
  
• Fire in the Valley: The Birth and Death of the Personal Computer, 3rd Edition
  
  Employment
  
  
• Cracking the Coding Interview: 189 Programming Questions and Solutions, 6th Edition
  
  
• The Complete Software Developer's Career Guide: How to Learn Programming Languages Quickly, Ace Your Programming Interview, and Land Your Software Developer Dream Job
  
  
• The Self-Taught Programmer: The Definitive Guide to Programming Professionally
  
  
• The Passionate Programmer: Creating a Remarkable Career in Software Development
  
  Language-Specific
  
  C
  
  
• The C Programming Language, 2nd Edition
  
  Python
  
  
• Automate the Boring Stuff with Python: Practical Programming for Total Beginners, 2nd Edition
  
  
• Python Crash Course: A Hands-On, Project-Based Introduction to Programming
  
  
• Python Programming: An Introduction to Computer Science, 3rd Edition
  
  
• Effective Python: 59 Specific Ways to Write Better Python
  
  C#
  
  
• The C# Player's Guide, 3rd Edition
  
  C++
  
  
• The C++ Programming Language, 4th Edition
  
  
• Starting Out with C++: from Control Structures to Objects, 9th Edition
  
  Java
  
  
• Introduction to Java Programming and Data Structures: Comprehensive Version, 11th Edition
  
  
• [Java: A Beginner's Guide](https://www.amazon.com/Java-Beginners-Seventh-Herbert-Schildt/dp/1259589315/, 7th Edition)
  
  
• Java: The Complete Reference, 11th Edition
  
  
• Core Java Volume I - Fundamentals, 11th Edition
  
  
• Starting Out with Java: From Control Structures through Objects, 6th Edition
  
  
• Effective Java, 3rd Edition
  
  Linux Shell Scripts
  
  
• The Linux Command Line: A Complete Introduction, 2nd Edition
  
  
• Wicked Cool Shell Scripts: 101 Scripts for Linux, OS X, and UNIX Systems, 2nd Edition
  
  
• Linux Command Line and Shell Scripting Bible
  
  
• Mastering Linux Shell Scripting
  
  Web Development
  
  
• Learning Web Design: A Beginner's Guide to HTML, CSS, JavaScript, and Web Graphics, 5th Edition
  
  
• Eloquent JavaScript: A Modern Introduction to Programming, 3rd Edition (also available for free on the author's website)
  
  
• JavaScript and JQuery: Interactive Front-End Web Development
  
  
• HTML and CSS: Design and Build Websites
  
  
• You Don't Know JS: Up & Going
  
  Ruby and Rails
  
  
• Ruby on Rails Tutorial: Learn Web Development with Rails, 4th Edition (Note: this book is somewhat out of date compared to the live version on the author's website.)
  
  
• The Well Grounded Rubyist, 3rd Edition
  
  
• Practical Object-Oriented Design in Ruby: An Agile Primer
  
  
• Agile Web Development with Rails 5.1
  
  
• Programming Ruby 1.9 & 2.0: The Pragmatic Programmers' Guide, 4th Edition
  
  
• Eloquent Ruby
  
  Assembly
  
  
• Assembly Language for x86 Processors, 8th Edition

> Structure and Interpretation of Computer Programs

I haven't read that book, so I just looked it up. And hey, the top review on Amazon is by Peter Norvig! Cool. It sounds like an interesting book, but definitely no replacement for a dedicated algorithms text. So, you do what I did in my schooling when faced with profs who assign the wrong books: you get the right books and read them on your own. :-) I did this in addition to reading the assigned garbage. Eventually after reading enough books on your own you realize that you can get any college education (minus the magic piece of paper) by just reading (to the point of true understanding) books.

I've read a handful of algorithms textbooks. The thing about this field is that a lot of concepts won't click the first time. So relearning is never a bad idea, even as a seasoned pro. When you interview for jobs eventually you'll probably go back and read an algorithms textbook again, assuming interview practices are still the same at that time, and you want a top company. The first algorithms book I read was this one which I think is much better for a beginner than CLRS. But if you don't know Java, you might have to learn it, which will require serious effort if you're learning Scheme at the same time too. And really, Scheme??? At least teach the kids something they can use in their career. Although, I admittedly learned a lot of really cool algorithms in Prolog, which I learned just for that class and promptly forgot how to use afterwards, and never used again. But the algorithms stuck with me. My favorite algorithms book is The Algorithm Design Manual by Skiena, but it's also not good for beginners. If you read Lafore, CLRS, and Skiena, you'll be an algo pro by the end of all that. :-)

I highly recommend Real-Time Collision Detection.

This next book might not apply to your field directly, but I believe it is a good idea to be at the very least aware of what it discusses, and it is a very excellent book on its subject: The Art of Game Design: A Book of Lenses

I recommend this book as more of a reference than a tutorial; it will allow you to quickly brush up on those areas of math and physics which you will need while writing (or perhaps working with) a physics engine. I don't recommend attempting to learn the subjects through this book alone though. Game Physics

Reading 3D Math primer for Graphics and Game Development is how I learned linear algebra, although I plan on studying the subject from a textbook when I get the opportunity. I keep the book close for easy reference of the math related to 3D rendering (such as the projection and view matrices), although if you get this book you will want to read the errata document on its website. There may be better books to teach this stuff now, so please don't jump on it too hastily.

A couple books I do not own, but plan to correct that as soon as I can:
Game Physics Pearls and Real-Time Shadows

If I think of any others, I will edit this comment.

This might be frowned upon by others in /r/compsci for not being "serious enough", but I greatly enjoyed "The New Turing Omnibus: Sixty-Six Excursions in Computer Science". To quote an Amazon review " He illuminates the dark corners of abstract thought with practical puzzles and plain language."

I had a lot of fun reading this book when I started studying CS, and it definitely helped me later on. It covers almost everything in plain language. I recommend you at least read the beginning on amazon's free preview and see if you like it: http://smile.amazon.com/The-New-Turing-Omnibus-Excursions/dp/0805071660 (click on the book thumbnail on the left)

>I didn't say it was correct but it makes it more likely that people will dismiss it out of hand.

That's fair, I agree. It's just frustrating: there are so many strawmen arguments related to AI that a huge number of intelligent people dismiss it outright. But if you actually look into it, it's a deeply worrying issue-- and the vast majority of people who actually engage with the good arguments are pretty damn concerned.

I would be very interested if anyone can produce a compelling rebuttal to the main points in Superintelligence, for instance. I recommend this book very highly to anyone, but especially people who wonder "is AI safety just bullshit?"

>Especially when those people get significant amounts of funding

Numerically speaking, this is inaccurate. Cf. this article.

I would recommend Mastering Regular Expressions for a gentle and accessible introduction to the topic. Seems like this is the primary thing you want.

Sublime also has multiple cursors. This lets you do certain things you would have done with regex interactively and without thinking, so that's another useful thing to know.

Apart from that, just familiarise yourself with all the buttons and toggles on the Find dialog and you should be good!

If you want to try a programming language, I'd recommend Python, as Sublime is very Python-friendly (just open the console and type expressions in, or try writing some simple plugins), and Python has great regex support, so is often used for slicing text up as well.

I'd say CLRS is the most fundamental, since all CS is built on algorithms.

For architecture/systems people (my area):

Computer Architecture: A Quantitative Approach by Patterson and Hennessy. Their other book Computer Organization and Design is excellent as well (and should be read first).

All books by Andrew Tanenbaum. His distributed systems, OS, and network books are excellent reads.

The Dinosaur book for OSes.

I also really like Smith/Nair for Virtual Machines. It is a new book and is not among the classics yet, but it is great.

For memory, caches, and disks, I recommend Jacob. It is also a newer book, but is essential to understand the Von Neumann bottleneck and possible solutions.

And, of course, the dragon book for getting started compilers. Then Ken Kennedy for advanced compilers.


And as a side note:

For AI, Russell and Norvig is required reading.

For type systems, Pierce is awesome.

Not sure how serious you are, but I was inspired to get better at RegEx when someone solved this problem that someone dedicated an entire project to in one line of regex. After a bit of research (not too much, as a lot of people pointed to it), I bought Mastering Regular Expressions. I'm reading it on and off, and about 30% of the way through, but even after a hundred pages or so, I felt so much more comfortable with them. Already applying a lot to solving work problems, and able to read expressions constructed by others much more comfortably. I highly recommend.

Hmm alright, considering your background, I'd probably recommend you giving Michael Sipser's Introduction to Theory of Computation a read (I sure there are many electronic copies floating around on the Internet). I think they cover the prerequisite math concepts required in a preliminary chapter before the content which I highly recommend you spend some time on. It works it's way up by walking you through notions of computations in increments, first through finite state automata before adding in more features, working its way up to a Turing machine. You can skip most of the exercises, since those are mostly for graduate students who need practice before undertaking research. If you ever get confused about concepts along the way just drop me a PM or a question in /r/askcomputerscience and I'm sure the community would be happy to help out.

Also if you're interested I could mail you my copy of (meaning a copy that I had bought some time ago, not that I wrote it) the Annotated Turing. It does a great job of explaining the concept of a Turing machine provided a non-mathematical and non-CS background. I'd be more than happy to share my books with people who are interested, plus there's no use in me keeping it around now that I'm done with it.

Just bear in mind that unlike most of science, the concepts here are very abstract, there aren't many direct physical implications, this really is a pure study of notions at play. i.e. how does one go about studying "how to do things" and its implications. A lot of details such as "how can such a machine exist with an infinite tape? what moves it? how does it implement its decision making scheme?" are all unimportant and ultimately inconsequential to the study itself.

Instead, what we care about are things like "I have a problem, is it possible for me to come up with a solution (algorithm) for it? Or is it logically impossible?" or things like "I have come up with a way to make a "computer", can it do things that other computers can? If I had to make it sort an arbitrary set of numbers so that they are ordered numerically, can my computer do it?". Turing machines, are a tool to help us reason about formally around these sort of arguments, and to give insight into what we can qualify as "computation". Further down the line we even ask questions like "are some problems inherently more 'difficult' than others?" and "if I can solve problem B, and I somehow use the solution for problem B to solve some other problem A?"

Perhaps this all sounds perplexing now, but maybe just go through some content and spend time reading a little and these should start to make a little more sense. good luck with your future endeavors on this journey!

Sure! There is a lot of math involved in the WHY component of Computer Science, for the basics, its Discrete Mathematics, so any introduction to that will help as well.
http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/ref=sr_sp-atf_title_1_1?s=books&ie=UTF8&qid=1368125024&sr=1-1&keywords=discrete+mathematics

This next book is a great theoretical overview of CS as well.
http://mitpress.mit.edu/sicp/full-text/book/book.html

That's a great book on computer programming, complexity, data types etc... If you want to get into more detail, check out: http://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/0534950973

I would also look at Coursera.org's Algorithm lectures by Robert Sedgewick, thats essential learning for any computer science student.
His textbook: http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=sr_sp-atf_title_1_1?s=books&ie=UTF8&qid=1368124871&sr=1-1&keywords=Algorithms

another Algorithms textbook bible: http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_sp-atf_title_1_2?s=books&ie=UTF8&qid=1368124871&sr=1-2&keywords=Algorithms




I'm just like you as well, I'm pivoting, I graduated law school specializing in technology law and patents in 2012, but I love comp sci too much, so i went back into school for Comp Sci + jumped into the tech field and got a job at a tech company.

These books are theoretical, and they help you understand why you should use x versus y, those kind of things are essential, especially on larger applications (like Google's PageRank algorithm). Once you know the theoretical info, applying it is just a matter of picking the right tool, like Ruby on Rails, or .NET, Java etc...

Learn some math, yes. Algebra, Discrete Math, Inductive Logic, Set Theory. Calc and Matrix Algebra are good for specific things, and just in general to beef up your math skills. But don't get hung up on it too much. It's a good thing to always have going in the background.

Start to think about how all computation is math - check out The Annotated Turing and really wrap your head around both what Petzold is talking about and what Turing is talking about.

That may require you to take a step back and study Formal Languages, Finite State Machines, and other related concepts (all the stuff that lets you build up to Regular Expressions, etc). Turnings thesis really gets to the heart of a computation, and those concepts build on that.

Then go learn LISP just to bend your brain some more.

Comp Sci is a fascinating subject, and you're off to a good start by thinking about what that Stack Overflow commenter meant - how are all languages similar? How do they differ? What's the underlying problem you're solving, and what are different ways of solving it? How do the tools you choose alter your solution?

Try writing something relatively simple (say, a program that plays Checkers or Tic-Tac-Toe and always wins) in a few different languages (start with ones you know, then learn some new ones to see how - if you've worked with Procedural or OO languages, try Functional ones).

I know the internet can get you pretty much anything these days, but books are still very valuable. Tutorials on the web are almost never as good as a well written book. This is a pretty good book to look at.

There are many other good books. The book to choose also depends on how much programming experience you have to begin with. Invest in a good book.

I would recommend (and I find that I recommend this book about every 3rd thread which should say something) a book on theoretical computer science. The book is all about the beautiful mathematics that underlie all of computing.

Computers keep getting faster and faster, but are there are any questions that we can never answer with a computer no matter how fast? Are there different types of computers? Can they answer different types of questions?

What about how long it takes to answer a question? Are some questions fundamentally harder than others? Can we classify different problems into how hard they are to solve? Is it always harder to find a solution to a problem than to check that a solution is correct? (this is the gist of the famous P=NP problem )

The book has essentially no prerequisites and will take you through (initially) basic set theory moving on to logic and then the fun stuff. Every proof is incredibly clearly written with a plain English introduction of what the author is about to do before the technical bits.

The only downsides are that is quite expensive and you might have trouble finding it unless you have access to a university library/bookshop.

Good luck with your love of mathematics!

Edit: lol the book... Introduction to the theory of computation - Sipser

Ah i really thought you'd say something like that. I had a similar mindset too when I started. Imo its a good attitude to have but it can be a bit of a curse because the hardest material doesn't come easily and it can be demotivating. (Isn't that why your here) Programming is one of those things where you want to start simple and improve you knowledge over time. You can do your projects/games in any language so why not pick one that makes your life easier when starting out. If you feel your being held back by your first language then by all means learn another one.

I'm not saying don't learn C++, it is a great language to learn if you can, and you will be aware of many things that java hides from you however I am saying it shouldn't be your first language, learn to walk before you run.

Here is the data structures book I read - it has served me very well. Not as 'comprehensive' or 'rigorous' perhaps as Introduction to algorithms by cormen but really its a great place to start. I find his style very easy to understand, it tries not to be too dry where as the cormen book is a classic but its so hard to understand.
amazon

pdf

This is a good list. I'd definitely not go for Winskel's book, and I'd skip the Dragon book because I think it is quite out of date (nothing on type systems, or first-class functions or even objects).

For languages, I'd go with Andrew Appel's Modern Compiler Implementation in Java (or "in ML"), and for language semantics, I'd go with
Semantics with Applications: An Appetizer, followed by Pierce's Types and Programming Languages (TAPL).

Also, Knuth's Concrete Mathematics is very very good, but is heavily skewed towards number theory. It is a must-read if one's interests are in crypto, but won't help you at all if for example, you want to work with databases, theorem proving, programming languages etc. You need a solid set theory foundation. Or if you were interested in graphics or machine learning, I'd go for a solid linear algebra foundation.

There are no systems books on your list, so I'd suggest one on operating systems: it is free and very good.
Operating Systems: Three Easy Pieces

Yeah, it's actually really interesting! When I say ARM, MIPS and x86 I'm talking about the processor architecture. Basically, your desktop has a processor that speaks x86 whereas your smart phone only knows ARM. MIPS is primarily for low power things like routers. Learning an assembly language means learning a lot about processors, which is also a lot of fun.

If you do want to learn about all of that, this book is great. Well written and pretty fun to read

http://www.amazon.com/Digital-Design-Computer-Architecture-Edition/dp/0123944244

Not exactly hardware focused, but I really enjoyed Gleick's "The Information, A History, A theory, A flood"

http://www.amazon.com/The-Information-History-Theory-Flood/dp/1400096235/

It does a great job of looking at computing in terms of information and its history. I loved the look at prominent figures like Babbage, Lovelace, Turing, etc.

Well, I learned Java programming from the ground up during my computer science classes at community college (I should note it's a pretty decent community college). Decent as it is, most of my learning was done through the use of textbooks, with the teachers mostly just giving assistance when you hit a bump in the road. With the internet though, you really don't need teachers, just forums to post at (or reddit, or IRC).

The first class was taught using this book:

http://www.amazon.com/Java-Programming-Joyce-Farrell/dp/032459951X

2nd class:

http://www.amazon.com/Starting-Out-Java-Control-Structures/dp/0321421027/ref=sr_1_4?s=books&ie=UTF8&qid=1331159174&sr=1-4

3rd class:

http://www.amazon.com/Data-Structures-Algorithms-Java-2nd/dp/0672324539/ref=sr_1_1?s=books&ie=UTF8&qid=1331159206&sr=1-1

The first two books cover a lot of the same material, so if you choose to go the textbook route I would just choose one of those (as you can tell from the reviews, the 2nd book is probably the better choice although the 1st book isn't as bad as the reviews would lead one to believe). There may be better starter books, but these were what were recommended at my school and they worked well enough for me. Whatever you choose to learn the basics with, I highly recommend the Data Structures and Algorithms textbook afterwards.

Good luck!

When you run Python it actually kicks of a VM {CPython}, think of it as a abstraction that will run on your machine. Finding "hotspots" in your code will allow you to make improvements independent of hardware.

On the other hand what I've seen is using SSD does improve reading performance, but there are lot of factors to consider: How big the file is, Are you using any Parser etc. Your best is to really gain a bit more of understanding of how things work under the hood.

If you're interested you might want to read Computer System a Programmer's Perspective, but be warned its pretty heavy.

TL;DR

Take a look at spaced repetition. Study without any music and use the absence of music as a check to see if you are still motivated to do your studying.

<br />

I fucked up my first part of my education too. Lucy i realized that and got motivated again before i finished school.

I am currently 19 years old and I also always loved math (and some physics). I am from the Netherlands so our education system does not really translate well to English but i was basically in highschool when i only did things that interested me. I got low grades on everything else.

1 moment in highschool really stayed with me where I now have finally realized what was happening. In highschool i had a course about the German language. I already had a low grade for that class so I sat to myself to learn extremely hard for the next small exam. The exam was pretty simple. The task was to learn 200 to 250 German words. So I took a peace of paper and wrote down all 250 words 21 times. 1 or 2 days later I had the exam. But when i got my grade back it sad that i scored a F (3/10) . I was totally confused and it only destroyed my motivation more and more.
What I now have come to realize is that learning something is not just about smashing a book inside your head as fast as possible.

<br />

So these are some tips I wished I could have give myself in the first year of highschool:

Go and sit in an quit room or in the library. This room should be in total silence. Now start with you studying. As soon as you feel the tension to put on some music than you should stop and reflect and take a little break.

The default in nature is chaos. Learn to use this as your advantage. I sit in a bus for 2+ hours a day. 1 hour to school and 1 hour back. Nearly every student does nothing in this time. So I made the rule for myself to do something productive in that time like reading a book. Normally I am just at my desk at home and before I know it it is already midnight. So this is for me at least a really good way to force my self to start reading a book in dose otherwise wasted 2 hours.

Get to know your body and brain. I personally made a bucket list of 100 items that includes 10 items about doing something for a week like running at 6am for a week of being vegan for a week. Fasting is also really great. Just do it for 1 day. So only drink water for one day and look how you feel. And try the same with coffee, sex, fapping and alcohol. Quit 1 day and look at how you feel. And have the goal to quit 1 time for a hole week strait.

Watch this video to get a new few about the difference of low and high energy. I never understood this but I think that everybody should know about the difference https://youtu.be/G_Fy6ZJMsXs <-- sorry it is 1 hour long but you really should watch it.

Learn about about how your brain stores information and how you can improve apon this. Spaced repetition is one of those things that really changed the way I now look at learning something. https://www.youtube.com/watch?v=cVf38y07cfk

<br />

I am currently doing my highschool math again for fun. After I am done with that again i hope to start with these 3 books.

• 3D.Math.Primer.for.graphics.and.game.development
  
• Mathematics for 3D Game Programming and Computer Graphics - Eric Lengyel
  
• Graphics C version
  
  I hope this helps someone and if you guys have any tips about learning shaders in unity than please share them.
  

readscheme is a good place to start, it hasa a bunch of good links to papers on issues related to macros: http://library.readscheme.org/page3.html

(It also has lots of other material, but you asked about macros specifically, so that's the link I've posted.)



If you can buy one book, buy Lisp In Small Pieces. It's generally excellent, and has good coverage of macro implementation strategies.

http://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/dp/0521545668/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1196347235&sr=8-1

Another good resource is the discussion of an implementation of syntax-case that's in "Beautiful Code": http://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1196346388&sr=8-1

who are you taking CS2 with?

my best advice is if you are struggling with the data structures in Java, get this textbook it's a Java DS & Algorithms book that is very easy to follow along with and the code is very well organized!

I used it when trying to build a Binary Tree Data Structure and it helped so much!

don't feel bad about failing, just keep moving and ignore anybody who tries to put you down. I failed out of college and things are going okay for me, things could very well be way worse, so just be happy as best you can. Use failure to better yourself and motivate yourself.

I took CS2 with Jason Smith, I do not recommend him for that class, he will just expect you to teach yourself everything, his projects also get a lot harder. He is only good because he covers a lot of material, not because he is a good teacher.

also avoid Zuilian Khan, that man lies out of his teeth, just be cautious about who you take, so many people just go into CS and expect good teaching at UTD and so many people fail because the profs are just not there for you, at least the ones i had so far.

learn as much as you can from class and be nice to people, work with others and you will be in better shape for the road ahead!

best of luck to you!

Three books that come to mind:

Types And Programming Languages by Benjamin Pierce covers the ins and outs of Damas-Milner-style type inference, and how to build the bulk of a compiler. Moreover, it talks about why certain extensions to type systems yield type systems that are not inferrable, or worse may not terminate. It is very useful in that it helps you shape an understanding to understand what can be done by the compiler.

Purely Functional Data Structures by Chris Okasaki covers how to do things efficiently in a purely functional (lazy or strict) setting and how to reason about asymptotics in that setting. Given the 'functional programming is the way of the future' mindset that pervades the industry, its a good idea to explore and understand how to reason in this way.

Introduction to Algorithms by Cormen et al. covers a ton of imperative algorithms in pretty good detail and serves as a great toolbox for when you aren't sure what tool you need.

That should total out to around $250.

This is a little less scholarly and a little more geared towards history, but it's a fascinating read and one of the best books I've read in the last couple of years. It doesn't start with Claude Shannon, but rather with different ways that human beings have disseminated information to each other (talking drums, the telegram, etc), over the years. Definitely, after you're done with everything else, put this on your list, it's great.

Edit: Apparently I forgot the link. http://www.amazon.com/The-Information-History-Theory-Flood/dp/1400096235

I agree with some points made by q00u but not all of them... my input.

I was just having a conversation with a friend of mine who likes to program. But he's really just cutting and pasting things and never really really understanding what's going on. He can't solve the basic problems that come up when coding.

Get this book:
3D Math Primer for Graphics and Game Development
http://www.amazon.com/Primer-Graphics-Development-Wordware-Library/dp/1556229119

Everyone says, "why make your own engine when you can get one for free". I made my own engine (a couple of times). Making my own engine gave me a tremendous understanding of Vectors, Matrix transformations, etc. that now using Unity3D (which I really enjoy) I'm super fast at using it as a result. You will never understand what a vector cross product is or the magic of quaternions if all you do is type transform.whatever.whatever and hope for the best in a game engine.

So go ahead and make your own engine. After you've done it a couple times, THEN seek out a pre-made one.

He's absolutely right about the New Years Eve resolution thing. Studies show the good feeling you get from telling people what your doing/going to do is just as good as the actual doing it. So people tell more and do less.

It is really common you hear "I'm an ideas guy" but what would really help is someone who knows how to get people together, organize ideas, how to collaborate etc. Knowing websites (like trello.com) and others to organize thoughts.

Signup for Trello.com (or something else) and write down ALL OF YOUR IDEAS, never begin a sentence with "this might be a stupid idea" or "this might not"... just write down everything you come up with.

The guy who made Angry Birds had 30 failures first. START TODAY and get those failures out of the way so in a year or so you can make something brilliant.

Finally... maybe we need a new subreddit called "GameDevNoob" or something?

It may be a big of a tough slog, but Sipser's Introduction to the Theory of Computation is great. The stuff on computability theory might be right up your alley, and even if you only make it through the chapter on deterministic finite automata you likely will be better at crafting a regular expression than many of my CS student peers.

Surprisingly enough, the book should be able to help you make sense out of that last sentence within 100 pages requiring only a bit of understanding of proofs. I think if you've got predicate logic under your belt you pretty much have all you need.

This free book is pretty good at teaching assembly language programming in a 32-bit environment. The best book imo to learn low level programming / computer concepts is this. It assumes only that you know C, and does a great job at teaching assembly language, computer architecture, and the basics of operating systems. It has great projects that you can do on its website. One of the projects is to reverse engineer a malicious program. Another project has you write buffer overflow attacks on a vulnerable program. Its a really great foundational book.

Yes, I believe it is very possible.

After reading [Superintelligence] (https://www.amazon.com/Superintelligence-Dangers-Strategies-Nick-Bostrom/dp/0198739834/ref=sr_1_1?s=books&ie=UTF8&qid=1479779790&sr=1-1&keywords=superintelligence), it is very likely that we may have whole brain emulation as a precursor to true AI. If we are on that path, it makes sense that we would be running tests in order to remove AI as an existential threat to humanity. We would need to run these tests in real, life-like simulations, that can run continuously and without detection by the emulations themselves in order to be sure we will have effective AI controls.

Not only could humans run these emulations in the future (past? present?), but the Superintelligent agent itself may run emulations that would enable it to test scenarios that would help it achieve its goals. By definition, a Superintelligent agent would be smarter than humans and we would not be able to detect or possibly even understand the level of thinking such an agent would have. It would essentially be our God with as much intellectual capacity beyond us as we have above ants. Time itself could run at nanosecond speeds for the AI given enough computational resources while we experience it as billions of years.

So who created the AI?
Idk, but that was not the question here...

piggybacking on what /u/T4IR-PR said, the best book to attack the science aspect of AI is Artifical Intelligence: A Modern Approach. It was the standard AI textbook when I took the class and it's honestly written very well - people with a basic undergraduate understanding of cs/math can jump right in and start playing with the ideas it presents, and it gives you a really nice outline of some of the big ideas in AI historically. It's one of the few CS textbooks that I recommend people buy the physical copy of.

Note that a lot of the field of AI has been moving more towards ML, so if you're really interested I would look into books regarding that. I don't know what intro texts you would want to use, but I personally have copies of the following texts that I would recommend

• Machine Learning (Murphy)
  
• Deep Learning Book (Goodfellow , Bengio)
  
  and to go w/ that
  
  
• All of Statistics (Wasserman)
  
• Information Theory (Mackay)
  
  for some more maths background, if you're a stats/info theory junky.
  
  After all that, if you're more interested in a philosophy/theoretical take on AI then I think Superintelligence is good (I've heard?)

I was once in your situation. Here is what I did.

• Find yourself a list of algorithms and data structures. A good place to look are on websites that have study guides for technical interviews or a table contents of an algorithms book. Anything that has Lists, Hash Tables, Sorting is a good place to look.
  
• Do some research on when said data structures and algorithms are taught in schools. Take your list and sort it from easy to hard.
  
• Go through your list, from the top down, and read (or watch videos, as I did) about those specific algorithms.
  
• And here is the important part: implement them from scratch. Create code and test data to exercise the code to see how it works. This will help you understand the algorithm better than any book.
  
  
  So, to answer your question (which is the first point I listed), Khan academy is good, but I think any videos or write-ups will do. The big problem is getting a priority list of things you need to learn, from the most fundamental (like Lists) to topics that utilize fundamental building blocks (like an A* search or dynamic programming). What helped me formulate such a list was the Table of Contents from algorithms books (good book, btw), course outlines offered by Universities, or certain websites with big lists.
  
  In terms of resources, the MIT data structures and algorithms lectures are available online for free. I used those when I got into the harder stuff, like dynamic programming. Prior to that, I googled a single algorithm, watched a video, and wrote a program. After that, I attempted to implement some google-style interview questions.

Aesthetics are almost never emphasized in university courses, but it's really important in practice. If you can write beautiful (i.e. readable/understandable, concise, efficient) code, you'll have a big leg up folks who bang out spaghetti code and pray it works.

Take a look at this book for famous 'beautiful' codes:
http://www.amazon.com/gp/aw/d/0596510047

If you're more interested in large scale software systems, dive into a widely used open source package and read the source. MySQL, Python, Hadoop, Rails, the complete Linux OS and many more are available for your autodidactic pleasure.

Your post has too little context/content for anyone to give you particularly relevant or specific advice. You should list what you know already and what you’re trying to learn. I find it’s easiest to research a new subject when I have a concrete problem I’m trying to solve.

But anyway, I’m going to assume you studied up through single variable calculus and are reasonably motivated to put some effort in with your reading. Here are some books which you might enjoy, depending on your interests. All should be reasonably accessible (to, say, a sharp and motivated undergraduate), but they’ll all take some work:

(in no particular order)
Gödel, Escher, Bach: An Eternal Golden Braid (wikipedia)
To Mock a Mockingbird (wikipedia)
Structure in Nature is a Strategy for Design
Geometry and the Imagination
Visual Group Theory (website)
The Little Schemer (website)
Visual Complex Analysis (website)
Nonlinear Dynamics and Chaos (website)
Music, a Mathematical Offering (website)
QED
Mathematics and its History
The Nature and Growth of Modern Mathematics
Proofs from THE BOOK (wikipedia)
Concrete Mathematics (website, wikipedia)
The Symmetries of Things
Quantum Computing Since Democritus (website)
Solid Shape
On Numbers and Games (wikipedia)
Street-Fighting Mathematics (website)

But also, you’ll probably get more useful response somewhere else, e.g. /r/learnmath. (On /r/math you’re likely to attract downvotes with a question like this.)

You might enjoy:
https://www.reddit.com/r/math/comments/2mkmk0/a_compilation_of_useful_free_online_math_resources/
https://www.reddit.com/r/mathbooks/top/?sort=top&t=all

Depending on depth, if you just want hardware (since you're asking in r/hardware) without regard to the computational side of computing then perhaps a free A+ certification course on Youtube or test prep book would be helpful.

Later if you wish to learn the theoretical side then I recommend a CS 101 course. A good Introduction to Computer Science textbooks will introduce things like abstraction and logic using gates then move into how programming is encoded into circuits. Good ones also give an overview of other things like complexity and networks without bogging down the reader in abstract mathematics. Although I haven't read it, I think this looks good - https://smile.amazon.com/Introduction-Computing-Systems-Gates-Beyond/dp/0072467509?sa-no-redirect=1

Another resource might be NAND to Tetris where you build a working computer.

We did something similar as well. The labs were tons of fun. I remember having to run a couple dozen lines of code through the CPU cache on a test once, including some sneakery of using code as data at one point. I do appreciate having done it, but I'm not sure how much practical lasting value that really contributed.

That said, for those who are interested in this there is The Elements of Computing Systems: Building a Modern Computer from First Principles, more commonly known as "NAND to Tetris".

Petzold's Code is excellent as well.

Edit: Actually, while I've suggested those two let me throw Computer Systems: A Programmer's Perspective into the mix. It's a book we used across two courses and I really enjoyed it. We used the 2nd edition (and I have no issue recommending people get a cheaper, used copy of that), but there is a 3rd edition now. Being a proper text book it's stupidly priced (you can get Knuth's 4 book box set for $30 more), but it's a good book.

Anyone have suggestions similar to that Computer Systems's text? I've always wanted to revisit/re-read it, but could always used a different perspective.

Work hard and you'll get there. I preferred the applied side of things, but if I just stuck with pure math I think I would have eventually gotten a tenure track position in the mathematics side of things.

My favorite book to this day, for a beginners course in Computational complexity is still, Michael Sipser's Introduction to theory of computation, I highly recommend it. It might be a little too easy for you if you already have a base, let me know and I'll recommend books more advanced.

Here is a link to the book on amazon, although any big college library should have it, if not just have them order it for you. I've gotten my college's library to buy so many books that I wanted to read, but not spend money on, you'd be surprised at how responsive they are to purchasing requests from PhD candidates.

The books posted are great for 3D rendering.

However, you're a flash developer and I'm concerned about your proficiency level with C++. If you're meh at C++, then I recommend that you write some sample C++ code to get the hang of C++ before you dive into implementing 3d mathematics and rendering.

Some resources for C++:
http://www.amazon.com/C-Pointers-Dynamic-Memory-Management/dp/0471049980

Although the best way to get good at C++ is to just code in C++! :)

Also you need a strong foundation in 3D math before getting to the rendering:
http://www.amazon.com/Primer-Graphics-Development-Wordware-Library/dp/1556229119

I'm sort of in the same boat as you, except with an aero and physics background rather than EE. My approach has been pretty similar to yours--I found the textbooks used by my alma mater, compared to texts recommended by MIT OCW and some other universities, looked at a few lists of recommended texts, and looked through similar questions on Reddit. I found most areas have multiple good texts, and also spent some time deciding which ones looked more applicable to me. That said, I'm admittedly someone who rather enjoys and learns well from textbooks compared to lectures, and that's not the case for everyone.

Here's what I gathered. If any more knowledgeable CS guys have suggestions/corrections, please let me know.

• Intro-ish: Structure and Interpretation of Computer Programs by Abelson & Sussman
  
• Math: Mathematics for Computer Science by Lehman et al.
  
• Computer Architecture: Computer Systems A Programmer's Perspective by Bryant & O'Hallaron
  
• Algorithms: Introduction to Algorithms by Cormen et al.
  
• Programming Languages: Programming Language Pragmatics by Scott
  
• Computational Theory: Introduction to the Theory of Computation by Sipser
  
• Operating Systems: Modern Operating Systems by Tanenbaum & Bos
  
• Networks: Computer Networks by Tanenbaum
  
• Compilers: Compilers by Aho et al.
  
• Security: Security Engineering by Anderson
  
• Type Theory: Types and Programming Languages by Pierce
  
• AI: Artificial Intelligence: A Modern Approach by Russell & Norvig
  
  Full disclosure: I haven't actually read more than the preface of any of those books. Software engineering topics are more directly applicable to me than CS topics right now, so here are some that I've actually started reading:
  
  
• The Pragmatic Programmer by Hunt & Thomas
  
• Clean Code by Martin
  
• Code Complete by McConnell
  
• Design Patterns by Gamma et al.

[edit: Missed a line when I saved; I'm not using vim keys in my browser] I loved this article! I hope you don't mind if I share a story.

I've been in IT professionally for 14 years, and computing for 35 years. I taught myself vim for log analysis, and it's paid off in so many ways that I evangelize about it.

Vim, by itself, is honestly only a bit useful if you give it only a surface examination. You can use Visual Mode (control V, then movement keys) to select blocks of text for removal, cutting, or pasting. However, a copy of Notepad++ will do the same, so at that level, meh. It's admittedly not user friendly at all coming in from the outside.

However, if you're willing to learn some Regex (and I can't recommend Mastering Regular Expressions (Amazon) strongly enough, then that's where vim really shines. I use it for cleaning up data daily, and between a strong understanding of regular expression, visual mode selection, and macros, I've done cleanup of data coming from odd sources in minutes that would have taken hours of work manually.

I'd love to give you a flat recipe on how to do some of what I do, but the thing about vim and data cleanup work is that the data coming at you for analysis is irregular, so your approach must be flexible. You learn the tools, not a recipe or two, and it takes time. I spent weeks in vim before it really clicked.

I spent time first in vimtutor (packaged with vim), and then w/ Mastering Regular Expressions. Once I had at least a rough understanding of :substitute (vim.wikia), that opened a lot of doors, and that's when I dropped using any other editor for raw text.

Here's an example of some of the things I find myself doing. I had a client the other day who had performed a change to an inventory control system that was filled with mistakes; the system has no undo, and the only record she had left (due to continued PEBKAC) was a PDF report she'd run before making things worse. Said PDF had data split across multiple lines, otherwise filled with garbage and oddball white spaces, and also had some duplicate rows within it. I exported it to text.

I needed to trim out all but two different forms of lines, then eliminate duplicates, then join the two altered line elements together into a single delimited line, flipping the last field from a negative to a positive number (or vice versa) which I could then use to make the corrections to her system. The end result was a 20,000 line file, so it was a lot longer before that.

I was able to transform the PDF in about 20 minutes.

Now, I've learned a few languages since, and I very well could have written a tool to do the job for me, however my relationship with massaging text in vim is such that, thanks to undo/redo, and the experience I've built up, it's actually faster for me to manipulate the file in real time than to alter script, execute, examine, adjust script, and repeat. Vim excels at working with large files, so while it's theoretically possible to do the same work in other editors, I've not found one that will handle massive sets of data with the same speed.

One other thought; if you are also willing to learn a little bit of Unix and pipeline, then invoking shell commands opens up a lot more doors, since Unix has massive amounts of tools and scripts available.

I really hope this helps you!

I don't even think we'll get that far. I honestly believe that once we create proper A.I. it will snowball out of control in a matter of months and it will turn against us. Their communist plans are mere fever dream when it comes to A.I. "Well, if the robots are nice to us, don't destroy the human species, and actually are subservient to us, then our Communist fever dream could work"

Yeah, okay, it's like trying to decide whether you want chicken or fish for the in-flight meal while the plane is going down.



I recommend reading Superintelligence if you want to get more theroies about it.

Based on my understanding of what you're interested in, I would see if your college offers a Digital Logic Design class. It's all about how you use and/or/not gates to create more complex logic gates, and then using those to do things like math and storing values.
If you don't want to shell out the money for a class, or it's not available, the book we use in mine is this one.

 

Also, if possible I would purchase a small FPGA. They're Field Programmable Gate Arrays - we use something like this in my labs, but there are some cheaper and smaller ones if you google for them. Basically they allow you to programmatically describe logic gates and run electrical signals through them, then output the results to various things like the LED's - it really helps ground the knowledge to reality.

Fortunately Digital Logic Design is pretty much a starting point, so it doesn't have any pre-reqs (at my college), should you choose to take it.

I read The Annotated Turing by Charles Petzold while I was in high school and it really sparked my love for logic, math and computer science. So, as far as popular science books go, I can't not recommend it.

Right now I'm interested in programming languages, and I think TAPL is a great resource. The (relatively) new blog PL Perspectives is also pretty cool, and so is /r/ProgrammingLanguages.

I was actually thinking this a few days ago about my dog. Having read The Singularity Is Near by Ray Kurzweil, there are a few sections devoted to uploading the brain and using technology to augment brain capabilities. What it boils down to is that the truly unique things about our brain are 'past memories', 'emotions', and 'personality'. Every thing else is the brain is just stuff that regulates our bodies and processes information.

If we take the personality, memories, and emotions of my dog, and improve on the other parts of the brain by adding better memory, speech recognition, etc. Then we might just be able to create another biological species that rivals our intelligence.

We already are making the assumption that technology will make humans more advanced, the same thing should eventually apply to all other biological animals as well. (Except Mosquitos, of couse)

Anyone interested in AI should read Nick Bostrom's book, Superintelligence. Fair warning, it is very dense but rewarding.

One take away here is he did a survey of leading AI researchers who were asked to predict when General AI might arrive - the majority (~67%) believe it will take more than 25 years, interestingly 25% believe it might never happen. Source

Also, really great panel discussion about AI with Elon Musk, Bostrom, others.

https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

This book is an excellent primer for a bottom-up look into how computers as machines function.

https://www.amazon.com/gp/aw/d/0123944244/ref=ya_aw_od_pi

This is my textbook from the class where we built a CPU. I greatly enjoy it, and it also starts at the bottom and works up excellently.

For OS development, I am following Philipp Opperman's excellent blog series on writing a simple OS in Rust, at http://os.phil-opp.com/

And as always Wikipedia walks and Reddit meanders fill in the gaps lol.

I hadn't heard of Lie Groups as well (and didn't look it up the first time you mentioned them) - they sound amazing!
Right now I'm mainly reading the Murphy Book after having finished Probabilistic Models of Cognition (which I enjoyed because I also always wanted to check out Scheme and has some great interactivity).

I suppose I'll have to put these books on the list, thanks! ;)

First of all, this is an excellent post. I've seen so many questions posted here but yours is the most concise and upfront. I know exactly what your background is and so I'm more confident that what I want to suggest would actually be relevant.

You have solid industry experience with academic foundation. And I think you already are aware of the pitfalls of expert beginner (http://www.daedtech.com/how-developers-stop-learning-rise-of-the-expert-beginner/). I think you are in a sweet spot where you can afford to invest resources without immediate gain - unlike early-career coders, you don't have to necessarily learn another language/framework right this second. You can afford to deepen your higher-level understanding of concerns and concepts that are timeless and not bound by the language/framework of the day.

I'd like to suggest you read other people's code/design. Here are some books to get you started.

• The Architecture of Open Source Applications
  
• Beautiful Code: Leading Programmers Explain How They Think
  
  Another thing you can invest in is everyday skills as a programmer. This is a classic on this subject.
  
  
• The Pragmatic Programmer: From Journeyman to Master
  
  You can couple ideas and tricks from here with any devops tools of the day to automate much of your workflow, such as bash/git/unix concepts onto automation tools such as docker/jenkins/ansible. Additionally, familiarizing/customizing your personal development environment. Improving scripting skills to automate many many things (practically everything that we do on computers that doesn't involve creative process are automatable. It's just a matter of ROI.).

I like The "New" Turing Omnibus for small pieces from a lot of CS areas. Since it covers a bunch of topics, you can read it in any order. It's a good way to see what specific areas you might want to dive into more deeply.

For more general, "fun" books to get excited about CS and its origins, I recommend Dealers of Lightning which is an amazing look at the work done at Xerox PARC in the 70s and Hackers: Heroes of the Computer Revolution which is about many of the people who paved the way for personal computers.

The best way to learn to write great code is to read great code.

Check out Beautiful Code for a book on the subject.

Or, pick some of the most popular open-source projects on github and read through their code. Find some small utility functions and see how they implement them.

Or, post some of your own examples here on /r/learnprogramming or on stackoverflow and ask for tips on how to make your code cleaner.

No problem. :) If you're trying to learn on the cheap, browse through edX and Coursera's offerings. There are a lot of free introductory CS courses on each, including Harvard's CS50. I'm not sure you'll have much luck finding introductory CS material in Haskell, though. Most will use C, Java, or Python. The good news is that if you learn any one of these three, you'll know the broad strokes of the other two.

If you want to hit on higher-level concepts and logic, the Lisp-based SICP is freely available and widely considered to be a classic. It would probably dovetail nicely with Haskell. If you want to get closer to the metal, Computer Systems: A Programmer's Perspective is a good text (slightly older editions that focus on 32-bit architectures can be readily found in .pdf form with a little Google-fu).

Side note: Tim Roughgarten's Algorithms course or Andrew Ng's Machine Learning course should be right up your alley if you're interested in AI. They may not be the best starter courses, though.

As well as discrete math, one thing some students have problems with is actually doing the amount of work required in a CS class. Not because they aren't capable, but because they don't realize that they probably shouldn't leave it off until the night before. If you get into the habit of doing an hour of work per night this summer, and just keep it up in college, you'll be way better off than most of your classmates. Do project Euler or Topcoder problems, or work on an open source project (imho harder). You'll get slapped around in Algorithms and discrete math no matter what.

If you want some light reading that you'll actually enjoy. http://www.amazon.com/The-New-Turing-Omnibus-Excursions/dp/0805071660 is an awesome book. I read it during my senior year summer, and I feel like it gave me a really nice cursory introduction to CS.

To anyone interested in reading about this stuff, I'd very highly recommend "The Information" by James Gleick. It's probably my second favorite book and discusses information starting with African tribal villages sending messages with drums, going through to the telegraph, Shannon's creation of Information Theory, etc. A decent amount of the book is dedicated to Shannon and it's generally a great read.

Okay, so that makes sense with Mormons I've met then. The "bible talking" Mormons, as I call them, seemed to me to be of the creation viewpoint. That's why I was confused about your view on it. I didn't know the church had no official position.

I read some of your blog posts. Very nice! It is interesting and intelligent. Your post about the genetic 1% is good. Incidentally, that is also why many folks are hypothesizing about the extreme danger of artificial intelligence -- the singularity, they call it, when AI becomes just a tiny bit smarter than humans, and potentially wipes out humanity for its own good. That is, if we are merely 1% more intelligent than some primates, then if we create an AI a mere 1% more intelligent than us, would we just be creating our own master? We'd make great pets, as the saying goes. I somehow doubt it, but Nick Bostrom goes on and on about it in his book, Superintelligence, if you haven't already read it.

Continuing with the "genetic 1%", it is possible we may be alone in our galaxy. That is, while abiogenesis may be a simple occurrence, if we think about the fact that in the 4.5 billion years of earth's existence there is only one known strain of life that began, it might be extremely rare for life to evolve to our level of intelligence. Some have speculated that we may be alone because we developed early. The idea is that the universe was cooling down for the first few billion years, which completely rules out life anywhere. Then another few billion years to create elements heavy enough for complex compounds and new star systems to emerge from the debris. Then the final few billion years when we came to be. Who knows?

man, I butchered my telling, thanks for fixing those inaccuracies.

For the last two points, I do actually have references, though I don't blame you for being dubious given the first half of my post, haha. When John McCarthy invented Lisp in the 1950's, he said he was directly inspired by Lambda Calculus, in his Recursive functions of symbolic expressions and their computation by machine, Part I. Or at least, that's the citation I found, I first heard about that connection in 'the annotated Turing', which is what got me on this whole rabbit trail in the first place. I'm admittedly too early on to have a great picture of it yet, but at least that detail has backing.

If you'd like to learn about the general connections between type theory and compilers/programming language theory, I recommend types and programming languages. I've only read the first chapter so far, but that's the topic of that first chapter. I'm intending to go back and properly hit the book at some point soon, but it's not a primary area of relevance to my work, so... you know. Only so many hours in the day, haha.

My understanding of your article resonating with something I think needs to be said. That goal directed learning trumps facts and the best way to hook a student is by telling a story.

I am huge fan of the no longer published Computer Recreations column by A.K. Dewdney. It showed how to gain insights into a problem with simple computer programs anyone could write.

His book, The New Turing Omnibus is an excellent example of teaching concepts while solving real problems.

There is so much complexity in the abstractions of computation that it is difficult to figure out what is and is not needed to explain a subject. Funny that the Lua book you cite is actually a pillar of good technical writing.

----

EDIT: this is horribly written. I will clean it up later.

I believe there is always another best code waiting for you. But till yet I find the Jon Bentley's version of Quicksort in Beautiful Code pretty awesome. He describes it as "The most beautiful code I never wrote"

this is a great video tutorial for C++ in my opinion (helpls if you have some java or c experience)

https://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C-/Stephan-T-Lavavej-Core-C-1-of-n

This is my data structs and algs book my class used. It basically have full examples of everything you're going to do in Java and has good tips. Big book but easy to parse for information.

http://www.amazon.com/Data-Structures-Algorithms-Java-2nd/dp/0672324539/ref=sr_1_6?ie=UTF8&qid=1457070413&sr=8-6&keywords=data+structures+and+algorithms


Here's a good link to some software that helps visualize algorithms. (I believe this is the right link)

https://www.cs.usfca.edu/~galles/visualization/Algorithms.html


Hopefully those links work.

Classic Russel & Norwig textbook is definitely worth reading. It starts from basics and goes to quite advanced topics:
http://www.amazon.com/Artificial-Intelligence-Modern-Approach-3rd/dp/0136042597/
Udacity has AI class that follows some chapters of that book.

Murphy's textbook builds ML from the ground up, starting from basics of probability theory:
http://www.amazon.com/Machine-Learning-Probabilistic-Perspective-Computation/dp/0262018020/
(I see, it was already recommended)

Coursera has the whole machine learning specialization (Python) and a famous ML class by Andrew Ng (Matlab).

I hope it helps. Good luck!

Suggested Steps

• Buy a cheap board from Altera or Xilinx.
  (I suggest Terasic which use Altera. They make some good entry level boards.)
  
• Decide on either Verilog or VHDL (I suggest Verilog)
  
• Know that you can do simulation online without installing anything (Well a browser)
  https://www.edaplayground.com/
  
• Download the tool suite from the vendor (Altera Quartus)
  
• Read some books and vendor technical material
  http://www.fpga4fun.com/FPGAinfo1.html
  https://www.altera.com/support/training/university/overview.html
  
• View some online presentations
  https://www.altera.com/support/training/curricula.html
  
• Get a handle of a vendor's specific flow and what all the various file types and programs are for
  
• Fool around and try things
  
  Books
  
  Digital Design and Computer Architecture, Second Edition
  May not be what you want, but I like it because it takes primitives and builds up a RISC processor.
  https://www.amazon.com/Digital-Design-Computer-Architecture-Second/dp/0123944244/
  
  Pong P. Chu's books are very practical. He covers both Verilog and VHDL for Xilinx and Altera FPGAs.
  https://www.amazon.com/Pong-P.-Chu/e/B001ITRMEY/
  
  Advanced Chip Design, Practical Examples in Verilog (Best Practices)
  https://www.amazon.com/dp/1482593335/
  
  FPGAs!? Now What?
  http://www.xess.com/static/media/appnotes/FpgasNowWhatBook.pdf
  
  Free Range VHDL
  Raw files
  https://github.com/fabriziotappero/Free-Range-VHDL-book
  PDF (The latest can be found on the free range website)
  http://www.gstitt.ece.ufl.edu/vhdl/refs/free_range_vhdl.pdf
  
  
  
  Prior Posts
  https://www.reddit.com/r/ECE/comments/451e7z/can_fpga_be_self_taught/czusnlc
  https://www.reddit.com/r/ECE/comments/2c513h/can_someone_explain_to_me_the_advantages_of_an/cjc18pg
  https://www.reddit.com/r/ECE/comments/1wqd34/can_someone_explain_to_me_the_fpga_design_process/cf4fqhy
  https://www.reddit.com/r/ECE/comments/1wqd34/can_someone_explain_to_me_the_fpga_design_process/cf4jw2i

Here's some lighter reading I've liked:

• Analog Circuit Design: Art, Science and Personalities
  
• The Chip : How Two Americans Invented the Microchip and Launched a Revolution
  
• Gödel, Escher, Bach: An Eternal Golden Braid
  
• Feynamn Lectures on Computation
  
  Readable, but more hardcore
  
  Hardware:
  
  
• The Design of CMOS Radio-Frequency Integrated Circuits, Second Edition
  
  
  Mathy:
  
  
• A New Kind of Science. I liked this book a lot, it is worth the price just for the interesting pictures. Make up your mind for yourself, and don't let negative reviewers unduly influence you.
  
• Probability Theory: The Logic of Science
  
• Information Theory, Inference and Learning Algorithms
  
  
  Programmy:
  
  
• Mastering Regular Expressions
  
  Unixy:
  
  
• Unix Power Tools
  
  
  Off the wall:
  
  
• Molecular Biology of the Cell
  
  

To get a feel for low-level computing you should learn C. All modern operating systems and low level utilities are written in C (or C++, which is C with objects). It is as close to the metal as you can get while still being useful. Maybe you could fiddle around with some assembly afterwards.

Now, as for understanding how an operating system form top to bottom works, Windows is a pretty shit place to start for the following reasons:

• Proprietary nature means little documentation about how the OS actually works internally.
  
• Single desktop environment and lack of naked shells makes it hard to understand how and why some things work.
  
• Limited capabilities for programming without an IDE, which is what you should be doing if you want to learn C (note that I said learn C. Particularly in the context of understanding, say, how data streams and the like work, programming without an IDE is infinitely better).
  
• etc.
  
  Instead, you should learn Linux, and learn how Linux works. Installing it in a VM is fine. If you're looking to learn, I suggest you start with Debian, and, after you get comfortable with the command line, move to Arch. Arch is great for learning, if not much else, because it makes you do most things manually, and has a pretty extensive wiki for everything you may need to know.
  
  Resources:
  
  A Linux tutorial for beginners: https://linuxjourney.com
  
  A pretty decent online C tutorial (note, you should compile the programs on your own system, instead of doing their online exercises): http://www.learn-c.org
  
  K&R2 (the "proper" way to learn C): https://www.amazon.com/dp/0131103628/ref=cm_sw_r_cp_awdb_t1_FSwNAbFDJ3FKK
  
  Computer Systems A Programmer's Perspective, a book that might just be what you're looking for: https://www.amazon.com/Computer-Systems-Programmers-Perspective-3rd/dp/013409266X

I'm a general engineer myself, with a side interest in computer science. Szeliski's book is probably the big one in the computer vision field. Another you might be interested in is Computer Vision by Linda Shapiro.

You may also be interested in machine learning in general, for which I can give you two books:

• Heavily Theoretical: Christopher Bishop - Pattern Recognition and Machine Learning (Very much research oriented. Assumes you're decent at calculus.)
  
• Heavily Practical: Toby Segaran - Programming Collective Intelligence (A shallow look at the most common practical algorithms straightforwardly applied to real life examples.)
  
  I see you're interested in compilers. The Dragon book mainly focuses on parsing algorithms. I found learning about Forth implementations to be very instructive when learning about code generation. jonesforth is a good one if you understand x86 assembly.

I like The New Turing Omnibus. It's kind of old, but gives a great overview over many interesting computer science topics. After reading it you should have a general sense what computer science is all about. Then you can dive into more specific books on topics that interest you.

Hey,

It looks like you haven't actually started with your emulator development. Begin to check out the opcodes of Chip-8, have a look at the hardware and try to reason, why you won't have an x86 assembly file.

In addition, have a look at the difference between those numbers and those numbers.

It looks like your understanding of computer architecture is quite limited - nothing to be ashamed of - you might be better off by reading Digital Design and Computer Architecture by Harris and Harris or Introduction to Computing Systems: From Bits and Gates to C and Beyond by Patt and Patel than writing an emulator right now.

Both books give you an absolutely wonderful overview of computer architecture, starting at the boolean logic, the transistors and the gates you can form with them, going over combinatorial and sequential logic and ending at the design of your own CPU written on an FPGA with a HDL (which few programmer encounter in their career). The latter even gives you a detailed overview of multicycle processors, and goes beyond that to analyse GPUs and some more modern techniques to improve multicycle processors.

As I'm giving out advice, you might want to have a look at openGL which is used to render modern games or SDL which is more common in the emudev community. (be aware that SDL is a few abstraction layers above openGL and relies on it)

• A decent idea of how all the internal parts of a computer fit together. I'd recommend Computer Systems: A Programmer's Perspective and Code: The Hidden Language of Computer Hardware and Software
  
• A good book to solidify your principles like Code Complete or Pragmatic Programmer.
  
• Really understanding the nuts and bolts of a text editor that can preferably work with any language and is cross-platform (Emacs, Vim, Sublime Text to name a few)
  
• A good understanding of a version control system like Git. I'd recommend Git for Computer Scientists and Git from Bottom Up

I took CS50x when they first offered it on edx in 2012 and it was by far my favorite online course. It's been a while and it may have changed a bit, but from memory a few things that helped me:

• Watching the videos at 1.5 speed and repeating/slowing down at more complex parts (David Malan is a great lecturer but the lectures have a lot of filler)
  
  
• Watching all the videos, including the workshops (or whatever they're called)
  
  
• Helping out others who are stuck (see CS50 subreddit): teaching is a great way to solidify learning concepts
  
  
• Read Programming in C

I bought this book solely for its section on quaternions (very well explained), but the rest of it is pretty good too. It covers a wide range of maths needed in 3D graphics and explains them well.

Most of its content isn't relevant to 2D, but I'd say it's a worthwhile purchase in the long run.

Some resources I found useful:

• This Github repository is a really good overview. Although it doesn't exactly give a deep understanding of any particular topic, it's a really good way of understanding the system design "landscape". After reading this, I had a much better idea of what I needed to study more.
  
• Designing Data-Intensive Applications is an awesome and thorough book that covers just about everything you need to know for a system design interview.
  
• Maybe a bit obvious, but CTCI's system design chapter is useful (although not enough on its own).
  
• It's in some ways a bit orthogonal to system design, but Computer Systems: A Programmer's Perspective gave me a much better idea of how the hell this machine I touch all day works. I think learning the things covered in here helped me speak with more confidence on system design.

I know that this is way more on the theory/mathematics side of the spectrum than CODE, but Charles Petzold also wrote a book called The Annotated Turing that I really enjoyed. He took Alan Turing's original paper on computability which was about 30 pages and annotated it until he had about a 400 page book. There were a couple of chapters in the middle that got a bit dense, but he did a fantastic job of making the subject more approachable and understandable.

I don't think type theory is what you're looking for. Type theory (and programming language theory) are mostly interesting from the perspective of a language designer or implementer. If you're just looking to upgrade your Haskell skills, then focusing on specific libraries and techniques will be faster.

With that said, here's my type theory track:

• Type Theory and Formal Proof is a fantastic introduction to the lambda calculus, starting with the simple untyped lambda calculus and exploring each of it's additions. It's very friendly to novices, and includes a guide to Greek letters and an introduction to sequent notation (the weird horizontal bar logical notation). Ultimately, it develops the Calculus of Constructions with Definitions which can be used to prove things using constructivist logic.
  
• Types and Programming Languages is a good read after that. It also starts with the untyped lambda calculus, and develops extensions on top of it. You'll implement a type checker and interpreter for the simply typed lambda calculus, and you'll add subtyping, record types, type inference, objects (!!!), parametric polymorphism, and existential types.

The way I got started was working through the exercises in Benjamin C. Pierce’s Software Foundations. It starts from the absolute basics (which was good for me). Volume 1 covers logic, theorem proving, and other Coq fundamentals. Volume 2 discusses proving programs correct and proving the soundness of type systems. I haven't worked through Volume 3, but it covers verifying algorithms and data structures.

It also helps to have a good understanding of type theory in general. For me, that background knowledge came from another Benjamin C. Pierce book: Types and Programming Languages.

Once you know the basics of how logic works in Coq, I think the material from a discrete math course (like this) is probably a good source of proofs to try (logic, graphs theory, combinatorics, number theory, etc).

Seconding collaborative filtering. It's also a fairly simple algorithm to implement yourself as long as you're not using Wikipedia as a guide.

Collaborative filtering is like what Amazon uses to figure out what products to recommend to its users. It finds users that have similar purchasing habits to yourself and recommends items that they bought.

The first chapters of Programming Collective Intelligence describe how to implement Collaborative Filtering in Python in a really intuitive way, along with providing source code. Two hours in and you'll have a working service recommendation system. I'd definitely recommend that book to anyone looking to build what OP is interested in making.

Thanks!

Have you read The Singularity is Near? It's quite an interesting read.

Dr. Steel has a great view of things; I agree to everything in this video!

>So what did you do? Anyone else have a formal CS education and feel like they came out of it with nothing?

I graduated in 2006 and I've been doing web development professionally for almost four years now. Until about two weeks ago, I felt like I could have skipped my entire five years at school because most of the stuff just doesn't apply to web development since it's so far abstracted from the hardware. I was reading my algorithms book on the toilet the other day when I realized that I learned a shitton at school and it gave me an incredible advantage over the guy who learned web development on the fly. It helps to go back and re-read things after you have a context to put it into so you can apply what the theory to what you've learned.

It took me a long time to start getting designs down. You have to make a lot of mistakes before you can learn from them. It's as simple as that. Don't get discouraged. If you haven't read Head First Design Patterns, buy that book right now and read it cover to cover. I had read design pattern catalogs, but none of them conveyed the 'why' as well as HFDP did. They don't have abstract, car has wheels, Ford is a car. They have real code examples and they show you why you should favor composition rather than inheritance. Why you should follow the law of Demeter.

I've entertained the notion of starting over several times. Don't quit, and don't get discouraged. If you ever get to the point where you think you've learned all you need to learn and you're writing code that can't be improved, start over.

Well, to be fair to him, he has moderated his tone in recent years. I bought and read his excellent book about QC a few years ago and learned a ton of stuff about QC and just general computer science(and a whole lot of scientific trivia).

I've also followed his blog sporadically. In his latest blogpost he's more nuanced, and even allows himself to take the pose of being a cautious supporter. That's not where he was just a few years ago. As people in the comment section pointed out, he used to joke that his laptop would beat QC and that Google should just pay him millions of dollars instead.

The reason why he's moderating is that he can see the writing on the wall. He's right to be skeptical(we all should be), but as I pointed out, all of his contentions are already laid out by Google in their paper. So what does he do in his blogpost, exactly, that is new?

D-Wave should be understood as an ASIC in QC. It's not a generalized QC, but rather optimised for specific tasks. Troyer explains this for laymen, here.

We're still some ways off a generalized QC, but the breakthroughs that D-Wave are doing will help pave the way for such a QC and this is the whole point of why NASA/Google are buying their stuff and working with them. Google also has a separate team doing more fundamental research work.

Thus, Scott's flippant "pay me millions for my laptop" kind of commentary have become faintly more sparse throughout these past few years to the point where he doesn't even attempt to do these jokes anymore, because the joke would be on him.

P.S. Re-reading my comment, I sound incredibly harsh on him. I respect the man, he's brilliant and his book on QC is awesome. But I am disappointed in how he has tried to avoid taking intellectual responsibility for his overt hostility in the past(which he has now moderated) and now tries to maintain he was always just a good-natured supporter who "tried to avoid hype". That's a deceptive and I don't like when people don't own up to their past positions, because they recognise they were wrong and the terrain shifted.

Digital Design and Computer Architecture is my favorite plain-language start to digital design.

You start with transistors and logic gates, and move all the way up to assembly language and compilers. Basically all the knowledge you need to create a simple processor.

It's going to help you think of Verilog as what it is, a description of physical hardware on a chip, as opposed to a set of instructions. Programming is like giving someone directions on a map, HDL is like building the roads. An if statement in C is a set of instructions executed in order. An if statement in Verilog is saying "Place a multiplexer here, and wire it up to these other pieces of hardware."

Absolutely and unequivocally The New Turing Omnibus. There are all sorts of scientific questions and solutions along with proofs and use cases over the years usually surrounding computer science. I loved everything I'd learned in this book and still remember learning what the Hamming Distance is and how it helped us develop a reliable way to communicate at such long distances with satellites and other such things. I have a copy sitting on my shelf next to me atm so I got a photo for you to check out the TOC if you wish. Truly a light favorite of mine.

In the interim, I suggest the following books:

• Digital Design and Computer Architecture, by Harris & Harris - covers the circuitry & hardware logic used in computers. Should also cover how data is handled on a hardware level - memory's a bit rusty on this one, and I can't find my copy of it right now. Recommend that you read this one first.
  
  
• Computer Organization and Design, by Patterson & Hennessy - covers the conversion of system code into assembly language, which itself turns into machine language (in other words, covers the conversion of programs from operating system code into hardware, "bare metal" code). Knowledge of digital circuitry is not required before reading, but strongly recommended.
  
  
• Operating System Concepts, by Silberschatz, Galvin & Gagne - covers all the basic Operating System concepts that each OS today has to consider and implement. While there are Linux-based ones, there are so many different Linux "flavors" that, IMO, a book that covers a specific Linux base (called a Linux kernel) exclusively would be incomplete and fail to address all the key aspects you'll find in modern OSes. Knowledge of coding is required for this one, and therefore should be read last.
  
   
  
  As for the coding books, I suggest you pick one up on Python or Java - I'm personally biased towards Python over Java, since I think Python's syntax and code style looks nicer, whereas Java makes you say pretty much everything you're doing. Both programming languages have been out for a long time and see widespread usage, so there's plenty of resources out there for you to get started with. Personally, I'd suggest going with this book for Java and this book for Python, but if you go to Coursera or Codecademy, you might be able to get better, more interactive learning experiences with coding.
  
  Or you can just skip reading all of the books I recommended in favor of MIT's OpenCourseWare. Your choice.

I wouldn't say too early for having a good high-level overview of best practices.

It's always good to have a solid theoretical/philosophical understanding before diving into the specifics.

I'll put my vote down for Site Reliability Engineering as a good reference for high level ideas and less on the low level details.

Here

Ubuntu is recommended, but you can use some other distro. However all of the support I'm doing is only for Ubuntu based distros. Some others have done things to get it working for other distros like Arch.

And here is the book

And as a bonus [here](https://drive.google.com/open?id=0B6g7zcZaFwPTVVI1eDBYcG1GbE0
) is a presentation I did last semester which includes an overview and some sample programs.

edit fixed 3rd link.

Check out The Annotated Turing by Charles Petzold. It's Turing's paper on the Entscheidungsproblem which introduces Turing Machines, annotated with a lot of background information and some stuff about Turing's career. Very interesting stuff.

I can also recommend Code, by the same author which describes how a computer works from basic principles. It's doesn't have a lot of material on Turing, but it's certainly an interesting read for anyone interested in Comp Sci.

Scott Aaronson would be the ultimate mindscape podcast guest for me. I am actually hopeful that this will happen at some point, knowing that Sean and Scott know each other personally.
For the uninitiated, Scott is a quantum computing researcher, accomplished author and blogger extraordinaire.
If you have never heard of him, read this interview and you will agree that he would make a great guest.

I highly recommend The Haskell School of Expression by the late great Paul Hudak. Also you should learn as much as you can about Lambda Calculus in general like for example this paper.
After that you should learn as much as you can about types, Types and Programming Languages is really important for that.
Finally don't skip the important fundamental texts, mainly Structure and Interpretation of Computer Programs and the original video lectures by the authors (about the nerdiest thing you will ever watch ;)

I figure a business background and are looking to incorporate machine learning/AI into your pipeline. Programming Collective Intelligence: Building Smart Web 2.0 Applications is a must-read. Doesn't go too much into it but still gives you a good idea of the popular ML techniques and how they're being used by top companies.

Why would it care if the goal we gave it didn't actually align with what we wanted? It has no reasons to care, unless these things were explicitly coded in, and as I said, morality is super hard to code into a machine.

To address your second point, I understand my example wasn't perfect, but say it understands that the more physical material a company controls, the more assets it has. So it lays claim to the entire universe, and sets out to control it. eventually, it is the company, and growing the company's assets just requires it to have more processing power. Again, it is an illustrative point, loosely derived from my reading of Superintelligence by Nick Bostrom. I would highly recommend it.

Two great introductions are:

• Armstrong - Groups and Symmetry
  
  
• Halmos - Naive Set Theory
  
  
  both are short and very well written. Some books particularly close to my heart are:
  
  
  
• Sipser - Theory of Computation
  
  
• Lothaire Combinatorics on Words
  
  
• Davey and Priestley Lattices and Order

> what OOP actually IS...

The one problem with this is that OOP isn't particularly well-defined. It's a mish-mash of different ideas, with different languages implementing different parts of the space. Nevertheless, Wikipedia has a good list of assorted things that are generally OO. It's just worth noting that not every OO language has all of them, and some of them aren't even specific to OO.

For example, look at encapsulation. If by encapsulation you mean "not exposing internal implementation details", then many languages with module systems have it (for example, ML (I think, I'm not really an ML programmer) or Haskell, neither of which is object oriented). If you mean bundling methods with data, then C can do that.

> things like polymorphism

"Polymorphism" is again an ambiguous statement - when people use it, they often mean either ad-hoc polymorphism, parametric polymorphism or subtype polymorphism, and their usage usually depends on which community they're in. For example, Haskell programmers say polymorphism to mean parametrically polymorphism, whereas Java programmers usually mean subtype polymorphism.

If you're interested in learning about these in more detail, I highly recommend Types and Programming Languages by Benjamin Pierce.

Also, while Bob Harper is a curmudgeonly troll, I've heard some good things about his book Practical Foundations for Programming
Languages

Not covered in this video: Peak Oil and the End of Cheap Abundant Energy.

All the bots in this video (and our whole society, in fact) are fueled by cheap abundant energy from fossil fuels. Reddit loves to pin its hopes on vaporware sources of cheap energy that are always JUuuuuST about to be figured out, but the reality is that we are NOT going to find a working replacement for our energy needs.

Bots may be here now, but they are not here to stay. The future will look more like The Long Descent and less like the Singularity.

Horses and human labor are poised to make a come back. Learn a trade craft. Grow food in your back yard. Develop a skill that will have value in the post-collapse economy. Become a beekeeper. Become a homebrewer. Make soap. Collapse now and avoid the rush.

EDIT: For a much more level-headed analysis, read this article right now: The End of Employment by John Michael Greer

My favorite relaxing math book was Chaos, Making a New Science by James Gleick

And The Information by James Gleick Was pretty good too.

The selection of accessible textbooks is not great. I agree with the existing suggestion to look at the relevant chapters of Sipser.

I think you should check out Quantum computing since Democritus by Scott Aaronson. He is a very entertaining writer, and this might be the closest thing to Road to Reality for CS. Scott's primary research expertise is in quantum computing, though the book covers a ton of other interesting CS-theory topics.

If you want a sneak preview of what's in the book, it grew out of the lecture notes that are posted here.

And here are some other popularizations that are probably less technical than QCSD:

• Computers Ltd.: What They Really Can't Do by David Harel
  
  
• The Golden Ticket: P, NP, and the Search for the Impossible by Lance Fortnow (mostly just about the P vs NP problem)

K&R is good. Also, Programming in C by Stephen Kochan is pretty good and might come across better depending on your learning style.

Beautiful Code is a great read with lots of interesting perspectives:

https://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047

-----
-----

BOOKS

Children Electronics and Electricity books:

• "Electricity for Young Makers" by de Vinck.
  
  
• "Make: Easy Electronics" by Platt. (12 experiments)
  
  
• "Electronics for Kids: Play with Simple Circuits and Experiment with Electricity!" by Dahl.
  
  
• "Electronics For Kids For Dummies" by Shamieh. (13 experiments)
  
  Newbie Electronics books:
  
  
• "Make: How to Use a Breadboard" by Ragan and Culkin. (10 experiments)
  
  
• "Make: Electronics" by Platt. (34 experiments)
  
  
• "Make: More Electronics" by Platt. (36 experiments)
  
  
• "Lessons in Electric Circuits - Volume VI - Experiments" by Kuphaldt. (free book)
  
  
• Series "Engineer's Mini-Notebook" booklets by Forrest Mims. (download archives)
  
  
• List of books about 555-series Timer ICs on Wikipedia.
  
  Basic Circuit Theory books:
  
  
• "Electrical Circuit Theory and Technology" by Bird. (download old edition)
  
  
• "Introductory Circuit Analysis" by Boylestad. (download old edition)
  
  
• Series "Lessons In Electric Circuits" by Kuphaldt. (free books)
  
  
• List of books about Diodes, Transistors on Wikipedia.
  
  Analog Design books:
  
  
• "Microelectronic Circuits" by Sedra and Smith. (download old edition)
  
  
• "Electronic Devices and Circuit Theory" by Boylestad and Nashelsky. (download old edition)
  
  
• List of books about Operational Amplifier (OpAmp) ICs on Wikipedia.
  
  
• List of books about LM-series Analog Linear ICs on Wikipedia.
  
  Digital Design books:
  
  
• "Digital Fundamentals" by Floyd. (download old edition)
  
  
• "Digital Design: Principles and Practices" by Wakerly. (download old edition)
  
  
• "Digital Design: with Introduction to Verilog, VHDL, SystemVerilog" by Mano and Ciletti. (download old edition)
  
  
• "Digital Design and Computer Architecture" by Harris and Harris.
  (download old edition)
  
  
• List of books about 7400-series TTL Digital Logic ICs on Wikipedia.
  
  
• List of books about 4000-series CMOS Digital Logic ICs on Wikipedia.
  
  Digital Signal Processing books:
  
  
• "Scientist and Engineer's Guide to Digital Signal Processing" by Smith. (download or online)
  
  Computer Design books:
  
  
• List of books about
  6502,
  6800,
  6809,
  8080,
  8085,
  Z80,
  68000,
  x86
  processors on Wikipedia.
  
  
• List of books about
  8051,
  ARM,
  AVR,
  PIC,
  RISC-V
  microcontrollers on Wikipedia.
  
  Electronics Reference books:
  
  
• "The Art of Electronics" by Horowitz and Hill. (download example chapter)
  
  
• "The Art of Electronics - The X Chapters" by Horowitz and Hill. Shipping in 2020.
  
  
• "ARRL Handbook" by various ARRL authors. (download very old edition)
  
  Historical books:
  
  
• "The Intellectual Rise In Electricity - A History" by Park Benjamin in 1895.
  
  
• "Electricity - It's History and Development" by William Durgin in 1912.
  
  
• "Bibliographical History of Electricity & Magnetism" by Paul Mottelay in 1922.
  
  
• "History of Communications Electronics in the United States Navy" by Linwood Howeth in 1963.
  
  -----
  -----
  
  

  MAGAZINES
  

  
  Current Electronics Magazines: (subscribe now)
  
  

• "Circuit Cellar"
  
  
• "Elektor"
  
  
• "Everyday Practical Electronics"
  
  
• "Nuts & Volts"
  
  Historical Electronics Magazines: (archives)
  
  
• "Electronics Today"
  
  
• "Everyday Electronics"
  
  
• "Popular Electronics"
  
  
• "Practical Electronics"
  
  
• "Radio Electronics"
  
  Historical Computer Magazines: (archives)
  
  
• "Byte" - 2nd group
  
  
• "Dr Dobb's Journal"
  
  
• "Interface Age"
  
  

• "Kilobaud"
  
  -----
  

Thanks for the upvote. Have one from my side too. :-)
But that certainly isn't a semaphore station but indeed a windmill.
Semaphores and semaphore stations became somewhat popular starting from the end of the 18th century. The Ruisdael-painting dates from halfway the 17th century.
Furthermore (Chappe) semaphores had 2 arms, with 1 articulation each. The Ruisdael windmill clearly has 4 blades or sails.
If you want to learn some more about semaphores and sempahore stations there's an insightful chapter on that subject in James Gleick's book The Information.

For a historical and theoretical overview that doesn't get too technical but is still comprehensive and fun to read, I highly recommend The Information by James Gleick. If you dig Zero, I think you'd dig this.

Alan Turing's original paper that introduced the Turing Machine is a great read. The Annotated Turing is a great way to both read and understand the paper if you don't have a background in compsci. It doesn't assume much more than highschool math, and the whole of Turing's paper is inline with the explanations.

It's a bit dated now, but Ray Kurzweil's The Age of Spiritual Machines is a fascinating look at where Kurzweil believes the future of AI is going. He makes some predictions for 2009 that ended up being a little generous, but a lot of what he postulated has come to pass. His book The Singularity is Near builds on those concepts if you're still looking for further insight!

In Chapter 1 of Beautiful Code, "A Regular Expression Matcher," by Brian Kernighan (an early draft of which appears on Princeton's site), he writes "[Regular expression] first appeared in a program setting in Ken Thompson’s version of the QED text editor in the mid-1960s. In 1967, Thompson applied for a patent on a mechanism for rapid text matching based on regular expressions. The patent was granted in 1971, one of the very first software patents [U.S. Patent 3,568,156, Text Matching Algorithm, March 2, 1971]." That patent is viewable online here.

It's not proof that this is the first program that actually had it, but it's a good pile of evidence. I would like to hear of any examples prior to QED (which some sources leave out, claiming ed as the first to have them). I went on a hunt for previous examples once (before giving a class on regular expressions for my company; I didn't want to make unfounded claims), but could find nothing earlier.

The book (Beautiful Code)[http://www.amazon.com/Beautiful-Code-Leading-Programmers-Practice/dp/0596510047] has a great chapter (18) on Python dictionaries, how they work and how they fit into the language. Definitely worth the read.

On the math side I read 3d Math primer for graphics and games as it was one of the only 3d math books available for the kindle. It is a pretty easy read and covers a lot of subjects. I'm considering picking up Essential Mathematics for Games and Interactive programming as a refresher if it ever gets released as an ebook since I've seen it be recommended a few times and it is a slightly more recent text.

As for the 3d programming side, it really depends on what you want to do. I chose to program in opengl and picked up the opengl superbible, which I would recommend. I've not touched directx yet, but have heard good things about Practical Rendering and Computation in Directx11 though I don't think this is intended as an introductory text for directx, but as a reference for those familiar with 3d already.

pattern.txt is more of a reference manual not exactly a great introduction. I'm not entirely sure what would be one, though. I can recommend you Mastering regular expressions, but that's not free, and perhaps a bit more than you need ;-)

Also: be aware that Vim regular expressions are different from many others! Basic patterns (like this) will work, but some of the more advanced ones are different (like .*? being .\{-} in Vim). Still, once you grasp the idea behind it, it should be easy to port the idea to Vim ;-)

Read this book: http://www.amazon.com/Programming-Collective-Intelligence-Building-Applications/dp/0596529325

It has examples in Python, but is not about Python per se but general advanced programming topics. Fairly easy read. In fact, all of the "red" Oreilly books might be what you want: Data Analysis with Open Source Tools, Machine Learning for Hackers, Mining the Social Web, Natural Language Processing with Python, etc.

Here are some links for the product in the above comment for different countries:

Amazon Smile Link: this book


|Country|Link|
|:-----------|:------------|
|UK|amazon.co.uk|
|Spain|amazon.es|
|France|amazon.fr|
|Germany|amazon.de|
|Japan|amazon.co.jp|
|Canada|amazon.ca|
|Italy|amazon.it|
|China|amazon.cn|




To help donate money to charity, please have a look at this thread.

This bot is currently in testing so let me know what you think by voting (or commenting). The thread for feature requests can be found here.

Give this a read. This isn't some crackpot, this is Google's director of engineering. I'm not saying it contradicts what you are saying.

>I doubt we'd anything like a true AI in 20 or so years

Is pretty close to his timetable too, but honestly even getting close to that computational power is well over what is needed to drive a car.

I would check out
The New Turning Omnibus .

It covers lots of great ideas in and around computer science without much code. Each chapter introduces some interesting idea, questions, and further reference. Overall quite a good read.

I read this one and thought it was pretty good. It's pretty simple and gets across the points fairly well and didn't feel overwhelming like some other books on the subject.

Having done an MEng at Oxford where I dabbled in ML, the 3 key texts that came up as references in a lot of lectures were these:

Pattern Recognition and Machine Learning (Information Science and Statistics) (Information Science and Statistics) https://www.amazon.co.uk/dp/0387310738/ref=cm_sw_r_cp_apa_i_TZGnDb24TFV9M

Machine Learning: A Probabilistic Perspective (Adaptive Computation and Machine Learning Series) https://www.amazon.co.uk/dp/0262018020/ref=cm_sw_r_cp_apa_i_g1GnDb5VTRRP9

(Pretty sure Murphy was one of our lecturers actually?)

Bayesian Reasoning and Machine Learning https://www.amazon.co.uk/dp/0521518148/ref=cm_sw_r_cp_apa_i_81GnDbV7YQ2WJ

There were ofc others, and plenty of other sources and references too, but you can't go buying dozens of text books, not least cuz they would repeat the same things.
If you need some general maths reading too then pretty much all the useful (non specialist) maths we used for 4 years is all in this:
Advanced Engineering Mathematics https://www.amazon.co.uk/dp/0470646136/ref=cm_sw_r_cp_apa_i_B5GnDbNST8HZR

If you liked “Code” I suggest you read his
“Annotated Turing” next --
fascinating paper, fascinating book.

The Singularity Is Near. Not sure why you're asking it in this forum, but it wouldn't mess with my theology at all, and I would welcome it as a blessing.

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

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

Read a book that approaches computer architecture from an implementation prospective, something like Digital Design and Computer Architecture

Take something relatively simple and like RISCV and read the ISA spec.

Using this spec figure out what state the machine defines. What registers must you keep track of in order to be ISA compliant. Implement the basic machine state.

Figure out what you need to do to implement specific operations. What information is encoded in all the fields of the instruction. What state is modified. Like for ADDIU: what does it mean to add unsigned add immediate, where is the immediate stored, what register do you read, what do you write? Implement a single instruction.

Writes tests, start implementing more of these operations. Learn about the rest of the ISA features (memory handling, exceptions). Implement this is any language. Try running small hand written assembly programs in your simulator, try larger programs.

I am pretty similar to you in that I have a weak math foundation while being a computer scientist. For me it was just simply a lack of taking classes that I now feel I should have taken. Over the years since college I have been picking up random things as a pro and hobbyist. Here was something major I did to pick up 3D math quick (2-3 weeks):

3D Math Primer. I read through this, and implemented everything that I could in code. I created a Generic and highly param-based (i.e. n-dimensional) C# math library that has classes for Vector, Matrix, Complex Numbers, Quaternions, as well as a bunch of general math functions. (edit: Don't just read that book and expect to pull everything off, you should find yourself tearing through wikipedia entries for vector/matrix/etc and google results to get those classes packed full of cool methods, but that book was the root of everything relevant to my library).

I highly recommend this approach for programmers that feel they're lacking in math as it is fast, it works, and you end up with a math library that's probably better than anything readily available to you that you can use in your games.

I should also mention that the more you read in this field of CS (physics books for gamers, rendering books, etc), the more you'll get used to esoteric looking math equations.

Yes and no. If you're asking these questions you'll probably be very interested in Claude Shannon's work. Take a read of his seminal information theory paper: http://cm.bell-labs.com/cm/ms/what/shannonday/shannon1948.pdf

For an easy read and a fun intro take a look at "The Information: A History, A Theory, A Flood":
https://www.amazon.com/Information-History-Theory-Flood/dp/1400096235/

Training == infer the parameters for the model, given the data. That's the learning bit basically. The idea isn't new, the stats people have been doing this for ages. It's just that in the recent two decades, computer science has somehow stumbled onto the same direction too after we realise that constructing AI by formal rules don't work well. Since you already know how to construct econometric models, you already have a headstart compared to most CS people who want to learn this stuff :P

One of the 'bible' in the field is Pattern Recognition and Machine Learning, which can be quite dense for many people. I prefer this book: Machine Learning: A Probabilistic Perspective, which is much friendlier for self-study. You can also find both books online as PDF after some searching hehe. But really the best way is doing by practice. Grab some public data and just do stuff with them. Also join this sub /r/machinelearning and /r/dataisbeautiful.

Edit: grammar

You should look for highly rated books in the subject you're interested in to get an idea of what you might want to learn. This information will generally be contained either in the preface or introduction chapters. Some books also contain appendices with maths background they think a reader needs. For example in Machine Learning: A Probabilistic Perspective under Preface > Target Audience:

> This book is suitable for upper-level undergraduate students and beginning graduate students in
computer science, statistics, electrical engineering, econometrics, or any one else who has the
appropriate mathematical background. Specifically, the reader is assumed to already be familiar
with basic multivariate calculus, probability, linear algebra, and computer programming. Prior
exposure to statistics is helpful but not necessary.

and in Pattern Recognition and Machine Learning the introduction says

> Knowledge of multivariate calculus and basic linear algebra
is required, and some familiarity with probabilities would be helpful though not essential
as the book includes a self-contained introduction to basic probability theory.

as well as in the appendix

> Appendix A Data Sets 677
>
> Appendix B Probability Distributions 685
>
> Appendix C Properties of Matrices 695
>
> Appendix D Calculus of Variations 703
>
> Appendix E Lagrange Multipliers 707

Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.

edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.

edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.

edit: Updated up to redline6561

• 14 The C Programming Language
  
• 11 Structure and Interpretation of Computer Programs
  
• 8 Introduction to Algorithms
  
• 7 Compilers: Principles, Techniques and Tools
  
• 6 Programming Erlang
  
• 5 The Mythical Man-Month
  
• 5 The Pragmatic Programmer
  
• 5 Applied Cryptography
  
• 4 Beautiful Code
  
• 4 The Little Schemer
  
• 4 Programming Perl
  
• 3 Types and Programming Languages
  
• 3 Gödel, Escher, Bach
  
• 3 OpenGL Programming Guide
  
• 3 Code Complete
  
• 3 Artificial Intelligence: A Modern Approach
  
• 3 Programming Pearls
  
• 3 ANSI Common Lisp
  
• 3 A Brief History of Time
  
• 3 Agile Web Development with Rails
  
• 3 Concrete Mathematics: A Foundation for Computer Science
  
• 3 Modern Operating Systems
  
• 3 Paradigms of Artificial Intelligence Programming
  
• 3 Operating System Design and Implementation
  
  

I was in the same position like you. I tried all the various sources. but the explaination in the 'Data Structures and Algorithms in Java' book helped me lot to understand all the data structure and algorithm very clearly.

​

Tip:

• Read about one algorithm or data structure topic.
  
• close the book
  
• Now try to write the same program on paper. (not on a laptop)
  
• Notice the places where you stuck during writing a program.
  
• Open the book and compare your code with code in the book and see your mistake.
  
• Repeat till you write correct program without any help.
  
  ​
  
  This way you will improve super fast.
  
  ​
  
  Book link:
  
  https://www.amazon.com/Data-Structures-Algorithms-Java-2nd/dp/0672324539

This question goes beyond the scope of a reddit post. Read a book like Code by Charles Petzold, or a textbook like Computer Organization and Design or Introduction to Computing Systems.

In the meantime you can look at things like datapaths which are controlled by microcode.

This question is usually answered over the course of a semester long class called "Computer Architecture" or "Computing Systems" or something like that, so don't expect to understand everything right away.

Anything can be self-taught if you're determined enough. Buy a good book on algorithms (http://www.amazon.com/Introduction-Algorithms-Second-Thomas-Cormen/dp/0262032937) and watch http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-046j-introduction-to-algorithms-sma-5503-fall-2005/. That book is definitive, so if you finish it and learn it, it's all you'll really need to get ahead of most programmers.

In terms of math, you'll pick it up. Recursive and Big-O notation were surprisingly easy to understand after watching a few lectures, not even looking at the book.

he lost me when he said this about GEB
> If you only read one book on this list, it should be this one.

seriously? it's not that i don't appreciate the sentiment, but things douglas hofstadter thinks are neat is no substitute for any single book on the rest of the list unless you

• have no other way to explain at cocktail parties what you studied at school
  
• try to sound smart at cocktail parties by talking about things in GEB without actually referencing the book.
  
  for my part, i'd add sipser's computation book and why not throw in some ken thompson in there as an amuse bouche?