I can definitely relate, this sounds just like me last year! I've done things the hard way and it took me 5x longer. I also prefer screencasts to books. I always need to create a project to solidify those fresh skills, otherwise they'll be gone in a month. Also tutorials for things like Backbone assume you know how to use jQuery, Underscore, and things like REST, and JSON responses... this can quickly get confusing if your not familiar with all of these. My largest regret is not building enough practice apps in the last year. I really should have applied more by doing, instead of staying in the theoretical world.

Here are some insights that i've made and the courses/tuts/projects that helped me the most:

Learn the language first:

• https://tutsplus.com/course/javascript-fundamentals/
  
• https://tutsplus.com/course/object-oriented-javascript/
  
• https://tutsplus.com/course/advanced-javascript-fundamentals/
  
• http://eloquentjavascript.net/ If you feel you need more coverage of the same topics (interactive html like CodeCademy).
  
• Build something interesting, things like games seem to also challenge your programming skills at the same time. Something like Whack-a-Mole, Connect 4, etc... Don't worry too much about the looks, unless you want to practice that too. At this point you should be able to do basic dom manipulation, events, and basic logic.
  
• The tut-plus courses cost a little for a few months but they're really high quality... most of them also give you projects too.
  
  

  Set up a comfy environment
  

  
  Take some time to start optimizing your development environment, the Paul Irish explains it very well below, but some of the topics are a bit too advanced for now (modules, build tools, etc...).
  
  

• Javascript Development Workflow of 2013
  
• Setup a jshint plugin (~4min above), read the website/docs for all the options. http://www.jshint.com/
  
  
• A more entry level talk on setting up your environment Front-end Tools for the Young Developer
  
  
  

  Learn the native DOM and it's API
  

  
  

• http://domenlightenment.com/
  
• Create your own DOM manipulation library
  
• While this one is a book, it's small and has js-fiddle examples for every code block to try it out... i'm currently going through this and it's great! They have a free HTML version (not final edit) and a cheap softcover on amazon. This will make using jQuery much easier and less 'mysterious'.
  
  

  Learn jQuery
  

• https://tutsplus.com/course/30-days-to-learn-jquery/
  
• https://tutsplus.com/tutorial/jquery-anti-patterns-and-best-practices/
  
• http://fixingthesejquery.com/#slide1
  
• https://tutsplus.com/course/jquery-plugin-development-best-practices/
  
• Re-write one of your previous apps to use jQuery instead of vanilla.
  
• While I love vanilla, jQuery just saves time. Learn when you can easily not use jQuery to gain some easy performance.
  
  

  Read "The Good Parts"
  

  
  Though very cliche at this point, read through this classic. If you don't really understand it all 100%, make sure you hang on to it though as it gets better with age. Try and follow it as close as possible, then later feel free to break the rules. By then you'll know why you can break them.
  
  

• JavaScript the Good Parts
  
  

  Learn Underscore
  

  This is a great library that gives you a lot of cross browser ES5 features and features that should be in JS. Not a lot of tuts on this one, reading the docs and source helps a ton here.
  
  

• http://net.tutsplus.com/tutorials/javascript-ajax/getting-cozy-with-underscore-js/
  
• http://vimeo.com/60216668
  
• http://underscorejs.org/
  
• https://github.com/bestiejs/lodash
  
  

  Learn Backbone
  

  There are lots of these libraries but Backbone is the most popular and easiest to learn. Keep in mind this is a library, not an entire framework like ember. This means in a larger app you will essentially use Backbone to help build you own SPA framework for your app.
  
  

• https://tutsplus.com/course/connected-to-the-backbone/
  
• https://tutsplus.com/course/advanced-backbone-patterns-and-techniques/
  
• http://addyosmani.github.io/backbone-fundamentals/ Great book!
  
• Build a Todo app with backbone
  
• Build a backbone powered Reddit mobile web app, read the following posts for inspiration.
  http://cheeaun.com/blog/2012/03/how-i-built-hacker-news-mobile-web-app
  http://cheeaun.com/blog/2012/03/how-i-built-hacker-news-mobile-web-app_26
  
  

  Learn Node
  

  
  

• https://tutsplus.com/course/introduction-to-node-js/
  
• Build a command line app ( I built a scaffolding app to spit out my boilerplates, and a really janky language transpiler)
  
  

  General Front-End, Programming
  

• Baseline for front end developers
  
• So you want to be a front end engineer
  
• http://pineapple.io/wiki
  
• https://www.edx.org/courses/HarvardX/CS50x/2012/about
  
• I can't stress how helpful the CS50 course has been to me, even on the front end.
  
  

  Read a comprehensive JS book
  

  I really like Nicholas Zakas's book over the definitive guide. I find that he is able to tell more of a story and makes it easier for me to absorb.
  
  

• Professional JavaScript Development
  
• JS the Definitive Guide
  
• Re-read "The Good Parts", this should make much more sense than the first time you read it.
  
  

  Testing
  

  
  Make sure you're comfortable with everything before moving onto testing... this includes frameworks etc.. Learning testing will only slow down the learning process if you're not comfortable with the rest. Mocha is the newer test runner and is better with async. However, Jasmine is very popular and time tested. The "Lets code javascript" below is an awesome course. Don't let the first sections turn you off, they may seem tedious at first (integration server, etc...) so feel to skip to dom/browser testing and then loop back when testing is more normal.
  
  

• http://www.youtube.com/watch?v=eVpXkyN0zOE - Short intro to Jasmine and TDD
  
• https://tutsplus.com/course/javascript-testing-with-jasmine-2/ - Nice n Easy course to Jasmine & TDD
  
• http://www.letscodejavascript.com/ - epic comprehensive JS TDD course from server to browser
  
• 
  
• http://visionmedia.github.io/mocha/ - My favorite runner (with Chai)
  
• http://karma-runner.github.io/ - Test in mult. browsers from the command line (advanced)
  
• https://github.com/rmurphey/js-assessment - test your skills (no pun intended)
  
  

  --
  

  I just started sketching out a website to try and solve this problem. It has different paths to follow to fill in gaps of JS knowledge quickly (much like hackdesign.org)... unfortunately it's not finished yet! Watch LevelUpJS on Github in the future. I also have some more links on app architecture and things like modules but this list is getting a bit large!
  
  Cheers and good luck!
  

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


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


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


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


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


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


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


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

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

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

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

Things on Reddit

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

You have a long journey ahead of you, but here goes :D

Beginner

C++ Primer: One of the better introductory books.

The C++ Standard Template Library: A Tutorial and Reference: Goes over the standard template library in fantastic detail, a must if you're going to be spending a lot of time writing C++.

The C++ Programming Language: Now that you have a good idea of how C++ is used, it's time to go over it again. TCPPL is written by the language's creator and is intended as an introductory book for experienced programmers. That said I think it's best read once you're already comfortable with the language so that you can full appreciate his nuggets of wisdom.


Intermediate

Modern C++ Design: Covers how to write reusable C++ code and common design patterns. You can definitely have started game programming by the time you read this book, however it's definitely something you should have on your reading list.

C++ Templates: Touches on some similar material as Modern C++ Design, but will help you get to grips with C++ Template programming and how to write reusable code.

Effective C++: Practical advise about C++ do's and dont's. Again, this isn't mandatory knowledge for gamedev, but it's advice is definitely invaluable.

Design Patterns: Teaches you commonly used design patterns. Especially useful if you're working as part of a team as it gives you a common set of names for design patterns.

Advanced

C++ Concurrency in Action: Don't be put off by the fact I've put this as an "advanced" topic, it's more that you will get more benefit out of knowing the other subjects first. Concurrency in C++11 is pretty easy and this book is a fantastic guide for learning how its done.

Graphics Programming

OpenGL: A surprisingly well written specification in that it's pretty easy to understand! While it's probably not the best resource for learning OpenGL, it's definitely worth looking at. [edit: Mix it in with Open.gl and arcsynthesis's tutorials for practical examples and you're off to a good start!]

OpenGL Superbible: The OpenGL superbible is one of the best ways to learn modern OpenGL. Sadly this isn't saying much, in fact the only other book appears to be the "Orange Book", however my sources indicate that is terrible. So you're just going to have suck it up and learn from the OGL Superbible![edit: in retrospect, just stick to free tutorials I've linked above. You'll learn more from them, and be less confused by what is 3rd party code supplied by the book. Substitute the "rendering" techniques you would learn from a 3d book with a good 3d math book and realtime rendering (links below)]


Essential Mathematics for Game Programmers or 3D Math Primer for Graphics and Game Development: 3D programming involves a lot of math, these books cover topics that OpenGL/DirectX books tend to rush over.

Realtime Rendering: A graphics library independent explanation of a number of modern graphical techniques, very useful with teaching you inventive ways to use your newly found 3d graphical talents!

I've posted this before but I'll repost it here:

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

Job Interview Prep

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

   Junior Software Engineer Reading List
   

   
   

   Read This First
   

   
   

10. Pragmatic Thinking and Learning: Refactor Your Wetware
    
    

    Fundementals
    

    
    

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

    Understanding Professional Software Environments
    

    
    

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

    Mentality
    

    
    

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

    History
    

    
    

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

    Mid Level Software Engineer Reading List
    

    
    

    Read This First
    

    
    

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

    Fundementals
    

    
    

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

    Software Design
    

    
    

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

    Software Engineering Skill Sets
    

    
    

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

    Databases
    

    
    

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

    User Experience
    

    
    

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

    Mentality
    

    
    

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

    History
    

    
    

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

    Specialist Skills
    

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

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

Here's a good list I keep posting because people often ask the same question - not like it's a bad thing.

In any case follow the below, but I really suggest for total newbies to first go through the course Codecademy offers. It won't teach you much in how to do things but the syntax education is good. Follow their HTML and CSS courses and when you're done, create a site using just HTML and CSS. Once done, try to emulate a few of your favorite sites using just these two languages.

Once done you should check out the free 30 day Tutsplus courses on HTML/CSS and jQuery. At some point you will want to go back to Codecademy and take their JS course. Syntax and method of doing or starting certain things is important. It's incredibly easy to pickup the actual methods of doing things once your head understands the syntax used.

Any form of education that follows a hierarchical format makes for easy learning.
__


Codecademy isn't bad. It won't teach you much in the way of doing things but it does teach you the way to type out code, the general process and stuff. I can't speak for myself because I work as a professional developer and have been tinkering with code for 10 years now, but I did give the first lesson to one of my brothers. He's not great with computers or the Internet, but he was able to follow the first two sections of the basic HTML/CSS course and able to make his own site albeit very basic in nature nearly a month later (3 week gap following him doing the lessons). He was able to do a rough basic site of his Facebook profile, and he nailed it. It should open doors for you in terms of having the basic knowledge of how to do things. It'll allow you to read more advanced stuff and pick it up much faster than if you hadn't.

Below is a list I sent to someone on here a while back.

>
>http://www.reddit.com/r/webdev/comments/1eqaqo/best_books_or_online_resources_for_comprehensive/ca2w2dn?context=3



>PHP and MySQL Web Development (4th Edition)
>
>Beginning PHP and MySQL: From Novice to Professional
>
>Read the second book, do all the examples, then go back to the first book. Pay a lot of attention toward array manipulation. When you're comfortable with that, get into OOP. Once you do and OOP clicks for you, you'll be able to go to town on anything. I've heard a lot of good about Jefferey Way's video lesson courses over at TutsPlus. I've never used them nor do I need to, but I've never heard a single bad thing about their video courses. Their Javascript and Jquery is a great starting point. This is great stuff too if you're willing to put in the time.
>
>Professional JavaScript for Web Developers
>
>JavaScript: The Definitive Guide: Activate Your Web Pages
>
>Responsive Web Design with HTML5 and CSS3
>
>The Node Beginner Book
> Professional Node.js: Building Javascript Based Scalable Software
>
>Paid online "schooling":
>
>http://teamtreehouse.com/
>
>http://www.codeschool.com/
>
>Bonus:
>
>http://hackdesign.org/
>
>
>I've got a shit ton (Excuse my French) of books in print and E-Format that I could recommend, but it would span a couple pages. Anything is easy to learn so as long is it's served in a hierarchical format that makes it easy to absorb the information. A year ago I started to learn Ruby and using ROR as a framework. I can say it's been quite fun and I feel confident that I could write a fully complete web app using it. I started node.JS a few months ago, but it's been on break due to being sick and some unexpected events.
>
>My knowledge is extensive only because I wanted it to be. I'm not gifted by any means nor am I special. Not by a longshot. Some people are gifted when it comes to dev and design, most are not. Most only know one or the other. I forced myself to learn and be good at both. I'm 23, I started when I was about 12. I'm only breathing more comfortably now. I know a load of people on here and other sites who make me look like complete shit.
>
>
>Also for what it's worth, sign up to StackOverflow. It's the bible and holy grail rolled up into one site. It's amazing.
>
>Also;
>
>Hattip to /u/ndobie
>
>> CodeAcademy
> Team Treehouse
> CodeSchool. This is more programming but still very useful & has free stuff.
> Tuts+
> Google. Probably the best way to find out how to do something specific.
> This subreddit. If you have any questions about how to do something, like parallax scrolling, try searching for it, then ask, make sure to include an example of what you want if you don't know what it is called.

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

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

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

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

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

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

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

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

Hi! I'd be happy to share some info. I didn't actually go to school for Computer Science so I learned everything I know from the internet really. When I first started learning programming in general, I started with a course in C http://www.computerscienceforeveryone.com/. I think it was a pretty good intro into computer science in general too. There were a lot of concepts in that course that were really hard for me to grasp at first and honestly pretty boring at times, but I stuck with it and I feel like it set me up for objective-C and iOS programming pretty well.

Moving on to iOS programming. The Big Nerd Ranch book was the best iOS development book I read. It's chock full of good tutorials and good explanations of concepts. It was just updated to the 4th edition to and is available on amazon.com

Finally getting into iOS Game Development, I think Ray Wenderlich's tutorials were the best help for me. Most of the iOS game dev stuff out there right now is mostly for Cocoa's 2d (which is great!). However, I wanted to try out Sprite Kit since it's newer and I think it's eventually going to surpass cocoa's 2d as the standard for iOS 2d game development. There aren't a lot of resources out there beyond apple's guide (which is good in my opinion) Sprite Kit Documentation
Ray Wenderlich has a great Sprite Kit book out with all kinds of great information that makes game development on the iPhone easy. Here is a link to his book: http://www.raywenderlich.com/store/ios-games-by-tutorials

I hope that answered some of your questions. Feel free to ask more if you had any other questions, or if I missed something. Thanks for trying out the game. I hope you like it :)

I took a deeper look at FCC. Before I was a bit against it due to how dry/textbook-like it is, but after taking a second glance I think it can definitely do the job.

However, I still stand by this roadmap, especially because I tested so many different free courses online (and subsequently wasted a bunch of time). Hopefully someone will find this useful.

