> # Teach Yourself Computer Science
>
>
>
> If you’re a self-taught engineer or bootcamp grad, you owe it to yourself to learn computer science. Thankfully, you can give yourself a world-class CS education without investing years and a small fortune in a degree program 💸.
>
> There are plenty of resources out there, but some are better than others. You don’t need yet another “200+ Free Online Courses” listicle. You need answers to these questions:
>
> - Which subjects should you learn, and why?
> - What is the best book or video lecture series for each subject?
>
> This guide is our attempt to definitively answer these questions.
>
> ## TL;DR:
>
> Study all nine subjects below, in roughly the presented order, using either the suggested textbook or video lecture series, but ideally both. Aim for 100-200 hours of study of each topic, then revist favorites throughout your career 🚀.
>
>
>
>
>
> Subject Why study? Best book Best videos Programming Don’t be the person who “never quite understood” something like recursion. Structure and Interpretation of Computer Programs Brian Harvey’s Berkeley CS 61A Computer Architecture If you don’t have a solid mental model of how a computer actually works, all of your higher-level abstractions will be brittle. Computer Organization and Design Berkeley CS 61C Algorithms and Data Structures If you don’t know how to use ubiquitous data structures like stacks, queues, trees, and graphs, you won’t be able to solve hard problems. The Algorithm Design Manual Steven Skiena’s lectures Math for CS CS is basically a runaway branch of applied math, so learning math will give you a competitive advantage. Mathematics for Computer Science Tom Leighton’s MIT 6.042J Operating Systems Most of the code you write is run by an operating system, so you should know how those interact. Operating Systems: Three Easy Pieces Berkeley CS 162 Computer Networking The Internet turned out to be a big deal: understand how it works to unlock its full potential. Computer Networking: A Top-Down Approach Stanford CS 144 Databases Data is at the heart of most significant programs, but few understand how database systems actually work. Readings in Database Systems Joe Hellerstein’s Berkeley CS 186 Languages and Compilers If you understand how languages and compilers actually work, you’ll write better code and learn new languages more easily. Compilers: Principles, Techniques and Tools Alex Aiken’s course on Lagunita Distributed Systems These days, most systems are distributed systems. Distributed Systems, 3rd Edition by Maarten van Steen 🤷‍
>
> ## Why learn computer science?
>
> There are 2 types of software engineer: those who understand computer science well enough to do challenging, innovative work, and those who just get by because they’re familiar with a few high level tools.
>
> Both call themselves software engineers, and both tend to earn similar salaries in their early careers. But Type 1 engineers grow in to more fullfilling and well-remunerated work over time, whether that’s valuable commercial work or breakthrough open-source projects, technical leadership or high-quality individual contributions.
>
>
>
> Type 1 engineers find ways to learn computer science in depth, whether through conventional means or by relentlessly learning throughout their careers. Type 2 engineers typically stay at the surface, learning specific tools and technologies rather than their underlying foundations, only picking up new skills when the winds of technical fashion change.
>
> Currently, the number of people entering the industry is rapidly increasing, while the number of CS grads is essentially static. This oversupply of Type 2 engineers is starting to reduce their employment opportunities and keep them out of the industry’s more fulfilling work. Whether you’re striving to become a Type 1 engineer or simply looking for more job security, learning computer science is the only reliable path.
>
>
>
>
>
> ## Subject guides
>
> ### Programming
>
> Most undergraduate CS programs start with an “introduction” to computer programming. The best versions of these courses cater not just to novices, but also to those who missed beneficial concepts and programming models while first learning to code.
>
> Our standard recommendation for this content is the classic Structure and Interpretation of Computer Programs, which is available online for free both as a book, and as a set of MIT video lectures. While those lectures are great, our video suggestion is actually Brian Harvey’s SICP lectures (for the 61A course at Berkeley) instead. These are more refined and better targeted at new students than are the MIT lectures.
>
> We recommend working through at least the first three chapters of SICP and doing the exercises. For additional practice, work through a set of small programming problems like those on exercism.
>
> For those who find SICP too challenging, we recommend How to Design Programs. For those who find it too easy, we recommend Concepts, Techniques, and Models of Computer Programming.
>
>
>
> [Structure and Interpretation of Computer Programs](https://teachyourselfcs.com//sicp.jpg)
>
>
>
> ### Computer Architecture
>
> Computer Architecture—sometimes called “computer systems” or “computer organization”—is an important first look at computing below the surface of software. In our experience, it’s the most neglected area among self-taught software engineers.
>
> The Elements of Computing Systems, also known as “Nand2Tetris” is an ambitious book attempting to give you a cohesive understanding of how everything in a computer works. Each chapter involves building a small piece of the overall system, from writing elementary logic gates in HDL, through a CPU and assembler, all the way to an application the size of a Tetris game.
>
> We recommend reading through the first six chapters of the book and completing the associated projects. This will develop your understanding of the relationship between the architecture of the machine and the software that runs on it.
>
> The first half of the book (and all of its projects), are available for free from the Nand2Tetris website. It’s also available as a Coursera course with accompanying videos.
>
> In seeking simplicity and cohesiveness, Nand2Tetris trades off depth. In particular, two very important concepts in modern computer architectures are pipelining and memory hierarchy, but both are mostly absent from the text.
>
> Once you feel comfortable with the content of Nand2Tetris, our next suggestion is Patterson and Hennesy’s Computer Organization and Design, an excellent and now classic text. Not every section in the book is essential; we suggest following Berkeley’s CS61C course “Great Ideas in Computer Architecture” for specific readings. The lecture notes and labs are available online, and past lectures are on the Internet Archive.
>
>
>
>
>
> ### Algorithms and Data Structures
>
> We agree with decades of common wisdom that familiarity with common algorithms and data structures is one of the most empowering aspects of a computer science education. This is also a great place to train one’s general problem-solving abilities, which will pay off in every other area of study.
>
> There are hundreds of books available, but our favorite is The Algorithm Design Manual by Steven Skiena. He clearly loves this stuff and can’t wait to help you understand it. This is a refreshing change, in our opinion, from the more commonly recommended Cormen, Leiserson, Rivest & Stein, or Sedgewick books. These last two texts tend to be too proof-heavy for those learning the material primarily to help them solve problems.
>

> (continues in next comment)

Android team lead here, I've been working with Android commercially since 2009 (before Android 2.0 was released) and have worked at, or done work for, some big companies (Mozilla, Intel, Google, HTC...). I was in a very similar situation to you in that I was a web development and was bored, I'd been playing with Android in my spare time; I got my first break by volunteering to do an android app at the company I worked for, and went from permanent employee to contractor fairly quickly after that and have been doing it ever since.

First thing to say is that if you can get your currently company to pay you to learn android and stay with them, that's a win win for both parties (you get to learn something new without a drop in salary and don't have to interview and they don't lose a good member of staff).

In terms of moving company, I don't know where you are based, but here in the UK I often see junior Android contract roles coming up for £200-300 a day. Failing that it's just a case of applying for lots of poisitions and really knowing your stuff.

What I would look for in a junior is to have read, understood and put in to practice Clean Code (https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) and Design Patterns (https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124). I would expect you to have a good understanding of basic Java and OOP; a working understanding of MVP or MVVM (https://news.realm.io/news/eric-maxwell-mvc-mvp-and-mvvm-on-android/, https://www.linkedin.com/pulse/understanding-difference-between-mvc-mvp-mvvm-design-rishabh-software); understand threading; know about all the major parts of Android (Services, Broadcast receviers, Activities, Fragments etc); know how to write a custom view; be able to efficiently design a layout in XML and correctly apply styles and themes; understand the support libraries - what they contain, why they exist and what they are used for (and also when you don't need them); understand the difference between unit testing and integration testing and know what makes for a good test; the Gradle build system is a really nice way of defining your project build - knowing the fundamentals is essential.

A few of the main libraries I'd expect you to know and have used would be OkHttp (https://github.com/square/okhttp), Retrofit (https://github.com/square/retrofit), Butterknife (https://jakewharton.github.io/butterknife/), Picasso (https://square.github.io/picasso/) or some other image loading library, GSON (https://github.com/google/gson) or Moshi (https://github.com/square/moshi) or some other json parsing library

If you want to level up then there are loads of advanced topics surrounding Android. Any of these following topics will take a while to learn, but will be worth it and will look good in interviews and on you CV:

• RxJava (http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/) - This is the new hotness in the mobile world (including iOS) at the moment. Version two of rxJava has just been released and knowing this will probably land you a job super quick.
  
• Dagger (https://www.youtube.com/watch?v=Qwk7ESmaCq0) - Dependency injection library. I actually find it super confusing to setup because of some overloaded annotations and lack of clean documentation, but lots of places use and expect you to know it, so it'd be a good idea to at least get a basic understanding of it.
  
• Kotlin (https://developer.android.com/kotlin/resources.html) - The new Android language - not many places are using in production but learning it now would be a great way to invest in the future (and it's fun)
  
• Clean Code architecture (https://fernandocejas.com/2014/09/03/architecting-android-the-clean-way/, https://fernandocejas.com/2015/07/18/architecting-android-the-evolution/, https://github.com/android10/Android-CleanArchitecture) - A great architecture that I use in my current projects - being able to mention this and talk about it would super impress me from someone with your experience.
  
• An understanding of different architectures (https://github.com/googlesamples/android-architecture) - A great resource for learning, it's a simple todo app but build in lots of different ways
  
• Room & the other new Android architecture libraries they've recently announced (https://developer.android.com/topic/libraries/architecture/index.html)
  
  There's so much more - this is a large topic and it's easy to feel overwhelmed (I know I did & do) but the sheer amount of stuff to learn, but take it slowly and it'll come. The best way that I found to learn all of this stuff is to have a personal project which I was working on (I started doing an app which teaches you how to play guitar - never released it but learned so much). Get the fundamentals down and them start looking at some of the more advanced things. A good test app would be to write a Reddit client (they have open APIs: https://www.reddit.com/dev/api/) - this will get you up to speed on networking, background services (to poll the API to see if you have any messages) etc
  
  Let me know if this helped or if you want to chat about stuff. Happy to help.

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

Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.

Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.

To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above

What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)

How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.

What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.

All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.

Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!

Oh god where to begin?

***

Well I Like to think there are level of programming understanding that are relatively tiered.

Tier 1 - How to Code

***
This one is tough as there is no real definitive best answer. My personal primer of choice is

• Sams Learn Java in 24 hours.
  
  > Fyi - , that is not "in one day" that is , in 24, 1 hour sessions equating to a hypothetical 4 college lectures a week lasting a month and a half of intensive training. A huge amount of homework is required to accompany that primer.
  
  so now you can write an app, what next? well. to finish the thought:
  
  
  

  Tier 2 - How to Code...
  

  so other programmers don't want to hit you over the head for each line in your longest function screaming CYCLOMATIC COMPLEXITYYYY
  
  **
  
  Here we talk about how to program properly* You want to be looking up Uncle Bob . Head over to
  
  

• www.cleancoders.com
  
  and check out his video form of his famous book:
  
  
• Clean Code....then buy that book.
  
  Now you should be writing code that doesn't make other programmers eyes bleed.
  
  

  Tier 3 - How to Code..To Solve Problems
  

  ***
  Here we talk about design patterns. Now, you will bump into a lot of debate over their value but...that is stupid. that is like some people saying all carpentry should be done with a saw and another group saying carpenters should never use a saw. Design patterns are names for recognised ways to solve problems you will hit every day in your programming. They may not always work in your case but at worst they will have you thinking around a problem better.
  
  For a primer, check out:
  
  

• Head First: Design Patterns
  
  In fact the entire head first series is great, It is like the For dummies series for programming principles. Great for morons like myself.
  
  With that read, get the real design pattern book:
  
  
• Elements of Reusable...
  
  Don't expect to actual understand almost any of this. I read that book cover to cover and it didn't actual click for me till it slapped me in the face when i was in the real world developing business tier applications. Although having read it so many times meant I new which pages to flip to when I was ready.
  
  

  Tier 4 - How to Code... For Users
  

  ***
  
  This is a whole different kettle of fish. Now you may have written the perfect app to do X with only two buttons, you will find quickly that users are adept at licking the buttons in just the correct order to cause your application to explode. You need to program applications so the cast of jersey shore can use it.
  
  I am a fan of the blog:
  
  

• Joel on Software.
  
  Joel (Co-founder of Trello) covers a lot regarding front facing applications and UX that is required reading...even if he a bit cavalier on his approach to testing.
  
  This is the next part. Testing. You are going to want to Learn about Defensive Programming andTesting. There is a wealth of tutorials over on pluralsight for these.
  
  

  Tier 5 - When NOT to Code
  

  
  **
  
  This is a hard step to get to. Realising that copy and pasting code is GREAT!..but for the right reasons. Once you jump over the initial Copy+paste = the greatest thing in the world barrier , most developers grow a level of defiance that borders on the absurd. Preferring to rewrite the wheel instead of using ...the wheel. When you can honestly say you could* program it from scratch, it is perfectly okay to use libraries and apis.
  
  This is where I go to:
  
  

• www.codeproject.com
  
  and hit up Sacha and others. They show you fairly feature complete and interesting implementations of problems, not just the one or two lines you get from Stack Overflow. Granted this is miles more complicated but it shows not only how to do it, but how to do it right and WHY to do it right. and github of course.
  
  

  Tier 6 - Learning From Mistakes
  

  ***
  
  Now that you have climbed code mountain and are absorbing the combined knowledge of all the internet geniuses, it is time to see where you went wrong.
  
  Head over to
  
  

• http://codereview.stackexchange.com/
  
  and post you functional applications. There a number of people will politely tell you not...how but how to do it better, general improvements in design, logic and reusability. take you through the solid principles and much more. Also..say hello to me if you like :P.
  
  You don't even have to learn exclusively from your own mistakes.
  
  check out:
  
  
• www.thedailywtf.com
  
  and cringe at some examples of real software....and if you don't understand why you should be cringing..learn.
  
  ***
  
  

  Tier 7 - How to think like a programmer
  

  
  Now things get a little bit meta. The best way to become a great programmer? don't JUST read programming. Read books like:
  
  

• Zen and the Art of Motorcycle Maintenance
  
  
• Don't Make Me Think
  
  Read anything and everything, exercise your mind. books on architecture, books on carpentry. any kind of design and problem solving with stretch your understanding of how to climb those brick walls you will hit.
  
  Read some of the more general programming blogs, like:
  
  
• http://blog.codinghorror.com/
  
  Read anything and everything.
  
  

  Final Thoughts
  

  ***
  
  Have fun.
  
  Check out:
  
  

• www.commitstrip.com
  
• www.xkcd.com
  
  and..well..here.
  
  I would also say as a personal suggestion, although i left it out of the mandatories up above as it is a bit controversial, I suggest going TDD. Test driven development. It is not for everyone, a hard ethos to get into but in the real world, in business applicable coding...a life saver. Uncle bob is the man for that again.
  
  Finally I am a fan of Rubber Ducking. Great way to work though problems.
  
  If you want some final reading, I left them out because everyone and their brother has these (and most of the above) in their top 50 programming book lists so it is a mite redundant:
  
  
• Code Complete
  
• The Mythical Man Month
  
• The Pragmatic Programmer
  
• Refactoring: Improving the Design of Existing Code
  
  ***
  Enjoy.
  
  
  
  

The usual advice is "get out and program!" and that works, but it can be very tricky coming up with something to write that's also satisfying. The idea is that you learn best by doing, and that many topics in programming can't really be learned without doing. All that stuff is true and I'm not denying that at all, but some of us need more. We need something juicier than spending hours configuring a UI for a project we couldn't care less about. It shouldn't be an exercise in masochism.

I guess what I'm saying is that there are a lot of ways to learn to write code and books are great if you can really sink your teeth into them (a lot of people can't). Code Complete is a great book on the practice of programming. You also say that you "get" OO pretty well, but it might open your eyes to read up on design patterns (e.g., Head First Design Patterns). You have a long way to go before you really get it

In addition to those, you could delve deeper into your languages of choice. There's no way around JavaScript if you're a web programmer, and a book like JavaScript: The Good Parts is pretty enlightening if you've got some experience in JavaScript already. It's a pretty interesting and unusual language.

But sometimes programming is about building gumption, so instead of just being practical, try to figure out what you like about computers and keep going deeper into it. If you have an interest in computer science and not in just building apps, then something like Structure and Interpretation of Computer Programs could instill in you an enthusiasm for computers that trickles down to everything else you do. If you're more interested in web design, there are probably similarly interesting books on artistic design principles.

I think what I'm ultimately saying is that you should find what you enjoy doing and just go deeper down the rabbit hole, getting your hands dirty when it's appropriate and interesting.

Heh, sure.

A lot of people are fans of Code Complete. I tried reading it after being in industry for a decade, and I found it to be very dry and boring. The general consensus from people that I've talked to is that it's more useful when you're just starting out. Maybe I just came to it too late.

A better book (in my opinion) in that same vein is Clean Code. Clean code is shorter, more focused, and has better real-world examples. It feels less "complete" (hue hue) than Code Complete, but to me, that's a strength. As a quick point of comparison: Code Complete devotes 32 pages to the chapter on identifier naming; Clean Code devotes just 14.

I got a lot out of Design Patterns. I seem to recall that the pattern fad was in full swing back when I read this in 2005-ish. I think I had independently discovered some of the patterns already at that point, but this book helped me to codify those ideas and also showed me some new ones. Some of these patterns are now seen as antipatterns (I'm looking at you, Singleton!), and all of the patterns have an object-oriented bias. But there's still something useful in the pattern language, and this book is a reasonably comprehensive start. The book is somewhat dry, and some people report that Head First Design Patterns is a gentler and friendlier introduction. Head First Design Patterns hits the essential patterns, but misses a lot of the less popular ones.

Eventually, you'll need to work in a codebase with some technical debt. Maybe it's debt that somebody else put there, or maybe it's debt that you introduced. Working Effectively with Legacy Code is still my go-to recommendation. It defines technical debt as code that is not under test, it introduces the idea of "seams" that you can use to pry apart code that's too tightly coupled, and it then provides a cookbook of specific scenarios and reasonable approaches.

If you're looking for thought-provoking videos, I recommend anything by Rich Hickey. I don't know if I've watched all of those, but I remember good things about Hammock Driven Development and especially Simple Made Easy.

Get comfortable with a source control system. I didn't use source control in college, since it wasn't needed for any classes, and that was a missed opportunity. The whole world loves Git, so you'll probably want to learn it if you haven't already. But I'll also toss out a recommendation for Mercurial. I haven't used it in years, but I remember finding it to be quite good.

Good luck!

OK. ModernRonin did a great job. Read his first. Also I'd like to put out the theory that you didn't receive many replies on /r/programming because that is typically a forum for high-level programming, not down-in-the-metal like this.

I've done this plenty of times, and let me tell you from experience, it can be done on the cheap, and pretty easy. Where ModernRonin provided specific answers, I'll try to provide examples of how it might work.

Something like this:

Temp Sensor --> Sensor control board --> PC.

The link between temp sensor and the board is probably I2C (eye-squared-see) or serial port. If it's serial port, you can technically skip the control board directly to the PC. If you're PC doesn't have a serial port (a 9-pin port that looks like a monitor plugin), then you'll have to buy this, which provides a serial port over a USB connection. If you manage that, then you can move on to adding other sensors to the control board. Typically, these extra sensors will all communicate with the control board, which then relays the data all at once to the PC.

Dont' worry about accessing ports, concentrate on the connections (I2C or USB? Serial or Xbee?), then learn how to access what you have.

Start with the control board, I'd recommend something pre-built like an adruino. Then build your own after a month or so. It's so easy you'll never believe it.

"Choosing" ports won't be an issue, each has a purpose, and typically you won't have a lot of flexibility.

Accessing ports is easy. Start with a terminal program. Realterm is the shit. Be friends with it. It'll dump anything coming in over a serial port, which makes debugging really easy.

Most programs will handle accessing the port for you. However, if you want to build your own program (and you will, probably), you'll have to learn how to do this with code. Luckily, libraries will exist to help you, and you won't be inventing anything so much as tweaking pre-existing examples.

Now the hard part is getting the control board set up. This is where people get frustrated and give up. That's why I strongly recommend paying money for this part. The control board will probably be something like an ardruino. I prefer using Microchip's sample program, which gives you access to cheap chips (but you have to know something about laying out a board).

Once you get this down, you can start building your own sensors if you want. Most control boards will have ADC and DAC which will help you with that. However, you probably will NEVER have to build a sensor.

OK. now a list of literature to get you started.

Programming Interactivity

making things talk -- the BEST book for beginners. I loved this book. If I still had my copy I'd mail it to you right now.

Practical Ardruino

And web sites:

Sparkfun -- hobbyist electrical engineering with tutorials

Microchip -- sign up for their free samples when you want to build your own boards

http://www.arduino.cc -- Excellent Beginner Boards

http://beagleboard.org -- Higher level control board, suitable for larger (but still small) embedded projects

Digikey -- catch-all supplier of all things electrical

Oh finally, do send me an msg if you have specific questions.

You may have to look up some of the terms in my reply and I apologize but, hey, you'll learn something.

I recommend Python, for the simple reason that Python manages to integrate several paradigms in one programming language (imperative, object-oriented, and functional) and a lot of what you learn with Python will carry over into other languages if you learn it deeply enough. E.g. Python has metaclasses which I believe were originally implemented in an older language called Smalltalk and so when I went over to experiment with Smalltalk (I like the Pharo implementation), it was no sweat understanding the idea of metaclasses.

Python also prepares you to read the kind of pseudocode you'll see on Wikipedia and in a lot of textbooks because Python reads a lot like pseudocode; it is an eminently readable language and actually enforces formatting conventions for clarity.

And should you decide to do a big advanced project, there are very frequently well-developed libraries available immediately available for your purposes, which is not an advantage you will get with some of the more obscure / less-used languages mentioned here.

For example, need to do machine learning? No problem! There's PyBrain.

Need to study complex graphs? No problem! There's NetworkX. (If you live in the United States, it's your taxpayer dollars at work, so enjoy.)

Need to do genetic algorithms? No problem! There's PyEvolve.

There's even a package for proving theorems in logic, FLiP.

Ruby comes recommended for similar reasons and has a purer object-oriented basis but (in my experience) fewer good libraries.

I have to disagree with several recommendations here: Lisp has been recommended in several posts and I have doubts about how much of a better or effective programmer it makes you; the evidence for such a claim is unclear and pretty much all anecdotal. And a lot of it is based on stereotypes about marginally competent enterprise Java programmer-types. Now that a number of programming languages have taken Lisp innovations like garbage collection and lexical closure to heart, there's not that much of an advantage anymore in Lisp. (IMO.) More to the point, I find that neither any implementation of Common Lisp nor Scheme enjoy quite the same support as Python.

For instance, even though Lisp has a reputation for being used widely in artificial intelligence, the AI libraries I can find for Common Lisp are relatively underdeveloped compared to those you can find for Python. For instance, in the case of soft computing methods in AI (which IMO are far more promising than logic-based approaches), between PyBrain and PyML you've got neural networks, SVM, reinforcement learning and more whereas I could only find fledgling projects like cl-machine-learning for Lisp, which apparently hasn't been worked on since 2009. (The Lisp community is notorious for not finishing projects once started.)

If you must use Scheme, I highly recommend Racket because it appears to be the most full-featured Scheme. (That's a major issue with Scheme: the standard specifies very very little and so the differing implementations tend to be kind of incompatible. One says that Scheme suffers from horrible "balkanization".)

Logo was mentioned, too. The NetLogo implementation is good for fast agent-based programming and a few other things (I found it highly useful for writing a Kohonen network implementation because of its inherently spatial character) but Logo as a language is not that great.

Prolog IMO is fucking terrible. Using it is like pulling your own teeth.

Pure functional programming languages like Haskell are kind of wanky as well. It's usually rather difficult to do anything useful with them because they disallow side effects completely but on the other hand, since you're interested in logic and computation, you'll get a lot of exposure to theoretical computer science ideas through these kinds of languages.

Bottom line is with Python you'll probably get more work done faster and have more fun that way too. And that's what counts.

One last note: I don't like SICP. Go on Amazon and look at some of the negative reviews to see what I mean. I can't exactly say what's a good intro to computer science because I'm well past that point now but this guy appears to come warmly recommended:

http://www.amazon.com/Python-Programming-Introduction-Computer-Science/dp/1887902996

And when you're a little more advanced, and want to dive into data structure and algorithms, the Segdewick "Algorithms" book is excellent, even if it uses Java for all the code:

http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X

I say this all the time, but: Who would have thought that in the 2012, the greatest OS war of our day would still be BSD vs SystemV (iOS vs. Android)?

Generally, a focus in Windows is going to take you into corporate IT, building internally-oriented tools to support organizations. Here you'll want to learn bout VMWare, the full Microsoft stack, and look closely at tools designed for Enterprise support. There's less demand in this arena for nix, but also less chance to make a real impact on the world. Sure, there's something to be said for helping maintain the compute clusters inside of banks, or using Altiris or similar tools to manage hundreds of desktops for gigantic offices. I've done this myself, but I didn't have very much fun.

For my money, where you want to be is in web operations, building the systems that drive popular websites. Think about Instagram, Etsy, Netflix, companies that move enormous amounts of data around on the cheap, with relatively tiny staff. Read the blogs by the infrastructure team behind Etsy, and you'll realize quickly that these guys are geniuses.

Here you'll want to learn about how to interact programmatically with cloud compute providers, such as Amazon AWS, Rackspace Cloud, and the OpenStack providers that are starting to pop up, like HP. (A cloud provider is generally not just virtualization, but virtualization coupled with an API. It may sound small but it's a big difference!)

Here's some reading: If you want to learn a lot about nix operating systems, check out The Armadillo Book and The Practice of System and Network Administration.

If you're interested in learning web operations-oriented sysadmin, which is a VERY interesting place to be, also check out The Art of Scalability -- well, the first 2/3 anyway -- and the followup book, 50 Scalability Rules.

And especially, especially read and understand this, because there won't be many web-oriented companies still in business by 2014 that don't follow this process: Continuous Delivery.

Good luck! You picked a GREAT time to get started in the industry. The 00's were pretty boring by comparison. :)

EDIT: I KAN SPEEL

First of all, applause for the great start.

Here are some criticisms/suggestions I would like to offer. Keep in mind, I am not assuming your level/experience as a software developer:

1. Functions with smaller size. You see, most of the functions that you have written is lengthy because of the sql statements. Here comes my second point.
   
   
2. Separate business logic, application code, data storage related stuff etc. Keep things modular. That separation is important because you want things to be maintainable and reusable. Your code should be open for extension, but close for modification. If that does not make sense to you, that's perfectly fine, just start from this
   
   
3. On that note, since you are using flask, might I suggest using flask-sqlalchemy instead of sqlalchemy? You may like it better. I know you have mentioned
   
   > I force myself to write raw SQL Request to get better with SQL
   
   while that is commendable, it is not really a good idea to write raw sqls in production code if there are ORM library alternatives available. Remember, it's not always you that is going to read/modify the code. While ORM syntax will be fairly universal, your style of writing SQL may vary starkly from other people - which is what creates confusion and lets errors sneak in. Even if you want to do that, maybe keep the raw sql in separate modules (point 2).
   
   
4. Instead of computing everything and then sending the result along with the page, maybe create api endpoints for specific sections; render page with bare minimum info and from the webpage make multiple calls to update the page sections when required. This way, it will be far more responsive, user will not be waiting for you to finish all the computation and if you detect any change in any section of the page, you can just update that particular section with an appropriate api call, thereby avoiding a whole page reload. Design choices.
   
   
5. PEP8. You don't have to blindly follow every rule - just make sure you understand why those rules are there, and that if you are breaking any, you know that it is absolutely necessary for accomplishing what you want. Again, what you want may not always be what you actually need - so be really careful.
   
   
6. This is something I wish I knew earlier - Design Patterns. Without going into much details, I would recommend reading these books to start with and really understand instead of memorizing:
   
   • Head First Design Patterns
     
   • Clean Code - focused more on java, but you'll get the ideas are pretty much language agnostic
     
   • Fluent Python
     
     
7. Documentation is also important. Follow the good practices there. A remarkable reference would be Ken Reitz's Requests library.
   
   Finally, remember that all these are just suggestions, and you may already know them. You will decide which ones to take and which ones to leave behind based on your situation.
   
   Again, great job (I also learnt something from this). Just make sure you keep running.

Ah, the age-old Drexel CS department dilemma...

tl;dr: Dr. Boady all the way if at all possible.

I've TA'd this course numerous times with numerous different instructors, including one term where I was assigned to both Dr. Nowak and Dr. Boady's sections of the course at the same time. It was kind of rough because whenever someone approached me to ask for help with the homework or go over a quiz or project, I'd have to remember to ask whether they had Boady or Nowak as the two versions of the course are very different while still ultimately covering the same material. I've also helped CS260 students in both Nowak's version and everyone else's version of the course in terms in which I was assigned to other courses, so I'm familiar with the course as taught by various instructors and the differences among them.

I sort of mentioned this last paragraph, but there are basically two versions of the course: the Dr. Nowak version and everyone else's version. The "everyone else" version has been very much influenced by Dr. Boady's changes over the past few years, so it's sort of become Dr. Boady's version moreso than everyone else's version.

I want to be clear here: Dr. Nowak is good. If you have to take it with him, it's fine, it's just less user-friendly than the alternative. The thing with Dr. Nowak though is that the's very much an old-school mathematician, maybe even more so than he is a computer scientist. That's not necessarily a bad thing; CS260 is basically a math course (not as much of a math course as CS270, however). People often forget that computer science is a mathematical discipline.

Dr. Nowak is also very set in his ways, perhaps to a fault. I think Dr. Boady may have finally found a suitable replacement for the Aho DS&A textbook (would you believe that some unscrupulous people use a PDF of this book they were able to easily find for free on the Internet rather than actually buying this??) via zybooks, so maybe every version of the course will use that from now on (and then again maybe all versions will still use Aho), but Aho is a pain in a number of ways. I get the sense Nowak is very attached to Aho as the standard textbook for the course.

Nowak's version will go through the text material in a different order than Boady, but his reason for doing so makes sense. While Boady goes through the chapters in their presented order, the first week or two of Nowak's version will cover chapters 1 & 9, skipping the 7 chapters in between (you'll circle back to them, though). This is because chapter 1 is "Design and Analysis of Algorithms" and chapter 9 is "Algorithm Analysis Techniques," so the two chapters are closely related. However, the material in chapter 9 is a bit more complicated and challenging than what you'll find in the first few chapters, which is why the Boady version covers it later in the course.

Really, the two chapters should probably be merged, but like I said: Aho is kind of a pain sometimes.

Boady's version will have more of a programming focus than Nowak's course while Nowak will require more theoretical assignments (stuff like formal proofs, or finding closed form expressions of summations, etc.). Boady's will still have theory questions and Nowak's will still have programming assignments, but the emphasis on each is different.

I vastly prefer the Boady version of the course. This is due to a number of reasons that I'll get into, but in the interest of full disclosure, one of the biggest factors is that Dr. Boady and I work very well together and I feel like we're on the same wavelength a lot of the time. He and I go way back, and one might even say that we "roll mad deep" (no one has ever said this but please feel free to start).

Dr. Boady is also incredibly good at teaching. Like, in addition to his computer science research, he's spent time actively keeping up with the research on education. One thing I find he does the best is that his labs and assignments (I don't think there are "labs" for 260 but it's been awhile) have the questions presented in a very deliberate manner such that they build off each other as you go; if you follow the order of the problems/questions as assigned, they start easy and get incrementally more complicated based on the previous question (or questions) until you reach an item that would have seemed extremely difficult if you looked at it first, but you are well-equipped to understand and solve based on the questions/problems you've already handled.

In my experience, people find that Dr. Boady is much more approachable and easy to converse with compared to Dr. Nowak (or most people, really). Dr. Nowak is a nice person and all, but I've had a few kind of funny awkward interactions with him stemming from simple misunderstandings, but nothing that made me feel like he was trying to insult me or scare me away or whatever.

Finally, one of the most important things is that Dr. Boady is much, much closer to being in your position as a student. I don't know if this is common knowledge or anything, but he did his undergrad degree at Drexel, immediately entered the graduate program here, and started working as teaching faculty as soon as he finished his PhD. He's literally taken this very course, and he took it recently enough that he remembers what it was like to be on the other side of things. A problem that I often find with older professors in general is that they're too far removed from the time when they didn't know any of the material that they're now teaching and that they may have struggled to learn it themselves and what ultimately helped them understand. When I started here, Dr. Boady was just a grad student named Mark; he understands where most of his students are at because he was in the same position relatively recently.

Anyway, I'll wrap up: he's passionate about the material and passionate about teaching and he's always actively looking for ways to refine the way he teaches his courses each term.

...but Dr. Nowak has some cool idiosyncrasies. Like, he pronounces "algorithms" as "algoritmas" and refers to the elements of a proof as "ingredients," so if you take it with Boady, you'll miss out on that ¯\_(ツ)_/¯

Hope that helps.

EDIT: I counted the chapters incorrectly which is not great in a post giving advice on computer science or math courses.

The Stanford Algorithm book is complete overkill in my opinion do NOT read that book. That's insane. Read it when you've been doing programming for a while and have a grasp of how it even applies.

Here's my list, it's a "wanna be a decent junior" list:

• Computer Science Distilled
  
• Java/ C# / PHP/ JS (pick one)
  
• Do some Programming Challenges
  
• SQL
  
• Maybe build a small web app. Don't worry about structure so much, just build something simple.
  
• Applying UML: and Patterns: An Introduction to Object Oriented Anaysis and Design Iterative Development
  
• Head First Design Patterns
  
• Clean Architecture
  
• Refactoring: Improving the Design of Existing Code
  
• If you're interested in Web
  
• Soft Skills: Power of Habit , A Mind for Numbers , Productivity Project
  
  ​
  
  Reasoning: So, the first book is to give you a sense of all that's out there. It's short and sweet and primes you for what's ahead. It helps you understand most of the basic industry buzz words and whatnot. It answers a lot of unknown unknowns for a newbie.
  
  Next is just a list languages off the top of my head. But you can pick anything, seriously it's not a big deal. I did put Java first because that's the most popular and you'll like find a mountain of resources.
  
  Then after some focused practice, I suggest grabbing some SQL. You don't need to be an expert but you gotta know about DBs to some degree.
  
  Then I put an analysis book that's OOP focused. The nifty thing about that book, is it breaks into design patterns nicely with some very simple design patters to introduce you to design patterns and GRASP.
  
  Then I put in a legit Design Patterns book that explains and explores design patterns and principles associated with many of them.
  
  Now that you know how code is structured, you're ready for a conversation about Architecture. Clean architecture is a simple primer on the topic. Nothing too crazy, just preps you for the idea of architecture and dealing with it.
  
  Finally, refactoring is great for working devs. Often your early work will be focused on working with legacy code. Then knowing how to deal with those problems can be helpful.
  
  FINAL NOTE: Read the soft skills books first.
  
  The reason for reading the soft skills books first is it helps develop a mental framework for learning all the stuff.
  
  Good luck! I get this isn't strictly computer science and it's likely focused more toward Software Development. But I hope it helps. If it doesn't. My apologies.

>How valuable is an Oracle cert?

No more than any other online course from a respected institution such as google, say: https://cloud.google.com/training/free-labs/ or one of the online courses available at MIT/Stanford.

>What else should I look into to boost my repertoire?

See if your university has any business partnerships you could do a 2-3 month project for. I worked with one of the university's here in the UK as part of a business/university partnership and that gives the students real world experience and us some free work. Win-win if the project is completed.

Sorry - mostly UK (amazon) links :)

TDD - https://www.amazon.co.uk/Growing-Object-Oriented-Software-Guided-Signature/dp/0321503627/ref=sr_1_1, Video by Trisha Gee whos fairly well known for speaking on this stuff: https://www.youtube.com/watch?v=QDFI19lj4OM (some very handy shortcut keys in the video and a good outline of some of the tools available to you).

Clean Code - https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 (by "Uncle Bob")

Design patterns - https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1

Learn to use shortcuts in Intelli J to speed up your ability to generate/refactor code: https://www.amazon.co.uk/Getting-started-IntelliJ-Hudson-Assumpção/dp/1849699615/ref=sr_1_1

Also Jetbrains does good newsletters (curated by the same lady that made the video above under TDD) sign up to stay up to date with interesting/relevant blogs/articles/industry news https://www.jetbrains.com/resources/newsletters/

Github - https://www.amazon.co.uk/Version-Control-Git-collaborative-development/dp/1449316387/ref=sr_1_4

Bash Commands - https://nikgrozev.com/2016/05/22/shell-cheatsheet-part-1-common-bash-scripting-tmux/

XP/Scrum/Kanban development process - https://www.agilealliance.org/glossary/xp/ the way we work

Trusted developer blog on various engineering topics https://martinfowler.com/

Interview Prep https://www.hiredintech.com/courses

Hint: the above books are likely to be available at any academic library. If not, request them. you likely only need to read 33-50% of them and you'll be golden. I imagine you can likely get hold of electronic versions of these books as well.

The best thing you can do to prepare yourself is to start practising developing projects... get them up on github. it could be a website, a desktop application/game/tool, a demo of sorting algorithms, a web service... literally anything. Fork others' projects, code a feature request and create a pull request back to the original repository/codebase on github. Just build something rather than nothing. Anyone can do the latter. There's so much more opportunity now that we have github available. Think of any thing you might be interested in working on and someone, somewhere has likely already got a project underway in that area, and you're free to submit a pull request to their repository at the click of a button. This wasn't really possible 10-15 yrs ago.

The simple answer is there's so much to know, you just have to find what your interests/passions are and follow those as much as possible.

No matter how good you are at what you do today, the tools will be different tomorrow and may even depend on the industry you enter: AI, web services, blockchain, computer vision, robotics? The list is long and each one requires you to be highly trained (over many years) before you're considered any good at it.

Just try to learn what you can. Find something that genuinely interests you and study it until you become a trusted authority on the subject, or you find something you're more interested in instead.

If you have any ideas for the type of area you might be interested in put them up here and perhaps someone can point you to a relevant project?

https://en.wikiquote.org/wiki/Howard_H._Aiken "Don't worry about people stealing your ideas. If your ideas are any good, you'll have to ram them down people's throats."

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

Coding

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

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

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

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

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

Work Methodologys

Kanban

Succeeding with Agile


p.s

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

There are some key concepts you want to get down if you really want to make the most of .NET

• OO design and basic patterns
  Design patterns are used over and over again in OO based systems. A good understanding of what they are for, and how they tend to be used will be helpful when trying to understand key framework extensions and 3d party libraries. I like to point people at Head First Design Patterns. The opinions on design patterns in this book are a bit dated and the examples use Java syntax but they are all relevant to the .NET world and will go a long way to understanding how class names and object structures are used in OO systems.
  
  IMO One of the biggest concepts you'll need to understand in OO currently is the Inversion of Control pattern (also referred to as dependency injection) and the frameworks that provide it. Most modern .NET applications leverage some kind of dependency injection to simplify development and make unit testing and porting of classes easier.
  
  NOTE: I understand many folks in the PHP world feel that PHP is a full OO system. While they have made strides in this area it is not a fully typed OO system. It's a procedural system twisted to provide some OO features.
  
  
• Syntax
  This is easy, just review MSDN docs and samples. The biggest different you will see in the .NET world is a different opinion in general on casing of object and method names.
  
  
• Frameworks
  This is the part that seems the most overwhelming IMO. The language itself is fairly easy but understanding the huge amount of 1st and 3rd party libraries, frameworks and tools can be daunting. Since you come from the PHP world I am going to assume you are most interested in web based applications. What I would recommend is to pick a set of tools for your web stack and learn them. Once you understand the key pieces of a web application and how they interact you can start picking and choosing different components to meet your needs. I am going to suggest you start with the following stack to get started with a web application, this is the same stack I use for most of my clients making smaller functional websites or simple content driven systems.
  
  
• .NET 4 (you can do 3.5 but really just go with the latest)
  
• Core Web App - MVC (3 or 4)
  
• Dependency Injection - Unity 2.0 or 2.1
  
• Data access - Entity Framework
  
• Application Security - .NET Membership Provider (there is a newer slightly better framework by MS but I cannot recall the name at the moment)
  
• Consuming 3rd party services - WCF
  
• Exposing your own services REST - MVC (since you are already using it for pages)
  
• Exposing your own services using multiple protocols/data formats - WCF
  
• XML Processing - Linq and Lambda's. Also be aware of XmlTextReader and XmlTextWriter for targeted high speed forward-only processing.
  
• Configuration management - build in web.config with CSD for complex configuration structures beyond what appsettings can provide.
  
  Key Concepts for Modern .NET Apps
  
  
• Generics
  
• Lambdas
  
• Linq
  
• Closures
  
• dynamic typing
  
• threading
  
  Some basic tools to help you:
  
  
• dotpeak - provides detailed assembly information and some decompilation.
  
• Assembly binding log viewer - helps troubleshoot dependencies by logging internal CLR calls to dependent libraries.
  
• MSBuild - Build management and orchrstarion. This is the system used internally by Visual Studio for building projects. It's a command line tool so you can build projects even without visual studio. A basic understanding of MSBuild makes it fairly easy to use any IDE or text editor you like for .NET development. I do however like VS2010 or 2012 as it goes a long way in helping you code and understand .net.
  
  Edit: Now with more links.

Quick note about number 6: Those terms are a lot more intimidating than they sound. Some of them take a little while to really grok what they are and why they are useful but once you understand them they are extremely useful (and huge selling points for yourself as a developer).

About the interview: From what I've heard the questions they ask are different based on different backgrounds. They are less likely to ask software development methodology questions to a new graduate since that's not really in the realm of computer science.

I did get asked some questions regarding data structures and algorithms. The ones that I was asked, and I feel I did really well on, were more related to problem solving and software architecture. Think of it this way, if they hire you, in your day to day job having memorized how to traverse a graph isn't going to come up that often. Your day to day is going to consist of coming up with solutions to problems presented with you.

So when they ask a question like how to traverse a graph, they aren't looking for you to be able to spit out Dijkstra's algorithm exactly. Instead, they are looking to see how your brain works and what kind of solution you can come to by logically breaking down the steps to solve the problem.

They are looking for how you take a problem, break it down in pieces, and what your solution would look like.

Example: Implement a scale, that has two sides and lets you know based on the objects on the two sides, which side is heavier and by how much?

My answer to this question would be something like:

• Create a WeighableInterface that requires the getWeight method.
  
• Create a few random classes that implement that interface. Maybe a horseShoe class.
  
• Create a scale class and scaleInterface that has the methods addToLeft(WeighableInterface $object) addToRight, getWeightDifference, getHeavierSide.
  
  How do you store the set of items on each side of the scale internally in the scale class? Do you need to be able to remove items from the scale, and why would this affect how you store the items internally? Should the scale have a weight limit?
  
  These are all great questions to ask. Think out loud, talk out loud. They want to see that when confronted with a problem you don't know the answer to, or don't know the best solution to that you don't freeze up but instead chunk it up and try to reason your way through it.
  
  "Should the scale have a weight limit?" Asking the interviewer this question is a huge win in your favor. It shows that not only are you trying to solve the problem, but you're constantly thinking about issues that might have been overlooked in the initial assessment.
  
  Back on number 6: I learned these by googling a fuckton. Watching a lot of videos, reading a lot of tutorials, and just asking a lot of questions.
  
  Here's some resources I still have bookmarked from the last year/18 months. Some of them are for targeted for php, but the concepts are universal. But if any of these don't do it for you, google a bunch.
  
  Solid: 1 2
  
  Inversion of Control & Dependency Injection: 1 2 3 4
  
  Domain Driven Design: This is actually a ton of concepts, and you don't necessarily need to learn them all at once. This book is the only software architecture book I've read cover to cover, its that good. If you can afford to, do buy it. Also another helpful link Intro to DDD.
  
  Test Driven Development and UnitTesting: 1 2
  
  Also I've found many of the top answers stackoverflow user tereško are great sources of wisdom regarding software development.

Follow interesting people on twitter, ready up on development subreddits to get a grasp. These are useful for keeping a pulse on what's new.

As for learning, go to local user groups and technology meetups. Most cities have them and these events are a cheap and good way to learn from you peers.

Go to local code camps in your area (again these are becoming more popular). It's worth taking a weekend to go and learn new stuff. Also keep an eye out for one off developer events. In my area we always have something going on.

See if your company will pay for you to go to paid conferences.

Lastly get a Pluralsight subscription, it's worth its weight in gold and will teach you a ton of technology. They're constantly adding new stuff by industry experts.

Don't make getting a leadership position your goal, instead focus on becoming a good developer. Don't just learn new buzzwords or technologies, but try to understand how to write good clean code. Learn about unit and refactoring and in time you will move up the chain and you'll see new job offers all the time.

A few books you might want to read:

• Clean Code a great book on how to write better code, maintainable code.
  
  
• The Clean Coder - Not code related, but how to be a professional programmer
  
  
• Domain Driven Design
  
  
• Head First Design Patterns
  
  There are more obviously, but these are a few good generic books. If you are going into a specific area (like front end dev or javascript) there are a ton of specialized books on those topics. Read the latest ones there.
  
  All in all, technology will change, but having a good programming foundation and understanding what is going on (not just using a framework) will allow you to easily pick up new skills as they arise.
  
  I've been a professional developer close to 15 years and I'm always learning something new and that's just how I like it :)
  
  Edit: I forgot to add, work on personal projects , open source projects and practice practice practice. I do a lot of code katas and koans, like on a regular basis. Even simple intro katas often help.

CompSci covers a wide range of subjects, many of which won't be that relevant to you. When I was at Uni my classes covered:

• Algorithms
  
• Functional Programming
  
• Architecture and Design Patterns
  
• Ethics, Professional Issues
  
• Artificial Intelligence
  
• Compilers and Programming Language Design
  
• Data Structures
  
• Database Systems
  
• Networked Systems
  
• Operating Systems
  
• Discrete Mathematics
  
• Low-Level Systems and Hardware
  
  This list isn't comprehensive, but covers most of the main points. For your job, you can happily ignore most of that core.
  
  I think you'll want to focus on with the highest priority:
  
  
• Design Patterns (Book Suggestion)
  
• Algorithms (Book Suggestion)
  
  Warning: Algorithms is a heavy and dry book. It might not be a good recommendation for a beginner to be honest.
  
  As you're interested in Data Science, you're already off to a good start with R and Matlab. Python is fine but has some issues that don't make it ideal for large-scale data processing. The good news is that once you've got the hang of Python, you can learn another language much easier. I think it's worth noting that R is quite obtuse in my experience, so if you get your head around that you're doing quite well.
  
  But I digress. You're also going to want to learn about data structures, networked systems and databases, especially if you want to work with "Big Data". I think thought that your best starting place here is learning how to code. With that under your belt along with your math degree, everything else should be easy enough to learn on a case-by-case basis.
  
  Source: Masters & PhD in CompSci subjects. Good luck, and feel free to PM me if you're interested in a mentor for this. With a better understanding of your position, I could probably help pare down what you need to study to more specific subjects.
  
  PS: Assuming you're at Uni, your library should have both books I have suggested.

First off, well done on getting one of your first apps out there. It's always a daunting step, especially when you're a beginner.

Some general things that will help you improve your current design and any other app you choose to create going forward:

• Learn about SOLID programming principles. I won't go into too much detail because there is a wealth of resources out there to explain the basics better than I ever could such as this. Once you understand what each of the letters in the acronym means, you can use it as a framework to assess your own design.
  
• Design patterns can also be a valuable tool for a developer (though use with caution, if not used properly they can make your application needlessly complex). This site has some simple examples available specific to C#, but you might want to check out some material on object-oriented design first to get a better understanding of WHY we use patterns in the first place. The Head First series is quite a beginner friendly option in this regard Book 1 Book 2.
  
• Take a look through the official Microsoft C# guidelines, I noticed a few instances where you could improve the readability of the code based on their checklist (using implicitly typed variables with the var keyword where applicable, using string interpolation etc, using auto-implemented properties for your classes, meaningful variable names etc).
  
• Look up DRY (Don't repeat yourself), and KISS (Keep it simple, stupid), it will help you write shorter, clearer methods. I can see a few places in your code where you could decompose certain operations into separate methods.
  
• Treat user-input as an unpredictable spawn of Satan that it is: using decimal.TryParse(...) instead of Convert.ToDecimal(...), try...catch blocks, you always want to validate user-input as far as humanly possible.
  
• BONUS TIP (though some may disagree with me here): try ReSharper out, it will give you valuable suggestions while coding that you can otherwise miss. Even after 8 years of experience with C#, it helps me out tremendously.

For more foundational stuff, I'd look at:

• GitFlow - a successful Git branching model - This is pretty much the prototypical Git usage model. I have seen it used pretty much everywhere I've worked that used Git, and a lot of software supports the model by default (Atlassian Stash, SmartGit, Git Tower, and more).
  
  
  • Also take note of alternative Git usage models like GitLab Flow and GitHub Flow. They fit rather different use cases, and GitFlow is typically used for software that follows a more old-school release model where releases happen periodically, or you need to support multiple production releases at any given time. GitLab and GitHub flow are geared more toward software that only sees a single version in production at any given time, and very common release cycles (e.g. daily or even shorter).
    
    Getting familiar with these branching models will also expose you to many commonly-used Git features like branching, squash merging, rebasing, tagging, and history rewriting.
    
    
• How to write a commit message
  
  No one's really gonna ask you about this, but you should develop a habit of writing great, clear, and concise commit messages.
  
  
• Continuous Delivery and Continuous Integration
  
  All the rage right now - having real/near-real time building/unit-testing/packaging/deployment of your software once you've made a code commit. Read the articles I linked, play with services like CircleCI or Travis-CI or CodeShip and integrate them with your projects in GitLab.
  
  
• Test-Driven Development and Behavior-Driven Development
  
  Probably the two most commonly used overarching test-based software development processes. I'm a strong proponent of TDD (when done right), and many teams you work on will probably employ TDD or BDD.
  
  
• Stemming from the last point, know how to write good unit tests and how they differ from integration tests or acceptance tests.
  
  
• Code organization - a lot of this will likely be influenced by the language/toolset you're working in, but you'll be interested in learning about Layered Architecture and software packaging metrics.
  
  
• Generic software design - all sorts of acronyms to read about and absorb, like YAGNI, KISS, DRY, and SOLID. Also, the Unix philosophy, which guided a lot of development of software for Unix and Linux these days. There will also be patterns that apply to specific languages or types of software, but the stuff above is rather generically applicable.
  
  Beyond those links, some books that cover a lot of general material are:
  
  
• Clean Code
  
• Pragmatic Programmer
  
• Mythical Man-Month
  
• Software Estimation - Okay, software estimation is really gonna be complex and difficult until you get a lot of experience, and even experienced developers get it wrong. I don't think it's particularly necessary to read this book when you're starting out.
  
• Domain Driven Design - I love this book - it's about breaking down complex software designs.
  
• Release It! - Nygard is a pretty battle-tested developer, so this book is about approaching software design practically rather than in a vacuum separated from real-world application.

Disclaimer: I don't know the EE stuff very well, but I do know enough to explain everything that comes after.

Here are two explanations of how you build logic gates from transistors: a simple one and courtesy of the EE StackExchange, a more technical one. (The value of an input and output is taken relative to V-/GND.)

Before you can build a CPU with logic gates, there are two concepts you need: (1) Boolean algebra and (2) memory cells.

----

If you look up Boolean algebra, you're going to get a lot of results that only math majors really understand (e.g. the Wikipedia page). To simplify it all, Boolean algebra is essentially the field of study that asks "if I only have two values to work with, TRUE and FALSE, what kind of math can I do?" Notice that TRUE and FALSE map neatly to 1 and 0 (hello, binary math!) as well as HIGH and LOW (V+ and 0V).

This means that you can make all sorts of circuits, like binary adders, multipliers, dividers, and so on. (Subtraction involves some extra logical tricks.)

At this point, what you essentially have is the ability to create any function.

----

Now what we need is some way to remember data: that's where memory cells come into play. (This is basically your RAM.)

The primitive form that gets taught in introductory EE courses is the flip-flop circuit: a circuit with two stable states. The stable part here is important: it means that if such a circuit enters this state, it will not leave this state until an input changes. (Similarly, if such a circuit enters an unstable state, generally, it will eventually transition into a stable state.) There are a lot more ways to construct memory cells, of course, but flip-flops are a simple way to see how you can store and manipulate data in a circuit.

With memory cells and Boolean algebra, you can now build state machines. Again, if you google this you're going to end up finding a lot of academic technical nitty-gritty, but at its most basic, a state machine has a finite number of states (A, B, C, ...) and each state corresponds to some function of its inputs.

----

The canonical example is a vending machine (keep in mind, all the electromechanical stuff is abstracted away here - we're only thinking about the control logic).

Let's start with a really simple vending machine. It only accepts $1 coins, it only dispenses one type of soda, and all sodas are $1 each. It's not our job to worry about restocking or counterfeit money or whatnot: our job is just the dispensing logic circuit. We know we're going to have one input and one output: an input for "is there a dollar coin being inserted" and an output for "dispense one can of soda". And if we think about it, the circuit should only have two states: dispensing a soda and not dispensing a soda.

That's pretty simple, then: we use one memory cell, to distinguish between the dispensing and not-dispensing state. The output will always reflect our internal state (i.e. output goes HIGH when dispensing, LOW when not dispensing); and if our input goes HIGH when we're not dispensing, we transition to dispensing, and no matter what our input is when we're dispensing, we transition to not dispensing.

Now we can start adding some complexity to our vending machine: let's accept pennies, nickels, dimes, and quarters too. How about dollar bills? To deal with this, clearly our state machine is going to need some kind of internal counter for how much money has been inserted. We're also going to need logic to compare how much money has been inserted to how much soda costs right now ($1), and also logic to dispense change.

But not everyone's a fan of Generic Soda™ so we're going to need some variety. Now we need a way for people to choose a soda. And since some people are snobs and want pricey stuff - they're willing to pay $2 for their canned beverage of choice (gasp! shock! horror!) - we need to add logic to handle different prices.

----

CPUs are built up much in the same way like the hypothetical vending machine above. A program is supplied as input, in the form of a list of instructions, and the CPU is basically a really big state machine that goes through the program line-by-line.

Explaining the details of how a basic CPU is designed is a full undergraduate course (Computer Organization/Architecture, usually), and seeing as how I've already outlined its prerequisite (Digital Logic) above, I'm going to stop here. The text I learned from was Patterson and Hennessy's Computer Organization and Design (you can find free PDFs of older versions floating around if you just google it).

----

Aside: if you have Steam and are interested in assembly-level programming, I've heard great things about Shenzhen I/O.

You didn't go into too many details, so I just wanted to make sure you weren't missing the things that make for a a foundation.

I think Domain Driven Design is a good path for you, mainly because it doesn't necessarily over prescribe a technology stack (those are in constant flux) and focuses on the fundamentals of designing for a domain and understanding how to deal with the complexities that come with it.

Eric Evan's book is a great place to start. Personally I have two other books that are incredibly helpful for DDD. The first is Implementing DDD by Vaughn Vernon, and the second is Patterns, Principles, and Practices of DDD. I think the second is a little more along the lines of what you're looking for, but doesn't go into as much of ideas and structures of DDD. What it does do is go into more of the patterns that you're far more likely to see in an enterprise application.

Two patterns that you should pay attention to are Command Query Response Segregation (CQRS) and Event Sourcing. CQRS can be used in a number of ways and incarnations. Event Sourcing may or may not be applicable in your application, but its useful to think of an application's state and interactions as an immutible ledger of events.

If you go down the road of microservices, then I strongly suggest you also explore message queues as well. Although they certainly are useful, microservices are seen as somewhat of a fad or buzzword. Message queues, and the patterns that go with them, are quite useful in this context and also applicable in more "traditional" service oriented architectures as well. A great book for diving into those messaging patterns is Enterprise Integration Patterns.

NoSQL and Big Data solutions will likely come up along the way, and although they are worth exploring in their own right, I think its important that they are implemented for the right reasons. I'll leave this here for now, if this is something that you want to explore further, I'd suggest reading through Fowler's Polygot Persistence as a good jumping off point

>I want to make more applications...but I don't have any ideas..is there any reading you would recommend me to do?


Have you read Head First Java?

Head First Design Patterns?

The pragmatic programmer?



>I want to be employable...after 3 years doing a computer science course, I feel like I still only know the basics. What Java books do you value most and feel helped you become a much better programmer?


In my particular case, I didn't read books. My interest has been developing web applications, so I have gotten more information from frameworks' documentation an tutorials than from books.


>What are some examples of programs you made when you were 1 or 2 years into your Java programming career?


Hmm... I created some plugins to check on the availability of some servers and services. When it detected those were unavailable, it sent email and SMS alerts to our system administrators. Things got interesting when the email server was down tho.

>What resources would you recommend me reading to understand how to make my android applications able to access the internet..so that users can compare high scores and achievements?


>I have the drive. I love programming and I want to be a successful one. What advice can you give me?


Code as much as you can. Check what kind of applications you want to develop and find which frameworks can help you build them. You don't need to re invent the wheel (unless necessary). Follow the developer's guide and check if there are any tutorials that you can use to improve your knowledge and make better applications in the better way possible.


>Thank you for your help. I really appreciate it. I've felt stuck for days and i honestly did browse a lot before I came here. I've seen a lot of Java developer jobs paying £20-40k but i feel i don't have the relevant experience to even apply to them yet. I feel like i know very little..I.e I have no idea what J2EE is and what it's used for.


From wiki:
"Java Platform, Enterprise Edition or Java EE is Oracle's enterprise Java computing platform. The platform provides an API and runtime environment for developing and running enterprise software, including network and web services, and other large-scale, multi-tiered, scalable, reliable, and secure network applications. Java EE extends the Java Platform, Standard Edition (Java SE)[1], providing an API for object-relational mapping, distributed and multi-tier architectures, and web services. The platform incorporates a design based largely on modular components running on an application server. Software for Java EE is primarily developed in the Java programming language and uses XML for configuration."


If you want to build enterprise web-enabled applications, this is what you should start reading:
J2EE 6 Tutorial
And I always recommend these as well, they helped me a lot when I was learning Java Server Faces:


http://balusc.blogspot.mx/

http://www.mkyong.com/ (He has an Android tutorial that might help with with your interest to develop applications for that OS)

http://www.coreservlets.com/

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

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


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

Top Recommendations:

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

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


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

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

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

For Intermediates:

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

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

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

You are on the right track. The most important to understand is the fundamentals of any programming language. You mentioned Java. Java is an object-oriented programming language. In order to write good code in Java, you will need to learn what is an object? What is object-oriented? Like, what is inheritance, polymorphism, classes, interfaces etc etc. Once you learn the concept of OOP and you want to learn Python (another OOP language), it will be that much faster, because you already understand the concepts. Python has its nuances but you learn as you go along. I think you should start with the Head First series by Oreilly. They are sooo good at teaching this sort of stuff. I will give u the links below:

Head First Java

Head First Object-oriented Analysis and Design

Head First Design Patterns

Buy just the one book and start from there. Checkout the Head First series, you may like other books too. Also, google 'design patterns' and read about it. Some people mention Algorithms and that is all great stuff and you will learn as you write good code. There is another book I would recommend:

Pragmatic Programmer



I would also suggest that you should try different types of programming languages as well. Like functional (LISP or Scheme) or procedural (C). When you do that you will start to think differently and it will expand your knowledge. LISP was created in 1958 by John McCarthy. My friend works at Google and he told me that they are using LISP behind Google Maps.

We assign mentors (usually the more experienced team members, but can vary depending on project and resourcing requirements) to new guys who will help them get to grips with things like our methodologies, coding standards, etc.

If we end up with a team consisting of a lot of guys without TDD experience (rare, but my teams can vary depending on other projects/resources within my company), we'll occasionally run TDD workshops where one of my senior guys or myself will go through a fill worked example of TDD, and then point the new guys in the direction of suitable resources so they can self learn (although we support them as much as required).

In terms of resources, there are a number of books we have on our internal "recommended reading" list:

1. The Clean Coder : A Code Of Conduct For Professional Programmers by Robert C. Martin (http://www.amazon.com/The-Clean-Coder-Professional-Programmers/dp/0137081073). This is a good book for developers in general, but has a good section on TDD.
   
   
2. Test Driven Development : By Example by Kent Beck (http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=sr_1_1?s=books&ie=UTF8&qid=1458766760&sr=1-1&keywords=kent+beck). Kent Beck is one of the leading proponents of TDD, and this is well worth a read. I find that the fact the text is example driven really helps our developers relate TDD principals to actual real life situations.
   
3. xUnit Test Patterns : Refactoring Test Code by Gerard Meszaros (http://www.amazon.com/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054). This is a bit more advanced and goes above why and how to use TDD - in fact, it's not specifically about TDD, but rather just unit tests in general. However, it explains ways and patterns that can be used to design your code and your tests correctly in order to produce quality tests.
   
   There's a lot of information on the web, but I find sometimes books are just the best source.

What OS? Linux, of course. When TPB order everything locked down, you don't want to be caught using a Microsoft OS. -- What distribution? The easy path is Ubuntu, with the Cinnamon UI, or LinuxMint 13, when issued (May 2012).

What IDE? There's lots to choose from. My favorite is "geany".

https://en.wikipedia.org/wiki/Geany

For TCP/IP protocol tutorial. Recently updated by Wright:
Stevens, "TCP/IP Illustrated", 3-volume set.

http://www.amazon.com/TCP-IP-Illustrated-Volume-Set/dp/0201776316

On human interface guidelines relevant to programming:

https://en.wikipedia.org/wiki/Human_interface_guidelines

For GNOME 2, see:

http://library.gnome.org/devel/hig-book/stable/

To develop Linux applications:

You are right. You MUST know how to program in C. When others tell you that object oriented programming is the thing, know that you can do object oriented programming in C. Avoid interpreted languages (Python, Java, and others) as a first programming language. Interpreted languages teach bad habits and hid too much of what's going on from you such that debugging becomes difficult to impossible.

However, if all you intend is "casual programming", the Python will do, if you must. It's just not the best choice first a first language if your intent is to become a "professional programmer". I use Python myself; It works for what I need to do quick and dirty.

Definitive, but for experienced programmers:

http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1335197606&sr=1-1

As a tutorial for someone learning a first programming language and how to program from zero:

Perry, "Absolute Beginner's Guide to C", 2ed.
-- I have not read the book, but the ToC looks reasonable for a beginner.

http://www.amazon.com/Absolute-Beginners-Guide-2nd-Edition/dp/0672305100/ref=sr_1_6?s=books&ie=UTF8&qid=1335197606&sr=1-6

OK, you don't want a full CS curriculum, but some topics in discrete mathematics are mandatory. ... Ack! Having looked over the offerings at Amazon, I believe that Epp, "Discrete Mathematics with Applications" may be the best of the lot, but at $187, it is hard to recommend without knowing your intent and interest. The reason I suggest this title is that it looks focused on application to computer science topics. It covers a number of topics that are NOT covered in many of the other titles, enough so that should you use other texts you will have spent more than the $187 that this title includes. JMHO.

http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/ref=sr_1_1?s=books&ie=UTF8&qid=1335199316&sr=1-1

See also: Sedgwick, "Algorithms" -- You'll probably need it sooner than later.

http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?s=books&ie=UTF8&qid=1335200153&sr=1-1

Remember that Linux OS? You are going to need some programming tools, right? If you intend to write GUI applications based on the GTK+ toolkit, then install the package "glade" or "glade-gtk". Installing a glade package will suck in over 100 other packages essential to building a GTK based GUI application. Specifying glade to the package manager is just easier that finding and installing all the other necessary parts by hand.

If you are going to do command line based UI programs, then package "build-essentials" should be adequate.

There are some other things to read:

On how to organize, grow and maintain a Linux software development project: Fogel, "Producing Open Source Software"

http://producingoss.com/

You can read it online here, but buy the book too to help support Fogel. He's gotta eat too.

On the culture of writing Open Source Software:

Raymond, "The Cathedral and the Bazaar"

http://www.catb.org/~esr/writings/cathedral-bazaar/

Linux programming is not like Windows programming.
Read and study ESR's TAOP.

Raymond, "The Art of Unix Programming"

http://www.catb.org/~esr/writings/taoup/html/

You can read it online, free. However, buy a hardcopy too. Raymond has to eat too.

Now to get really technical. What interface do you write to?

Kerrick, "The Linux Programming Interface: A Linux and UNIX System Programming Handbook"

http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200/ref=sr_1_1?s=books&ie=UTF8&qid=1335201257&sr=1-1#reader_1593272200

Beginning to focus on GNU style programming:

GNU Coding Standards

https://www.gnu.org/prep/standards/

GNU Coding Standards is more than how to and how much to indent a line or how to set braces. You will get into the topic of Make and Autotools. Make is a program to build complex softare and Autotools is about how to build a package for distribution, the package that any Unix flavor can use; it is not focused on any specific distribution. See also: "configure and make"

Enough! There's more, but I have too much time in this already for today.

[edit: typos]

> Maybe now is a good time to step back and consider what kind of programming job you might want to target.

This is definitely something you should keep in mind. Try to become really awesome at one thing. That's not to say you shouldn't have a well rounded education in programming, just that someone who is simply ok at everything isn't getting a job anywhere.

Here are a few texts which I consider to be great for a novice programmer:

The C Programming Language : ANSI C

It's an older book, but it's still the best book to learn the language.

C++ Primer : C++

I used this book to get started with C++, and found it to be easy to follow and informative. Some say it's not a beginner book per-se, they may be right. I was already very familiar with C when I started.

Objective-C Programming: The Big Nerd Ranch Guide : Objective-C

If you're planning to write apps for Apple's iOS and OS X platforms, you're definitely going to need to learn this. Otherwise, don't bother.

Algorithms : Algorithms / Data Structures

This is not the be and end all authority on algorithms, but it's a great book. It's less theoretical and more concrete in my opinion.

I don't feel qualified to give recommendations for other topics like Java or web development, as those aren't really my strong suits. Happy hunting!

Fungus Cave

Github repository, screenshot.

It has been over a month since I finished my last project, Cursed Souls. Now I am working on a new Unity game, Fungus Cave. There are not so many things to talk about the game itself yet, so I would like to share the books I have read about C#, data structure & algorithms, and Unity.

C# 7.1 and .NET Core 2.0 is my C# textbook. It explains everything step by step for beginners. Although you need a PhD in math to create Dwarf Fortress, to learn data structure & algorithms is not so demanding with the help of these books:

• A Common-Sense Guide to Data Structures and Algorithms
  
• Learning JavaScript Data Structures and Algorithms
  
  After that, I browse articles in RogueBasin to learn about: time system, dungeon generation, pathfinding, FoV and AI.
  
  There are tons of books on Unity. I cannot tell which one is the best, but two of them which I have bought are well worth the money:
  
  
• Unity 2018 By Example
  
• Mastering Unity 2D Game Development
  
  Save/load system and coroutines are two topics that I care about but still do not understand after reading these books. So I googled around a bit and found something in addition to Unity tutorials:
  
  
• How to Save and Load Your Players' Progress in Unity
  
• Coroutines in Unity3D
  
  That's all. It took me about three months to learn all these things. I hope this book list would be helpful to other developers. Happy coding!
  

Agreed. There are plenty of resources out there that will help you understand design patterns. If you're new to the concept, I would recommend Head First: Design Patterns, it might be based on Java, but the examples are simple to understand and can mostly apply to PHP as well. When you feel like you've grasped the basic concepts of design patterns, you can move on to more advanced texts, like Martin Fowler's Patterns of Enterprise Design - this is a great reference for a lot of the more common patterns. There is also Refactoring: Improving the Design of Existing Code. These are great investments that will help you with any project you work on, and will help you if you decide to use a framework like Zend which uses design patterns very heavily.

You sound exactly like me 10 months ago. I also took the plunge, moving from PHP/MySQL to C#/.NET. Keep in mind that I am not a .NET veteran, but I have gone from knowing nothing to developing all of my sites in it in just under 10 months.

• Object Oriented is a big part of it. If you know this from Java, great. If not, start there. I recommend Head First Object-Oriented Analysis & Design
  
  
• MVC - if you have used a PHP MVC framework you are going to have a much easier time of it. I did not, so I had to learn MVC, OOP, C#, and .NET all at once.
  
  
• Wrox ASP.NET MVC3 has been invaluable. My copy is covered in sticky notes and highlighter after reading, and I refer to it heavily.
  
  
• I just bought Pro ASP.NET MVC 3 Framework, and it also seems good, however, I like the Wrox book better.
  
  
• Pluralsight.com - A little pricey at $30 / mo, but they have a plethora of extremely high quality videos. If you have enough free time to make use of the monthly subscription, I do recommend it.
  
  
• When you come to databases, I highly recommend going the Entity Framework route. Most other things seem like garbage by comparison in my limited experience.

Objects are for grouping related data and methods together. It really is as simple as that.

Start off by writing applications where you're just creating and consuming objects, not writing your own classes. Java and .NET both have tons of libraries that contain a wide assortment of objects. You mentioned C#, so write a few .NET apps. Try to start identifying and understanding the way properties and methods are grouped into objects, and how the different objects relate to each other.

Once you're comfortable using objects, then you can start writing your own classes. A lot of universities try to teach this by having you write common data structures. This approach is worth considering, as it's important to be familiar with data structures, but this isn't the only way to learn object-oriented programming (nor the best, in my opinion). Another commenter recommended writing a video game, which sounds like it's worth a try. Ultimately, the right approach is the one that interests you the most.

Getting good at OOP will take some practice, but it is possible. Objects are like functions: they should do one thing well. Enforce separation of concerns. Learn the design patterns. Practice makes perfect(-ish).

Recommended Reading:

• Refactoring: Improving the Design of Existing Code
  
• Head First Design Patterns
  
• Design Patterns: Elements of Reusable Object-Oriented Software
  

Smaller business logic frameworks would be mutations and ActiveInteraction.

They would replace the operations (and parts of reform) of TB.
Personally, I wouldn't use either of them over TB, they still add complexity, but don't offer too much over self-written stuff. YMMV of course.

If you want to start simple: create POROs for your "operations" with 2 public methods - initialize and run (or call, execute, apply, process etc.). Put your logic in them, create / execute them in your controllers.
Call them services, workflows, procedures, operations, scenarios, whatever.
try to put no persistent state in them - let them do their thing, return some sort of result (true / false, model / nil, small result object).

This fulfills a number of your criteria: it shouldn't slow you down much at all, it's simple, fairly maintainable and easily unit testable.

If you would like to research a different approach, look into DDD. The Arkency book should make for a good start, with the original DDD book giving quite a bit more background information.

> I'm not coding SPAs, so I still need awesome logic for Views / Presenters.

If you liked the Cells from TB, you can use them without using the rest of TB.
If you want something simpler, use a decorator like draper with ERB or Slim.

Algorithms are not an indicator of how good a programmer you are. Yes, algorithms are how you solve problems and it feels bad when you can't figure out the algorithm, but there's a million different algorithms that could potentially do the job, each with different constraints like time complexity, memory space taken during execution, initial order of the input data etc. If you're issue is not being able to solve a problem because you can't figure out what algorithms to use, you're actually already half way to the solution and further ahead than about 50% of my IT class. I'm in college right now and a lot of students don't even get to the point where they realize they need an algorithm to solve the problem, they just sit there and freeze and hope someone helps them or get a TA. While it's great to be able to solve algorithms on the fly, how about you not try to reinvent the wheel/rediscover a textbook's worth of human knowledge? There are literal textbooks which just contain different algorithms for different purposes: https://www.amazon.com/Algorithms-Algorithms_4-Robert-Sedgewick-ebook/dp/B004P8J1NA/ref=sr_1_3?keywords=algorithms&qid=1554225551&s=books&sr=1-3 (This one btw is used in a college CS course). Being able to memorize and/or recreate every algorithm in this textbook is not good programming (although I will say anyone who could recreate each algorithm independently is actually a genius). Being able to understand an issue and its constraints, and having a base of knowledge enough to either solve it immediately or help guide you to a new concept that would solve the problem is the ideal for being a programmer.

Take this challenge for example: https://www.codingame.com/training/medium/skynet-revolution-episode-1

I know I need a certain type of path-finding algorithm which always finds the shortest path for me to cut. I don't know what algorithm it is though since I've never learned about it. I could spend 10 hours rediscovering whatever algorithm is needed that was invented decades ago. Or I could be a smart, take the hint from the problem that a breadth first search is needed, and start learning about that to eventually solve the issue without trial and error. Over time, after completing multiple challenges, you'll accumulate the knowledge required to solve most problems as you are already familiar with all the algorithms required. And if you can't, that's just an opportunity to learn something new.

​

There are some SUPER valuable insights in the replies of this thread that took me YEARS of programming to fully understand. So you did yourself a great service asking this question here :)

 

These insights are:

by u/cmd-t
> think in OOP in terms of passing messages from object to object. Every function call is actually sending a message to an object: a request for it to do something.

by u/saturnflyer
> Don't model the real world. Create the world you need.

by u/tom_dalling
> It's a common misconception that classes model real-world things. Classes model data, or behavior, or responsibilities.

 

To answer your question, yes, OOP is hard to master. As a result, there are many books written on the subject. And for a complicated system, even senior developers will have trouble getting the design right on a first try.

 

If you feel lost, it's not because you are not good at this. It's because the subject you are learning does require lots of time and practice.

IMHO, the best way to learn this is by actually working alongside with senior engineers in a real production project. So you can see some existing designs and also bounce ideas with other engineers.

While that might not be possible at the moment, you can

• look at existing designs of open source projects
  
• read books: Practical Object-Oriented Design in Ruby by Sandi Metz, Smalltalk Best Practice Patterns by Kent Beck These two might be a bit too advanced. I couldn't think of any good OOP introductory books of the top of my head, maybe Head First Object-Oriented Analysis and Design?
  
• practice and bounce your design ideas with other engineers
  
   
  
  Happy coding and I hope to see you posting more questions here! :D
  
  

So kudos to you for wanting to create more manageable code. I will take a look at your class when I get some time and give you some ideas, but for now I recommend this book that helped me immensely: Head First Design Patterns: A Brain-Friendly Guide. It is a fun read and goes over some of the most important patterns in OOP. I had to read each chapter a few times and practice coding solutions for the knowledge to sink in, but what you will learn is amazing. I was able to apply concepts to one of my games when using for instance the Strategy Pattern to swap out flying behaviors super easy and separate code that will change from code that will not change. I will be posting tutorials on this subject in the future at my new Unity Game Dev site: https://www.theunitygamedev.com

You can take a look at the book on Amazon here: https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124

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.

In my experience, languages are pretty easy to pick up once you know one. I think you'd be better off sticking with Java and exploring concepts, algorithms, data structures and certain frameworks.

When I was starting I got a lot out of the GoF Book. It's a C++ book but they don't really use any C++ features that are hard to translate to Java. I've heard good things about Head First Design Patterns too but haven't read it.

As far as Java goes Spring and Hibernate are two great libraries to be familiar with, since you'll encounter them in the wild pretty regularly.

If I were to suggest something you might not have learned, consider installing VirtualBox and using it to run Ubuntu. Familiarity with Linux will give you a big leg up and Ubuntu is a pretty good way to ease into it. Plus it has packages for a ton of different programming languages so you can experiment with any that catch your fancy.

I've read a lot of these but I'm glad to see not all of them :) Adding to my reading list for sure.

Thanks!

EDIT: forgive me if these are already listed but just in case...

Bug Hunter's Diary - http://www.amazon.com/Bug-Hunters-Diary-Software-Security/dp/1593273851
Gives real hands on real-life experience in a "diary" format and covers some great bugs

Gray Hat Hacking - http://www.amazon.com/Hacking-Ethical-Hackers-Handbook-Edition/dp/0071742557
Despite a bad generic "ethical" title this book goes really in-depth on a lot of subjects (almost to the point of rambling actually) including fuzzing, client-side exploits (mostly browser-based), and much more.

Hacking Windows Exposed - http://www.amazon.com/Hacking-Exposed-Windows-Microsoft-Solutions/dp/007149426X
Another generic title but this book has small good parts scattered throughout, really written more for pentesters it has some very common red team methods but also has a few hidden gems hidden within the various subjects it tries to cover.

Also for anyone looking to get TAOSSA (The Art of Software Security Assessment) it's absolutely huge and WILL split down the middle while reading...it's sitting on my bookshelf right now in its ripped state but I've read it 4 times and still don't feel like all the material has sunken in, if you're going to buy any book at all it should be that one as it will provide countless hours/days/weeks/months of reading.

Download Virtual Box.
Download a few Linux Distros - Ubuntu, CentOS, etc. Ubuntu is rather user friendly. Get the server version, not desktop. (Or get both, but you want experience with the command line, and the server version will force you to work with the command line.)

O'reilley books are great. Very dry, but reliable sources of info. Go "used" for now, as they can get expensive when you buy too many.

Learning the Unix OS is a good intro.

Also, this book is a large overview of linux sysadmin: Essential System Administration by Frisch

A Bash book would help, as well.

Oh, and the "man" command. On the command line, run "man anycommand" to bring up manual pages on any command. You can run "man man" or "man bash" to get started.

Best of luck!

Edit: typo

I'M REALLY SORRY YOU'RE HAVING A HARD TIME.

NOT SAYING YOU HAVEN'T TRIED, I COMPLETELY BELIEVE YOU. BUT IF YOU BRANCH AWAY FROM THE CODE-BOOTCAMP/WEB-DEV ARENA THERE IS CURRENTLY A MASSIVE SHORTAGE OF PEOPLE THAT CAN ACTUALLY PROGRAM. COMPANIES LIKE NIKE FLY IN DEVELOPERS FROM ALL OVER THE COUNTRY STRAIGHT OUT OF COLLEGE.

WE INTERVIEW SO. MANY. FUCKING. PEOPLE. THAT DON'T KNOW THE ABSOLUTE BASICS.

PUSH THE "WRITING SOFTWARE IN PYTHON" ASPECTS OF YOUR PAST EXPERIENCE AND DOWNPLAY ANY HTML/CSS/JAVASCRIPT STUFF. SPEND A MONTH LEARNING THE BASICS OF JAVA. THEN SIGN UP FOR LEETCODE AND CODERBYTE (FREE VERSIONS) AND SOLVE A PROBLEM A DAY FROM EACH, FOR 30 DAYS. IF YOU DON'T KNOW HOW, GOOGLE IT UNTIL YOU DO. LEARN THE ABSOLUTE BASICS OF ALGORITHMS, EFFICIENCY, AND RUNTIME COMPLEXITY THROUGH COURSERA, OR A BOOK LIKE THIS, AND ADVERTISE THE SHIT OUT OF IT ON YOUR RESUME. THIS IS WHAT THEY'RE LOOKING FOR.

SHOW UP LOOKING LIKE A NORMAL HUMAN, YOU'LL BE ABLE TO ANSWER QUESTIONS ABOUT THE EFFICIENCY OF CERTAIN ALGORITHMS OVER ANOTHER AND WHEN THEY ASK, YOU WILL SOLVE A WHITEBOARD PROBLEM THAT WILL LIKELY BE A WORD-FOR-WORD COPY OF ONE OF THE PRACTICE PROBLEMS YOU SOLVED ON LEETCODE. DO THIS AND I GUARANTEE THEY WILL JUMP YOUR BONES TO GET YOU ON THE TEAM. THAT'S WHERE THE MONEY AND MARKET IS RIGHT NOW, AND THERE ISN'T ENOUGH PEOPLE TO FILL IT.

>is book could have been useful also for C++ real-time programmers of course because i would include also HW information used in that field.. probably I'm asking too much now..

It wouldn't be. You misunderstand how that field of programming works. Differences can be HUGE and you would end up using at least something like https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269.

Why? Because hardware used there can be fundamentally different than your typical computer. How much? Well... some CPUs don't support recursion. No, really. Do more than 2-3 recursive calls and CPU rans out of memory. You also end up using FPGAs and ASICs. To explain all that is way more than a book.

You seem to want a hypotethical book on "current PC hardware and it's performance". Which frankly is not in a form of a book but comes from visiting places like Guru3d and anandtech. Actual low level differences that WILL matter for a programmer are hidden in CPU specs sheets and to read that you need resources that target computer architectures and your problem domain specifically. Well, that and practice really - someone working in game engine development is likely to know graphics pipeline like the back of their hand and can easily talk about performance on several GPUs and pinpoint what makes one better than the other. But that came from experimenting and plenty of articles, not a singular resource. Too many different requirements really to create a single resource stating that "X is good for Y branch of programming but bad for Z".

I mean, even within desktop CPUs themselves. Would you rather have a 14 Core i9 9980XE or a 32 core Threadripper 2990WX? Answer is - it depends. One has far superior single threaded performance due to higher clock, the latter will eat it alive in heavily multithreaded and independent processes (2990WX has 32 cores but only 16 are connected to the rest of your computer, this can cause very visible delays so there are multithreaded scenarios when it will underperform). And in some cases you will find out that an 8-core 9900k is #1 in the world. It ALL depends on a specific application and it's profile.

If you did the Princeton Algorithms course and have two years experience as a professional developer you're way too advanced for CS50 and other intro classes.

The classes I'd recommend for someone in your position are:

• Networking (probably the most relevant for you since you're a front-end dev, some knowledge about TCP/IP and HTTP would be beneficial): Udacity has a good course on this
  
• Analysis of Algorithms (teaches you some more general algorithmic techniques like dynamic programming, greedy strategies, approximation algorithms, as well as how to mathematically analyze an algorithm to determine its performance): Coursera has a good course on this
  
• Computer Architecture and Assembly (teaches you how a computer actually works; not terribly relevant for a front-end dev, but computers will stop being magic after you finish it): Check out OpenSecurityTraining's Intro x86 course for the best course I've ever found on this subject
  
  More than the above though I'd recommend learning the following concepts and subjects even though there aren't any good MOOCs on them (to my knowledge):
  
  
• Design patterns. There's a couple books that are highly recommended on this subject: Head First Design Patterns and the aptly named Design Patterns
  
• Back-end web development. You already know how to do front-end development. Learning back-end development will probably make your job easier when you have an idea of what's going on behind the scenes. It will also allow you to move to full-stack if you ever wish.
  
• Design patterns.
  
• Web security. Priceless for any web developer, though granted it's more relevant to back-end engineers than front-end.
  
• You should really learn design patterns.

DSP is really useful in a wide variety of disciplines, especially if you end up becoming an embedded programmer. A lot of embedded code hooks into digital or analog sensors, and gleaning useful information from these sensors usually requires some amount of signal processing. Granted, it isn't always as complicated as what you'd learn in a DSP class, but it is really useful to know that stuff is available when you need it.

All this being said, I'm not going to lie to you, this material is not exactly intuitive, and can be very challenging to learn on your own. It is very math heavy, and there aren't very many good resources out there that I know of that can help with the learning curve.

Things that I used to help me get through the classes were:

• MIT opencourseware
  
• The signals and systems bible (oppenheim). Looks like there might be a newer edition, but I used this one.
  
• This doesn't look like a bad resource. Could be worth the look
  
  
  I'm sorry to hear that the main prof is shitty. Maybe another thing to consider would be taking the class online from another university? This one looks pretty solid.
  
  Good luck!

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.

im not sure what you do with CIS, but im guessing sysadmin type stuff? if that doesnt interest you and the job listings dont either, look into a straight BS in CS degree. you can probably transfer some credits. check out an algorithms book like this one (google it for the pdf) http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X or this one http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844 and if they interest you check out CS. take some courses for free on codecademy and see if web programming interests you. theres a million ways to go online and check out other cs related avenues that might be more for you. explore cs classes on your campus after reading the course descriptions, audit a class for free. sign up and then leave during drop add. see how things sound. check things out. good luck!

Interesting!

Looks to me that you can "feel" what good code looks like but you're not able to rationalise it enough for you to write it on your own.

Couple of suggestions:

When you see elegant code, ask yourself: why is it elegant? Is it because is simple? Easy to understand? Try to recognise the desired attributes so you can try to reproduce on your code.

Try to write really short classes/methods that have only one responsibility. For more about this, search for Single Responsibility Principle.

How familiar are you with unit testing and TDD? It should help you a lot to write better designed code.

Some other resources:

• Uncle Bob's SOLID
  
• Clean Code
  
• TDD by Example
  
• The Art of Unit Testing
  
• Refactoring
  
• Domain-Driven Design
  
• Patterns of Enterprise Application Architecture

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

Programmer here.
"If you cannot explain it simply, you don't understand it well enough."

What I'm trying to say is that a good programmer can always find ways to simplify a concept, or explain it using real-life analogies, even to people who don't know anything about programming or computers in general.
This is actually one of the most important qualities of a good software developer - the ability to rationalize often complicated abstract concepts in simple terms and break them down into simple tasks.
I want to make this clear - I am not saying that your boyfriend is a bad programmer and I don't know his professional level.

However, it sounds like both of you could turn this situation to your own benefit.
If he makes an effort to explain his work in ways that you could understand, it would work in his favour in the long term, and you could share his excitement.
I actually recommend reading Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to OOA&D for easy-to-digest examples of complex issues in software development, explained with tools and objects from everyday life, he could probably take a hint from that book and learn something.

Finally - big props to you for being a supportive girlfriend and taking interest in his work.

It's all about reading good source code. Books tell you how people think the world should be, or how they want to be. Source code shows you how it is. Learn C and get reading. Linux is a great platform because you have the source code for everything and it's written by people who care about the code (and know it will be looked at). Windows is a bad platform because you have the source code to nothing, and only have books to go from. There are of course good books, but the best ones tend to have lots of code in. As normal I'll push my favourites :

http://www.amazon.com/Lions-Commentary-Unix-John/dp/1573980137
(Old, but very very good and the grand daddy to SOO much)

http://www.amazon.com/Black-Art-Game-Programming-High-Speed/dp/1571690042
(Again old, but very good)

http://www.starstonesoftware.com/OpenGL/
(Modern accelerated crossplatform 3D)

http://lxr.linux.no/linux
(Good for those "how does my OS do...." reading)

http://source.winehq.org/
(Don't like the idea of Win32 as a common platform, but the code is good, and can help when MSDN fails you)

http://minnie.tuhs.org/UnixTree/Interdata_v6/
(pretty much the same version as Lion's Commentary, so useful online reference when the book isn't to hand)

Hope this helps someone. Might have helped a younger me.

Oh and python for kids! (And adults when it doesn't need to be C.)
(I'm not pushing C++ as I regard it as a handle with care language I'm not sure I'm for.....but it does feed me.)

It depends on how far and how fast you want to go. If you want to quickly learn enough programming that you can make code that actually does useful stuff then you might want to start from scripting languages like python, bash etc. If you want a solid(but slow) foundation for programming then you're better off starting with C, moving to C++ and then going to high level languages like Java or C#. If you want to start from C, I'd recommend Problem Solving & Program Design in C. You can easily transition to C++ from C. When you've learned enough C++ & want to dive into algorithms, you should read this book by Robert Sedgwick.
If you just want to have fun with Maths. You can start learning Matlab(It wouldn't teach you a lot about general programming though). You can easily start learning image processing & Artificial intelligence with Matlab, and these are really fun things to do.
Unfortunately, there is no single language that you can learn to be able to talk to all phones, computers, fridges and browsers. You have to pick one area and start from there.

As a software developer the hardest part will probably be sharpening your mathematics skills. At my undergrad the CS kids only took up to Calculus II, which is really not enough math.

I started on DSP as a sophomore, teaching myself from this book. Even though I was able to implement a few filters successfully and understand the basics, I don't think it really clicked until I took a linear systems course.

All that being said, you can totally do it. But it won't be easy without the technical background - sure you use the tools we make, but honestly we hide most of the technical parts from the user anyway (the user doesn't know about or care about Butterworth vs Chebeshev filters). Put in the work to learn the mathematics. I recommend Oppenheim and Willsky if you don't have the linear systems background. Besides that, you really just need to show the company that you're a music lover, and it looks like for you that should be easy enough. PM me if you want more info.

A book I have recently been recommended was "How to create a mind." Seems to have some bias, but has interesting takes on the subject.

I won't deny I'm fairly early on in my degree myself, but if you want what I've been using as supplementary material, here they are.

If you're looking for some code books, I suggest the big red book. That's pretty standard as the go-to Algorithms book. Fairly dry, but it the 4th edition has some good explanations of nice and efficient algorithms - plus, clean code.

Finally depending on your preferred language (I'm a C++ person myself) this book might have some relevance.

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

It seems to me you have set the bar too high. Searching and sorting algorithms alone are one semester course and are programming language independent. You are not tied to Java to learn them, though coding them up in Java will help you come to grips with the language.

If you really want to learn the language, then try to implement the first part of your goal that is stacks, queues, linked lists and binary trees. Do not let the jargon "...data abstraction as applied to elementary ..." come in between. Ask your faculty in helping to write efficient and robust code, that is make your stacks, queues, lists and trees take any sort of data that is use generics they are a big thing in Java. This will help you understand how to make your code be able to serve any type of data.

After you have done the coding of these data structures compare them with the libraries that Java provides for list, stack, queues. This comparison will give you insight as to how to write better code in Java.

Also try to learn a few patterns while coding these things up. For starts you can go to sourcemaking or look up at the book Head First design patterns. You may get lost here or overwhelmed, so do ask your faculty for guidance here as to what you should cherry pick to get the best footing.

Congratulations, and all the best for your job!

These are great suggestions. The three books I typically give devs early (that fit in well with the two presented here) are:

Refactoring by Martin Fowler

This is a list of patterns of common refactoring a and how to do them safely. It’ll help you recognize transforms you need to make in your code as it changes.

The Pragmatic Programmer by Dave Thomas and Andy Hunt

This is a great guidebook for how to get better at being a software engineer. Essential read.

And while there are lots of options for design patterns books...

Head First Design Patterns was the one that helped me internalize them. Even if you aren’t writing much (or any) Java, the method of teaching is hugely valuable.

Ah good, household voltage gets complicated. The official arduino site has some great tutorials to get you started, Tom Igoe helped develop the whole thing and has a lot of great stuff on his site. He recommends a few tutorials on that page. He seems to be shuffling his website stuff around recently, so some of it might be hard to find.

I think there have been some good books published recently, like Programming Interactivity that has some good stuff about Arduino in it.

Back to the project though, like some of the other commenters have mentioned, just relating it to pure volume should be simple enough. Audio processing, like eq filtering might be a lot more complicated. I know that there are some bluetooth type connections available with Arduino, although I haven't done that personally, so you might be able to communicate with the board wirelessly.

I’m taking Data Structures and Algorithms right now. It’s definitely not an easy class so it’s very ok to struggle. I’m not sure which language are you guys using, but if you’re using Java, then this is an amazing book that starts from the basics! https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=mp_s_a_1_4?ie=UTF8&qid=1536420166&sr=8-4&pi=AC_SX236_SY340_QL65&keywords=algorithms&dpPl=1&dpID=41%2BpJNrGujL&ref=plSrch

On the other hand, you have to build things by your hand in order to understand them. Don’t worry about how quick you get the concepts, it’s ok to meditate on them. After all, what took scientists years to build is not supposed to be understood in an hour. Take your time and good luck!

For language specific stuff like c++ I'd suggest:

https://www.toptal.com/c-plus-plus/interview-questions as a pretty good quick review. Going through c++ primer (or whatever book you learned C++ from) and just touching on all the topics that you don't remember can help a lot.

What helped me with design patterns is head first design patterns. Even though that book seems very 'intro' it has helped me pass all the design pattern question I've ever gotten. I think just visitor, singleton and MVC are the most popular interview design patterns. The more canonical 'gang of four' book would be: this.

For just practice tech interview problems that you'll see on silicon valley, big4 tech interviews, the most popular site is probably leetcode (hackerrank, or top coder or even codewars are pretty good sources too). The most popular book (as mentioned many times) is Cracking the coding interview.

Just grinding out problems on leetcode, you'll probably learn enough to pass most tech interviews after about 100-200 questions (if you've never done this before, less if you have).

Before/during your leetcode practice I've written a series of tech interview tips to help you check on your fundamentals (you can check it out at fizzbuzzed.com). I try to go over the questions I see people failing most often. I'm also trying to help readers so would love to help you if you run into problems.

I also think you should ask the recruiter the style of interview you'll be having. If you are on the whiteboard then you should practice on it before hand (whiteboard interview tips here.

Depends what you want to learn. Some of my favorites are

• Code by Charles Petzold if you want to know how your computer works under the hood.
  
  
• Peopleware if you want to learn how to manage knowledge workers.
  
  
• Clean Code by Uncle Bob if you want to learn about good practices and program structure. Impressive content, covers much more than I expected.
  
  
• Don't Make Me Think if you want to learn about usability.
  
  
• Algorithms by Robert Sedgewick if you want to learn about DS & algorithms.
  
  
• The Art of UNIX Programming by Eric S. Raymond if you want to learn about the unix philosophy. Lots of hidden gems in there. Have you ever heard: write programs that do one thing and do it well; don't tune for speed until you've measured; imagine all this knowledge distilled to you in one book.
  
  This a good list to get you started :) most of my favorite books are not language specific.

It depends on what I'm reading. 20 for the average book is about what I can read. I've had things like What Every Programmer Should Know About Memory that I could only do 5 pages at best and things like Head First Design Patterns where I could do 40 or 50

An interesting side note is that I've also been reading books like Thinking, Fast and Slow that basically say that we have a finite amount of mental will power. We can only focus on a difficult task for so long before we run out of steam. The only way we know to improve focus this is by maintaining decent glucose levels. So you might be able to improve your limit by having a snack or breaking for something to eat.

I've also been reading Seach inside yourself. It's book on meditation written by a programmer at Google. I'm hoping to improve my focus with meditation. It might also let you bump up your number number of pages per-day or at least let you settle in to reading faster

While Design Patterns is the original book, I feel most people are better suited to getting books that were published later that make the first Design Patterns more digestable. DP is a good reference to have on the bookshelf for any software developer but I feel if you're new to Design Patterns:

A. There are better free online sources for the raw Design Patterns in the GoF book like this website

B. There are better books out there for explaining Design Patterns in the GoF book to newbies like Head First Design Patterns

I've found that I gained most of my best experience on the job, and that staying at a job where I wasn't learning anything was a huge mistake and detriment to my career.

That said... I don't think I'm a super genius either. I did well in college and my GPA helped with my first few jobs. But I have lots of hobbies outside of work, and rarely spend my time at home thinking about the office. A lot of times companies aren't looking for the super genius type either... if they were they'd have a hard time filling staffing requirements. I think the keys are learning how to interview well, focusing on letting the interviewer know that you're willing and good at learning and having the basics of OOO down to a T. Come off as confident, even if you don't feel it. It never hurts.

As far as books go, here are some of my favorites:


Programming Interviews Exposed


Programming Pearls


Refactoring



I'm mostly a java programmer, so here are three absolutely necessary java books:


Head First Design Patterns


Core Java 1


Core Java 2 - Advanced

> Not once have I thought to myself "Man, if only I'd wrapped this
> thing in an interface" during refactoring

Really? I say this to myself all the time, especially working with legacy code bases. Mostly in cases where business logic and persistence logic are deeply intertwined. The interface puts a hard firewall between the two, and protects the business logic from the persistence logic (and vice versa).

> Again, I've never actually seen this work.

I have seen this work all the time. For example, we started with a code base with no clear domain model at all, and by refactoring towards a domain model, the code became simpler, much easier to understand, and substantially easier to modify. Because the domain model speaks the language of the business, adding new business rules is a natural process, not an exercise in hacking in a new business rule into a mass of code in non-obvious ways.

The Domain Driven Design book demonstrates this transformation with several very good examples. This is a very good book in general to understand how to design effective domain models.

> I would agree some of the abstractions coming from FP are useful

That's not really the point... The point is that abstractions are everywhere. You can't escape them and thus abstraction certainly isn't a dirty word.

> the OOP cargo cult

OOP isn't a cargo cult, but there is cargo culting in OOP, just like any other methodology. It all boils down to understanding why things work, instead of blindly following "best practices".

I actually had this exact discussion today. A number of people argue that type classes must have laws. I definitely share the general sentiment that it is better for type classes to have laws. But the extreme view that ALL type classes should have laws is just that...extreme. Type classes like Default are useful because they make life easier. They reduce cognitive overload by providing a standardized name to use when you encounter a concept. Good uniformly applied names have a host of benefits (see Domain-Driven Design for more on this topic). They save you the time and effort of thinking up a name to use when you're creating a new instance and also avoids the need to hunt for the name when you want to use an instance. It also lets you build generic operations that can work across multiple data types with less overhead. The example of this that I was discussing today was a similar type class we ended up calling Humanizable. The semantics here are that we frequently need to get a domain specific representation of things for human consumption. This is different from Default, Show, Pretty, Formattable, etc. The existence of the type class immediately solves a problem that developers on this project will encounter over and over again, so I think it's a perfectly reasonable application of a useful tool that we have at our disposal.

EDIT: People love to demonize Default for being lawless, but I have heard one idea (not originally mine) for a law we might use for Default: def will not change its meaning between releases. This is actually a useful technique for making an API more stable. Instead of exporting field accessors and a data constructor, export a Default instance and lenses. This way you can add a field to your data type without any backwards-incompatible changes.

Here's a list I compiled, the list books kind of hit a wide range. I don't really have any given list of talks I like. I'll just randomly google for videos by a speaker i like or subject I'm interested in.

Books:

• Patterns Of Enterprise Application Architecture
  
• Design Patterns: Elements of Reusable Object-Oriented Software
  
• Domain-Driven Design: Tackling Complexity in the Heart of Software
  
• The Grumpy Testing Bundle
  
• Build APIs You Won't Hate
  
• The Art of Readable Code
  
  
  Watch:
  
  
• Rafael Dohms at Kings of Code Festival 2012
  
• PHPNW13 Track 2 Talk 5: Ross Tuck - Models and Service Layers; Hemoglobin and Hobgoblins
  
• Aloha Ruby Conf 2012 Refactoring from Good to Great by Ben Orenstein
  
  Podcasts:
  
  
• dev hell
  
• PHP Town Hall
  
• Larave.io Podcast
  
  Blogs:
  
  
• Mathias Verraes
  
• Eric Barnes
  
• Phil Sturgeon
  
• Fideloper
  
• nikic
  
• Ross Tuck
  
• Use The Index Luke
  
  News Letter:
  
  
• Laravel News Letter
  
• websec.io
  
  Misc:
  
  
• Twitter List of php devs
  
• php architect magazine

> Have a lot to learn about OO

Read Head First Design Patterns. It is written in a style that is super-corny but actually sticks in your head really well. Also, the syntax it uses is java, but you don't need to know how to write Java.

Learn how to write Automated tests. They will help keep you from spending late nights hunting down bugs. Test-Driven Development with Python is excellent and free.

Also, learn to use assertions and pdb to find bugs.

Learn how to set up your development environment and servers. I recently wrote a tutorial on this and would be grateful if you would check it out and give me feedback: https://amfarrell.com/saltstack-from-scratch/

The book, Head First Design Patterns, is actually pretty good.

You could also read the book that started it all, Design Patterns: Elements of Reusable Object-Oriented Software. Although good, it is a dull read - I had to force myself to get through it.

Martin Fowler is also really good, in particular, I thoroughly enjoyed his book Patterns of Enterprise Architecture.

If you want more of an MS/.NET slant of things, you should also check out Dino Esposito. I really enjoyed his book Microsoft .NET: Architecting Applications for the Enterprise.

My recommendation would be to start with the Head First book first, as this will give you a good overview of the major design patterns.

I would focus more on deciding what you want to make. When you can make something that works, you're a programmer. When your code isn't brittle, is well commented/documented, is "clean" and other devs can understand and work with it, you're a good programmer.

So pick something you want to create and make it: a website, a simple program, a game, etc.

How to go about it? Once you have that thing you want to make, break it down into bite size tasks and start tackling them one at a time. First, you'll need to figure out what language and libraries you need (or want) to use. Then set up your dev environment and get a "Hello World" example to work. Then just start building piece by piece. Once it works, make it work better (i.e. refactor it).

I use a bunch of resources to be a better programmer:

• dev blogs (a google search for "best <insert your field here> blogs" should give you some good ones
  
  
• books for the basics. I can particularly recommend Code Complete 2, The Pragmatic Programmer, Head First Design Patterns, Design Patterns: Elements of Reusable OO Software and Algorithms in a Nutshell
  
  
• Tutorials. I love a good tutorial. The trick is to find one written by a professional (usually on a blog you trust or from a tutorials site that vets the content, like tutsplus). Unfortunately, any asshat can throw up shitty code and call it a tutorial, so be careful googling and look at the comments first to look for people calling out issues. As you get more experience, you'll be able to spot 'code smell'.
  
  
• pair programming. I hate pair programming. I instantly lose my ability to type or form coherent thoughts when someone is lurking over my shoulder. I am constantly terrified that someone will think I'm stupid. But it works.
  
  
• fellow devs. Nothing really replaces direct communication with another dev. Find someone or a community online or at work who you are comfortable with. Someone you can go to when you're stuck or don't get something. The difference between needing babysitting and needing help is having specific questions. Instead of saying "I don't understand x", approach them with a more specific question like "I'm trying to get comfortable with closures so I set up a simple counter, but instead of counting to 10, I get 10 printed 10 times, can you help me spot where my error is?"
  
  I hope that helps.

You are welcome :).
This is one of the best book to learn programming http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871. It's freely available and the class at MIT which uses this is here http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/
Peter Norvig's advice http://norvig.com/21-days.html
Programming Pearls : http://www.cs.bell-labs.com/cm/cs/pearls/
At https://www.codeeval.com you can solve questions and get interview calls.
You may also want to brush up your design skills as few interviewers might ask those kind of questions. http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124 might be a good place to start.
I think http://www.geeksforgeeks.org is a good place to look for nicely explained solutions and you can find almost all the questions ever asked in a software engineering interview at careercup.com

He used a specific CPU design that already has a compiler for it. So you will essentially load "code" as a set of minecraft blocks which represent the code. You can do ANYTHING with the CPU. It just crunches numbers, does maths and shits out results, same as your CPU.

A CPU is at once a simple thing and a horribly complex thing. A CPU has a set of instructions. This set of instructions and some other parameters of how you interact with the CPU represent your CPU Architecture. Instructions are the lowest level unit a programmer works with the CPU. An instruction is simple "load a number into a register" (register is just a really small piece of memory, just big enough for a 32bit or 64 bit number). Then you might say something like, "multiply stuff in these two registers" and then the result goes to some other register. You might have an instruction that says "move data from here to this location in memory".

You have I/O devices.. "ports" that you poke and prod with the CPU that perform input and output and allow humans to interact with the devices.. but none of that really matters. When you can actually SEE the CPU like in minecraft you can watch what is happening without the need for a lot of I/O.

He used the CPU architecture described in: http://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/026214087X this book. Since that CPU architecture has a compiler for it that is how it will run code. He will "compile" the programs, translate that "machine code" to "minecraft block machine code" and then the CPU will be put into a state to execute that program :)

(Oh, that book is pretty awesome). I dug this up: http://en.kioskea.net/contents/pc/processeur.php3 which gives you a rough overview of things. Honestly ANYONE that can do basic arithmetic can sit down and understand how a CPU works in about 8-10 hours. You just have to "accept" many things just work at first and that CPU can do all of this. A simple CPU is so easy. x86 and x86-64 are not so simple, yet I think assembly is fairly easy to understand for any programmer. Oh well. :)

Then you can deconstruct the basics of logic gates and building simple circuits to make your own CPU, which is what this guy did.

My opinion:

On one hand, you should learn what you can do with the tools
Mocking framework
Testing framework
Various other tools / techniques / patterns (thinking about test data builders, object comparison, code coverage...)
This part is not necessarily difficult. The basic mechanics of moq and xunit can be learned in a couple of days, maybe less

Then, on the other hand, you must learn proper and useful ways to use those tools to have meaningful tests. And this is harder, the job of a lifetime of testing. I would encourage you to:
Check blogs of people like uncle Bob
Peek into how other people in successful projects do testing. Enter github, and look for repos
Books. I can recommend you this one: https://www.amazon.com/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054

Relax. There are plenty of good books, but most of them will actually be your course literature in university. You do not gain anything substantial by trying to go through that now. Instead make sure that CS is the right field for you at all. Figure out what studying CS is all about, realize that it will not be like taking programming classes for 4 years. Instead, like I said, work on basic programming skills. Lots of students go into CS without being able to program, and you'll have a much easier time if you have familiarity with practical concepts by then.

If you really want some classic books, though:

• Aho, Ullman & Hopcroft have the classical book on algorithms.
  
  
• The Dragon Book on compilers. You'll probably use this in a compiler course. Warning: don't try this now. It's a complicated book and requires being comfortable with some other theory.
  
  
• Russell and Norvig have the book on AI. Definitely difficult in places, this is perhaps my favourite CS book. You can take a look at it to learn what studying AI is like, but keep in mind that a full-semester course at university will only cover part of the book. According to the book itself, covering it in its entirely is expected to take two full semesters.
  
  
• The Dinosaur book is the typical text for an OS course. Note that in terms of a CS course, operating systems doesn't so much mean studying the difference between Linux and Windows, but rather learning about process scheduling, virtual memory, deadlocks and that sort of thing.

In addition to Code Complete 2, which, while very dense, is a compendium of wonderful coding knowledge... I recommend Clean Code by Robert C. Martin.

One of the best books on concurrency that I've ever read is definitely Java Concurrency In Practice it's (obviously) written with Java in mind, but most of the concepts map rather easily to constructs in other languages as well.

The standard for design patterns is still probably Design Patterns (colloquially "Gang of Four")... but I've heard good things about Head First Design Patterns as well, despite the really stupid cover.

You can get a degree or you can teach yourself

The above resource is pretty good in outlining the major topics that all CS programs cover, but I would change some of their textbook and class recommendations.

I would replace the programming book/course with CS for all

Algorithms I would recommend sedgewick which is also available as a website or clrs for a more in depth review.

Those two topics will give you a very solid background. For what you want to do computer architecture, networking, operating systems, math, languages and compilers, and distributed systems aren't as important. If you wanted to expand your abilities as a programmer then you should explore those topics.

As for databases, for your purposes you may not need to learn so much how databases work as opposed to how to query databases. For this you need to learn SQL.

This should give you all the background you need in CS, now its time to start building applications. You'll probably hit roadblocks and need to research how to accomplish certain tasks, but with the above background that should be very doable.

Extract properties into a class, so if you have a class like User and it has a series of address properties, create an Address class and extract those properties out into your new class and make sure it belongs_to :user. Then, if other types of classes need something similar (such as a Billing object), you can use the same class and have that belong to that object as well.

As far as naming, feel free to use whatever you want, though it might be best to use province instead of state since the word "state" in programming means something different, not to mention a province generally covers that same kind of location as a US state does (in fact I'm pretty sure under the hood Google Maps API handles it this way as well). Also make sure you store zip codes as a string since many countries use letters in their zips and US zip codes use a dash to include localized neighborhoods or PO boxes.

I'd pick up a book like Refactoring (Ruby ed.) which covers this pattern and a whole lot more.

Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.

• Modern Operating Systems - Tanenbaum. This, or any good OS book is something that anyone writing software that runs on servers should read. If you happen to only write frontend JS or HTML, you can probably skip it or push it to the end of the list.
  
  
• Design Patterns:
  Elements of Reusable Object-Oriented Software - "Gang of Four". My preferred way to consume this book is to read it lightly, understand the basics of the patterns, and then come back to them individually when you encounter them in the wild or think you want to employ one of them.
  
  
• Algorithms - Sedgewick. If you want a more mathematically rigorous treatment, Introduction to Algorithms - "CLRS" is excellent as well.
  
  
  
  
  Then there are these books that aren't really "CS books", but are geared more twoards practitioners.
  
  
  
• Clean Code - Martin
  
  
• Code Complete - McConnell
  
  
• Working Effectively with Legacy Code - Feathers
  
  
• The Managers Path - Fournier This one might seem like a weird suggestion, but even if you don't have plans to become a manager, it can help with understanding the path to a Tech Lead type of role. You'll also get a good idea of how your boss can and should be helping you, and what you should be asking of them.

I'll let you know once I figure that out.

The biggest problem is that as cool as design patterns are, real world problems rarely, if ever, fit directly into the mold of a design pattern. Sometimes you need to combine multiple patterns. Sometimes you need to majorly tweak the pattern to make it fit your problem. Then there's question of, are you over-engineering your solution?

All hard questions to answer. The best way to know is... experience. Have real world experience of trying these things out. So to answer your question, the best way to learn how to use design patterns effectively is to use them on real world problems. Not a satisfactory answer by any means, but for some things in life, there are no shortcuts.

It's like answering, "How do you get good at public speaking?" The answer is to speak in public. There's no book you can peruse, there's no youtube video you can watch. You just have to do it again and again and again.

That being said, reading about design patterns is step 1. Everyone knows GoF. It's a really dry read. Personally, I own Head First Design Patterns. Very easy to read. I haven't bought the design pattern resource you listed, but I did read the freely available ones. Personally I think it's too simplified. Again, I highly recommend Head First Design Patterns. I wish there was Head First everything.

If you are looking toward application development(games or otherwise) I'd suggest looking at more practical beginning programming books, don't even worry too much about making a game yet or building complex algorithms. I've found the Head First series fairly good in the past, so maybe try out https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208

Once you get your head around basic application development a bit more, I would highly suggest learning design patterns and can fully recommend the Head First book on that topic.
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
You can follow that up with the Game specific book on patterns, https://www.amazon.com/Game-Programming-Patterns-Robert-Nystrom/dp/0990582906

With all of that you should have enough to start asking more pointed questions and being able to Google up useful answers and tutorials that will get you on the road to building games.

Edit: That said, if you are looking at doing to extensive AI programming, specializing in engine design or other systems type development, start looking for books on the topic that interests you most. It's pretty easy to Google up book lists on these kinds of topics, and from there you can cross reference recommendations and should be able pick out ones that will help you get started.

Bitcoin mining programs are pretty advanced pieces of software, especially due to the rise of ASICs and other esoteric hardware that must be supported. You might want to consider an easier project for the time being.

Fundamentally, you need to have a good grasp on data structures before you can really get going with Merkle trees and cryptocurrency mining in general.

Here are some free resources to get started

If you want to consider grabbing a book, Algorithms (4th ed) is generally regarded as a decent book to get started on thinking with and using algorithms and data structures.

edit: depending on the time you have, you may also want to consider reading this on set theory. It tends to make later algorithms a bit more clear as a lot of it draws from set theory.

I love this book: http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X

It's a great read without being too math heavy. That combined with the fact that it has a great associated booksite, a Coursera course, and a couple of followup books by the same author that do go into the more mathy aspect of it, if you're so inclined, make it a great introduction to the world of Algorithms.

My blog about software architecture: http://www.tutisani.com/software-architecture/ (may not be for very beginners but I hope that it's able to communicate important topics).

I'd also suggest reading the classic book about design patterns (a.k.a. Gang of Four): https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_3?crid=1XRJO0L09LHLY&keywords=design+patterns+elements+of+reusable+object+oriented+software&qid=1557502967&s=gateway&sprefix=design+patterns%2Caps%2C162&sr=8-3

There are several good thought leaders in this direction, specifically Martin Fowler (https://martinfowler.com/) and Eric Evans (he does not write much online, but his book is great - all about modeling properly): https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215

​

I'm big on modeling, objects, etc. so reply back if any questions.

Not sure about EE-related topics, but for CE you're almost guaranteed to use these textbooks:

• Computer Organization: Patterson and Hennessy.
  
• Computer Architecture: Hennessy and Patterson. Same people as the computer organization textbook, but this one goes a bit deeper into architecture.
  
• Algorithms: Cormen, Leiserson, Rivest, Stein, AKA CLRS. Standard algorithms textbook for 99% of CS/ECE algorithms courses.
  
• C: Kernighan and Ritchie, AKA K&R. Ritchie is the original creator of C and a co-creator of Unix, so this content comes straight from the source.
  
• C++: Stroustrup. Like Ritchie, he's the original inventor of C++.
  
  And of course, the most important and useful textbook of them all for almost anything coding-related.

I learned mostly through reading textbooks in University, but not many of the books we were assigned stood out as being particularly great. Here's a few that I did enjoy:

• Artificial Intelligence: A Modern Approach.
  
• Computer Organization and Design: The Hardware/Software Interface
  
• Algorithms (Sedgewick). I liked this much more than CLRS.
  
  To balance things out, I'll also give a list of books I thought were awful:
  
  
• Discrete Mathematics with Graph Theory
  
• Fundamental of Database Systems
  
• Programming 32-bit Microcontrollers in C: Exploring the PIC32
  
• Software Engineering: A Practitioner's Approach
  
• Essentials of Theoretical Computer Science

> That's exactly a multi-agent simulation.

Well yeah, that was kind of my point. At least in biology, this isn't unusual.

> For most processes this is a too low level representation to be
> useful.

I find very useful, and I've modeled pretty much all business processes that I've implemented this way. Eric Evan's excellent book Domain Driven Design describes some very useful ways to reason about business processes, in effect, as multi-agent simulations (if you call an agent an entity in DDD terms).

I'll tell you my approach. I use c# to make windows applications used internally at a college that usually display student and loan information. I use a couple patterns (unit of work / repository and mvp.)

I break my project down to multiple layers (data, domain, service, presentation, and view).

My domain layer simply holds poco classes. That's plain old clr objects (classes with only public properties). Each class represents a table in my database and each classes' properties represent a field in that table. This layer also holds my validation classes.

The data layer is used to interface with my database. I use Entity Framework as my ORM and wire everything up using generic repositories and a unit of work.

My service layer is the middle man between my data layer and the rest of the application. It defines and implements what I can do against my database. For example: StudentService.GetAllActiveStudents() or CampusService.GetTeachersByProgram() etc...

My presentation layer is, well, the 'P' in MVP. And my view layer is the 'V'. Look up mvp pattern if you're interested.

The beauty of doing it this way is that everything is loosely coupled from everything else. I can switch out my data source and only have to change code in my data layer. I can write a new user interface that implements the view interfaces defined in my presentation layer and i know it will work. I can allow another application to use my service layer (create an api) for reuse. And the real beauty is that everything is testable. I follow test driven development pretty hardcore and doing it this way allows me to unit test everything.

I don't want to go to into detail about what each of these layers do because that information is easily found from google but the point is is that there are patterns out there which define how you design your project, how you break up your project into layers, and what those layers are responsible for. You might want to check out the book Head First Design Patterns. It uses java examples and it's really good at putting patterns into perspective.

In terms of practical, professional skills, here are a few I would recommend:

• The Pragmatic Programmer - writing non-trivial applications requires discipline and a practical mindset. This book is frequently recommended to new programmers as exposure to how think about and approach software development.
  
• Head First Design Patterns - schooling introduces you to OOP, but design patterns really highlight the strengths of object orientation. The Gang of Four book is also recommended, but I feel like the Head First book is more approachable.
  
• Working Effectively With Legacy Code - You didn't mention if you're coding professionally, but I think the above two books are applicable to someone who wants to take their work to the next level. If you are looking to work in software development, you're going to encounter a lot of legacy code - code that is poorly designed or hasn't evolved well with the application. This book gives you methods for recognizing and untangling the mess.
  
  For more tailored recommendations, where do you feel that you're weak? There are plenty of college textbooks that can introduce you to algorithms, but if you have an end-goal in mind, you can really focus your learning. Work on some tougher projects than you're used to, and study open source code that does interesting things.

Oppenheim gives a really great explanation for the motivation and derivation behind the Laplace and Fourier Transforms in is book Signals and Systems.

I know he also has some lectures on MIT Open Courseware, but I haven't seen them. I've heard good things.

I was really happy to have read that book before my Diff Eq class. Because that text just threw the Laplace Transform at us like it was handed down from the gods.

Some book recommendations:

• Clean Code
  
• Code Complete
  
• The Pragmatic Programmer
  
  Others that are great and related but not as "necessary" as the above three:
  
  
• Refactoring
  
• Design Patterns
  
• Head First Design Patterns
  
• Working Effectively With Legacy Code
  
• Beyond Legacy Code
  
  Unrelated to "better code" but still great:
  
  
• The Mythical Man-Month
  
• Soft Skills

E-commerce is where it's at my man. E-commerce is straight forward. It's a store where you buy stuff. Real simple. However, the backend architecture is a bit more involved. You have to handle things like Databases, Queues, Cacheing, Error Logging, Load balancing, etc. If you want to be a mid-level back end dev you really need to understand the basics of Service-Oriented Architecture (SOA). You should also be familiar with CI/CD Pipelines and docker containers. Try looking into some open source e-commerce platforms:

https://codinginfinite.com/best-dotnet-core-e-commerce-open-source-platforms/

https://github.com/dotnet-architecture/eShopOnContainers

Also you need a strong understanding of Object Oriented Programming (OOP). So you'll need to understand S.O.L.I.D principles very well. Of the SOLID principles, you should focus heavily on the 'D' which stands for Dependency Inversion.

Lastly, in any decent back-end interview, they'll ask you about design patterns. I'd recommend "Head First Design Patterns" (https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?crid=3JOAGN3VIZZ8P&keywords=head+first+design+patterns&qid=1574177751&sprefix=head+first%2Caps%2C187&sr=8-1 )

Hope that helps!

1. Learn the syntax of your programming language and the core API - http://docs.oracle.com/javase/tutorial/
   
2. Learn object oriented design - Head First Object-Oriented Analysis and Design
   
3. Learn design patterns - Design Patterns: Elements of Reusable Object-Oriented Software
   
4. Pick a platform - Applets, Android, Desktop or a combination. Core Java and design stuff will be the same but basic things like how you draw graphics or play sounds will vary. Usually you end up adding libraries or frameworks on top of Core Java to help you handle game specific things like graphics, sounds, input, etc. Some might be different across the platforms you want to support and others (LibGDX for example) try to be a single framework that supports multiple platforms.
   
5. Learn your platform/libraries/frameworks.
   
6. Make "retro" games with bad artwork or learn to also be an artist or how to find/hire an artist.
   
   Many game programming books start off at step 4 so you need to do 1-3 before you get into those books. Never get an old book for step 4, the game specific stuff gets out of date too fast. Anything that does 1-4 all at the same time probably isn't worth it.
   
   

You mentioned Robert Sedgewick. His book, Algorithms and his online courses are highly recommended. And he uses Java in them.

http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
http://algs4.cs.princeton.edu/home/

For object-oriented design the Head First books are great. It also worth to have the classic book Design Patterns: Elements of Reusable Object-Oriented Software.

http://www.amazon.com/dp/0201633612

I also recommend the books Code Complete, and Clean Code, they are great.

So Tangled Web is a good book but it's not about exploitation in the sense it seems you're meaning. The Kernel Exploitation book is good but daunting if you don't have any exploit development experience. You may also consider A Bug Hunter's Diary by Tobias Klein

Grab a copy of the Intel IA-32 Assembly Reference http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html. I wouldn't recommend reading through this as a how-to but having a local copy to reference various unfamiliar instructions would be helpful.

Phrack articles are pretty useful too. Exploit-DB and packetstorm will be useful for finding working exploits for legacy bugs you may be practicing on.

Whatever language you're writing your exploits in (Perl/Python/Ruby) you'll probably want a reference for that.

https://www.amazon.com/dp/0201633612/?tag=stackoverflow17-20

https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

And you could check stack overflow for question on general programming books. I would always go for a general concept functional programming over how to functional programming in haskell.

But I'll be perfectly honest, I'm a victim of the curse of knowledge so I honestly don't know how one should start. What I do remember is that I had huge problems with syntax (how do I tell language X to do a for (Employee e in employeeList), how do you write a switch and stuff, why would I ever need a ternary operator, and like that.

But once you master the basics of how to write x, y and z in your preferred language, you absolutely need to understand design patterns, you absolutely need to understand how code is supposed to be written, you absolutely need to understand data structures, you absolutely need to understand inheritance and polymorphism, you absolutely need to understand lambdas and functional programming.

Then you can get to the more "neat" stuff like the benefits of having immutables, and "job specific stuff" like how to solve race conditions in threading; sockets and web communication, etc.

I understand how you feel, honestly - as someone who did poorly in school, and I am somewhat dyscalculic, I really feel like I can relate!

The important thing for you, in my opinion, based on your explanation there, is to look for learning materials that suit you. Some people learn easily from really academic materials, some (like me) don't - and fortunately, there are lots of materials out there trying different approaches to teaching this kind of stuff. It gets easier as you go, as well - once the ball starts rolling you find it much easier to grasp future concepts. I got a massive 1300 page book called "An introduction to Algorithms" many years ago... Introduction my arse. It might as well have been alien language to me. But now, years later, I can actually understand its contents. It definitely was not an introduction (but it is a great book, both physically and literally).

A few recommendations for actual introductory books on these subjects:

"A Common-Sense Guide to Data Structures and Algorithms" by Jay Wengrow (2nd Edition coming 2020)

This book says the following in the opening chapter:

>"The problem with most resources on these subjects is that they're...well...obtuse. Most texts go heavy on the math jargon, and if you're not a mathematician, it's really difficult to grasp" . . . "Because of this, many people shy away from these concepts, feeling like they are simply not 'smart' enough to understand them."

It's not a perfect book, but it goes into a lot of basic data structures and explains them in a not-insane way. It helped me a lot! Understanding not just how they work, but why they are useful, is so helpful.

"Grokking Algorithms: An illustrated guide for Programmers and other curious people" by Aditya Y. Bhargava

A similar book, however, more algorithm and less data structure focused, and it goes into somewhat more depth, although usually the extra material is considered optional. The author here expresses a similar concern that books and learning materials on these concepts are often very hard to understand, and it need not be that way!

You can learn these things, you just need to find the right book/method that works for you! It can take some searching to find it. I know from experience!

Read the books, try to implement some of their concepts, and then try applying those things to real problems (i.e. from HackerRank or similar sites, try more than just HR). Read the book again. Repeat. You will understand a bit more each time. That was what worked for me, at least.

This class on udemy is great, it covers absolutely everything about angular. https://www.udemy.com/the-complete-guide-to-angular-2/

Other than that if you want a strong understanding of the fundamentals you should invest some time in studying Object Oriented Programming and design patterns built on OOP. For instance angular uses the Decorator and the Observable patterns heavily. A good book on this is Head First Design Patterns, though it uses java code it may still help. It has a lot of pictures and psuedo code puzzles
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?ie=UTF8&qid=1518933015&sr=8-1&keywords=head+first+design+patterns

Just think of these design patterns as mental tools, along with a little bit of coding syntax, that will help you elegantly handle more complex problems in your code. Using TypeScript lets you put all of the tools in that book to use.

fwiw, bare minimum working code is often a good idea if we're talking about the amount of code to do some task :)

Design patterns are most useful in that they help you start recognizing patterns in your own code, and they show you a number of common patterns which can be useful - but it's good to keep in mind that you shouldn't force a design pattern somewhere just because it's a design pattern.

Anyway, the Design Patterns book is good, and so is Head First Design Patterns.

I've always preferred to learn by videos such as from Udemy or Udacity, but if books are your preference I suggest Algorithms(4th Edition).

It's pretty intensive at times but it also has a course that goes along with it which is pretty fantastic.

It isn't always necessary to take some introductory courses. At my school, students coming in with a background in computing could skip CS101 and head right into CS102.

To be fair, not all schools carry identical curriculums, so OP should reach out to some professors to gauge whether he can skip an introductory course.

OP, if you have a good understanding of Java, you might want to check out Algorithms by Robert Sedgewick and Kevin Wayne. It's a great introduction to computer science and was one of the textbooks in my CS102 class. Sedgwick and Wayne also have a website which has a number of great resources.

One thing that's awesome about Python is the language itself helps solve a ton of the gang of four's design patterns. That said, I really appreciated reading Head First Design Patterns because it helped me understand what I already did intuitively better https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?ie=UTF8&qid=1540609515&sr=8-1&keywords=head+first+design+patterns&dpID=61ZG-hATOeL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch.

I second the comment to learn SQL really well. Also regular expressions come up frequently enough to be worth learning a bit about. Some familiarity with data structures is worth picking up, and getting a grasp on some common design patterns is well worth the time.

On the last point, I’d recommend Design Patterns in Ruby and Refactoring Ruby

Hope that helps.

Many of the "why" questions are more general than just Java. I'd suggest a book on design patterns ([Head First Design Patterns](Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.com/dp/0596007124/) is pretty good and accessible for a beginner) or object oriented programming in general.

Learning the theory and patterns of polymorphism, composition, etc will certainly help when trying to understand why languages implement certain features, and will also make you much more capable of using those features in the wild.

You've already done the first step: admitting that college can only teach the fundamentals while the rest of the things you need to know, you will learn while working.

With that out of the way, here's the next step: apply the Joel Test to your new employer.

If it gets an 11 or 12, you'll be fine. Find a senior developer there to mentor you and you'll be a decent software engineer in 1 - 2 years.

Otherwise, while you might learn a lot of new stuff in your first job, they might be inadequate, outdated, or outright incorrect. In this case, plan an exit strategy ASAP so that you can leave to another company that has a much higher score in the Joel Test. In this fast paced software industry, it makes no sense to spend 5 years in a company where you'd only get to grow the same amount as another guy who just spent 6 months in a better company.

Next step: read. No, not those "Teach yourself [insert language that will be deprecated in 2 years] in 24 hours" books - find the books that teach software engineering, lessons that don't get outdated. Here's the usual suggestions:

• Code Complete 2
  
• The Pragmatic Programmer
  
• The Mythical Man-Month
  
• Peopleware
  
• Rapid Development
  
• Refactoring
  
• Head First Design Patterns
  
  Finally, if you have free time, find a local user group or open source community and join them. Not only will you learn fundamentals like version control and automated testing, you'll also be up to date to the latest trends in the industry. Because of this, high school/college students who are active in these communities have a great advantage over their purely academic classmates, not to mention the connections they get in the industry allow them to be employed faster.

If we are going to talk about a good new netsec book, I recommend everyone check out "Tobias Klein's" - A Bug Hunter's Diary. You can get it at nostarch.com but I recommend saving the cash and getting it from amazon.com. I got my copy on Monday and its been a pretty good read so far.

Copy pasting my response to a similar question:

Edited to have more resources and be easier to read.

It's hard to draw the line between "essential" and "recommended." That depends a lot on what you want to do. So, I will present a rough outline of core topics covered in the 4 year CS program at my university (UC Berkeley). This is not a strict order of topics, but prerequisites occur before topics that depend on them.

Intro CS

Topics include Environments/Scoping, abstraction, recursion, Object oriented vs functional programming models, strings, dictionaries, Interpreters. Taught in Python.

The class is based on the classic MIT text, "Structure and Interpretation of Computer Programs." Of course, that book is from 1984 and uses Scheme, which many people don't want to learn due to its rarity in industry. We shifted recently to reading materials based on SICP, but presented in python. I believe this is the reading used now. This course is almost entirely posted online. The course page is visible to public, and has the readings, discussion slides / questions and solutions, project specs, review slides, etc. You can find it here.

Data Structures and basic algorithms

DS: Arrays, Linked Lists, Trees (Binary search, B, Spaly, Red-Black), Hash Tables, Stacks/Queues, Heaps, Graphs. Algorithms: Search (Breadth first vs depth first), Sorting (Bubble, radix, bucket, merge, quick, selection, insert, etc), Dijkstra's and Kruskal's, Big-O analysis.

This class uses two books: "Head First Java" and "Data Structures and Algorithms in Java" (any edition except 2). The class doesn't presupposed knowledge in any language, so the first portion is covering Object Oriented principles and Java from a java book (doesn't really matter which), then moving to the core topics of data structures and algorithms. The course page has some absolutely fantastic notes -- I skim through these before every interview to review. You can also check out the projects and homeworks if you want to follow along. The course page is available here (note that it gets updated with new semesters, and links will be removed -- download them soon if you want to use them).

Machine Structures (Intro Architecture)

Warehouse scale computing (Hadoop Map-Reduce). C language, basics of assemblers/compilers/linkers, bit manipulation, number representation. Assembly Language (MIPS). CPU Structure, pipelining, threading, virtual memory paging systems. Caching / memory hierarchy. Optimization / Performance analysis, parallelism (Open MP), SIMD (SSE Intrinsics).

This class uses two books: "The C Programming Language" and "Computer Organization and Design". This class is taught primarily in C, so the first few weeks are spent as a crash course in C, along with a discussion/project using Map-Reduce. From there in jumps into Computer Organization and Design. I personally loved the projects I did in this class. As with above, the lecture slides, discussion notes, homeworks, labs, solutions, and projects are all available on an archived course page.

Discrete Math / Probability Theory

Logic, Proofs, Induction, Modular Arithmetic (RSA / Euclid's Algorithm). Polynomials over finite fields. Probability (expectation / variance) and it's applicability to hashing. Distributions, Probabilistic Inference. Graph Theory. Countability.

Time to step away from coding! This is a math class, plain and simple. As for book, well, we really didn't have one. The class is based on a series of "Notes" developed for the class. When taken as a whole, these notes serve as the official textbook. The notes, homeworks, etc are here.

Efficient Algorithms and Intractable Problems

Designing and analyzing algorithms. Lower bounds. Divide and Conquer problems. Search problems. Graph problems. Greedy algorithms. Linear and Dynamic programming. NP-Completeness. Parallel algorithms.

The Efficient Algorithms class stopped posting all of the resources online, but an archived version from 2009 has homeworks, reading lists, and solutions. This is the book used.

Operating Systems and System Programming

Concurrency and Synchronization. Memory and Caching. Scheduling and Queuing theory. Filesystems and databases. Security. Networking.

The Operating Systems class uses this book, and all of the lectures and materials are archived here (Spring 2013).

Math

Those are the core classes, not including about 4 (minimum) required technical upper division electives to graduate with a B.A. in CS. The math required is:

• Calculus 1 and 2 (Calc AB/BC, most people test out, though I didn't)
  
  
• Multivariable calculus (not strictly necessary, just recommended)
  
  
• Linear Algebra and Differential Equations.
  
  Those are the core classes you can expect any graduate from my university to have taken, plus 4 CS electives related to their interests. If you could tell me more about your goals, I might be able to refine it more.

my path from pre-oop to feeling like I finally understand why to use OOP principles and when / how to implement them has been:

cakephp (briefly) > yii > laravel > Symfony 2 > starting now on ZF2

shortly after getting serious with learning MVC for work reasons, I started by trying to use a framework. I experimented with various - and only really got a basic grasp of why after trying yii properly for a project.

I then redid the project in laravel - improving it but it was still a complete shambles really.

Then I got the headfirst design patterns book:

http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?ie=UTF8&qid=1369730778&sr=8-1&keywords=headfirst+design+patterns

I cannot recommend that enough.

It's in java but you should be able to grasp it - the main thing is the way constructors are named after the class name in java threw me at first, but after that, its very similar indeed.

Don't pirate that book either - I have tried it in pdf and I bought it in the end, as its not a very easy book to read if you dont have it on paper.

From there, I read about half that book and was able to apply what I had learned to how these MVC frameworks were working - and that was without ever touching the MVC chapter.

Learn about why / how to abstract, factories, why programming to interfaces is super important, and a ton of other things that will take you from being somewhere around beginner / intermediate, to comfortably intermediate heading towards advanced.

• The Passionate Programmer: Creating a Remarkable Career in Software Development by Chad Fowler
  
• Head First Design Patterns by Eric Freeman and Elisabeth Robson
  
• The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt and Dave Thomas
  
• Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin
  
• Code Complete (2nd Edition) by Steve McConnell
  
• Refactoring: Improving the Design of Existing Code by Martin Fowler

The other major website on this subject is the Aggregate Magic Algorithms.

You can also find some interesting hacks at the Chess Programming site bitboards.

The magnificent book Hacker's Delight is the Knuth of bits. It's actually better than Knuth on this subject! (At the end of 50 pages of bitwise stuff in Volume 4, DEK basically says "read Hacker's Delight for the real deal.")

> Like a bunch of spaghetti

That might not all be your fault, I have no idea how good the codebase is! ;)

Two resource recommendations for you:

• The Object Oriented Thought Process. This book really helped me wrap my head around the core OOP concepts.
  
• Head First Design Patterns. A great intro to common patterns we use in software development. For example, the Singleton Pattern!
  
  One other thing I encourage you to do is to ask questions of the senior devs on the team. Try to find someone who you get along with and might be able to serve as an informal mentor. I know it is difficult to say "I don't know", but it is a lot better than floundering with a problem for a week. Good luck!

Buy an Arduino or another open source microprocessor and research interactive programming... tinker with embedded hardware. Or switch industries, find a software position within an industry that actually does make a real world impact, preferably one you are passionate about. At my day job I do have some mundane tasks as far as development is concerned but my overall contributions to our final product makes me love my job and remain passionate about software.

CLR is a great book, but like all text books, it's not cheap. If you're looking for used books, and find that you can get Sedgewick for a better price, then that's an equally good book to learn from.

Hey there! I personally love patterns. I think there are one of the single best things you can learn as a programmer. So here are some resources I have used and was successful with.

• Head First Design Patters
  
• Recorded Lectures on Design Patterns

These are insightful questions and the answers are less obvious that it might seem. There are subtleties that for various reasons I can't and won't cover here, and the best advice I can give you is to read about the subject(s). The second best advice I can give you is to search Google like mad, because there's a lot of stuff out there and I don't have time to find other books.

• Scott Meyers' Effective C++ series are aimed at C++ but contain some general purpose advice w.r.t. API design and code structuring (in contrast, Herb Sutter's stuff is almost purely C++, so don't bother with that).
  
• Eric Evans' Domain-Driven Design is a little more high-level than your questions but a good read.
  
  > but setters should be protected, for extensibility
  
  How often do you extend your classes? If it's often, it's probably too much -- favour composition ("has-a") over inheritance ("is-a"). I declare all my classes final to start with and I rarely have to change that. More, your private members are the only ones you have complete control over -- as soon as something is protected a deriving class can use it, and then the member is effectively part of the public API after all. For this reason, protected is nearly as bad as public. This is one of the things Scott Meyers talks about.
  
  > Furthermore, do I even need setters if my class is going to be the only thing setting its variables?!
  
  Automatic code generation is one of the least helpful things IDEs have given us and, I contend, a direct source of much shitty code. Make no setter or getter until it is absolutely needed, and provide neither for public fields (that will cause confusion).
  
  > Should I ever be setting object variables outside the class?!
  
  "It depends". There are valid reasons for it, and of course I can't think of any off the top of my head. What you should absolutely avoid is the ability to construct a Foo without a Bar when Foo cannot work without Bar. In this case, it's a constructor dependency, and a Foo::setBar() implies that Foo's Bar instance can be in an invalid state.

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

Try Algorithms by Robert Sedgewick and Kevin Wayne. I haven't read the book itself (I have used it for reference once or twice) but I have taken a Coursera course on algorithms given by professor Sedgewick, and the clarity with which he lays the material out is really notable. There is something great about learning how to implement red-black trees from the guy who invented red-black trees. (Oh, by the way, that course is free and starts again on August 7th. The course and book together would complement each other very well, I think.)

Hey,

ECE212.


ECE241 - You learn C++ and OOP fundamentals in this course. We didn't have a textbook when I took it. Just online notes.

ECE241 - Stephen Brown is a prof at UofT and a great lecturer. I also still have this book if you are interested in buying from me!

ECE216 - Might still have this book if you're interested.

ECE221 - Professor Stickle probably will teach this course. Great lecturer but his tests/exams are notoriously hard.

ECE243 - Did not have a textbook when I took the course. Prof. Moshovos provided course notes online.

ECE297 - No textbook for this course. It's like a mini design project that lasts all semester where you have to build a concurrency based storage server in a team of 3. Picking a good team of programmers and technical writers is imperative.

Protip: Next time check TUSBE for textbook names and buying second-hand textbooks.

PS: Congrats on getting through 1st year, 2nd year will be tough.

The feedback about "jargon for development" can be solved by going through some books cover to cover, making sure you understand the theory, and implementing the exercises. I understand that feedback to mean that the person who gave the feedback believes there is too high a chance you will inflict damage on the codebase by making decisions not grounded in solid theory.

Examples of titles that are classics and widely known:
Algorithms (4th Edition): https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X (there is an accompanying coursera course).

Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?s=books&ie=UTF8&qid=1469249272&sr=1-1&keywords=code+complete

Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&ie=UTF8&qid=1469249283&sr=1-1&keywords=clean+code

Functional Programming in Scala: https://www.amazon.com/Functional-Programming-Scala-Paul-Chiusano/dp/1617290653/ref=sr_1_2?s=books&ie=UTF8&qid=1469249345&sr=1-2&keywords=scala

Learning Python: https://www.amazon.com/Learning-Python-5th-Mark-Lutz/dp/1449355730/ref=sr_1_1?s=books&ie=UTF8&qid=1469249357&sr=1-1&keywords=learning+python

Effective Java: https://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_5?s=books&ie=UTF8&qid=1469249369&sr=1-5&keywords=java

Haskell Programming From First Principles: http://haskellbook.com/

I included multiple languages as well as language-agnostic ones. Functional programming is the near-to-medium term future of software engineering, and most languages converging towards that as they add functional features.

I don't think bootcamp is required. Learning how to learn is the most important thing. If you get into these books, lose track of time, and feel "aha! that's how these things that I previously thought were unrelated are actually the same thing!", and are able to keep it up for weeks, then that is a good sign that you can get to where you want to be.

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.

Design Patterns (Head First).

It's the "gang of four" patterns covered in a somewhat silly way to help you learn it. Teaches you some very good stuff.

I'd get the gang of four book for a reference, but get the Head First one to learn them first. It's not precisely pure OO, but it teaches you concrete ways to apply good OO practices, such as (the most important one IMHO) favoring composition over inheritance.

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.

Awesome list, thanks for sharing. This so very useful to me as I'm currently in an apprenticeship to become a software developer and am working through this textbook Data Structures and Algorithms and could use all the other helpful links I can get!

Headfirst Design Patterns (pardon the ugly cover), this book easily illustrates and explains software engineering patterns that many would consider essential to writing good software. I'm currently in my senior year of Computer Engineering with a Software Emphasis and patterns are very important for writing manageable, maintainable, and readable software. (apologies for ugly link)

Amazon: https://www.amazon.com/gp/aw/d/0596007124/ref=mp_s_a_1_1?ie=UTF8&qid=1487231105&sr=8-1&pi=AC_SX236_SY340_FMwebp_QL65&keywords=head+first+design+patterns&dpPl=1&dpID=61APhXCksuL&ref=plSrch


Something else I recommend is buying a raspberry pi and setting up a basic home web server, you can Google easily how to so this. This is a fantastic introduction to full stack development and the possibilities are endless.

Hope this helps, good luck!

Edit : I also work as a software developer and will be working there full time when I graduate.

The one book that every programmer should read is Code Complete. It goes over all stages of development in a high level overview that applies to any project.

I would then move onto Algorithms by Sedgewick and Wayne. I tried reading Introduction to Algorithms because it was strongly suggested to me, but it goes into higher level math really quick. I haven't taken calculus since high school and never took any higher level math classes in college, so I got lost after about page 30.

After that, I would just look for a book dedicated to design patterns in the main language you work with. There are some overlapping patterns between languages, but it's best to be practical about what you learn.

If you don't have time/want to get results quickly then you could look into using Navmeshes. Otherwise you need to get your hands dirty with some algorithms.


Most people use A*, DBF, or Dijkstra. There are tons of easy to find resources on them.
A good book that has a few chapters dedicated to graph traversal is Data Structures and Algorithms




Sidenote, how are you using raycasting with the zombies? If you simply want them to not run into shit and don't really care about how smart they are, a simple solution would be to get the radius of the collider around the zombies, check if another collider has collided with it, if it has then make the zombie rotate x degrees and begin moving again. OnCollisionEnter should be sufficient enough. Just make sure the prefab zombie has a collider on it and each wall has a collider.

If you want to understand why objects and interfaces are useful, I'd recommend reading Head First Design Patterns. It is truly the first resource I came across that made me grasp why objects and interfaces have a useful purpose.

I started to write an example for ELI5, but I decided that the first two chapters of that book would be a great example. It even includes ducks. :P

The book Domain Driven Design: Tackling Complexity in the Heart of Software sort of revolves around this topic. The author speaks at great length about projects where spending way more time in modeling / researching than coding allowed them to solve the problems in ways which allowed them to scale way better - and what they did during that time.

The book is a bit old, but if you take it for the modeling aspect it's still a great read.

I would recommend you reading O'Reilly's Head First: Design Patterns It is oriented for Java, but the patterns are the same in most OO languages. I compiled all the examples in C++ and all was great.

The book essentially teaches you how to write code that is easy to modify later on.

I think the best way to learn is by doing, so I suggest doing a big project in Java. The Java documentation talks about object-oriented programming a lot and is a good read.

If you want something to read, this book looks a little kooky, but don't judge a book by its cover. It is probably one of the easier to read books on the subject, but still has a lot of good information

It sounds like design patterns might be useful: http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124

Also, like the other commenters have said, you are mainly breaking up your program into smaller subprograms. However, it is really difficult to decide how exactly to break up your program. This is an entirely separate concern from things like algorithms and requires a different type of thinking. Design patterns, if you use them correctly, save time because you don't have to think up a new solution for every problem. They also make it easier for other people to understand your code, force separation of concerns, and make your program more extensible and modular.

+1, don't just circle jerk and pretend you're above learning patterns before you even understand why they exist. They can be abused, but they exist for good reasons.

I strongly recommend going over Head First Design Patterns to anyone interested.

Low level stuff is pretty academic. You need textbooks just to get started.

These were my college textbooks (I have earlier editions):

Computer Architecture: A Quantative Approach

Computer Organization and Design: The Hardware/Software Interface

The material is pretty dry but if you can slog through it you will gain good insight into how and why chips and systems are designed the way they are.

Below this level is logic gate design where if you don't have a background in semiconductor physics you'd never get through it.

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

Learn about...

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

Software Engineering: Code Complete by Steve McConnell

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

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

Why we love Joel: Joel on Software by Joel Spolsky

Problem Solving: The Pragmatic Programmer by Andrew Hunt

Common Code Solutions: Head First Design Patterns by Eric Freeman

Pearls!: Programming Pearls by Jon Bentley

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

Thanks! Just to make sure, do you mean these two books?

• Introduction to Algorithms
  
• Algorithms
  
  If so, I'm glad you mentioned those. Both of them are already on my to-read list, but they were further down than Knuth's work. Since, as you say, they might better for starters, I'll check those out first.
  
  By the way, I have also heard some good things about this one:
  
  
• The Algorithm Design Manual
  
  Have you any experience with that book? It's also on my to-read list.

> Data Structures and Algorithms

http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237

Is this the book you're referring to?

I've been focusing on C# for the past year when I can. Currently "developing" an archiving tool for certain files that I am hoping to use as a resume piece. Trying to show off things like MVVM, IoC/DP, async/await, cloud storage integration and the new .net stuff. Metro style UI, maybe.

I know that C++ is in demand, but I thought I'd have an easier time starting with C#, which I also see a lot of firms looking for. Based on the networking I've done, C#, Javascript, or C++ would all have been good places to start. I just want to get my foot in the door somewhere. Getting past the resume glance inspection is my biggest hurdle.

Why stay at a school where you're not studying what you want, and which doesn't even offer what you want nor one of the most popular in-demand majors??

Anyway, there are any number of online courses/tutorials about Data Structures, and how to build/use them in various languages. You can use C++ for them, or try to learn something else too. For speed & simplicity in interviews, a lot of people seem to prefer Python for discussing DS&A, but by their nature the concepts are fairly language-agnostic.

Try visualalgo for one ... there are plenty of others.

Since a lot of algorithms require/suggest the use of specific data structures to make them work, it's probably better to learn what those are first, and then try to tackle the algorithms that rely on them.

Grokking Algorithms - illustrated & pretty basic intro to concepts

Common Sense Guide to Data Structures and Algorithms - slightly less so, but still pretty basic intro to concepts

CTCI - problems covering arrays, linked lists, stacks & queues, trees, graphs ... Actually kind of useless if you don't already know what those are though.

Introduction to Algorithms (CLRS) - 1 of 2 standard U.S. college-level algorithms textbooks

Algorithms, 4th Ed. - the other standard U.S. college-level textbook, w/free online "book site", code, and a free Coursera course to go along with it.

Data Structures and Algorithms is what I used in my class... not so easy to read but a ton of sample code that is easy to understand. I would recommend checking it out at a library before buying it, though... my class was fairly 50/50 on who liked it and who didn't.

I strongly suggest picking up the book Head First Design Patterns. The examples are in Java (but simple enough to do with no Java experience) and easily adaptable to PHP. It teaches best practices, design patterns, and coding principles and explains why they're good.

Once you start thinking and coding in design patterns you will be able to learn Unit Testing. After you know how to write Unit Tests you can then write code by TDD (Test Driven Development).

Edit: It's also imperative you know about PSR-0. It allows PHP to easily implement the SR (Single Responsibility) principal.

I think this is a pretty standard book used in universities: http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X

Using it right now in my CS masters class and it's pretty helpful.
You can easily find it free just searching for the pdf online.
It goes over hash tables, trees, stacks, queues, sorting, and more.

Google "c# github projects for beginners". Theres a whole bunch of interesting stuff out there. You could also download/fork a github repo and try to extend a project, or build on top of it.

I think this repo has been posted here before, but learning design patterns is really useful prior to designing something from ground up. https://github.com/Finickyflame/DesignPatterns

Here's a good beginner's book on design patterns. https://www.amazon.com/dp/0596007124/ref=cm_sw_r_cp_apa_i_FmHsDbGWQ0NTJ

Head First Design Patterns: A Brain-Friendly Guide

A relatively unique methodology of approaching design patterns (using Java examples). Understanding design patterns will transform both you and your code.

EDIT: Adding my comment below to my comment here for better visibility and description of the book:
> It can absolutely be read as an introductory book! I would recommend going into the book having a foundation in an OO language, such as Java or C++.

> This was the "textbook" we used in my Object-Oriented Design course; however, the great part about this book is that it reads more as a "narrative" than a traditional textbook. I definitely think this is the best book for learning about design patterns. The GoF book should be used as a reference, after you understand them better.

> All I can say is do not judge a book by its cover, and in this case I mean it literally. I think they are trying to be ironically cool by using stock photos on the cover and within the book. It seems odd to be reading through a "serious" book that look like that, but believe me when I say it will be an eye-opening experience.

Consider 'The Elements of Computing Systems' if you would like a grand tour of our current computer architecture. Start with logic gates and eventually build an operating system: http://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/026214087X

The book has got to be five out of five for a reason, right? Good luck!

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

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

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

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

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

I hope this helps :)

I suggest you read some books that focus more on the general topic, IMO they provide more information and are more understandable.

Back when I was in university the first book about A/DS I read was "Algorithms and Data Structures" by Niklaus Wirth. I've looked it up now and it's freely distributed by the author in PDF format. http://people.inf.ethz.ch/wirth/

Then I read "Data Structures and Algorithms"
by Aho, Ullman and Hopcroft https://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237

and "Introduction to Algorithms" by Cormen, Leiserson, Rivest and Stein https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

Those books overlap in many parts, but it never hurts to re-read about a subject to better understand and memorize it. The first book is smaller in volume as compared to the other two, so it might be a good start, but judge for yourself - look at the tables of contents and compare what you find more appealing.

as a beginner you're stuck in a position where you want to learn how to do things, but also how to write them. i.e you don't only want to paint a painting, but you also want it to be pretty and admired.

for programming there's a lot of schools of thought on this subject, some guys prefer test-driven development, others domain-driven design.

some think comments outside of method parameters are good coding praxis, others think it's a code-smell because if you have to explain your code you probably wrote it in a way that makes it difficult to understand.

some think patterns are for hipsters, others are of the correct opinion (ahem) that they are standardised solutions for common problems.

all in all, if I could go back in time 15 years when I started programming, I would read the following if they were available at the time:

https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215

Domain-Driven Design is the concept of breaking your code into logical real world units and bundling your code around these objects so that it makes sense to program if you understand the real world your program is mirroring. i.e if you're making a fruit shop program, you might have a fruit seller, a register, a fruit warehouse, a process to deal with ordering fruit etc.

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

Clean code talks not so much about the architectural patterns (outside of test-driven development) but rather what's good and bad about code at it's core. i.e

if(fruitStand.Amount < 5)
{
fruitHelper(fruitStand, 3434)
}

vs

if(fruitStand.Amount < dailySoldAverage)
{
OrderNewFruit(fruitStand, wholesaleDiscountCode)
}

outside of that, I think you'll find a lot more resources by simply researching the concepts these guys talk about. programming is constantly changing, as long as you have the fundamentals in place as these guys talk about you're golden as long as you're willing to learn.

I'll quibble with the "easy to read" part. As a reference, to look up one individual pattern and learn how to use it, I agree with you. As a cover-to-cover book to learn why patterns are important and how they relate to each other, I prefer Head's Up Design Patterns. I find it much more readable (source: I read it cover to cover, after having had the GoF book on my self for years and only reading bits and pieces).

My suggestion to anyone interested in design patterns is to read the Head's Up book, then have the GoF as a reference.

... none of which helps OP for his upcoming interview. :)

I currently work with the Axon Framework. The community isn't that great, but the inventor is fantastic. He's always willing to help (at least it seems that way). I would suggest looking around the internet at things such as CQRS, Event Sourcing, and DDD (Domain Driven Design).

Since you asked for resources I would suggest Vaughn Vernon. Also, my coworker has a giant list of resources, here you go.

DDD Stuff:

• http://www.methodsandtools.com/archive/archive.php?id=97
  
• http://martinfowler.com/bliki/BoundedContext.html
  
• http://martinfowler.com/tags/domain%20driven%20design.html
  
• http://martinfowler.com/bliki/CQRS.html
  
• http://codebetter.com/gregyoung/2010/02/16/cqrs-task-based-uis-event-sourcing-agh/
  
• http://www.amazon.com/Patterns-Principles-Practices-Domain-Driven-Design-ebook/dp/B00XLYUA0W/ref=pd_sim_351_4?ie=UTF8&dpID=61jV2fUPQDL&dpSrc=sims&preST=_AC_UL160_SR128%2C160_&refRID=0YSBRDAXH1YMJ0BD4GRZ
  
• http://sculptorgenerator.org/
  
• http://www.infoq.com/articles/ddd-in-practice
  
• http://www.developerfusion.com/article/9794/domain-driven-design-a-step-by-step-guide-part-1/
  
• https://www.youtube.com/watch?v=I4A5ntHeoxU
  
• http://danielwhittaker.me/
  
• http://danielwhittaker.me/2014/10/18/6-code-smells-cqrs-events-avoid/#more-171
  
• http://blog.sapiensworks.com/post/2014/10/31/DDD-Identifying-Bounded-Contexts-and-Aggregates-Entities-and-Value-Objects.aspx/
  
• http://dddcommunity.org/library/vernon_2011/
  
• http://udidahan.com/2009/12/09/clarified-cqrs/
  
• https://cqrs.files.wordpress.com/2010/11/cqrs_documents.pdf
  
  Axon Stuff:
  
  
• http://www.axonframework.org/
  
• https://groups.google.com/forum/#!forum/axonframework
  
• https://github.com/avthart/spring-boot-axon-sample
  
• https://github.com/avthart/spring-boot-axon-sample/blob/master/src/main/java/nl/avthart/todo/app/configuration/AxonConfiguration.java
  
• http://stackoverflow.com/questions/9646884/real-life-experience-with-the-axon-framework
  
• https://github.com/meltmedia/jgroups-aws
  
• https://github.com/AxonFramework/Axon-trader/wiki/Architecture
  
• https://github.com/AxonFramework/AxonFramework/blob/master/quickstart/src/main/java/org/axonframework/quickstart/RunSaga.java
  
• https://groups.google.com/forum/#!topic/axonframework/7c-k-U7tQtc
  
• https://groups.google.com/forum/#!searchin/axonframework/mongodb/axonframework/J3APCvLubgQ/hjdwtcU3QYAJ
  
• https://github.com/tomsoete/spring-boot-starter-axon
  
• https://blogs.vmware.com/management/2013/02/scaling-in-complex-domains-using-cqrs-axon-and-spring-insight.html
  
• https://github.com/AxonFramework/Axon-trader/blob/master/infrastructure/src/main/resources/META-INF/spring/cqrs-infrastructure-context.xml
  
• https://ath3nd.wordpress.com/2014/03/28/using-an-axon-saga-in-a-spring-app/

That was a typo it's CE12. The past three quarters it has focused on digital logic structures, binary/hex math, basics of building a processor, and the MIPS assembly language. If you want to get a head start on the book pick up Computer Organization and Design.

CS101 will depend on the instructor. If you are assigned to Tantalo's class then you will be doing a mix of programming assignments and proof stuff. I'm not super familiar with the details but luckily, his materials are all posted on his course websites, just google UCSC CMPS 101 and find it. If on the other hand you are assigned to Sesh's class then (at least based on this last quarter) you won't be doing coding, you'll be doing very thorough proofs about algorithms. Both of these classes use CLRS which, if you're serious about CS, you'll probably want to have as a desk reference regardless.

Algorithms in C++ by Robert Sedgewick. If you go through this book and actually try out all of the examples, you will be well on your way to being a good programmer. It's not language agnostic, but C++ is a good place to start. Once you've gotten programming concepts down in one language, it's easy to apply them to another.

Pragmatic Programmer, Clean Code, and Head First Design Patterns come to mind right away. They're 3 of my favorites.

There's also Design Patterns by the Gang of Four. That's a lot more dense IMO than Head First, but it's fantastic material.

Since you're looking to jump ship and start interviewing, take a look at Cracking the Coding Interview. That will prepare you for any questions you run into during the process.

It's probably also worth brushing up on Algorithms and Data structures.

I took the same two courses, as well as EE123 (digital signal processing), which had a very good text: http://www.amazon.com/Discrete-Time-Signal-Processing-2nd-Prentice-Hall/dp/0137549202. Another good one is http://www.amazon.com/Signals-Systems-Prentice-Hall-Signal-Processing/dp/0138147574/ref=sr_1_1?ie=UTF8&s=books&qid=1240638404&sr=1-1 , which was an optional text for EE120 when I took it (much better than the Lee & Varaiya text IMO).

> I don't know what the fuck you're actually advocating.

Try to get some more experience, kid. Especially with things like Dependency Inversion and Domain Driven Design. Then maybe you'll understand.

> Put adaptors on all the things so you don't depend on them, but
> you're not passing interfaces to everything.

You don't create such fine grained interfaces that wrap around a single library in particular. That would make the adapter nothing more than a call translator. You would end up with a bunch of interfaces around every little library you need, and that would be dumb.

The whole point is that your code represents some business functionality, and the architecture should be dependent on the rules of the business. At some point you'll need help with some aspect of the business or another. You write an interface to describe that need. The adapter simply fulfills that need.

The adapter will probably have functionality of its own, and depending on the system, perhaps not trivial. But that functionality is isolated from the rest of the system. It can be replaced at some cost that is isolated.

J2EE application servers do a lot of work, and the EJBs leveraged that capability (like clustering, distributed transactions, etc.). We had to find replacements for those capabilities. The replacement wasn't trivial. But the application itself could care less about most of that. So the risk to the application was substantially reduced.
Which allowed us to focus on specific, isolated areas and didn't risk the entire application.

> Then you talk about the one time that architecture saved you
> time and not the five hundred times it didn't.

Prove it.

> If you're putting all libraries in an adaptor then you're interfacing
> all the things and your constructors will be huge or nested.

The number of interfaces depends on how fine grained your abstractions are. You don't want your abstractions to be too fine grained, or you'll have a ton of dependencies. If you end up creating 15 interfaces in your constructor, that means you have way too many dependencies. That's a definite code smell and a definite sign you need to rethink your abstractions.

> If you're transforming your data

And what data would that be? For the most part, we are talking about parameters.

> you've got application logic in your adaptor which means
> replacing it is not low risk.

Not application logic, which is another domain. But logic related to the domain of the library. Because that logic is isolated, and independent of the business rules of the application, it is a lot easier to replace.

> If you're encapsulating your errors you've broken your stack
> trace.

Nope. The error is simply being recast into the application's domain. That is if it needs to be recast into the applications domain at all. The adapter can do much of the error handling itself, if that error handling falls into its domain.

> Separating your business logic from your presentation layer has
> nothing to do with being dependent on libraries.

It has everything to do with it. The separation of presentation layer from business logic is small potatoes compared to what I'm talking about. The Domain Driven Design book has a great section about the Anti-Corruption Layer, which describes how to protect an applications architecture from the architecture of other libraries and systems.

Libraries that represent an entire domain separate from the business domain shouldn't affect its architecture. If the library is substantial enough that it could effect the architecture of the application and more importantly is a risk to the application, it belongs to a different domain and the domains should be separated to reduce risk. We're not talking apache-commons-lang which just does string manipulation.

I agree with the Amazon review. Unless you need for a class, or learn an advanced topic not available in other places, I wouldn't touch this book ever. There are much easier algorithms books to read such as https://www.amazon.com/gp/product/032157351X/ This book isn't introductory at all as mentioned on Quora by multiple people https://www.quora.com/What-are-the-best-books-on-algorithms-and-data-structures

And if you've bought this for algorithms interviews preparation, it's better to buy cracking the code interview or similar which has explicit instructions for interview questions.

One more thing to add to the review was the algorithms are written in pseudocode, array indices start with 1 instead of 0, some lines refer to other pages in the book so you can never read a code inside this book sanely.

The book Clean Code will help with improving your code in general.

Head First Design Patterns is great! But in Java. The patterns still apply to Python though.

Here are patterns in Python https://github.com/faif/python-patterns

It can be hard at first, but it's really worth it. If you surpass the 100 lines limit for a class it's surely doing too much, try splitting it into several smaller classes, or at least some concerns.

Something which can help with that is Refactoring: Ruby Edition, it's more of a senior-level book than POODR, and you can't read it from cover to cover, you have to stop at each pattern, see if you can apply it, then repeat, but it's definitely a great resource, and it helps you "develop an eye" for bad code.

Reek seems to use some smells from the Refactoring book. Not sure if all of them can be analyzed statically though.

EDIT: I didn't know Sandi was updating POODR, I think she's just working on 99 Bottles of OOP, her new book.

Okay. Watch the official tutorials for sure, and I recommend looking at the tutorials posted on the /r/Unity3D sidebar fore more.

If you haven't already, learn some design patterns! Head First Design Patterns was an amazing resource for me. You'll learn how to organize code in ways that actually makes it readable extendable in the future.