Rithm (https://www.rithmschool.com/courses)

• Awesome for going from 0 to beginner/intermediate; possibly the best fundamentals I've found
  
  
• Doesn't hand hold so it teaches you how to think
  
  
• Writing is friendly and understandable
  
  Eloquent JS (http://eloquentjavascript.net/)
  
  
• Great for solidifying intermediate
  
  
• This is when you begin to learn "real" coding
  
  
• Can be difficult to grasp, but with a solid understanding of the fundamentals, you should be good
  
  Secrets of a JS Ninja (https://www.amazon.com/Secrets-JavaScript-Ninja-John-Resig/dp/193398869X)
  
  
• Great for going from intermediate to advanced
  
  
• If you've methodically mastered the previous two, you will be good. Really deepens your understanding and sharpens skillset
  
  Finally, if you supplement all this with Codewars (https://www.codewars.com/ , allows you a bunch of puzzles/katas to check your level as you progress; great because you can go back and see how your skills have actually improved, you'll definitely cringe at some of your old code, ha), it's a pretty fucking awesome roadmap to get you from 0 to advanced, though it'll take a LOT of work. There are no shortcuts!
  
  Hit me up if you have questions, always down to help others get started.

Hey /u/Xerack! I'm the original author of the post linked here.

Appreciate the feedback! If you think I could clarify anything better, please let me know.

As far as resources for Reverse Engineering, I can provide you with a baseline that I would recommend starting with.

x86 Assembly:


If you don't know assembly language at all, this list of videos was where I picked up a decent amount of x86 assembly language.


A few good books would be:

• Hacking: The Art of Exploitation I am a huge advocate for this book. I learned a lot from this and have read it multiple times. It is written very well and teaches someone with no experience how to do C programming and assembly. This is mainly a book for learning exploitation/vulnerability research, but that can play hand and hand with Reverse Engineering. It will show you the assembly language break down of basic exploits and this can help you with RE.
  
  
• Practical Reverse Engineering I read through the beginning of this book and it gave me some good foundations of understanding memory and computer architecture for RE along with assembly of course
  
  
• Secrets of Reverse Engineering This book is a bit in depth, but the beginning gives another good foundation for Comp Architecture and assembly stuff.
  
  
• The IDA Pro Book Haven't personally read this book yet, but I have been told it is the defacto standard for learning IDA Pro, and it has examples you can learn from.
  
  Hands On:
  
  
  
• Legend of Random Very useful hands on with tutorials. Mainly based on cracking, but that requires reverse engineering. Highly recommend this!
  
  
• Lenas Tutorials Again, another awesome hands on tutorial, mostly based on cracking as well.
  
  
• Crackmes These are more of challenges once you start to have a little understanding down
  
  Courses:
  
  Tons of courses on youtube. I learn well from visual, so I recommend these youtube videos:
  
  
  
• Basic Dynamic Analysis
  
• Real World Decompilation There are a few videos to this series and he disassembles a game, definitely nice to learn from.
  
  
  Beyond that, Google will always be your friend, and /r/reverseengineering. I also have a bunch of material for Malware RE, but that's a bit different than Software RE, though it is relatable.

Depending on what you want to learn:

PYTHON SPECIFIC

You mentioned building websites, so check out the flask mega tutorial. It might be a bit early to take on a project like this after only a month, but you've got time and learning-by-doing is good. This'll teach you to build a twitter clone using python, so you'll see databases, project structure, user logons etc. Plus he's got a book version, which contains much of the same info, but is good for when you can't be at a computer.

The python cookbook is fantastic for getting things done; gives short solutions to common problems / tasks. (How do I read lines from a csv file? How do I parse a file that's too big to fit in memory? How do I create a simple TCP server?). Solutions are concise and readable so you don't have to wade through loads of irrelevant stuff.

A little while down the road if you feel like going deep, fluent python will give you a deeper understanding of python than many people you'll encounter at Uni when you're out.

WEB DEV

If you want to go more into web dev, you'll also need to know some HTML, CSS and Javascript. Duckett's books don't go too in depth, but they're beautiful, a nice introduction, and a handy reference. Once you've got some JS, Secrets of the javascript ninja will give you a real appreciation of the deeper aspects of JS.

MACHINE LEARNING
In one of your comments you mentioned machine learning.

These aren't language specific programming books, and this isn't my specialty, but:

Fundamentals of Machine Learning for Predictive data analytics is a great introduction to the entire process, based upon CRISP-DM. Not much of a maths background required. This was the textbook used for my uni's first data analytics module. Highly recommended.

If you like you some maths, Flach will give you a stronger theoretical understanding, but personally I'd leave that until later.

Good luck and keep busy; you've got plenty to learn!

Happy to help!

>Did you stabilize it somehow with a gyro and arduino or was is literally just the receiver, transmitter and ESC?

Flight controller with built in gyros handled all the stabilization. FCs are really cool and you can have as many features as you like or virtually none at all. I used a CC3D, but like I said that was years ago and you'll probably find much better. Apparently some even have built-in RC receivers.

Every programmer hates their own code, unless they don't want to get any better at it. Finding one language and getting good at it comfortable with it is a good start, and it doesn't have to be c/c++. I started with perl, quickly switched to python, probably suck at both to this day.

There's a lot to be said about learning libraries and their implementations rather than trying to learn a particular language.

I've also written java code that ended up in production and is still used. The only C++ code I've ever written was for arduino and other microcontrollers, which is loaded with tons of convenience features that have a tendency to hide the hard parts, like memory management and stuff, but you can still get at them.

There's a surfeit of free information out there, but if you want a short booklist I recommend these:

• How to think like a Computer Scientist with Python free and freakin awesome, should be in every school curriculum
  
• Seven Languages in Seven Weeks kind of advanced, but teaches lots about the under-the-hood differences of programming languages
  
• Zed Shaw's Learn Code the Hard Way books are pretty good. Used to be free, now he charges, but still worth it imo.
  
  EDIT: and if I didn't mention it before, hackerspaces are an excellent resource. One near you will probably be full of smart people and they might even have the occasional class or workshop.

No problem. I am by no means an expert in writing code or buffer overflows but I have written several myself and even found a few in the wild which was pretty cool. A lot of people want to jump right in to the fun stuff but find out rather quickly that they are missing the skills to perform those tasks. I always suggest to people to start from the ground up when learning to do anything like this. Before going into buffer overflows you need to learn assembly language. Yes, it can be excellent sleep material but it is certainly a must. Once you get an understand of assembly you should learn basic C++. You don't have to be an expert or even intermediate level just learn the basics of it and be familiar with it. The same goes for assembly. Once you get that writing things like shellcode should be no problem. I'll send you some links for a few books I found very helpful. I own these myself and it helped me tremendously.

Jumping into C++: Alex Allain

Write Great Code: Volume1 Understanding the Machine

Write Great Code: Volume2 Thinking Low-Level, Writing High Level

Reversing: Secrets of Reverse Engineering

Hacking: The Art of Exploitation I used this for an IT Security college course. Professor taught us using this book.

The Shellcoders Handbook This book covers EVERYTHING you need to know about shellcodes and is filled with lots of tips and tricks. I use mostly shells from metasploit to plug in but this goes really deep.

.

If you have a strong foundation of knowledge and know the material from the ground-up you will be very successful in the future.

One more thing, I recently took and passed the course from Offensive Security to get my OSCP (Offensive Security Certified Professional). I learned more from that class than years in school. It was worth every penny spent on it. You get to VPN in their lab and run your tools using Kali Linux against a LOT of machines ranging from Windows to Linux and find real vulnerabilities of all kinds. They have training videos that you follow along with and a PDF that teaches you all the knowledge you need to be a pentester. Going in I only had my CEH from eccouncil and felt no where close to being a pentester. After this course I knew I was ready. At the end you take a 24-long test to pass. No questions or anything just hands on hacking. You have 24 hrs to hack into a number of machines and then another 24 hours to write a real pentest report like you would give a client. You even write your own buffer overflow in the course and they walk you through step by step in a very clear way. The course may seem a bit pricey but I got to say it was really worth it. http://www.offensive-security.com/information-security-certifications/oscp-offensive-security-certified-professional/

TL;DR Improve yourself, invest in your future, don't worry about the mistakes...read the books listed at bottom, and practice!

Few months ago I royally fucked up an interview at Microsoft. A really simple question. But I had no experience doing coding on paper instead of a computer.

I spent a lot of time studying various books and paper coding to make sure it wouldn't happen again.

I then had an interview for another (in my mind at the time) dream job. I did fine for all the phone interviews and they flew me over to the west coast for an in person interview for the day. I did well for the first bit until they started pulling out dynamic programming and integer programming questions on me and expecting me. Once again something I didn't prepare for, and f'd up. Didn't get this job either. For the longest time I was really hard on myself at fucking up on both these interviews one after another. Especially this second one since a lot more was riding on it than just the job (another story).

But then I decided I didn't want to have this sort of experience again and expected better of myself. I made myself further improve and brush up on all those concepts as well. Did a few mock interviews with friends, spent some time working on interview type questions on both the computer and on paper. A month or two later I started interviewing again. By this point I was an interviewing machine - and I'm now able to do just about anything thrown at me. I've had my choice of employers and until just recently, was in the situation where I had so many offers I didn't know which one I wanted most. I'll be heading to silicon valley soon at one of the top tech companies in the world with a fantastic offer considering I just graduated.

The point is - learn from the mistakes and improve yourself. I realize you don't want to be that guy spending heaps of time coding outside of work or whatever... but this is an investment in yourself and your career. Do it once, and then just brush up on your skills from time to time. Get into the interviewing mindset and just rock them so you can have your choice of job - and then you can go about your thing once you have the job locked. The up front investment will be worth it!

Things that helped me:

• www.hackerrank.com - practiced a lot of questions on here
  
• www.careercup.com - another great site for questions
  
• Cracking the Coding Interview More help on questions, but also some great insights into the interview process for the larger tech companies and many hints and tips on how to go about solving the more complex problems
  
• Code Complete A great book for helping you to refresh or learn about software design
  
• Eternally Confuzzled Great resource to learn how to think about common data structures and algorithms
  
  Having trouble with Algorithm design/analysis? These are some of the go-to books for that:
  
  
• The Algorithm Design Manual Probably the defacto for learning about algorithm design and analysis
  
• Introduction to Algorithms A great book with many different algorithms and data structures to learn about
  
• Algorithm Design A great book if you want to dive deeper into more complex subjects like graph theory, dynamic programming, search algorithms, etc.. etc..

I have not made anything up. I've described the long-standing accepted definition of the term. You don't just get to claim I'm making stuff up as if it were fact, sir.

> "smart pointer" is not a catch-all for any object with pointer-like behavior.

And that's not the way I described it. A smart pointer is an object that behaves like a regular pointer but is smarter in some way.

> Smart pointer (as opposed to a "dumb" or "raw" pointer) is a C++ structure that behaves almost identically to a common C pointer but it also includes some other capabilities, e.g. throws an exception when it's NULL and someone tries to dereference it, or it destroys its contents automatically when it goes out of scope.

http://www.csc.lsu.edu/~kosmas/smartPointers.html

> In computer science, a smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic memory management or bounds checking.

http://en.wikipedia.org/wiki/Smart_pointer

> Smart pointers are objects that look and feel like pointers, but are smarter. What does this mean?

> To look and feel like pointers, smart pointers need to have the same interface that pointers do: they need to support pointer operations like dereferencing (operator *) and indirection (operator ->). An object that looks and feels like something else is called a proxy object, or just proxy. The proxy pattern and its many uses are described in the books Design Patterns and Pattern Oriented Software Architecture.

http://ootips.org/yonat/4dev/smart-pointers.html

> So what's a smart pointer? A smart pointer is a C++ class that mimics a regular pointer in syntax and some semantics, but it does more.

>...

> This is the mantra of smart pointers: You can replace pointer definitions with smart pointer definitions without incurring major changes to your application's code. You thus get extra goodies with ease.

http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315

And finally http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Smart_Pointer

Although I don't agree with most of the intent and motivation sections in that one and would never implement handle/body in that manner.

Hey, I'm flattered you care what I think!

I learned basic Objective-C on my own in high school (read this one during boring classes), and then went on to do a Bachelor in Computer Science at uni. Learning some basic programming really helps, because at least at my school it was very much fundamentals for the full first year, and if you understand them well enough it'll be a breeze.

That being said (and take this with a major grain of salt, as it's just me) I wasn't that big a fan of school. I got into and taught myself iOS development as my school, like most, was mostly based around Computer Science theory rather than practical applications and programming. I did learn some valuable things about algorithms and whatnot, but it's nothing that I couldn't have taught myself and everything that I've found to be "marketable" (things that have helped me get jobs) have been self-taught.

But university's awesome for a whole wealth of reasons (met awesome people), and you may adore it, I'd just be very careful not to learn a wealth of knowledge but have little experience applying it to anything concrete. Employers appreciate the latter far more (my GPA was rather meh, and I got some really cool jobs).

I do most of my work alone, but a lot of smart people have helped me along the way. :) It's just how I personally like to work at the moment. If you have any more questions I'm happy to answer. r/cscareerquestions as mentioned is a great resource too!

I'm at work right now ( library is at home), but there's a few books I can recommend. there's no one great path though, it'll be "find a hole in knowledge, fill it, move forward until you find another hole in your knowledge".

First, learn a programming language, and master it. Then learn to abstract that. Use this book as a good way to abstract. You'll come to recognize two basic abstraction: first, every language does all the same things, in just a little different way. The book acts sort of as a Rosetta stone for comp sci. Second, some languages are better than others for some things, and for AI, none of that matters, just pure processing power. I started the project in c# ( very simple for prototyping and testing, not super efficient) , and then swapped to C++ when I started working the outcomes into a game world to see evolutionary behavior better ( using the unreal engine) .

Next,Hofstadter has two books worth reading, "I am a strange loop" and "Gödel, Escher, Bach: An Eternal Golden Braid" - this ( combined with Kurzweil's "How to Create a Mind") will give you some of the more theoretical on neurology/computer cross over. read them both, even though it's 60% the same book. there's enough differences to make both worth while.

On the biology side, This book has some info on what it means to be "alive" which is a prerequisite for what it means to have "artificial intelligent life" this will likely lead you into genetic research and how DNA works - it's important, but not until you get there.

On the sociology / economic side, I can't think of one book that would be a great starting point. I will say that specifically understanding risk/reward principals and game theory are critical to development of any AI that goes beyond a linear regression model. Also look into OODA loops, it's a military term for "Observe, orient, decide, act"

For machine learning, there's no one better to teach it than Andrew Ng, the chief scientist at Baidu. His course at Stanford is recorded and free to take on Coursera. You can find it here

Saw your PM, but figured I'd post it here since you weren't the only person who pinged me on it :). Happy to answer any more questions, but i'm not online all that much so please be patient!

Take care and good luck!

I found Lynda.com to be extremely dry and slow. To me it was the equivalent of those old school mandated educational movies you would watch in classrooms back in the 90s on your faux-wood tv. Take this opinion with a grain of salt though as it has been almost two years since I have looked at anything on Lynda, I hear it may be better today.

If you are looking for web development in particular I would suggest the following:

• Codeademy - Free and very good at introducing basic web development skills.
  
• Team Treehouse - Paid subscription but well worth it in my opinion as they will walk you through everything from the most basic HTML to building advanced JavaScript applications.
  
• CodeSchool - CodeSchool tends to be more advanced and I would wait until you have a strong grasp on your HTML, CSS and JavaScript before investing in their coursework.
  
  In addition, StackOverflow; A general programming Q&A website, has an answer to just about any programming issue you may be running into. If the answer is not already there, then chances are you will have one within 24hours.
  
  I began my pursuit into web development about 2 years ago. In that time I have gone through the resources listed above as well as the following books which have helped immensely:
  
  
• HTML and CSS: Design and Build Websites - Ducketts whole series is extremely friendly to the new web developer and will help you build a solid foundation quite quickly.
  
• JavaScript and JQuery: Interactive Front-End Web Development - Another Duckett book which was just released focusing primarily on JavaScript.
  
• JavaScript: The Definitive Guide - A massive JavaScript reference. It has answers to just about everything.
  
  Some personal career history if you're interested:
  
  In the last two years I have gone from making 18k a year as a Technical Support Representative to 80k a year as a Front-End Engineer building JavaScript applications at a large FDIC Bank. It was only in the last two years that I really dug into Web Development (and programming for that matter) and I really can't see myself ever doing anything else for a living. The job requires an immense amount of learning (which I love) and will keep your mind sharp. I really do get a kick out of problem solving all day. Programming will require a major adjustment to the way you think. I can say that the way I work through problems now is completely different to the way I did before. I feel as if critical thinking has eluded me until the last two years and it has been a major life changing event. By far the biggest contributing factor to my growth has been the team I work with. You have to do your best to find a team that is willing to work with you as a junior so you can siphon that knowledge. Even if that means taking a low paying job, however; know your worth so that you can ask for the right amount of money once you have gained the necessary skills. As a personal rule of thumb, I will not stay at a company where I am the most knowledgable member of the team. This inhibits growth as a developer and will prevent me from realizing my true potential.
  
  Feel free to hit me up if you have any questions.
  
  
  

TAOCP is too hard: its like one of those fantasy wishlist items: the kind of thing every computer scientist wishes they had read but never really has the time to. Some nicer books that are gold standards in their respective fields are:

CLRS (Algorithms)

SICP (Just see the top two amazon reviews)

Kernighan and Ritchie (if you want to be a pretty accomplished C programmer and have little to no real C experience before)

Since you mentioned security, Ross Anderson's Security Engineering is a fantastic read, and very easy to parse: you could read it through in less than a week and have a deeply changed view of the structural issues in security: there is little crypto in the book (for that, Schneier is the gold standard) but more discussion about protocols, where protocols fail, real-world protocols like the military classification scheme, etc. It is absolutely fantastic. If you read this and Schneier you'd have a very thorough understanding of the entire security stack.

Kleinberg and Tardos is a much easier read than CLRS when it comes to algorithms, doesn't cover as much, and is very graceful in its explanations. Personally, I love it.

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

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

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

Some other resources for Python:

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

Learn Python the Hard Way

A Byte of Python

Good luck!

I'm going to agree with others and recommend that you not go with C++. The first programming class I ever took was in C++ and it very nearly made me give up on programming forever.

If you want to learn how to code "closer to the machine", go with C. If you want to learn something useful and fun, go with Python or Ruby. If you want to learn useful Windows-specific skills, go with C#. C is much simpler than C++ but still challenging compared to VB. Also, it's still widely used and probably will be used forever. Python and Ruby are just plain fun and make many tasks easy to do. They're also excellent general purpose languages to have in your tool belt. C# is great if you're coding on Windows and significantly easier than C++ (Java is an option too, it's very similar to C# but since you already know some VB, C# will probably be easier to pick up).

There are plenty of other languages you could try as well, at some point you'll want to dabble in a functional language just to see how wildly different that is from object oriented and procedural languages.

Actually, I just finished this book and it's a very cool way to get a quick idea of just how many options there are:

http://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X

Oh jeez, almost forgot, you'll definitely want to tinker around with some Javascript and do some client side web stuff (and node.js on the backend if that interests you).

I would cross-post this to /r/cscareerquestions since that's the subreddit that's more career focused.

My recommendation is to start building a coding portfolio. Specifically set up an account on www.github.com and start posting some of your projects there. Basically how github works is after you set up an account you download the client and create a folder on your computer. Any code or documents you put into that folder and then "push" will appear online. This will allow you to have lots of code samples to show a prospective employer. Another good idea is to build your own website. There are a couple of good web hosts such as www.bluehost.com and www.nearlyfreespeech.net. I personally use www.nearlyfreespeech.net because it's very very cheap. (You pay only for what you use and since your website will primarily be used to show employers it will be a few cents a month.)

Once you have a website and Github you'll also want to start studying more and learning more and then creating personal projects. There are a lot of good places to continue learning programming. You could sign up on www.pluralsight.com for their $29 a month plan and then follow along with courses. Alternatively you could buy books about programming and go through them and upload code samples to Github as you go through them. (A strategy I use is to look at books on www.amazon.com and buy used copies or copies that are 1 edition older than the current edition, it is very realistic to get books for $4 including shipping and handling.) There are also many free resources such as www.codeacademy.com.

Some good books you could buy that will help you once you get job interviews are: Cracking the Coding Interview, Programming Interviews Exposed, and Elements of Programming Interviews. Out of these books "Programming Interviews Exposed" is the best for beginners while the other two are more meant to get you ready to interview at huge companies like Google or Microsoft.

As far as projects to do just pick some ideas and implement them. For me personally I made a website (www.cslearner.com) and created my own blogging software. There is better blogging software out there then the stuff I wrote for myself but it beefs up my portfolio and gives me something to talk about in job interviews. One idea may be to make some sort of CRUD application/website. CRUD stands for CREATE, RETRIEVE, UPDATE, DELETE. Since a lot of what we do as software developers is data manipulation you can create some sort of app or website that creates and manages information. In my case the first CRUD thing I created was a comment section using PHP and MySQL. Literally all it did was allow people to post comments on a website and then a SELECT statement would display all the comments that people had left. You could do a similar project. The cool thing about CRUD is that you can build apps using a huge assortment of technologies. You could create a CRUD app using ASP.NET, server side Java(JSP), PHP and MySQL(the LAMP stack), or a bunch of other technologies.

Also a huge thing is to apply for jobs even if you don't feel very ready. Check out this YouTube video in particular. Employers put down a wish list of things they'd like in a candidate but know in advance they won't get everything they'd like. If you seem like someone that could learn the technologies they may hire you even though you don't know everything yet. Also you'll want to apply to a lot of places. I've had 15 job interviews so far (I'm graduating this next April) and I have no job offers yet. This means I have to apply to even more places. Even though Computer Science is a very high demand field job hunting is still hard and you still need to put out lots of applications.

The best way I know how is by solving problems yourself and looking at good solutions of others.

You could consider going back to "fundamentals".

Most programming courses, IMO, don't have nearly as many exercises I think they should have. Some books are particularly good on their exercises list, for example K&R2, SICP, and TC++PL. Deitel's has long exercises lists, but I don't think they're particularly challenging.

There are some algorithms/DS books which focus on the sort of problem solving which is about finding solutions to problems in context (not always a "realistic" one). Like the "Programming Challenges" book. In a book like that, a problem won't be presented in a simple abstract form, like "write an algorithm to sort numbers". It'll be inside some context, like a word problem. And to solve that "word problem", you'll have to find out which traditional CS problems you could solve/combine to get the solution. Sometimes, you'll just have to roll something on your own. Like a new algorithm for the problem at hand. In general, this helps you work out your reduction skills, for once. It also helps you spotting applications to those classical CS problems, like graph traversal, finding shortest plath, and so forth.

Most algorithms/DS books though will present problems in a pretty abstract context. Like Cormen's.

I think, however, people don't give enough credit to the potential of doing the exercises on the books I've mentioned in the beginning.

Some books I think are worth reading which also have good exercises:

• http://www.amazon.com/The-Programming-Language-2nd-Edition/dp/0131103628 - K&R2
  
• http://www.amazon.com/Elements-Programming-ML97-Edition-2nd/dp/0137903871
  
• http://www.amazon.com/Database-Systems-Complete-Book-Edition/dp/0131873253
  
• http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871 - SICP
  
• http://www.amazon.com/The-Programming-Language-4th-Edition/dp/0321563840 - TC++PL
  
  I imagine the other Stroustrupp programming book also has good exercises, but I've never read it. Brian Kernighan is not only the author of K&R2, but of many other books. You could look at his stuff.
  
  Depending on what you mean by good code, though, you could look at other books.
  
  There are also the math books. I'd not discard those. And also, there are other programming books as well. Some I've never read, but want to, like Programming Pearls:
  
  
• http://www.amazon.com/Programming-Pearls-2nd-Edition-Bentley/dp/0201657880
  
• http://www.amazon.com/More-Programming-Pearls-Confessions-Coder/dp/0201118890
  
  Not only those, but, anyway... The point is that you can look at those books to find examples of good code, good exercises, challenges and so forth.
  
  Here are some books I've mentioned previously:
  
  
• http://www.amazon.com/Programming-Challenges-Contest-Training-Computer/dp/0387001638 - Programming Challenges book;
  
• http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844 - Cormen's (and other 3 authors) book.
  
  By the way, there are websites with programming challenges for you to look at too. Like https://projecteuler.net/ and others. Just start looking this up and you'll find plenty. They all tend to start dumb easy and move up the difficulty to pretty damn difficult stuff from what I've heard.
  
  Edit: SICP is available for free (http://mitpress.mit.edu/sicp/) together with videos from the course taught at MIT in 85 (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/).

Here is a "curriculum" of sorts I would suggest, as it's fairly close to how I learned:

1. Programming. Definitely learn "C" first as all of the Exploitation and Assembly courses below assume you know C: The bible is pretty much Dennis Richie and Kernighan's "The C Programming Language", and here is the .pdf (this book is from 1988, I don't think anyone would mind). I actually prefer Kochan's book "Programming in C" which is very beginner freindly and was written in 2004 rather than 1988 making the language a little more "up to date" and accessible. There are plenty of "C Programming" tutorials on YouTube that you can use in conjunction with either of the aforementioned books as well. After learning C than you can try out some other languages. I personally suggest Python as it is very beginner friendly and is well documented. Ruby isn't a bad choice either.
   
   
2. Architecture and Computer basics:
   Generally you'll probably want to look into IA-32 and the best starting point is the Intel Architecture manual itself, the .pdf can be found here (pdf link).
   Because of the depth of that .pdf I would suggest using it mainly as a reference guide while studying "Computer Systems: A Programmers Perspective" and "Secrets of Reverse Engineering".
   
   
3. Operating Systems: Choose which you want to dig into: Linux or Windows, and put the effort into one of them, you can come back to the other later. I would probably suggest Linux unless you are planning on specializing in Malware Analysis, in which case I would suggest Windows. Linux: No Starch's "How Linux Works" is a great beginner resource as is their "Linux Command Line" book. I would also check out "Understanding the Linux Kernel" (that's a .pdf link). For Windows you can follow the Windows Programming wiki here or you can buy the book "Windows System Programming". The Windows Internals books are generally highly regarded, I didn't learn from them I use them more as a reference so I an't really speak to how well they would teach a "beginner".
   
   
4. Assembly: You can't do much better than OpenSecurityTraining's "Introductory Intel x86: Architecture, Assembly, Applications, & Alliteration" class lectures from Xeno Kovah, found here. The book "Secrets of Reverse Engineering" has a very beginner friendly introduction to Assembly as does "Hacking: The Art of Exploitation".
   
   
5. Exploitation: OpenSecurityTraining also has a great video series for Introduction to Exploits. "Hacking: The Art of Exploitation" is a really, really good book that is completely self-contained and will walk you through the basics of assembly. The author does introduce you to C and some basic principles of Linux but I would definitely suggest learning the basics of C and Linux command line first as his teaching style is pretty "hard and fast".
   
   
6. Specialized fields such as Cryptology and Malware Analysis.
   
   
   Of course if you just want to do "pentesting/vuln assessment" in which you rely more on toolsets (for example, Nmap>Nessus>Metasploit) structured around a methodology/framework than you may want to look into one of the PACKT books on Kali or backtrack, get familiar with the tools you will use such as Nmap and Wireshark, and learn basic Networking (a simple CompTIA Networking+ book will be a good enough start). I personally did not go this route nor would I recommend it as it generally shys away from the foundations and seems to me to be settling for becoming comfortable with tools that abstract you from the real "meat" of exploitation and all the things that make NetSec great, fun and challenging in the first place. But everyone is different and it's really more of a personal choice. (By the way, I'm not suggesting this is "lame" or anything, it was just not for me.)
   
   *edited a name out
   
   
   
   
   
   

Not tutorials, but I highly recommend the following JavaScript books:

JavaScript The Definitive Guide (6th Edition, Flanagan)

http://www.amazon.com/JavaScript-Definitive-Guide-Activate-Guides/dp/0596805527/ref=sr_1_1?s=books&ie=UTF8&qid=1310948024&sr=1-1

Pro JavaScript Design Patterns (Harmes/Diaz)

http://www.amazon.com/JavaScript-Design-Patterns-Recipes-Problem-Solution/dp/159059908X/ref=sr_1_1?ie=UTF8&s=books&qid=1310948075&sr=1-1

JavaScript Patterns (Stefanov)

http://www.amazon.com/JavaScript-Patterns-Stoyan-Stefanov/dp/0596806752/ref=sr_1_1?s=books&ie=UTF8&qid=1310948115&sr=1-1

Object-Oriented JavaScript (Stefanov)

http://www.amazon.com/Object-Oriented-JavaScript-high-quality-applications-libraries/dp/1847194141/ref=sr_1_1?s=books&ie=UTF8&qid=1310948145&sr=1-1

Most people swing from Douglas Crockford's nuts and recommend JavaScript: The Good Parts (http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_1?s=books&ie=UTF8&qid=1310948183&sr=1-1).

I received a free copy while at Yahoo in 2008 and honestly, I didn't find this book that good of a read. I felt it was definitely geared more towards those with formal CS backgrounds. Keep in mind, I definitely need to re-read it (to see if I feel the same way), but I read it a couple times back in '08 and tossed it on the shelf. The books I mentioned above I've read several times as well and can only say buy them. I'm on my 2nd read of Flanagan's book now.

jQuery in Action is a decent book, but the copy I have is for 1.3, I think. I think I have the first edition and it looks like there is a second.

http://www.amazon.com/jQuery-Action-Second-Bear-Bibeault/dp/1935182323/ref=sr_1_1?s=books&ie=UTF8&qid=1310948303&sr=1-1

jQuery Reference Guide 1.4 is also good, but it's for 1.4 and jQuery is at 1.6 now so it's tough for the books to keep up! I think it's pretty much the online/official reference guide as well

http://www.amazon.com/jQuery-Reference-Guide-Jonathan-Chaffer/dp/1849510040/ref=sr_1_2?s=books&ie=UTF8&qid=1310948347&sr=1-2

Could you post a link to the negative response you received? I would be curious to judge it for myself.

There was a fairly strong anti-OO backlash that I would place in the early 00's up to about 2008. The furor has since died down (or at least I'm no longer seeing anti-OO blog posts like I used to). If you're interested I could probably dig up some more, but off the top of my head:

• Execution In The Kingdom of Nouns
  
  
• Why Arc Isn't Especially Object Oriented - and in particular "the smartest programmers [Graham knows] are some of the least excited about [Object Oriented Programming]".
  
  
  Personally, I'm not a huge fan of OOP. It models some problems very well, such as GUI widgets and simulations. But in most domains it tends to result in a bunch of scaffolding that becomes a permanent part of your code base. It is a crutch for when you poorly understand your problem - objects give you something "concrete" to grasp and this is fine for a first pass - but ultimately you should prefer cleaner and simpler abstractions that more closely map to the problem domain.
  
  I also think that C++ is a horrible language for OOP. It's not flexible enough and thus requires a great deal of biolerplate to achieve object-like behavior. For OO-tasks I prefer to work in Smalltalk-inspired languages like Python or Ruby. In particular, characteristics of "real" OO languages would be: late-bound, dynamically typed, and introspective.
  
  Instead, when I work in C++ I prefer to use (what I think of as) "modern style" which was first defined (to the best of my knowledge) in Alexandrescu's book, and is perhaps best embodied by the Boost C++ library style. I realize that this is not everyone's cup of tea. But I think that this is the one area that C++ legitimately shines. It is what I call the "no compromise" style of programming - with the help of template meta-programming libraries you can write your code at a very high level of abstraction, and yet compile it down to extremely efficient code as if it were hand-coded in C to do that specific task. It can be pretty amazing, although it can also be (and probably is) a Turing Tarpit.
  
  EDIT: Not sure why it really matters but: mid-30's, and I work on automotive infotainment systems. C & C++ are the only languages officially supported on the platform, so despite my dislike of C++, I write a lot of it and it is probably my strongest language.

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

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

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

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

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

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

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

Not really related to mobile development, but he should still really enjoy these if he hasn't read them already:

• Clean Code (http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) anything by Uncle Bob tends to be easy to learn and extremely useful
  
  
• Seven Languages in Seven Weeks (http://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X) really fun read and a good way to quickly learn a little about a lot. Great for a jack of all trades
  
  
• The C Programming Language (http://www.amazon.com/The-Programming-Language-2nd-Edition/dp/0131103628) a book every dev, no matter the domain, should read
  
  
• Land of Lisp (http://www.amazon.com/Land-Lisp-Learn-Program-Game/dp/1593272812) because learning functional programming makes you a better programmer
  
  
• The Pragmatic Programmer (http://www.amazon.com/The-Pragmatic-Programmer-Journeyman-Master/dp/020161622X) I actually just started this one last night so I can't say much about it. Including it anyway because really smart people recommended it
  
  
• Eloquent JavaScript (http://www.amazon.com/Eloquent-JavaScript-Modern-Introduction-Programming/dp/1593272820) really good "intro" to JavaScript. Even if he's already familiar with the language, there maybe be a lot more to it than he know about (closures, prototype, "this", functional programming, etc.)

As /u/mr_stark said you have the interest and love for it which is a big plus. Don't get discouraged, programming is not just about the language or the language. It is about problem solving, collaboration and design.

I always recommend stepping back from the code when you first approach a problem. How would you solve the problem if someone asked you to do it using regular English sentences.

For example "tell me the length of a string"
*Go through each character and add 1 while I have not reached the end

• return the end result
  
  Learn your data structures. Arrays,Lists, Hash Tables, Dictionaries they all typed of problems they are good for and types of problem they are horrible for. Learn the difference, and when to use which.
  
  Once you have these two down, you are now ready for the different algorithms. This is where the design comes in. This book is very good at helping with this. It's old but a very good book.
  
  Note that as you are learning this you should choose a language and code up the different data structures and do small programs to learn the ideas. This will also teach you the language as you go along. www.coursera.com is great for free courses and resources.
  
  Once you have the basic ideas you can start getting more in depth courses for the languages you want to learn. For C# I recommend CLR via C# for example for C#.
  
  Lastly as with most things the only way you will get better is practice practice practice. Start creating apps to help yourself out and automate daily things you do. Start exploring and creating different applications.
  
  Hope this helps!
  Good luck!

If you know a language that you want to learn, go ahead and look for tutorials online (there really isn't the perfect beginners guide).

If you don't know/care for any specific language, I'd recommend the book 7 languages in 7 weeks to get started.

That way you can learn a few different language paradigms and find what suits you best.

I highly recommand that you not only go over the book and do all the examples, but ask yourself after each language: "What cool (small) thing could I build myself with it?".

And then browse the web for some more tutorials on that language.

You won't know any of these languages very well at the end, but you'll have a general overview and can then dive into any that you like.

If you are interested, you can also PM me and I'd offer some help (mostly chat-based explaining and pointing to resources, etc.).
I currently have a lot of spare time and know C#/Java/Php, generall HTML development and am always happy to support someone willing to code (most people only care for the result, but I believe coding to be an art itself worth more than that ;) ).

tl;dr find a language you like, look for online tutorials or books and just start learning

edit: also check our subreddits like /r/coding and /r/programming.

Check out this online book, it covers a wide array of PHP topics, but there are some solid chapters on objects including the building of a basic OOP website.

The book, PHP Objects, Patterns, and Practice is an incredible resource of PHP OOP concepts and application design. It starts off with a few chapters on the basics of OO PHP coding, giving you the rundown of syntax and inner-workings. From there it covers popular OOP design patterns (MVC, Adapter, Component, etc) and then lives up to its name by showing the patterns in practice.

After you've picked up the basics of OOP, check out a PHP web framework. I would recommend CodeIgniter for its amazing documentation, not to mention this wonderful set of video tutorials CodeIgniter from Scractch featured on Nettuts.

Once you get a working knowledge of a framework and have built some basic applications and websites, take the time to study the code behind the framework. Find out where the entry point is and trace its execution, checking out the source for each and ever object that is instantiated. Not only will you pick up on some sweet OOP concepts, but you'll gain a great understanding of how a typical OO PHP application is structured.

Good luck and have fun!

Keep your programs DRY! (Don't repeat yourself) In procedural, you would take those large blocks of code and faction them up into functions. With OOP, look even more abstractly and take several large blocks of related code and put them into classes, which are, at a very basic level, a collection of related functions and properties.

You mentioned some issues that sound like code cleanliness and structural issues. Getting better at algorithms really comes down to practice and exposure, there's no shortcut to this. But there's no reason to suffer from bad coding practices if there's room to improve.

A few books come to mind, which may seem like they're coming from left field, and may not seem immediately useful to the task of solving algorithm puzzles, but might be useful in the long term for you to learn how to write correct, clean code and reduce uncertainty:

• Code Complete 2. Some good tips in here regarding code cohesion, and how to write functions and classes cleanly.
  
• Clean Code. More on writing functions cleanly, along with design & testing.
  
• How to Prove It. This is a great book that delves deeply into logic. Even just the first chapter or two could be incredibly useful to you. It discusses things like DeMorgan's Laws, which show up a lot in programming and electronics. It deconstructs common logical concepts and phrases into boolean algebra and set builder notation (which inspire Python's list comprehensions). The world of math and logic and proof is not completely isolated from the world of programming.
  
  EDIT: One other thing is to make sure you understand the limitations of how computers represent numbers. The need for this understanding will become clear very quickly on, say, Project Euler problems. Look into bits, values, integers, signed vs unsigned, IEEE754 floating point.
  
  And one other thing is that it's easy to compare your solutions against some of the best solutions that exist for those problems and think you're doing a bad job when in fact you're doing an alright job if you manage to solve the problems with decent runtimes. Mind your 80/20 rule here. The extra time it probably took those people to craft those solutions is not 0, which includes whatever time they spent over the years becoming an expert at that language, etc.

So, this post is close to a week old. I hope I'm not too late.

Microsoft actually has some pretty good training courses that you can go through for free.

C# Jumpstart

ASP.NET Jumpstart

I used the jumpstarts as a refresher a while ago after I got stuck developing on Oracle for a while and they are both good overviews.

That said, when you are looking at doing MVC .NET development you are really talking about three things. Learning C#, learning about the .NET framework, and learning how to develop in Microsoft's implementation of the MVC framework. I would learn in that order.

Since you have experience with Java, C# should be fairly familiar to you. I'd still recommend skimming over the basic differences. Once you've got that in hand, it is good to learn about the basic offerings of the .NET frame work. I've found that C# 5 in a Nutshell does a great job at going over both C# and the .NET frame work. It is dry, but worth going over. Once you've been through the first few chapters, you can pick and choose where you want to dive in next. IMO, LINQ is great.

Then, once you've got a good grasp for C# and the underlying framework, it is pretty easy to tack the MVC model on to it. The biggest problem I've seen is devs trying to learn every thing all at once. Depending on your experience level, you may be able to dig right in. Best of luck.

I will agree that it isn't cheap but if you're serious about your professional development, it is well worth it. If you want to just try it out, they have a 10 day free trial.

To be honest, though, I'm not sure what you mean by "advanced topics and concepts." There are plenty of courses on PluralSight that I would consider advanced but it sounds like there is only one on there that interests you.

Regardless, if you are looking for something more intermediate, PluralSight has you covered. If you're looking for something more advanced than PluralSight can offer, maybe you should look into https://www.amazon.com/CLR-via-4th-Developer-Reference/dp/0735667454

Edit: I'd like to add that http://bafflednerd.com/learn-csharp-online/ was on this subreddit the other day and seems like a pretty thorough list. Free courses and never as good as paid ones, though (in my experience).

I went to school for it, but I'll be the first to tell you that a fucking class isn't the best way to learn how to code. What kind of questions do you have?

If you're confused about why something like "System.out.println("Hi");" actually prints something to the console, I can explain to you what everything in that statement means (it's actually really intuitive and easy, and it's something professors usually don't tell you when they're introducing you to code writing).

If you want a recommendation on where to learn, Khan Academy and Code Academy are fantastic free resources, but another free service that I've found to be phenomenal has been [tutorialspoint.com] (http://www.tutorialspoint.com/java/). I also just recently purchased [a really good C# book] (http://www.amazon.com/5-0-Nutshell-The-Definitive-Reference/dp/1449320104/ref=zg_bs_697342_6); I like what I've seen in it thus far and if one by the same author exists for Java I'd recommend it.

All that said, by all means, ask me (or anyone else in this thread that'd like to answer questions) whatever you'd want. You also might want to check out /r/learnprogramming, and when you start getting to the more intermediate levels of programming stackoverflow.com is one of the best collab resources out there.

I'm not sure if mods would be okay with a programming question thread in this sub, so if you make a new thread somewhere else make sure to PM me so I can help answer your questions.

I'm 35, no degree, 2 young kids, little time to study. I had an interest in coding but have done nothing more than an intro to HTML/CSS and Javascript while in community college.

I got a job as a tester/DBA support. I expressed interest in learning to develop as we were short staffed (still are).

I started with Udemy.com, C# Beginner with Mosh. I liked this course but felt it was a bit disjointed. His lectures did not always cover the material used in his challenges, but I will go back into his other two courses eventually.
Next I watched the Bob Tabor videos others have mentioned. I liked these, they were a little more direct and showed more actual coding than the Mosh vids.
Third - I read the first 20 chapters of this book: https://www.amazon.com/C-Players-Guide-3rd/dp/0985580135/ref=sr_1_1?ie=UTF8&qid=1521128465&sr=8-1&keywords=C%23+Players+Guide (most of this would be a review, but I like seeing how other people teach the same material)
Now, I'm working through this book:
https://www.amazon.com/Head-First-Learners-Real-World-Programming/dp/1449343503/ref=sr_1_2?s=books&ie=UTF8&qid=1521128540&sr=1-2&keywords=Head+First+C%23.

After this book, i will move onto Pluralsight.

I am very much still a beginner, probably still a year or more away from supporting our devs at work. But the best advice I got was to code every day. You won't learn it if you don't do it. I don't know if any of this will help you get "job ready" super fast, but its the advice I was given and I just wanted to pass it along.

> Most of the jobs out there are temporary or contract (short/long/C2H)

This sounds patently untrue. I'm certain that the vast majority of people in CS have full-time jobs rather than temp or contract.

> Recruiters won't even look at you if you don't have a knowledge in a specific stack (even for entry level)

Also untrue, especially for entry level, where good companies won't care what tech stacks you know.

> Recruiters don't even look at your resume, all they do is keyword search

Partially true. Resumes are often automatically filtered by how many buzzwords they contain. If you can use buzzwords without making your resume seem over the top, do it.

> I've been told that I shouldn't even apply for SDE jobs because I'm a "tester" and how I probably don't know of any CS fundamentals (because my degree is in CompE, not CS)

Bullshit. Any company worth working for - most companies - will not take that attitude. They might be skeptical, but they would never suggest you don't apply.

> Interviewers don't seem to have interest in interviewing

It doesn't matter; it's their job. And most interviewers are competent at interviewing, so nothing to worry about, regardless of how "interested" they are. (Though an "interested" interviewer, while rare, is a pleasure!)

> Companies have absurd hiring standards (they are all looking for a unicorn for 50-60k/yr pay, through contract)

Depends on the company.

> * Entry level jobs require years of PROFESSIONAL experience in a specific technology


Entirely false.

---

The current job market is fine, prosperous even. Craft a strong resume, post it in the resume advice thread, and send it out to companies. Apply to a bunch of companies, account for a 5-15% response rate (higher if you're more skilled).

Getting interviews will be the easy part; to pass them, you'll need to pass difficult algorithms questions. Books like Cracking the Coding Interview and Elements of Programming Interviews are essential reads; then go on a website like LeetCode and grind away at problems until you can solve easies in 20 minutes or less, mediums in 30 minutes or less, and hards in 60-120 minutes. I'd say a 3:9:1 ratio of easy:medium:hard would be a good ratio to go with, and do as many problems as possible until you're comfortable with where you are (for me, that was about 120 problems). The premium subscription is well worth it for problems tailored to certain companies.


Edit: spelling

Reversing: Secrets of Reverse Engineering - Is probably the most common book recommendation. Its an older book (2005) but its about as gentle as it gets in terms of the core concepts but its missing a bit due to its age (32bit RE only). I'd liken it to something like Hacking: The Art of Exploitation for exploit developers. Its a solid book, it covers the fundamentals but it'll take a bit more work to get up to speed.

Practical Reverse Engineering - This one is a newer book (2014) while it doesn't cover as many topics as the above book, its less dated in what it does cover, and it does cast a wider net covering things you'll see today like ARM and x64 instead of just x86. I tend to recommend starting with this book, using Reversing and the next book as a reference if there is a chapter of interest.

Practical Malware Analysis - While this one has more traditional RE introduction, where it excels is in dynamic analysis and dealing with software that doesn't want to be analyzed. Now, its from 2012 and malware has changed since then, so its age certainly shows, but again fundamentals remain even if technical details change or are expanded upon.

Practical Binary Analysis - This is the newest book of the list (December 2018). It wouldn't use it alone, but after you've gone through any of the above books, consider this an add-on. Its focus is on dynamic analysis and its modern. I'll admit I haven't read the entire thing yet, but I've been pleased with what I have read.

Edit: s/.ca/.com/g

Ah, the context of the Uncle Bob rant from a few weeks ago. I don't see how any of the author's particular complaints have anything to do with TDD:

> You therefore are more reluctant to make large-scale changes
> that will lead to the failure of lots of tests. Psychologically, you
> become conservative to avoid breaking lots of tests.

This is a bad thing? If you think a whole lot of tests might break if you make large changes, clearly there are massive side-effects to the change you propose, and then wouldn't a conservative approach to making the changes be the right thing to do?

Personally, I like fixing broken tests when I make large changes. It gives me greater confidence that I won't introduce regressions and allows me to understand the impact of what I am doing and gives me insights to the design of the system, particularly when it comes to the level of coupling.

But, this is the consequence of having a test suite, and doesn't say anything about whether that test suite was created through TDD.

> Sometimes, the best design is one that’s hard to test so you are
> more reluctant to take this approach because you know that
> you’ll spend a lot more time designing and writing tests

The author didn't give an example of this, but I am assuming he probably means GUIs. Well, not everything needs to be tested, and especially with TDD. The key is to separate code that needs to be tested from code that doesn't (or tested in a different way).

When it comes to GUIs, I usually write a "shell" without tests (because really, besides interaction, what are you testing?) and delegate functionality to interior objects which I definitely implement test first.

Another example I can think of is heavily algorithmic code. Like, back in the day, I worked on seismic processing software. Well of course, you don't develop those kinds of algorithms test first (or, maybe in a very different way - the geoscientists involved wrote papers which discussed the math involved before writing any code). But again, like GUI programming, the seismic processing algorithms were isolated from the rest of the system, which was written test first.

TDD works well for some types of code and not others. The requirement of using judgement to decide the development processes for specific cases has nothing to do with the effectiveness of TDD as a general practice.

> The most serious problem for me is that it encourages a focus
> on sorting out detail to pass tests rather than looking at the
> program as a whole.

No it doesn't. Test-first just means you write tests before you write the code. That doesn't mean you can't look at the program as a whole first before that. The first half of Uncle Bob's book Agile Patterns, Principles and Practices is devoted to UML. Yes, you heard that right.

Check out this chapter from that book, Heuristics and Coffee. Before diving into the code, Uncle Bob spends a good chunk of time going through the use cases and coming up with a first pass at a high level structure for the system, in UML.

TDD is one part of "Agile" software development, where the rubber hits the road. But before you start driving, you should have a basic idea of where you are going, which is design. The "epicycles" of TDD then serve to validate that you are on the right course, from minor turn-by-turn directions to occasionally stepping back and making sure you are still on course.

The idea is to come up with as much UML as necessary to get a basic idea of the overall design, and then use TDD to execute and validate that design, incrementally.

The author is taking TDD out of context and missing the bigger picture.

> But the reality is that it’s often hard to specify what ‘correct
> data’ means and sometimes you have to simply process the data
> you’ve got rather than the data that you’d like to have.

What does this have to do with TDD? Again, TDD is a part of a larger process, which involves the business. Software that does "real work" doesn't work in a vacuum. Programmers have to deal with the business to understand the data to the best of their ability, and even still, you'll still make mistakes.

At least the tests document an executable understanding of the data, and test failures can actually give valuable insights on changing assumptions of the data.

It does the job, good stuff! I think you've got loads of suggestions about the actual code / arrays.

For me an important programming skill is called "clean code", there is a book.

It may be a little over the top given you are learning arrays, but I'll rabble on a little bit about it as I think its quite a simple premise and also I think a real good thing to start doing as soon as possible as it can keep clean and code simple.

Essentially how to make your code easier to read and understand. It applies to any coding, not just java. Short can curlies relating to your code post, meaningful naming and small methods that do basically 1 thing.

So for example take line 25:

if (userChoice > 12 || userChoice < 1) {

I dont know right away what that is doing or it means. Given we are talking about months, this looks like a range check and looking at the code within the if statement I can figure out it looks like this is the "good / valid" part of the check and we another have a bad / error check as well.

But the problem is I have to figure that by looking at what the code is doing. In another example where its not months / something new to me and the if's are doing something a little more clever, it'd be alot more difficult to figure what the code is doing.

So one / the traditional solution is to write a comment something like:

// bounds check the user input to make sure its a valid month
if (userChoice > 12 || userChoice < 1) {

But comments are likely to get old + out of date if someone makes changes and ignores the comment (happens all the time). They also muddy up the code with extra lines / make it harder to read + understand.

So an alternative way is extract the if logic to another method and give it a nice friendly name, for example:

if(isValidMonth(userChoice)) {
... rest of method...
}

private boolean isValidMonth(int input) {
return input > 0 && input< 13;
}


Now when you read you read that if statement its telling you exactly what its doing so you dont have to figure anything out yourself. Its quick, easy and clean. If this logic is difficult / doing something odd, then rather a comment, you can right some javadoc for the method.

See my example below of one way the main loop in your application could look:

while (continueInput) {
printUserMenuToConsole();
userChoice = userInput.nextInt();

if (isValidMonth(userChoice)) {
printSelectedMonthToConsole(userChoice);
String askQuit = getIt.nextLine();
continueInput = isContinueInputQuit(askQuit)
}
else {
printErrorMessage(userChoice);
}
}

You can see how that loop now is much more readable, its telling the reader what its doing. Essentially what is happening is taking a method that does a lot and break it down into smaller more manageable chunks and separating process and logic.

It still is a little clunky, we could take that one step further:

private void doUserInputLoop () {
boolean continueInput = true;
while (continueInput) {
printMonthMenuToConsole();
takeUserMonthAndPrintToConsole();
continueInput = doesUserWantToContinue();
}
}

You can see here the logic / complexity of all the months is now stripped out each into there own methods and this method is not much smaller and is all about the process of the loop. Within 2 seconds you can understand what you app does by reading those 3 lines, print menu console, get user input and print to console and ask use if they want to loop again. Its a little clunky with the while loop / boolean but its not too bad.

Its handy as well becuase if the code tells you what its doing, you never (or very rarely) need to write a comment.

Word of warning, balance is everything, this can be taken too far. The key is to name variables / method names fully to describe what they do (your variables are good). If you cant / struggling to come up with a name or they are getting too long, then its warning bells that a bit too much is going on / there is probably a simpler way to achieve what you are trying to do.

Starting this off as saying that I work primarily in iOS and mac environments. I think PCs are great and apple is overpriced but I really enjoy it and I love Swift so whatever.

If you're building applications in Windows most people seem to start with Visual Studio. There's a ton of resources, frameworks, libraries, and a large community for it. At the very least it's probably a good place to start. For C++ development maybe start here: https://msdn.microsoft.com/en-us/windows/uwp/get-started/create-a-basic-windows-10-app-in-cpp

Now for your broader question of application development, I would start with the Gang Of Four for code design. These aren't easy concepts to get right off the bat, it's putting in some reps before it becomes natural. You'll never use just one either, most projects become a mesh of different design concepts and there's way more than 4. I recommend coming up with a simple project to build on your own and then attempting to architect that from a high level before coding. Then actually building it. It's really the only way to learn. For C++ reading maybe check this out (not 100% on this, I don't do much with C++, but seems recommended as an update for the original Gang of Four): http://www.amazon.com/dp/0201704315/

Another book: http://www.amazon.com/dp/0735619670/

it's from this list: http://blog.codinghorror.com/recommended-reading-for-developers/

This all said, don't get bogged down in books. Read enough to feel comfortable starting something then start it.

Hopefully you can find some helpful answers, guidance, or a starting point in these responses.


From OP:

>The exact four books I read are:

>Learning Obj-C

>Learning Java

>iOS Programming: The Big Nerd Ranch Guide

>Android Programming: The Big Nerd Ranch Guide

>However, I would now recommend learning Swift instead of Obj-C. At the time when I was looking into iOS books, good books on Swift were few and far between.

From u/AlCapwn351 in regards to other sources to learn from:

>www.codeacademy.com is a great site for beginners (and it's free). It's very interactive. W3schools is good for learning stuff like JavaScript and HTML among other things.

>When you get stuck www.stackoverflow.com will be a lifesaver. Other than that, YouTube videos help and so do books. Oh and don't be afraid to google the shit out of anything and everything. I feel like an early programmers job is 90% google 10% coding.

>Edit:

>It's also good to look at other peoples code on GitHub so you can see how things work.

I don't really like the term "design your system using interfaces" because it doesn't tell you why. It's a generic idea without any context.

It is better to start with a principle, like Dependency Inversion. Dependency Inversion says you should separate your code from its external dependencies. This is good, because it keeps your code isolated and not dependent on the particular details of things like storage.

Does your application use MySql? Does it use MongoDB? It doesn't matter. In your interface, you can specify query methods for objects from a data store, and a method to save objects to your data store. Then implement the interface specifically for the data store. Your interface could be called FooRepository and the implementation MySqlFooRepository or MongoFooRepository. I dislike interfaces called FooRepositoryImpl. This strongly suggests an interface isn't necessary.

Interfaces are contracts that help you preserve your design and to explain what you need out of external dependencies.

Interfaces are good, but so are classes. Don't overuse interfaces, because indirection isn't always necessary or good. It can make your code impossible to follow and understand.

Start by learning principles like SOLID, which will help you understand where usage of interfaces makes sense. Agile Patterns, Principles and Practices is the best book I've read about this. Another book which does a great job of explaining how to properly use interfaces is Growing Object Oriented Software Guided By Tests.

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

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

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

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

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

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

Some great suggestions here around complimentary languages. Let me chime in on the tools. Depending on where you want your career to go deploying Ruby without Heroku wouldn't hurt at all.

• When to use Varnish / Nginx and why
  
• Why Capistrano is a popular way to deploy code
  
• How to demonize and monitor ruby processes
  
• Why people use Chef
  
• Knowing the key difference between how Unicorn scales and Puma
  
• Understanding Git, Git merging strategies and having an awarness of Git Flow style branching models
  
• etc...
  
  I've made no assumption on what you already know so please don't feel like you need to know all of this but as Rubyist these are things I look for in candidate's that I hire :).
  
  PS: I've not included Databases in all of this which I think is obvious to say is important when fleshing out a CV.
  
  PPS: Two books I would recommend highly (can easily be read on holiday in the sun)
  
  
• Seven Languages in Seven Weeks
  
• Seven Databases in Seven Weeks
  
  Both of these books are fairly light hearted, give you a grounded understanding of the core differences in languages and databases, assume your a programmer already and IMO are very interesting reads for someone that is keen to look at languages from different angles. Prolog == mind blown
  
  Good Luck

Usually the CTCI referred to here is Cracking The Coding Interview. It´s probably the best known interview preparation book. You can easily find the PDF online but I would recommend buying it because it´s like an algorithms/datastructures bible and it will make it easier to take notes (it´s also a tiny investment compared to the potential pay-off). I think if you can comfortably do all of the questions (incl. moderate+hard) then you will be close to ready for Google. It depends from person to person. But I would recommend doing some LeetCode Google flagged questions afterwards to gauge how well prepared you are. For some people CTCI alone is enough while for others an additional 50-100 LeetCode are sufficient (some skip to LeetCode directly and do 150-300 questions on there). Note that CTCI is an alternative to EPI (Elements of Programming Interviews). Doing both would be a bit redundant. From what I gather EPI has more challenging problems so might prepare you better for Google, but if you´re very rusty then CTCI might be an easier start.

There´s plenty of resources available on this; I suggest checking out the relevant FAQs in the sidebar of this subreddit.

Great question!

A lot of intro classes skip over the 'why' and 'how' of programming languages. Lets backup for a second - the purpose of a programming language (C#, Java, etc.) is to abstract away the actual machine code that runs on the hardware. It would be a very difficult and tedious task to write large applications in machine code. This is where the compiler comes into play; even though we have these great high level languages, hardware still only understand machine code. The compilers job is to take statements that we write in high level languages and turn them into machine code.

Now, keeping in mind the above - back to your question. All of the specific words you are wondering the meaning of are keywords the language has. They are reserved for a specific function/meaning and help the compiler understand various traits about the code you are writing (context, control flow, etc.).

String - A String is a type and a type describes to the compiler what kind of data you are working with. In this case, a string means text (words, sentences). That's why variables that are of type String usually have the " ".

Console - (I am assuming that you are referring to the class here) The console class is a group of methods that tell the compiler how to interact with output on a terminal (the black window with a blinking cursor). You can use any methods (like WriteLine) to tell the compiler what you are trying to accomplish. Classes like this save us a lot of time, there is no need to always re-invent the wheel and write I/O code.

Namespace - This is one of the context keywords I eluded too above, it tells the compiler the scope of variables and expressions that you are writing.

Main() - This is a method name! It is a very important method because it is the entry point for an executable!

? - This is the funny one - The question mark operator is actually shorthand for an if/else control flow fixture. If the variable to the left of it evaluates to true, the first expression is executed, otherwise the 2nd. https://msdn.microsoft.com/en-us/library/ty67wk28.aspx

Pro Tip - MSDN is your friend! Microsoft has a lot of great documentation on C#... how did I find the above link? I googled "C# ? operator". Also, if your text book is not working out for you, see if your library has access to the C# 5.0 in a Nutshell book

Sure, though I've also read people in your position are better at building apps with JS if they're new to it because things like PHP are completely different in how you start growing an app (classical vs prototypal inheritance) not to mention that if you also do PHP instead of just straight JS you're getting used to and learning 2 languages that are completely different in how you code. In either case you're right you have to learn JS anyway, here are the best resources after codeacademy basics stuff:

JavaScript: The Definitive Guide: Activate Your Web Pages (Definitive Guides):

http://www.amazon.com/JavaScript-Definitive-Guide-Activate-Guides/dp/0596805527/

JavaScript: The Good Parts:

http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/

Programming JavaScript Applications: Robust Web Architecture with Node, HTML5, and Modern JS Libraries:

http://www.amazon.com/Programming-JavaScript-Applications-Architecture-Libraries/dp/1491950293/

A cool talk from last year of the Fluent conference (and the author of that last book) explaining how different something like PHP and JavaScript are and why JS doesn't deserve the bad rap it used to get (He's a pretty cool guy from Adobe and I got to talk to him last week about all of these things we're talking about right now and where web development is heading, and why JS as a single language for the web can work even better):

http://www.youtube.com/watch?v=lKCCZTUx0sI

This was a really cool overview on JS today, and you get to see Unreal Tournament and the Unreal 4 engine run in a web browser:

http://www.youtube.com/watch?v=aZqhRICne_M

You need to understand there are a couple of ways to do Java web development.

• Servlets & JSPs. - Check out Core Servlets and JavaServer Pages or the Java EE Tutorial. Note that I link to an older EE tutorial because the newer versions try to switch to JSF and not much changed in Servlets and JSPs between Java EE 5 and 6. I recommend learning Servlets and JSPs before anything else.
  
• JSF - A frameworks that is layered on top of Servlets and JSPs. Works well for some tasks like making highly form centric business web apps. Most of the JSF 2 books are okay. JSF is covered in the Java EE 6 Tutorial
  
• Spring - Spring is actually a bunch of things. You'd want to learn Spring MVC. If you learn any server-side Java web tech besides Servlets and JSPs you'd probably want to learn Spring MVC. I wouldn't bother with GWT or any other server-side Java web tech.
  
• JAX-RS - After you get Servlets and JSPs down, this is the most essential thing for you to learn. More and more you don't use server-side Java (Servlets & JSPs) to generate your clients HTML and instead you use client-side JavaScript to make AJAX calls to a Java backend via HTTP/JSON. You'll probably spend more time with JavaScript:The Good Parts and JavaScript: The Definitive Guide than anything else. Also the JAX-RS api isn't that hard but designing a good RESTful api can be so be on the lookout for language agnostic REST books.
  
  Definitely learn Hibernate. You can start with the JPA material in the Java EE tutorial.
  
  As for design patterns, Design Patterns: Elements of Reusable Object-Oriented Software is a classic. I also like Patterns of Enterprise Application Architecture for more of an enterprise system pattern view of things. Probably avoid most J2EE pattern books. Most of the Java EE patterns come about because of deficiencies of the J2EE/JavaEE platform. As each new version of Java EE comes out you see that the patterns that have arisen become part for the platform. For example you don't create a lot of database DAOs because JPA/Hibernate handles your database integration layer. You also don't write a lot of service locators now because of CDI. So books like CoreJ2EE Patterns can interesting but if you are learning a modern Java web stack you'll be amazed at how archaic things used to be if you look at old J2EE pattern books.
  
  p.s. Don't buy anything that says J2EE, it'll be seven years out of date.
  

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

You could start with this book if you wanted:

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

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

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

Personally I wouldn't mind if == never did implicit casting and acted like === (in fact I wish it did), but the rules don't seem that bad to me.

The example I gave was very contrived, and solution was naive, the best way to compare two arrays to each other would be to loop through them, like this. What I was doing was showing you how you'd take advantage of the implicit casting.

I think it was in John Resigs book where I read the best advice I have seen for JavaScript and it went something like "Treat everything as if it was an object and use === unless you need to use ==".

Also never use the wrapper objects if you can help it. Let the interpreter use them in auto-boxing and leave them alone. Because you are 100% right, things can get a bit weird then.

Both are wanted m8! Seriously there is no shortage for Cyber Security Professionals, there are too many jobs, and too little people to fill them!

Red Team is a little harder to break into then Blue Team is, due to the wide range of knowledge you need. Red Team is more offensive, so you will be hacking companies (legally) and testing for vulnerabilities, misconfigurations, etc.

Blue Team is more defensive, so you will be working for a company internally - basically preventing cyber attacks, setting up firewalls, managing IDS/IPS, tracking malware, working with SIRT on breaches, doing DFIR and Data Recover, etc.

Since you said you want to break into Red team, then I highly suggest you start with the Security+ (as I posted above) so you can get the basics down.

At the same time start listening to podcasts like Paul's Security Weekly, Down the Security Rabbit Hole, etc. As well as start reading blogs on hacking to get a feel for whats done, get a grasp at security terminology, and just recent news overall.

Get a home lab and learn a few tools like Wireshark and Nmap for basic Cyber Security work - to learn how packets work, how they are structured, and how to scan pc's for ports and services. At the same time, focus on learning about threats and vulnerabilities (which are covered in security+).

If you want to get into PenTesting then you need a wide range of knowledge. Pick up and learn a few languages (master the basics and understand what the code does and how to read/interpret it). You need to know: PHP, HTML, SQL, Python (or Ruby), and a basic language like C, or Java (but this is for more advanced topics like buffer overflows and all)

If you want to dig deeper into PenTesting then start reading: https://www.offensive-security.com/metasploit-unleashed/

The above is a good way to get into the Kali Distro and learn how to run Metasploit against vulnerable VM's.

Take a look at https://www.vulnhub.com/resources/ for books, and vulnerable VM's to practice on.

https://www.cybrary.it/ is also a good place with tons of videos on Ethical Hacking, Post Exploitation, Python for Security, Metasploit, etc.

Pick up some books such as

The Hacker Playbook 2: Practical Guide To Penetration Testing

Hacking: The Art of Exploitation

Black Hat Python: Python Programming for Hackers and Pentesters

Rtfm: Red Team Field Manual

The Hackers Playbook is great resources to get you started and take you step by step on pen testing that will allow you to alter explore the endless possibilities. The Art of Exploitation is also very good, but it's more for exploit writing and buffer overflows (much more advanced topic to save for later!)

Also a good list of resources that you can learn more about security:

Getting Started in Information Security

Pentester Labs

Awesome InfoSec

Awesome Pentest

If you don't have any prior knowledge with programming, I'd first recommend learning Python. If you do have programming knowledge, then jump straight into ObjC. I read these 3 books and my Objective-C knowledge grew so much. I highly recommend reading these books.

Book One

Book Two

Book Three

I'd recommend reading these books in the order I listed them.

After you have read those books, you'll want to get friendly with theos. Theos is what you will use to make your tweaks. Learn how to install/use it here: http://iphonedevwiki.net/index.php/Theos/Getting_Started.

Now, you can look at open source tweaks. There is a great place to see a lot of them: http://iphonedevwiki.net/index.php/Open_Source_Projects.

Once you are comfortable, get started writing tweaks!

Always feel free to PM me if you need any help or have a question. :)

>Do you find that the standard system of technical interviews (data structures & algorithms) is an effective way of assessing candidates? Why or why not?

When I was an undergraduate, the dominant interview approach involved brainteasers like "why are manhole covers round?" Initially, these were reliable indicators of future success. But after every other company started copying Microsoft mindlessly and asking the same set of questions, the approach quickly became less effective. People optimized for interview performance with books like How Would You Move Mount Fuji? and How to Ace the Brainteaser Interview.

Brainteasers were mostly phased out after Google introduced the current approach involving data structures and algorithms. Initially, these were reliable indicators of future success. But after every other company started copying Google mindlessly and asking the same set of questions, the approach quickly became less effective. People optimized for interview performance with books like Cracking the Coding Interview and Elements of Programming Interviews.

There are certainly parallels between what happened then and what's happening now. The difference today is that people have taken things to another level with platforms like Pramp and bootcamps like Interview Kickstart. New businesses keep popping up that focus on cracking the current system, and I don't think that bodes well for its future.

But what can we do about it? The fact is that any interviewing process can be cracked once its format becomes popular and standardized. Let's say that some major company like Facebook introduces a new standard that involves candidates giving two-hour presentations about significant personal projects and then answering tough questions from a committee. You may be familiar with this format if you've ever applied for a research position. I actually think this would be great for 2-3 years until everyone starts doing it and Gayle Laakmann McDowell or whoever publishes "Cracking the Personal Project Presentation." And then a bunch of new businesses will pop up to sell you slide templates, professional reviews, etc.

In short, I'm not a big fan of the current system (EDIT: because it's been "cracked") but I honestly don't know of a better one (EDIT: that won't suffer the same fate).

I don't have any experience with Clay and have a vested interest in D, so take the following with a grain of salt.

Here are my impressions on Clay vs D2 after having read the brief docs on the wiki:

• Clay seems to have no take on concurrency whatsoever. In fact even googling for Clay concurrency is quite difficult. D2 tackles concurrency issues directly with a no-default-sharing model.
  
• I like Clay's syntax desugaring (what I call "lowering"), but it assigned a name for each operator, which I believe is adverse to generic programming. D2 lowers operators by passing the operator as a compile-time string into the function, which enables further generic processing.
  
• Clay's iterators and coordinates seem to be similar to D's ranges. I'm unclear from the documentation provided about the pervasiveness of related entities and idioms in Clay. D2's ranges turned out to be wildly successful. Both use compile-time introspection to assess membership of a type to a concept. For example, in Clay you assess the presence of a member "size" like this:
  
  [S] SizedSequence?(static S) = Sequence?(S) and CallDefined?(size, S);
  
  whereas you do the same thing in D like this:
  
  template hasLength(R) {
  enum hasLength = isInputRange!R && is(typeof(R.init.length) == size_t);
  }
  
  I don't know how to enforce in Clay that the type of "size" is size_t; I'm sure there must be a way. And indeed the Clay version is shorter.
  
  
• Clay mentions multiple dispatch as a major feature. Based on extensive experience in the topic I believe that that's a waste of time. Modern C++ Design has an extensive chapter on multiple dispatch, and I can vouch next to nobody uses it in the real world. Sure, it's nice to have, but its actual applicability is limited to shape collision testing and a few toy examples.
  
• The docs offer very little on Clay's module system (which is rock solid in D2). The use of an antipattern in Clay's docs worries me though:
  
  import myownlib.test.*;
  
  
• Both languages seem to pay attention to linking with C and assembling applications out of separate modules.
  
• D2 is aggressively geared towards allowing its users to write correct code. Clay seems to have nothing else to say beyond a run-of-the-mill exception model.
  
• Clay lacks object-oriented programming support, although it does offer a number of palliatives (discriminated unions, for which D2 has powerful library offerings). This design choice seems odd to me because I believe straight OOP is much more important than supporting the obscure multiple dispatch.
  
  Overall Clay's current offering (judging only by the docs) is very scarce compared to D2's. I found nothing in Clay that's sorely missing in D2, and conversely there's plenty in D2 that I'd sorely miss in Clay.
  
  Clay looks a lot like the toy language I was working on before deciding to build on D: long on hope, short on bread and butter. In hindsight, I am happy with the decision to start with a language (D1) in which I could take for granted a lot of stuff.

Neat interview question, I'd either love it or hate it depending on what they expected to get out of it. I do think it's a bit problematic because how programming languages are different usually has (among other things) straightforward technical answers, but asking why one is more popular or successful than another is usually better answered from a historical/political perspective than a technical one (often, anyway). Part of your job will be to narrow down what the interviewer is actually asking.

To learn more about different programming languages themselves, I've seen this book recommended highly before (on this sub) and have it on my reading list, though I haven't got to it myself yet. If you're into MOOC's then I can say that I surveyed this course and enjoyed it for the price (free).

For the "why thing x is popular" side I would recommend just googling around (or waiting on reddit) to familiarize yourself with the popular flame wars. Most everything you will read is straight up wrong (just wait around for people to talk about the performance of Java for the best example). It may sound terrible, but you don't need real answers, for an interview you just need something to talk about. The history of CS is still a tiny field, and I'd eat my shorts if an interviewer was actually well informed on the subject. Here is a classic essay on why C beat out Lisp historically, it's arguments tend to get recycled a lot for other topics as well (Java, OOP, etc) despite it basically being an opinion piece.

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

If you want an introduction to computer science:

Introduction to CS: https://itunes.apple.com/us/course/this-is-cs50-2012./id624655973.
Stanford's iOS course: https://itunes.apple.com/us/course/coding-together-developing/id593208016 - This can be challenging for beginners as it assumes prior computer programming experience. That said the course is incredibly comprehensive and does an amazing job of teaching iOS.

• Free Online Tutorials -
  Ray Wenderlich : http://www.raywenderlich.com.
  Mobile Tuts : http://mobile.tutsplus.com/category/tutorials/iphone/ - Less quality control then Ray Wenderlich in my opinion but greater variety.
  
  
• Recommended Books -
  Big Nerd Ranch: http://www.amazon.com/books/dp/0321942051. Amazing series where you build projects out while learning objective-C along the way. My only gripe is that this is for iOS 5 and iOS 7 is right around the corner I would love to see an update.
  Stephen Kochan: http://www.amazon.com/books/dp/032188728X - Some say this is the go to for learning objective-C. I really like that they include detailed examples for each concept. I would recommend this as a reference when you run into major issues.

Generally speaking, "reverse engineering" implies getting an executable (like a .exe file on Windows) and trying to figure out what it does at the level of the source code. Reverse engineering is a long and tedious process that is not as simple as it sounds for several reasons.

The first thing that you have to understand is how a program goes from source code to EXE (since we're going in the opposite direction when we reverse an .exe file). When a program is written in a high level language like C or C++, it can't be run by a computer until it has been compiled, a special process performed by a compiler. Compilers take the source code, and translate it first into a middle language called an intermediate representation that represents the logical structure of the program, and then based on that middle language emit machine code. Machine code (which can be translated into a human readable form called assembly language) is the binary language that the CPU actually uses to do computation - it contains very simple instructions like "move this data to this location in memory" or "add these two numbers together". Most compilers will also make a lot of optimizations in before emitting the machine code - for example, if they see a certain piece of data being accessed and stored unnecessarily, they may move the code responsible for the redundancy to another place in the executable to avoid wasted operations. The compiler will finally output a file called an object file, which contains optimized machine code.

However, this file is generally not executable - it still has to be linked by the linker, (which sometimes automatically runs after the compiler). The linker performs several tasks, like fixing up absolute addressing to ensure that a program can be loaded anywhere in it's address space, as well as providing references to shared libraries. Usually when writing big programs, developers will use already-written code, like the C library or other vendor specific packages, by referencing it in the source code. For example, C source code can use statements like

include <stdio.h>

to indicate that the program includes references to the standard input/output library in the C library, which is used to allow user-provided data and to print data to the screen, among other things. So, it's the linker's job to ensure that these libraries are included in the final executable and that the other object files can reference them correctly. To make matters worse, the linker will build the executable program in whatever file format the operating system uses (PE on Windows, ELF on Linux, and Mach-O on OSX), and these file formats store the program data and code in separate locations. However, the linker handles this cleanly and produces a compiled, optimized, and linked program in the right format, which can then be executed. So that's how it happens normally.

So now, let's do it in reverse. Suppose you have suspicious.exe, a file that you think is malware and you want to find out what it does so that you know whether it's dangerous or not. Suspicious.exe is a compiled and linked executable, and since it was optimized, you don't necessarily have a 1-to-1 correspondence between each machine code instruction and each line of source code (and you don't have the source code anyway). Furthermore, the Intel x86 architecture that most commercial personal computers use in their CPUs uses variable length machine code instructions - some of the instructions will be longer than others, so it is very difficult to look at them in a binary and figure out what is doing what. This is where a disassembler is used - a program that takes a raw binary file and emits human readable assembly language. Because of variable length instructions, some disassemblers even emit the wrong assembly instructions sometimes! However, because the program has to be able to run consistently and reliably when given to the CPU, there is always a way to disassemble it into the correct machine code - it sometimes just takes a few hours (and a headache or two).

Now, you've disassembled the file using a tool like IDA Pro (which can cost hundreds or thousands of dollars, depending on the license), and you have human-readable assembly. So why is it still hard to figure out what the program does? Firstly, any descriptive variable names that a programmer used to make the source code more easy to read are gone because the compiler got rid of them once it generated the intermediate representation - so you don't even know what the various memory references are where data is stored. Secondly, while you can tell where functions begin and end, you can't necessarily tell what they do - they're just blobs of assembly, and sometimes not even that; if the functions were included in a shared library, they'll often be just references to the address in memory where the imported library is placed when the operating system loads the process into its address space (it depends on whether the executable is dynamically or statically linked, but that's a more in depth and tangential discussion). You also don't where important data structures - like strings or pointer tables - are because what the disassembler doesn't recognize as code, it'll just call "data" and leave it at that. Thirdly, most of the data in the program depends on the memory state while it's running, which you can't tell just by looking at the assembly. You need to actually run suspicious.exe.

So you take a look at this mess, ask yourself why you chose this job in the first place instead of being a web developer even though they get paid about the same as you, open another can of Rockstar, and you get to work. Generally, you'll start suspicious.exe in a sandbox environment like a virtual machine using a debugger, which is a special program that will allow you to halt it and examine its memory state, register states, and other activity. As the program executes, you will begin to notice behaviors that resemble C structures - how you actually do this is a huge discussion that people have written entire books about, but suffice it to say for now that it comes with experience. Furthermore, if you use IDA (or keep a notebook), you'll write down lots of notes about the program behavior, and use Microsoft's MSDN pages (or Apple's developer documents or the Linux man pages, depending on what environment your executable runs in). Eventually, whatever it is that you were aiming to find out becomes clear, or you quit out of sheer frustration (but usually and hopefully the former).

Bear in mind that most people don't aim to entirely reverse engineer every bit of machine code in an executable. A lot of it isn't related to what you're trying to discover, and so part of the game is first finding what pieces of code are actually relevant (which you do with a debugger by stopping the program's execution once it starts doing stuff relevant to your reversing purposes), then reversing those little parts of the code.

Yeah there was nothing in the talk about it.

As far as I can tell, it's a somewhat silly reference to the fact that the influential book "Modern C++ Design" was written in the C++ 98 era.

This 2001 book advocated a clean break from the C heritage in C++:

https://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315

It's heavy on template metaprogramming. I actually prefer "C with classes" for many problems, but it's it's clear that C++11, 14, 17 are going further in this direction.

And I believe that Immer relies on many features from C++11 and 14. Those features enable C++ the language to delegate all its data structures to libraries, rather than being part of the language.

-----

For a completely different and more useful application of the word "postmodern" in programming, I recommend this paper:

http://www.mcs.vuw.ac.nz/comp/Publications/CS-TR-02-9.abs.html

It's very insightful, fun, and in the 15 years since it was written has become more relevant. I haven't blogged about this, but this kind of thinking underlies the shell and the design of the Oil shell in particular. In particular, in large systems, there is "no grand narrative", and it makes sense to opportunistically use models when they are useful, but throw them out when they are not.

There is a tendency among programming language designers to assume that they are at the center of the universe. A big part of shell is about making existing pieces written in different languages work together.

And that includes the operating system. To me, it's obvious that runtime is more important compile time, and too many programming languages are ignorant of the other enormous piece of code that runs when your program runs -- the operating system.

I'm mainly looking for things they could do to shore up their resumé when comparing it to somebody coming out of a 4-year CS program someplace. They need to have projects to talk about, and github's a good place to put that. Making contributions to open source projects seems like a good way to build experience doing the sort of maintenance work that keeps business systems churning, and a good way to get some practical experience cutting code that they won't have from a 3-month bootcamp. It's also a way to get experience using source control, dealing with code reviews, etc. I totally agree that they should be building their own projects, but github also seems like a good way to present that part of their portfolio.

They should keep up to date, specifically, on developments in tools and technologies they're trying to get hired to use. There's no reason to expend effort tracking, say, Haskell, unless you really want to work with it, professionally, but, if your skillset is all webdev, it might behoove you to have a clue about, say, ES2017 and how much of it's actually supported and where.

There's no reason for a junior dev to be mastering languages or tools they're not actually going to be using, but a bootcamper is going to have pretty narrow exposure to programming paradigms outside their existing skillset. Rolling through something like Seven Languages in Seven Weeks as a project you spend an hour or two on each week would help broaden their foundation, and maybe expose them to some other ideas and programming paradigms. Likewise, a survey of, say, algorithms and data structures, if only to the point of being able to explain the difference between a queue and a stack, or an array and a linked list. This isn't because these are immediately useful skills, but because they're things I wouldn't expect a bootcamper to have picked up in bootcamp and they are things I'd expect a CS grad to know (if not necessarily know well), and the bootcamper is competing with the CS grad for the job.

For comparison, somebody in r/csharp asked what people actually expect from junior developers a while back. This was my answer to that question, which was bounded in terms of the language and technology stack.

I feel compelled to lead with this:

> I'm sorry, but you really should have been asking this question a year ago, not now as a graduate.

> Other readers: have a career plan in development while you're in school - otherwise you may find yourself left behind when you graduate.

But anyway, I'm a current student, and here's what advice I can give you based on what I have learned.

If you want to learn offensive security, you can take a certification course that includes Lab Sim like PWK for OSCP, but they are an expensive proposition and intimidating to someone without experience.

You could do what I'm doing, and build your own lab. Interview people in the industry that you have made connections with (and if you haven't made those connections by now, get on it!), and learn a bit about what their network environments look like. Then, emulate them, learn to set them up, and then use that lab as a shooting gallery to follow an online penetration testing guide and other self-learning resources such as The Hacker Playbook.

If you can find some in your area, I would highly suggest taking any in-person pentesting courses you can find. I'm lucky enough to live in the LA area to take Peter Kim's training classes. He's the author of the book mentioned above.

Get involved in local groups! Other people in your area are passionate about security too, and they may be learning or teaching exactly what you're interested in. I've had good luck with meetup.com.

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

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

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

For one of my projects, I decided to just use vanilla JavaScript AJAX and for the rest, I ended up using jQuery. I felt this gave me a better handle of what was going on behind the scenes.

For vanilla JavaScript resources, the MDN documentation was helpful to get going. Using vanilla JavaScript was hard and it isn't super intuitive. This is why I think most people just end up using a library to call out to APIs. There's also a good Lynda course that's called "AJAX and JavaScript." It's pretty fast paced, and the course assumes you already know basic JavaScript, but I found it helpful with learning vanilla js ajax.

As far as jQuery goes, this video was also really helpful. Again, fairly fast pace but overall, good info. Once again, using the jQuery documentation is ESSENTIAL. I've found that in general, if I am stuck, asking myself the right questions, going to the documentation, and finding the answers is usually best.

I also read through the book Secerts of the JavaScript Ninja which had a few things to say about asynchronous code. Hope this helps!

Books that helped me to get the hang of JS

John Resig's Secrets of the JavaScript Ninja and Douglas Crockford's JavaScript: The Good Parts are pretty much the only ones worth reading in my opinion.

Projects

The best thing would be to build something you want to use yourself. Maybe you try cordova and build a small app with the browser platform so that you can create a simple App that you can bring to your Smartphone.

More advise

Read a lot of code: TODO MVC is a good place to start, people try to write good code for this one because they want you to use their framework :-). The problem with the source code of many projects is that the JS ecosystem is in a constant flux and ES6 modules are skyrocketing right now. You may want to check out the jQuery source code - you can pretty much watch the evolution by looking at older versions of the source code and how it evolved.

If you feel really adventurous the NodeJS source code is a fun read - although it's a very big project that also got some C/C++ code sprinkled in - but that shouldn't be a problem for you :-).

I would advise you not to bother reading the Angular1 code for the time being, Angular2 maybe interesting but its written in Microsoft's TypeScript - which is a nice language on top of JS that is worth learning about.

I've read both Effective Java and Clean Code and highly recommend them as well.

There's also Agile Software Development (by Robert C. Martin):
http://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445/ref=sr_1_1?ie=UTF8&qid=1451828712&sr=8-1&keywords=agile+software+development

This book contains among other things a description of the SOLID principles of software design. For example the Single Responsibility Principle tells you that each class should have only one responsibility. This reduces coupling and leads to small and more easily understandable classes. The book also contains some nice case studies showing how to apply these techniques.

While Clean Code deals with writing code and how to design methods and classes, Agile Software Development tackles the topic at a higher level and discusses how to develop and design software consisting of different classes and packages etc. It requires a basic knowledge of programming and OO, though.

Robert C. Martin has also created a series of purchasable training videos at cleancoders.com. These videos cover the topics of both books starting with the rules for clean code and then going into the SOLID principles and other advanced topics.

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

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

The book Learning PHP, MySQL, JavaScript, CSS & HTML5 was one of the most useful PHP books I read as a newcomer to PHP. It's very basic but it teaches how you can start using PHP to do useful and interesting things.

After making it though that book, I think PHP Objects, Patterns, and Practice is a really good next step. It will help you learn to design, organize, and write your code to a more professional standard. It will also help you better understand the workings of a PHP framework.

Even if you don't plan on writing your bots in C/C++, you should still understand how most commonly used compilers compile them to native code.
Most games* are written in C/C++, although .NET ones seem to be gaining popularity.
Once again, assuming Windows, it's usually enough to know how MSVC works.

It's hard to summarize what exactly is 'necessary', as a lot of this comes with experience and some trial & error, but I'll try it anyway:

• Understand C/C++
  
  
• Understand how C/C++ code is compiled to native code
  
  
• Understand x86 assembly
  
  
• Understand the portable executable file format (.exe, .dll, ..)
  
  
• Understand how Windows processes work
  
  
• Basic understanding of how OpenGL and DirectX work (interaction points game<->gfx-backend often provide good starting points)
  
  
• Windows API experience
  
  
• Know your tools (IDA Pro, OllyDbg, WinDbg, ..)
  
  
• Many many more..
  
  Some good starting points:
  
  
• Lena's Reversing for Newbies Best introduction to reversing imo
  
  
• R4ndom's Beginning Reverse Engineering Tutorial series
  
  
• ...
  
  Some references:
  
  
• Reverse engineering C++ code
  
  
• Intel 64 and IA-32 reference
  
  
• Windows API reference
  
  
• ...
  
  Some books:
  
  
• Reversing: Secrets of Reverse Engineering You have to read this!
  
  
• The IDA Pro Book: The Unofficial Guide to the World's Most Popular Disassembler Best guide to the best disassembler
  
  
• ...
  
  Hope this helps.

Depends on what you want to learn.

Web Application Security?

Exploit Development?

"Pentesting" techniques?

Also check here for tons other of resources.

As for certs, if you are a beginner beginner, then probably stuff like Security+ and Network+. Unlike the guy behind me, I will never get, nor do I really recommend CISSP, unless you are going for strictly blue team (defense) work. I personally enjoy red team (pentesting, etc), so something like OSCP would be more useful.

Like I said in a post above, feel free to PM me with questions. I'm always happy to help others on their quest to learn more about the wide world of infosec :)

2008-2009: Took 3 High school level Computer Engineer/Science courses and studied Assembly Language Robotics (This is where I really took up an interest in programming)

2010-2012: Attended Humber College (Toronto, Ontario, Canada) for a multimedia course that mainly focussed on web development.

2011-2013: While still in school and for a bit afterwards I worked at a company that did AS3 based facebook games and then ported them over to iPad using Objective-C (This is where I was transitioned over to iOS programming)

2013-Now: I've worked at many companies in different roles from junior->lead.

My learning basically was from trial and error, and not from being scared to just jump into large projects. You really shouldn't because it could put you off but I was in the state of mind that this is my career and I love learning new things so one of my first major personal projects was an RPG game engine made from scratch for iOS. It didn't use ARC, IB, or any 3rd party frameworks (When I was first taught Objective-C I was told this is how it should be so I continued down that road). I was very proud of what I was able to accomplish as such a Junior developer. I did go onto making more apps, for example: Sky and being on development teams, for example: BNN GO.

Books: Programming-Objective-C-6th & C-Programming-Language-2nd are the two books I read when starting out and sometimes reference or read them still.

Future: I hope to teach myself to be more patient as a developer and not jump the gun on features being "prematurely" completed or bugs being fixed. I believe this is a problem a lot of developers suffer from and could be seen as ADD-Developers if you will. I would like to crack down on this personally because I find myself shifting towards more of a lower level, application architecture role and will need to be more sure of my code as it would hold together the application in a sense.

I don't think you need it explained from a Rails point of view. Ruby is an OO language, and Rails simply exploits that.

You need to learn proper design patterns in Ruby (which apply to most OO languages). Sandi Metz's Practical Object-Oriented Design in Ruby is pretty much the gold standard for Ruby and very readable.

It's based heavily off of Martin's Agile Software Development, Principles, Patterns, and Practices.

After that, you can look into SOLID but, in Ruby-land, I think the single responsibility principal coupled with the rules laid out in Metz's book (summarized here) is a good place to start.

Also, it's worth noting that if you have good test coverage it makes re-factoring much, much easier.

Good luck!

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

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

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

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

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

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

While you only need to learn the languages you're going to use, it can help to be familiar with how to read (and solve problems) languages of various lineages, structures, and dialects (e.g., C-like functional, imperative, etc.).

There are books (like this one) on the topic, and many CompSci programs include a 3rd or 4th year language survey course. I found that this course (and much later that book) helped me think about solutions more clearly, especially after having solved one problem across several languages.

Also, if you're at all interested in language design (or processing), having more mental models of programming languages can help immensely.

On the other hand, when I'm hiring I don't really care what language(s) you know, as long as it's clear you've done well with the ones you use (and how you talk about your opinions around them). If it's clear you actually know a number of languages, you'll get some bonus points.

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

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

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

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

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

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

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

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

I found The C# Player's Guide (3rd Ed.) to be pretty solid at teaching the basics of the C# language. I particularly liked how they diagrammed the various data types.

Head First C# (3rd Ed.) was also good, but it's pretty out of date at this point. If you can use Visual Studio 2015 or earlier, you should still be able to follow along without too much trouble. After that, the templates they use for doing UI are no longer available, so you'd have to do some extra work there.

That said, Head First C# includes a lot more general Computer Science information the Player's Guide, and includes UI design and implementation.

I think one issue with hard copy books is that C# and .NET are evolving really really fast currently, which makes it hard to keep up to date.

As far as projects go, I totally know how difficult it can be to think of something when you're specifically trying to.

Several projects I've made ended up being due to some need. For example, I have a project idea I really need to get started at some point for a recipe book for Breath of the Wild. I want something light weight that I can use to record the recipes I find in game, as well as being able to store additional useful information (such as places where ingredients drop or can be purchased, purchase prices, etc).

Another project idea that I've played with a bit here and there is a basic character stat generator for an RPG. This is something that can be super simple, but can also be expanded a great deal into a complex program.

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

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

Accelerated C++: Practical Programming by Example

Programming: Principles and Practice Using C++

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

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

Things have changed a lot! A good summary would be:

Front-End Frameworks: Robust libraries that make developing good-looking UIs easier and make your code more scalable. (ex: Vue, React)

No More Frames: Only the <iframe> tag remains. The use of frames is discouraged, and CSS flexbox (a responsive style that makes your site work for desktop and mobile if used correctly) is used.

Fancy New Paradigms: It is no longer encouraged to program javascript in traditional OOP styles with classes + inheritance. Instead, a paradigm called Functional Programming is encouraged. Functional Programming drifts away from classes and inheritance, and towards functions, and specifically, higher order functions. In addition, creating mutable variables in excess has fallen out of favor.

So, while a lot has changed, if you know Java 8, are familiar with Lambda Expressions + Closure, and ready to devote some time to JavaScript and the frontend, you'll be making near-professional to professional looking websites in around 6 months (at least, that is my experience). And even if you aren't, JavaScript isn't hard to learn. I would recommend the following books + websites:

MDN - Good JavaScript Resource + Tons of documentation. https://developer.mozilla.org/en-US/

Javascript: The Good Parts - https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742 (Bit outdated)

How Javascript Works - https://howjavascriptworks.com/ (Recent)

Javascript: The Definitive Guide - https://www.amazon.com/JavaScript-Definitive-Guide-Activate-Guides/dp/0596805527 (Bit outdated)

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

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

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

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

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

Honestly? Mostly youtube and udemy tutorials. Here below is my copy pasta of C#/Unity stuff which I post pretty often on /r/learnprogramming and /r/learncsharp . I only need to find a moment one day and add some computer science theory links.

Free C# ebook

• http://www.csharpcourse.com/ <- The download link is under 'here' at the end of the first paragraph.

If you want youtube tutorials:

• https://www.youtube.com/playlist?list=PLGLfVvz_LVvRX6xK1oi0reKci6ignjdSa <- apart from C# this dude has also A LOT OF other tutorials on many other languages.

• https://www.youtube.com/watch?v=pSiIHe2uZ2w <- has also pretty good Unity tutorials.

• https://scottlilly.com/build-a-cwpf-rpg/ <- learn WPF (desktop application with GUI) by making simple RPG game.

• https://www.youtube.com/user/IAmTimCorey <- This guy is also good, but I dislike his coding style and that he uses a lot of nugets instead of writing stuff himself.

Book reference guide:

• https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650/ref=sr_1_1?ie=UTF8&qid=1547990420&sr=8-1&keywords=C%23+in+a+nutshell <- But treat is as a language reference guide, not a programming learning guide.

Text-based tutorials

• https://www.tutorialspoint.com/csharp/index.htm <- C#

• https://www.tutorialspoint.com//wpf/index.htm <- WPF (GUI programming)

Udemy - wait for $10 sale which occurs at least once in a month:

• https://www.udemy.com/csharp-tutorial-for-beginners/ <- for C#, dude has also more advanced tutorials to choose from.

• https://www.udemy.com/user/bentristem/ <- for Unity

Do not move to Unity or WPF before you get good grasp on C# syntax and OOP concepts.

Coding style (read after getting good grasp of OOP concepts)

• https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM/ref=sr_1_1?keywords=clean+code&qid=1562330510&s=gateway&sr=8-1 <- Clean Code, recommended for every newcomer at my work

• https://www.amazon.com/gp/product/B075LRM681?pf_rd_p=2d1ab404-3b11-4c97-b3db-48081e145e35&pf_rd_r=22NFZ5GCWM7YMK2A5A2G <- Clean Architecture

I have been a software engineer for about a year. We use Test Driven Development where I work, and I have found that it really helps me think through the requirements and make decisions about what the software should do one step at a time. I definitely prefer this method to just "feeling it out" like some of the intuitives do.

I have also found it incredibly useful to get familiar with good programming practices and patterns and would recommend stocking up on books and maybe reading them with another person or two for discussion. Clean Code and Agile Principles, Patters, and Practices have been very useful for me. Once you start to get the general patterns down, designing something from scratch isn't such a mind explosion, because you have a general idea of how things should be designed and what "good" software looks like.

I think learning OOP is a very good idea. There are tons of books on the subject but I would recommend these 2:

Uncle Bob's Agile Principles, Patterns, and Practices in C#

This book will teach you not only about good OOP principles (SOLID principles) but a also a lot about other programming practices such as testing and refactoring.

Sandy Metz's Practical Object-Oriented Design in Ruby: An Agile Primer

Don't worry about being a Ruby book, you should be able to understand the concepts (and learn some Ruby). Sandy ha a very good way of teaching how to think about OOP.

Hope it helps.

PS: I'm curious: what exactly did you struggle with? What made you think you should learn OOP?

Oh, regarding the book - I don't really know, it's been too long for beginner books, but I do recommend the C# Yellow book for absolute beginners, though you can skip over things if they are beneath you.

If you get up to 'late beginner'/'early intermediate' then CLR via C# is an excellent deep technical dive into how everything works.

I'm big on people knowing as much as they can about what they are doing, programming-wise, and this book covers a lot of details. It might be a stretch for a beginner but to me it's necessary data to be truly great at this particular tech stack.

I'm gonna try to give you some real advice, instead of shitting on a newcomer.

First, you really gotta know your systems. You're a software developer, but that doesn't mean you have experience in assembly. Learn assembly. Pick up books on it. Know how overflows work, etc. Also, get a vulnerable system, and start practicing the exploits given to you in Metasploit. Once you feel comfortable exploiting a certain vuln, look at the code for that particular exploit. Learn how it works, what it exploits, etc. Get comfortable with the language.

You also have to figure out what type of hacker you want to be. Do you want to be specialized in host, or web app, network, etc. It really depends. You obviously don't have to pick a specialization up front, but it should guide you on the type of material to learn. In all, it comes with practice. I will copy/paste exactly what I told someone else who asked a few days ago. I feel the list I put together below will get you started.

Offensive Security has some great material for you to browse, and even some lab environments to work in. Read up on Metasploit and OWASP get comfortable with a linux command line, python scripting, and powershell if possible. Other than that, attend security conferences, learn from books, (I personally recommend Hacker Playbook 2) and just learn by practicing on vulnerable boxes like Metasploitable and DVWA
Other than that, you just learn by doing it. Get down a methodology, and learn why and how systems are vulnerable. Further down the road, reverse engineering, static code analysis, and other specialties come into play, but I think thats enough info to get you started. If you need anything else answered, or have any other questions, just DM me.

I read this like you assume it will take longer to learn two or three languages than one, but this isn't necessarily true. It will take you longer to learn two languages to a professional level than one, but if you're starting from fresh then trying multiple languages has a lot of advantages. Every programming language has a different philosophy and emphasises different features, making some things harder or easier. If you only ever program in Java, there are things that are easy in say Ruby or Clojure it would never occur to you to try, because the language makes it so much harder. But if you only program in these two and not say C, you won't appreciate how the languages manage memory for you. The list is almost endless, but the more languages you're exposed to the more you deepen your understanding (and learn new tricks) by triangulation.

Realistically it takes a few years to get to a professional standard in programming, don't be afraid of spending a few months to get a good start. The book Seven Languages in Seven Weeks may interest you: http://www.amazon.com/gp/aw/d/193435659X – also there are Bitcoin implementations in most main languages, so once you can read a language you can use these to compare how they and how they're used in practice.

The agile principles are based around the idea of iterative development. This invites what you're calling rework to make the product the best it can be.

Obviously, you're coming at this from a place of frustration because you want to meet deadlines but the "simple" solution is to build all these steps into your estimates. If you're not setting the deadlines, then you need to be up front with your manager about what you can get done in the given time. Maybe it'll work, but not be clean code (the P.S. here is that after it ships, you need time to make it clean). Maybe you can get features X and Y done, but not Z.

Refactoring and code reviews are part of the job. Yes, your manager is going to make suggestions you might not agree with and, yes, the senior devs are going to send you back to the drawing board sometimes. Sometimes it's because they're jerks and sometimes it's because experience has taught them something.

All in all, I'd recommend reading any of the following by Robert Martin. Clean Coder is perhaps most relevant to estimates and deadlines but they're all really helpful.

• Agile Software Development, Principles, Patterns, and Practices
  
  
• Clean Code: A Handbook of Agile Software Craftsmanship
  
  
• The Clean Coder: A Code of Conduct for Professional Programmers

> even some "old but gold" ones are fine

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

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

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

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

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

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

Excerpt from the description on Amazon:

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

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

I've never done any embedded software development, but as a web developer looking at you from the other side, this is what I see...

At the domain level, you'll be working with different technologies than you're used to. Embedded software developers do a lot more low-level interactions with inputs from sensors, so you'll see less of that. Web developers are generally dealing more with human interaction and data persistence and retrieval.

Another big thing to think about would be your OOP experience. Are you familiar with SOLID? Have you done any real-world development using OOP? Most of the web frameworks available today (from a server-side standpoint, at least...particularly ASP.NET) are rooted in OOP.

If you've got 10 years of experience developing, learning C# will be easy. I wouldn't focus as much on the language itself as I would learning the .NET standard libraries. You'll pick up the patterns as you go. I really liked the "Pro ASP.NET MVC" books, now available for MVC 5.

If you're looking specifically for books on C# and .NET development, I don't think there's any book better than CLR via C#. Don't let the title scare you away, it's a great book for learning the lower-level bits of the .NET platform, which are relevant everywhere from ASP.NET to WinForms.

If you aren't aware, there are huge changes coming to the .NET framework and ASP.NET, so you could choose to focus on ASP.NET 5 and get ahead of the game a bit, at the expense of availability of reference material.

Some books that could help you practice algorithms and coding challenges are:

1. Elements of Programming Interviews
   
   
2. The Algorithm Design Manual
   
   
3. Cracking the Coding Interview
   
   If you want some actual practice solving challenges with some guidance and/or help, I'd recommend Coderbyte which provides solutions to the problems along with the ability to view other user solutions so you can learn how others solve the same challenges. This article might help you find some other coding challenge websites as well.

I did this back when it was only like $150
https://www.udemy.com/the-complete-ios-7-course-learn-by-building-14-apps/?dtcode=zVm6tx21l7ow

Vea Software - simple and easy projects
http://www.veasoftware.com/tutorials/

Chris Ching - great guy
http://codewithchris.com/

The Bible
http://www.amazon.com/Programming-Objective-C-Edition-Developers-Library/dp/0321967607

And, if you get stuck, come back here and ask questions or message me! It's a great skill and fun to do as well.

> I just think that it would be good to know the language better in case I get a job were I need to make desktop apps.

Then I will go with the obvious and suggest Jon Skeet's C# in Depth, I really like the way he explains things. But it's so well-known that odds are very good you will already have checked it out.

Jeffrey Richter's CLR via C# is also a very good resource if you are into lower-level CLR details, which is always good stuff to know.

I've recently been working on my JS skills and heres a few resources I've found super useful:

Books:

Javascript Patterns

Javascript: The Good Parts

Javascript: The Definitive Guide (While an exhausive resource on the topic, this one is a bit verbose)

Web:

Mozilla's Javascript Guide (One of the best free online javascript guides/references.

How to Node (Tutorials on server-side Node.js)

Daily JS (Interesting JS related news)

Echo JS (Similar to above but updates less frequently)

Hacker News (This is more general tech news but there is a ton of useful web stuff, especially as node.js is currently a hot topic. Reddit actually spawned from HN)

Online Videos (free)

Douglas Crockford's Javascript Lectures (I would recommend these to anyone getting into javascript)

• Aduni algorithms course - i plan to review that course soon.
  
• For my class, we were assigned Algorithm Design - Kleinberg, Tardos. It's readable but from what I heard, CLRS is the undisputed recommended text, best read that one first.
  
• Algorithms: A Creative Approach - some say this one is a good alternative if you're after a less mathsy version

Not much to go on. Let's try this.

Do you understand the notion of decomposition? A well-organized program will have many functions, each of which does one thing and does it well. The higher level functions will use these as a toolkit to orchestrate more complex tasks. A program organized in such a way is easier to continue adding to even as it grows large.

Let's have an example. You have made the following lower-order functions in a hypothetical game, each of which does exactly what they advertise:

advanceToNextTurn
setPlayerMaxHealth
setPlayerSpriteGraphics
playSoundEffect

These are simple functions. Now let's make a function that uses them as a toolkit to accomplish a larger task. Let's turn the player into a werewolf.

def changePlayerIntoWerewolf():
setPlayerMaxHealth(player.currentHealth * 1.2)
setPlayerSpriteGraphics("sprites/werewolf")
playSoundEffect("audio/werewolf/howl.flac")
if(player.movementPoints < 1.0):
advanceToNextTurn()

Let's make an even higher-order function that uses this one.

def advanceMoonPhase():
if(moon.phase == 0): # full moon
if not player.inWerewolfForm:
changePlayerIntoWerewolf()
else:
if player.inWerewolfForm:
changePlayerIntoHuman()

Regarding your Roguelike - it's pretty simple as it is. I'm not sure what kind of trouble you have with it. A few hundred lines of code in a few files is not a complex program. You might consider rethinking some of the parts in terms of more stringent modelling of the game elements (for instance, shouldn't you have a Map class with all of the map data and information about which Being is standing where? Your movement methods might take the current game Map as an argument).

Books are always nice. Reading code is important, and there are many good books with excellent examples.

• Pragmatic Programmer
  
• The Gang of Four book
  
• Clean Code

This is the book that helped me a lot when I was studying C# years ago:

Amazon link

It's fun and easy, and there's a few simplistic games that it teaches you to code here and there.

As others mentioned, good programming concepts are independent of language. Given your post wording, I think what you need to learn now is good object-oriented programming, so you need to learn the concepts of polymorphism, inheritance, overload, abstraction, etc. It's those concepts that make code expandable, independent and easily manageable. This book might just help you grasp those concepts and improve your overall C# coding.

Ray Wenderlich's site has great tutorials. I'd strongly encourage you to work through these books - they should give you a pretty strong foundation:

• Programming in Objective-C - this will also give you a primer/background in C language features as well.
  
  
• BNR's Objective-C Programming - great overview of the language
  
  
• BNR's iOS Programming
  
  Ray Wenderlich also has some Swift tutorials but if you are just starting out I'd focus more on Objective-C for now as it will be very useful to know when looking at libraries that aren't ported to Swift.
  

I'd suggest finding a good course and a good book that you can use for reference. Then cementing your skills by doing lots of problems.

The book: this one's easy. Skiena's Algorithm Design Manual is highly regarded, surprisingly readable, and affordable by textbook standards. Don't need to read it cover to cover, but it's great reference, and I'd suggest reading the really critical chapters like graph search and sorting.

The course: You can't really do better than Stanford's course, taught by Tim Roughgarden. I took it a few years ago and have used it to brush up every time I apply for a new job.

The problems: it's important not to dive into this until after you've learned the basic concepts. But Leetcode is the standard, and for good reason -- it has a ton of problems, many of which are leaked from real companies. At first, these problems will seem very difficult -- it make take hours to solve a 'medium' level problem, if you can get it at all. If you simply can't get it, read the solutions and really understand them.

I also recommend the book Elements of Programming Interviews. You'll hear a lot of love for Cracking the Coding Interview on this sub, but it's too easy and outdated for current interview prep. It's a fine intro book, but it won't take you all the way to where you need to be.

I found that often the best way to know if your implementation is SOLID is to write the unit tests for it.

For example, if you want to test the PreferencesThing class, you could run into an issue because of the dependency on PreferencesStorage() : if it needs a file, the network, whatever, it will be hard to write. So PreferenceStorage should implement a IPreferenceStorage interface, that you would mock during the tests. And your class constructor or GetThing method would take a IPreferenceStorage parameter. In a strict SOLID approach, I guess that even the ObjectSerializer could be considered problematic.

That being said, keep in mind that SOLID is an excellent way to structure your code, not a magical hammer. Use it wisely.

I would recommend (if it has not been made) reading http://www.amazon.com/Agile-Principles-Patterns-Practices-C/dp/0131857258 which goes in length on those topics. Also, anything else by Robert Martin (uncle bob) is usually a good reference on the topic.

I'm in a similar position (besides having a nice cert ;), and what I'm going through right now is a combination of Lena's tutorials, and Reversing - Secrets of Reverse Engineering. The book actually seems like a really good "foundation" kind of book, since it spends the first 4 chapters or so going over the basics of compilers, operating systems, memory, etc. As for Lena's tutorials, it's hard for me to say because I've only finished a few, but I've heard good things about them. Good luck.

> Yet, from reading books/tutorials/examples

First, be mindful of the limitations of the various teaching media and how difficult it is to teach something like design, TDD or otherwise, in small snippets. In fact, that's what I got out of the OP: design is a skill, TDD is a tool.

Second, I'm curious - which particular books are you referring to?

The books that most resonated with me are:

1. Growing Object Oriented Software Guided by Tests by Nat Pryce and Steve Freeman.
   
2. Agile Principles, Patterns and Practices by Uncle Bob - which has really little to with Agile, but anyways...
   
3. Domain Driven Design by Eric Evans.
   
   These books devote substantial time putting the practices in context.
   
   The PPP book did a great job discussing design in general, and showed how to apply the design principles using TDD and showed me a way to use UML without hating it.
   
   The GOOS book carefully works a single case study, starting with a basic architecture in mind and showing how to grow the architecture in that direction guided by tests.

There are so many books out there and I've hated most of them. A lot of them read like a 2000 page tome about corporate tax law - all the text is the same, its just paragraph after paragraph of babbling. Sure its accurate, but who wants to read that?

Not me.

BUT there are some books that don't suck - the Head First books. I swear they were built for ADHD minds.

https://www.amazon.com/Head-First-Learners-Real-World-Programming/dp/1449343503/

BUT... Books still kind of suck. I wouldn't recommend them unless you want to learn general concepts.

And my particular example uses XAML which is an XML layout language that only Microsoft uses... Which is good if you are writing Windows desktop apps, but who does that anymore? Most of it has moved to web or mobile.

But I do recommend:

1. Figuring out a project of something you DO want to do. Let's use an example of "I want to build a web based To Do list application. I want to use C#."
   
   
2. Find a tutorial online that is relevant. Like this: https://mva.microsoft.com/en-us/training-courses/asp-net-core-beginner-18153
   
   
3. Work through the exercises to get a basic foundation for ASP.NET Core, C#, web applications, etc.
   
   
4. THEN think about the ToDo app you want to build. Find a tutorial that works well for it like... Oh... I dunno... Maybe this one: https://medium.com/@ThisisZone/to-do-write-to-do-app-with-asp-net-core-c02bc3ca9fa1
   
   Its helpful if the tutorial has all the source code on GitHub like this: https://medium.com/@ThisisZone/to-do-write-to-do-app-with-asp-net-core-c02bc3ca9fa1
   

The first thing that comes to mind is understanding scope. In particular, if you come from a C-esque language, this might be one of your biggest hangups. Understanding how the scope works before you write your code will inevitably lead to a better-written product.

(tl;dr for the rest of this: know the fundamentals)

The route I came up, I started as an OOP developer and thought JS was a toy language for much of my career. It wasn't until I took the time to understand the language that I came into my own as a JS dev, and it is currently my favorite language to develop for. If you're the book-reading sort, I would suggest the following resources in sequence:

• JavaScript: The Definitive Guide (David Flanagan)
  
• JavaScript: The Good Parts (Douglas Crockford)
  
• JavaScript Patterns: Build Better Applications with Coding and Design Patterns (Stoyan Stefanov)
  
  If you follow this link and look at the Frequently Bought Together section, you'll see that these three form a common trifecta. What you can expect:
  
  
• The first book will give you a fundamental understanding of the language (I would personally skip the DOM-related parts, since that's more framework/environment than language)
  
• The second book will tell you "Okay, we just gave you a drawer full of knives, here are the ones that won't send you to the hospital"
  
• The third book gives you a rationale for how and why to apply the language in certain ways. It deals with JS-specific issues, and also brings in some of the Gang of Four patterns and other best practices.
  
  (edit: added link to Amazon page for the first of the three books, fixed formatting)

Clean Code is a good one :) The book where he goes into SOLID is the Agile PPP book . I believe he refers to Clean Code as a sort of prequel to Agile PPP.

It sounds like you’re doing pretty well and on the right track. CORS is an area where I’m not especially strong, tbh. I would probably put the api on an api.example.com subdomain, but that’s sheer personal preference.

I’ve spent so much time in .NET recently, it’s nice to jump into a JS discussion. Time well spent, in my mind.

Reverse engineer Microsoft patches.

edit: serious answer:

I do this kind of work for a living. I started out in 1995 when I was 13 years old learning from mudge's excellent article on how to write buffer overflows and I progressed from there.

If you're analyzing software for which you have access to source code, you can't beat The Art of Software Security Assessment: Identifying and Preventing Software Vulnerabilities.

Chris Wysopal's Art of Software Security Testing is also good.


If you're attacking software for which you have no source code, learn about fuzzing and reverse engineering. An excellent intro to reverse engineering is Reversing: Secrets of Reverse Engineering.

Those will get you started, but it helps to have people around you who are successfully discovering and exploiting software vulnerabilities. This is also the kind of field where you absolutely have to stay on top of the latest developments in software security. Things move at a mind-boggling pace. Read security blogs, talk to people in the industry, read books, etc...

I'll tell it like it is. Most colleges don't really teach useful things these days in favor of giving you a broad education and emptying your wallet. You'd probably only have one or two courses on reverse engineering, if that. The best thing to do is probably learn it on your own and take whichever major of those you enjoy more. I recommend checking out this book for software RE. http://www.amazon.com/gp/product/0764574817/ref=as_li_ss_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=0764574817&linkCode=as2&tag=viewsite-20

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

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

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

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

As far as courses go just take the math-oriented ones like algos and data structures seriously. It's about developing your problem solving ability more than anything. Strong problem solver, strong interviews. Also developing an intuitive understanding of complexity and problem classes will help you to think clearly.

For interview-specific stuff courses won't help you. Pick up Cracking the Coding Interview and Elements of Programming Interviews. The latter used to be called Algorithms for Interviews which is also good.

Protip: last time I checked all these books were available through Safari Books Online, which most university libraries give you access to for free.

I rarely see this posted here for some reason, but I've found Elements of the Programming Interview to be a really great book, and far more helpful than websites like careercup.

I just saw your edit. Since you are not looking for books just like Grokking Algorithms, I will suggest another amazing book on algorithms.

https://www.amazon.co.uk/Algorithm-Design-Jon-Kleinberg/dp/0321295358

Algorithm Design by Kleinberg and Tardos. I thoroughly enjoyed it and I highly recommend it to anyone interested in algorithms. One of my favourites.

Okay, first install the lab, add Virtual machines of Windows XP, 7, 2008R2, Linux, different servers like Apache, SQL DB.. then go ahead and scan them, see how different Kali tools work.
I recommend you this book https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566

Good Luck

What's Possible With Hacking?:

Things are more possible than you think; the more you know, the more you can do (hacking isn't just one thing to learn, it's a combination of different subjects).

Where can I learn about it?:

I recommend try to learn anything you can get your hands on, E-books, videos, etc. You should take the paid online courses later on, once you advance your knowledge.

!!TIP!!: Recommend reading some questions from him https://www.reddit.com/r/hacking/comments/4up17b/i_am_a_lead_penetration_tester_ama/

This book (recommended by a real pentester): https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566

Video on Kali Linux: https://www.youtube.com/watch?v=7nF2BAfWUEg&list=WL&index=3
(i recommend Kali btw, install it on a virtual machine. )

I got all this just from the internet, the internet has all the information you need; just get it from the right places.

(I know basically squat, i am also starting off as of today) good luck!

Alright man I was sort of in the same boat.

You don't have to rely on your Airforce job to be your only source of NetSec training. https://hireourheroes.org/veterans-training/

If NetSec is your passion you should start reading up on Blue team / Red Team type procedures. Get familiar with Firewalls and Cisco equipment. Work on getting maybe a CCNA Sec, work your way to a CISSP. Learn networking itself inside and out, to form a base for the security concepts. Practice Network Forensics, learn about write-blockers, legal procedures to work NetSec, that kinda stuff. If you find the time, learn Python.
https://www.amazon.com/Hacker-Playbook-Practical-Penetration-Testing/dp/1512214566/ref=sr_1_sc_1?ie=UTF8&qid=1474252248&sr=8-1-spell&keywords=the+hacker+paybook+2

If you have Linux experience, a well recognized PenTest OS is Kali Linux. You can use it to practice on a home network, or build your own virtual environment.

I'm finishing my Bachelors in Cyber Security here in May and testing for my CISSP, if you want any more info on programs/certs stuff like that feel free to shoot a PM.

If you are interested, CLR via C# will provide one with a metric fuck-ton of trivia on how it really works. I read the 2nd edition about 7+ years ago, but most of the really trivial stuff fell out of my head. However, a lot of that knowledge isn't needed to actually build a working product.

One reason I like out params is the patterns similiar to bool TryParse(string text, out T value). This way a single if statement can shorten code up considerably if I need to write other conditions limiting the value to perform default or special case logic. The more I can reduce boilerplate/noisy code the better IMO.

Step 1: get a better learning resource.

Most online tutorial suck. They're fine for a quick intro or to learn more about one feature, but not for learning everything from scratch.

Buy a book.

Programming in Objective-C is pretty good and it's aimed at beginners.

If you don't want a physical book, get the Kindle edition and read it online.

Step 2: spend more time building.

For every minute you spend reading or watching, you should spend 10 minutes trying it out, doing stuff.

Programming is not about knowledge, it's a craft, like woodworking or pottery. You can't just watch masters build things for a month, then go home and build a dresser. You need to start small, build up your skills before you can actually build useful things.

So as you're reading the book: are you learning to write a loop? Stop, put down the tutorial or book, and type it in and run it. Get used to the syntax. Experiment with it - can you make it do something different?

I'm going to disagree with a several of the other comments here: don't feel pressed to ask textbook questions that are narrowly related to the job you're hiring for. Hiring narrow specialists tends to yield devs that are good at a narrow set of tasks. "Abstract algo questions" have a better track record of hiring strong devs that are better able to pick up any task that may come up.

Remember: it's easier for a great programmer to learn a new technology than it is for someone who knows that technology to become a great programmer. I should know: I've done over two hundred interviews for my current employer, most for positions where I would have to work with the developer directly. I've been in interviews where we hired the wrong candidate and it's almost never worked out well. In most of those failed hires, the rationale was "well, yes, he didn't do great on the interview, but he has experience with $TECHNOLOGY that we desperately need!"

As for your question: I highly recommend "Elements of Programming Interviews" by Aziz, et al. Amazon link

It provides a wide range of questions that you can tweak to suit your needs, in a range of difficulties from relatively easy to mind-bendingly difficult. None of the problems, however, are trivial in the way FizzBuzz is. (And seriously, if you're asking FizzBuzz or similar in interview, your sourcing process needs some work.)

I hope this helps. Interviewing programmers is a devilishly hard problem and tough, pointed data structures, algorithms, coding, and design questions under interview conditions isn't an ideal solution, but it is the least shitty one anyone's yet found, so far as I know.

Best of luck in your search!

Most Objective-C books are written for a person who already knows how to program. I would recommend Steven Kochan's book because it teaches you how to program while teaching you Objective-C's syntax. After you've completed that get the Big Nerd Ranch, or some other book.

Truthfully, programming is hard. It's not hard in the "you're not good enough" sense, but maybe it is in the "you can't learn this goofing around one or two hours a week" sense. It takes practice and perseverance. Sometimes you have to deal with inscrutable errors. Sometimes things just don't work and you want to cry. But when they do you feel like you're on top of the world.

I couldn't teach myself how to program in my spare time like some people have, so I went through the CS program at my local state school. External motivation was a big help for me. I may not be a great computer scientist, but I am a very good Objective-C programmer. It took a long time to get here, but it was totally worth it.

Eu sunt în general împotriva tutorialelor, cel puţin pe partea de programare. E greu de urmărit şi nu prea are de-a face cu procesul de învăţare ci mai degrabă cu cel de înmagazinare a unor cunoştinţe.
Cel mai bine ar fi la început să începi să citeşti o carte/un articol despre concepte ale programării în general pentru ca apoi să te apuci de sintaxa unui anume limbaj. Plus că îţi trebuie determinare şi multă răbdare.

Odată ce ai prins basicul limbajului, recomandarea mea ar fi să te implici într-un proiect la care poţi contribui cu cod. Codul ăsta va suferi o grămadă de transformări pentru ca la final să nu mai semene deloc cu cel de la început. Ştiu, sună descurajator dar ăsta e procesul natural prin care îţi îmbunătăţeşti skillurile.

Dacă vrei neapărat tutorial video, singura mea recomandarea ar fi PHP with MySQL Essential Training
with Kevin Skoglund
, însă repet: nu mi se pare cea mai fericită metodă de a învăţa programare. Cele mai sfinte lucruri în PHP sunt: cărţile, practica şi http://www.php.net/manual/en/index.php!

Dintre cărţi ţi-aş recomanda:

• Programming PHP
  
• Learning PHP, MySQL, JavaScript, and CSS: A Step-by-Step Guide to Creating Dynamic Websites
  
• PHP Objects, Patterns and Practice 3rd Edition (Expert's Voice in Open Source)
  
  Astea fiind spuse, îţi urez spor la treabă!

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

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

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

You need to pick a project that is bigger than your understanding of the language. It really is that easy.

Since you know a bit of Java, get this book: C# 5.0 in a Nutshell. It's an excellent reference.

I find myself using the following sites:

http://www.dotnetperls.com/

For basic learning.

http://stackoverflow.com/

For finding specific answers.

http://www.codeplex.com/

For finding useful open source projects and libraries.

http://www.codeproject.com/

For finding useful open source projects and libraries, as well as tutorials and guides.