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

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.

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

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

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

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

You can dive right into Objective C, I was only vaguely familiar with C and I've published a few apps without any problems. However, if you're intent on learning C pick up 'The C Programming Language' (K&R), not only the best C programming book, but one of the best programming books ever written.

Objective C books, I recommend one of the two or both books,
'Programming in Objective C 3rd edition' or
'Objective C: The Big Nerd Ranch Guide'

Both of these books are excellent resources for learning and I keep them close by whenever I have a question.

In terms of learning iOS development. I recommend going into iTunes U and downloading the latest Stanford University iPhone development course. I believe Winter 10 is the newest, follow along those classes and the class website, treat it like a real class, do the homework and all the assignments. There is no text book for the class, but this other book by Big Nerd Ranch, 'iOS Programming: The Big Nerd Ranch Way' is totally awesome.

After these classes and books you should have a great foundation for iOS development. Once you feel comfortable with everything and have an app or two under your belt, download Madison Technical College's Advanced iPhone Development course videos from iTunes U and Apple's own WWDC Session Videos.

Each MTC video is about 3 hours, watch them in chunks. The professor, Brad Larson is one of the best iPhone developers out there and in my opinion is one the best contributors to the community, (see his posts on stack overflow).

Lastly, check out www.raywenderlich.com. My personal favorite iPhone development website. It's updated every Monday, Wednesday, Friday with great technical tutorials that are funny and educational.

Best of luck to you and welcome to iOS development :-D.

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.

I was right where you are now about 6 months ago. I'd done some unit tests in previous projects and could kinda see the point in using them for certain things, but I didn't understand the need for writing tests first, and didn't understand the value in the red, green refactor cycle.

I can tell you six months ago I started working for a company that believes heavily in TDD, and after going through the initial pain barrier, I now can't see any other sane way of writing code.

There were a few hoops I had to leap through in order to get to this point. One of them was due to the fact that I simply wasn't testing things correctly in the past. You should always isolate your tests to the EXACT thing you are testing in each case - so you should never really be connecting to the database, or depending on other modules etc. Any dependencies therefore need to be injected into the system under test and mocked accordingly, so you know you are isolating the thing you want to test.

You also should never be testing implementations, which is why you should never have to test private methods. You only care that the public methods of a class will return whatever you expect under the conditions you are testing for. This is crucial, because it's this that makes it really easy to refactor your code later.

When you take this approach for everything you do (combined with doing red, green, refactor), you find yourself soon entering a luxorious position of being able to refactor things at a higher level just to make things cleaner and easier to understand.

Just this week I took a system with over 2500 unit tests and refactored some of the fundamentals of that system - found some abstractions and moved them higher up the chain + extracted some interfaces to make the code easier to extend without modification, and all the while I knew everything was working because my unit tests proved it. This is part of the core of a system that deals with literally millions of users each day (seriously), and I did so without fear.

This approach means the code is constantly getting cleaned and tidied up as we go along.

The red/green/refactor approach works something like this:

• write a failing test (this is important, because simply going for a green pass right away can sometimes bite you - perhaps the test is providing a false positive? You should always see the test fail first for this reason)
  
  
• Make the test pass - I tend to do this in a sane way, but I don't try to engineer my code so much at this point. Just get it passing. The key to this is to only test the expected behaviour of the class, not to test the implementation - we only care about the result, not how the result is achieved. Doing this brings us to the next part:
  
  
• Refactor. This means we can do obvious stuff like removing duplicate code, and then generally chopping and changing stuff around to make it easier to understand and less complicated.
  
  The refactor step is crucial, but because your tests should be rapid (because we've mocked out all dependencies), you can refactor in very small steps and run the tests each time you make a small change. This way you can neaten up and tidy your code in small, safe, incremental steps, and you keep doing so until you are happy that it's easy to understand and give you the flexibility you need. Once you're happy, you move onto the next test.
  
  The entire cycle is quite quick actually - much of the complexity comes down to to learning the best way to test and how to mock out dependencies etc.
  
  Our suite of around 2500 tests takes about 15 seconds to run, but as I'm working on a feature I may only be running one test at that point, so it'll usually take less than a second to run the tests as I'm refactoring. Toward the end of the process I run the entire test suite to make sure everything still passes.
  
  I went from not believing to seeing this work in practice, and now I honestly don't think I can work anywhere that doesn't do TDD. I would be happy to teach other people how to do it in a company, but as mad as it sounds, to me now, not doing TDD is like saying you don't want to use version control. This has all changed in the last 6 months, having seen it work in practice.
  
  Here's a book I highly recommend: http://www.amazon.co.uk/Growing-Object-Oriented-Software-Guided-Signature/dp/0321503627
  
  I love the title of that book "Growing Object Oriented Software Guided By Tests" - this it the thing - working this way allows you to "grow" your software, and the tests really do guide you towards the solution you actually need (this is powered by the refactor step).

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!

From Data Classes and Sealed Types for Java:

>Digression -- enums
>
>If the problem is that we're modeling something simple with something overly general, simplification is going to come from constraint; by letting go of some degrees of freedom, we hope to be freed of the obligation to specify everything explicitly.
>
>The enum facility, added in Java 5, is an excellent example of such a tradeoff. The type-safe enum pattern was well understood, and easy to express (albeit verbosely), prior to Java 5 (see Effective Java, 1st Edition, item 21.) The initial motivation to add enums to the language might have been irritation at the boilerplate required for this idiom, but the real benefit is semantic.
>
>The key simplification of enums was to constrain the lifecycle of their instances -- enum constants are singletons, and instantiation is managed by the runtime. By baking singleton-awareness into the language model, the compiler can safely and correctly generate the boilerplate needed for the type-safe enum pattern. And because enums started with a semantic goal, rather than a syntactic one, it was possible for enums to interact positively with other features, such as the ability to switch on enums, or to get comparison and safe serialization for free.
>
>Perhaps surprisingly, enums delivered their syntactic and semantic benefits without requiring us to give up most other degrees of freedom that classes enjoy; Java's enums are not mere enumerations of integers, as they are in many other languages, but instead are full-fledged classes (with some restrictions.)
>
>If we are looking to replicate the success of this approach with data classes, our first question should be: what constraints will give us the semantic and syntactic benefits we want, and, are we willing to accept these constraints?

I generally agree with the other replies that a vanilla computer science degree is better than a game degree, but let me use the example of the University of California Santa Cruz (UCSC) game degree to offer a balanced comparison.

At UCSC, the only difference with a computer science versus games degree is one class in the senior year. The fundamentals of both degrees are identical - you take the same math, physics, and programming in the game degree as you would in the CS degree. Only in your senior year does it differ, where as a games major you do a 1 year elective working on gaming group projects using Unity. If you did vanilla CS instead, you would use that year to take something like operating systems, artificial intelligence or databases. Deciding which one is a better fit for you partly depends on your philosophy of the purpose of school:

• Ivory tower camp - If you feel that a university is best served teaching theory and fundamentals, rather than masquerading as a trade school, then you might agree that learning operating systems or databases in a "pure" manner, without worrying about production concerns like working in a group, would be the best use of your time while you have the privilege of being in school.
  
  
• Emphasis on practicality - If instead you concede that while theory is nice and well, the practical needs of the working world sometimes take precedence, then you might feel that the year of working on gaming projects with others and being able to point at a concrete example of something you did would be time well spent in being able to land that first job.
  
  You can see this difference of philosophy being played out in not just the debate over a gaming degree program, but in things like the programming language of choice for first-year students, where some schools lean toward the practical (UCSC uses Java and C++) and some toward the theoretical (MIT traditionally used Scheme and now uses Python).
  
  Specifically at UCSC, I would say the pros and cons are as such:
  
  Pros:
  
  
• Get to study and spend class time on what is presumably your main interest - game development.
  
  
• Dedicated time to a group project that at graduation, you can cite on your resume and be able to say, "I made that."
  
  
• Possibly make contacts with game industry veterans through the program.
  
  Cons:
  
  
• Spend a one-year class being forced to work in groups and deal with the messiness of production tasks rather than being immersed in 'pure' theory like in a more typical computer science course.
  
  
• Slightly negative connation among the uninformed of having the words "game degree" on your resume and possibly having to defend that your fundamentals are as sound as a vanilla CS major.
  
  The first question you should ask yourself is whether the school you're looking at has a comprehensive undergraduate education and a good reputation, like UCSC, or if it's a specialized trade school like Fullsail or DeVry (stay away) with a bad reputation. Not all game schools are bad - both Digipen and Guildhall at SMU are notoriously challenging programs and in my experience working with a handful of their graduates, I found them to be quite competent. Allen Chou will be graduating Digipen with his first job at Naughty Dog (which was Naughty Dog's first time they've hired someone straight out of school rather than someone with industry experience, though it should be noted that Allen earned a previous bachelor's in electrical engineering before attending Digipen). And USC's game school is well known for having produced Journey developer thatgamecompany, among others.
  
  As for the poor working conditions known at most gaming companies - yes, in general you will work more hours for less pay in the gaming industry than you would outside it. Yes, the industry is rife with constant layoffs. It is likely you will need to move all over the country and possibly world as you chase jobs throughout your career. It's up to you to decide if working on games and with other game developers is important enough to you that it's worth that sacrifice. Many people don't find it worth it, and they are not weaker for choosing another path. It's a personal decision of how much it means to you to work on games; alternatives are arguably more sane.
  
  For working at the kind of companies you mentioned like Bethesda and Blizzard, you will need to be an expert at C++. Because C++ is such a large and complicated language to first tackle, I recommend learning C first. My book of choice is C Programming: A Modern Approach by KN King, which is also highly recommended in the C programming FAQ. Or if you prefer a shorter book, many people have learned from the C Programming Language by Kernighan and Ritchie.
  
  For learning C++, there is only one book you need to know to start with: C++ Primer by Stanley Lippman, which is also the #1 recommendation of the C++ FAQ and highly reviewed elsewhere. You do not need to worry whatsoever about C++ becoming obsolete by the time you graduate. But you do have plenty to worry about mastering the language, because there is a lot of material to cover.
  
  I'm a moderator at /r/TheMakingOfGames and I would recommend perusing some of the videos there that show behind the scenes of development companies (though arguably, the bright side of development). Some examples:
  
  
• Behind the scenes of God of War 3 with the programming team
  
  
• Since you mentioned Blizzard, read Patrick Wyatt's articles on the development of Starcraft. He was a lead programmer at Blizzard before leaving to found ArenaNet and making Guild Wars.
  
  
• Nine examples of dirty programming hacks to fix baffling bugs is a Gamasutra article that might give a glimpse at the harried side of game development, when under pressure and lacking time.
  
  
• Naughty Dog's lead programmer Jason Gregory talking about their interview process and culture

I know how you feel, my college was practically the same. Here are some resources that helped me through:

https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb

TheCherno has a really nice C++ tutorial. Might not be the best on modern standards, but if you are looking for a place to start, this is a good one, really explains stuff nicely.

​

https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784/ref=cm_cr_arp_d_product_sims?ie=UTF8

https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/ref=cm_cr_arp_d_product_top?ie=UTF8

These two so far is the most recommended books I could find in this thread, Programming Principles has more nice exercises and is what I personally used, but to be honest just go with the one that clicks for you. read through the preview chapters if you could find them and choose the one you like.

​

https://codeforces.com/

https://www.hackerrank.com/dashboard

https://www.codewars.com/

I think this is what helped me the most at the start if you don't know what to do, solving problems really helps you get comfortable with the basic language syntax, programming logic and is a lot of fun.



Lastly, Google search is your best friend, seize it. Don't be afraid of making a lot of mistakes because you are going to make many AND be willing to explore! Because chances are, there is always going to be a better modern way to do something. Try to know the advantages and disadvantages(Important) of each way if you could, it all may seem so cryptic at first and confusing(it probably is) but it will all click someday.

​

Learning C++/Programming is a life-time learning, Good luck on your journey!

The biggest hurdles I had motivating myself to work on a project was never coding itself. It was always setting up the compiler, IDE, environment, finding something to work on, etc. The biggest one for me is blank page syndrome.

You don't need to convert to linux if you don't want to but it is good to get some experience in it if you can. I spent sometime setting up a headless Ubuntu server to manage my torrents and be network storage. It took a lot of time starting from scratch but the experience has helped me out.

http://www.ubuntu.com
http://www.reddit.com/r/linuxquestions
http://ubuntuforums.org/

If you want to continue with Java (which is a good choice). I believe the most popular IDE is Eclipse. It has great plugin support and has been used everywhere I've been. You can use it for development on android phones as well if you want to play around with mobile development.

http://www.eclipse.org
http://developer.android.com/tools/sdk/eclipse-adt.html

If your college is like mine, most of the later courses in computer science will not involve much coding at all but will involve a lot of math and knowing popular solutions to common problems (sorting, searching, graph theory, combinatorics). If you feel like you need to brush up on a language, there are a lot of web resources and books to help you.

http://www.codecademy.com
http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_2?s=books&ie=UTF8&qid=1382580434&sr=1-2&keywords=head+on+java

Computer science and software development is a broad field which makes scaling it daunting at times. The only way to make it less daunting is to just dive in and do it. Pick a project and work on it. You will encounter problems you have no idea how to solve and that's great because now you've found something you can learn (usually through Google).

Solve problems in manageable bits. If you try to implement your whole program at once it will seem impossible. Implement small portions of your project at a time. Trying to create a Java chat client? Just work on getting some basic sockets to work and build a library you'll be able to use going forward. This will make the goals seem manageable and help you modularize your code. It helped me with not feeling overwhelmed about my project's scope.

I hope I didn't sound condescending. I just wanted to share some things that have helped me. I don't think you are in a bad spot, you just need to stay motivated and find some things to work on to help you learn. If you have any specific questions I can try to help out, but there are other people on this sub that are far more knowledgeable than me.

>How valuable is an Oracle cert?

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

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

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

Sorry - mostly UK (amazon) links :)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Coding

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

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

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

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

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

Work Methodologys

Kanban

Succeeding with Agile


p.s

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

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!

Let me start by saying good code is code that solves the business problem at hand. For someone that really cares about internal quality of software that was a hard thing to accept.

You didn't quite define what you mean by "good" in your question, so I assume you mean adherence to SOLID principles. I've long thought like this too but realized adherence to some metric by itself is not very helpful, exactly because you end up in situations where your code is overdesigned, or worse, has the wrong abstractions.

What helped me figure out where the line is was stepping away from SOLID and focusing on Test Driven Development (TDD). TDD is great because it forces you only to write as much code as you need, not more not less. But in order to write testable code you'll have to apply SOLID principles. So you end up with code that reaches just the abstraction level you need to solve the business issue you're trying to solve.

The interesting aspect of this is that there's no clear universal line you can draw and say "this is too much design!" or "this is too little!". What I've observed is that there's just the right amount of design, and interestingly that's, at least in my opinion, a function of how much change you expect. Writing a 100 line hack to do something that you'll never change again is perfectly good code - it does what you need it to, it has certainly no wrong abstractions or over design. But as with most software, change is inevitable and with change internal quality becomes more important. If your code has good internal quality changing it is easier. The better the internal quality, the easier, within limits. So finding the line is an interesting exercise to balance the cost of design vs the expected rate of change.

If I may recommend some reading here:

• Sandi Metz' blog post on the cost of wrong abstractions and I highly recommend her other blog posts
  
• Growing Object-Oriented Software, Guided by Tests helped me figure out how to think about software quality and how to better design it

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.
  
  
  

Hi, thank you. :)

You should learn C++ using C++ Primer by S. Lippman. (Not to be confused with C++ Primer Plus which was linked here before). Just be sure to learn modern C++, not "C with classes"! Then I recommend reading Effective C++ and Effective Modern C++ by Scott Meyers. Effective Modern C++ has some awesome examples of modern C++, but it also contains pretty hard edge-cases, so be aware of that.

The best way to learn Lua is by this book. It's very well written and I consider it to be not only the best book about Lua, but one of the best programming books ever!

Lua Users wiki is also very useful and contains lots of resources and sample code.

I also recommend checking out SFML Game Development book which is well written and contains some game programming patterns. You'll find it very useful even if you don't use SFML.

Oh, and Game Programming Patterns is a great read too.

___

Now, how much experience should you have with C++ to make games with it? That's a hard question! You should just start learning it and try making some small games with SFML or Corona. You'll see what you have to learn for yourself. :)

I don't think there is anything you need to cover before the class, if it's a good class. However, I would suggest the following -- not before class, but probably before, during, and after class:

• If the class goes reasonably well, pick up this book. It's a collection of best practices for Java. You will learn bad habits in class, and this will help. (It's not necessarily the class's fault, it's that Java warps your brain in all the wrong ways.)
  
• For Java, learn Eclipse, and learn it well. You may find you prefer other IDEs, but Eclipse is among the most popular, it's open source, and Google builds things on it, like the Android and Dart SDKs.
  
• Learn source control. It doesn't matter which you pick up first -- in my opinion, SVN was easier to learn, but Git is the best all around, once you get past the learning curve. And once you learn a distributed VCS like Git, you can use it on class assignments -- which I recommend doing, whether it's required or not. (And always make sure you tell your VCS what to ignore. Like, ignore .class files.)
  
• That said, learn to do things without the IDE, so you understand what the IDE is doing for you.
  
• Extra credit: Learn other JVM languages, like JRuby, Clojure, or Scala. In particular, learn at least one with a good REPL. This may be confusing, because you're using more than one language at once. But it also helps when you want to explore how a Java library actually works, in real time. I haven't found a good Java interactive shell, which is why I use JRuby's IRB for that.
  
• Google any term I used above that you don't understand.
  
• My experience with a community college was much worse than my experience with a university. If a university isn't practical, I understand... If it fails you -- that is, if you find yourself asking the professor questions that they can't answer, or if their answers don't make sense, don't be afraid to come back here or to StackOverflow.
  
• If the in-class projects aren't big enough, start one out of class! Practice is what makes you a better programmer and better with the language, and the best way to practice is to give yourself a project that you're actually interested in. Work your way up from Hello World, but if you find yourself not wanting to practice, you probably need an exciting project.
  
• Don't stop with Java. Learn other languages, learn other ideas. That said, when you find something you're really into, specialize and master it -- but you'll still always need to be stepping outside of that. Keep in mind that your skills in all likelihood will become obsolete. You don't need to chase every programming fad, but you do need to stay on top of the pulse of the programming community.

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

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

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

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

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

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

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

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

I think it depends on your location. If you live in or a commutable distance to a city with a strong technology sector, they will be quite a bit of companies willing to hire an high school level intern.

For example, a friend of a friend got an internship after graduating high school for the summer in the city he lives. I live outside the city and I am taking a year off before university because I got sick in the summer. I'm better now but all the companies near me are kind of old fashioned and they don't accept interns after a lot of cold calling; my calls and emails get sent to their HR manager, and they don't feel like giving me a chance. Also the benefit of an internship in the city for him was that he used pretty modern web development stuff.

As a high school intern unless you find a research group, you will highly unlikely use R. You can probably do front-end web development, so learning HTML, CSS, JavaScript, Jquery, and the Bootstrap framework would be awesome. If you don't want to do front-end web development, you really have to market yourself and make sure you are competent in Python if you want to use Python.

As a person who graduated high school last year and is taking a year before university to recover from an illness, I have to compete with other university students of various years who even the freshman have some sort of qualification as a candidate for a bachelor of applied science or math degree which tells the potential employer the applicant is knowledgeable. If you want to be competitive with the freshman or maybe the sophomore students, you really need a good GitHub portfolio which shows you are knowledgeable as them.

For example, in my GitHub portfolio, I have an Android application (GitHub and Google Play). In this small to medium sized application (35, 000 lines of code), I show I can use a version control system and a bug tracker by using Git and GitHub, respectively. Furthermore, in the bug tracker, I show I can debug by showing results of me using an allocation tracker, a heap dump analyzer, a GPU rendering profiler, and the like. In the actual source code, I show my experience with Java. But more importantly, I show I can implement an architectural pattern like Model-View-Presenter (a deviation from Model-View-Controller), some design patterns like wrappers, singletons, mappers, adapter, presenters, contracts, providers, and factories, and design an API which performs network requests, database queries, and file input and output. In the source code, I try to apply as much as I can from reading, Effective Java (2nd Edition), Clean Code: A Handbook of Agile Software Craftsmanship, Design Patterns: Elements of Reusable Object-Oriented Software, and Introduction to Algorithms while I get acquainted with reading Software Engineering: A Practitioner's Approach. I still need to try to utilize TDD and Agile practices; I read about them, but I never tried them out.

I think if you have a GitHub portfolio with project(s) of a good size that shows a lot of computer science and software engineering concepts, you will be ahead of most freshman students whose only projects might be a small class project in their Intro to Java class which all their peers did.

Currently, the application has around 5,000 downloads in about a month with 4.4 rating to place it 5th in its specific category above 4 stars on Google Play: https://play.google.com/store/search?q=Manga+Reader&c=apps&rating=1; it took about a month and a half. However, every time I send my resume to a local company outside the city for an internship, I get no response. I'm going to a Career Fair at a friend's university in the city on Friday, so I'm a test my luck there; they have quite a few recruiters for mobile application interns, and one company develops a full stack product and service whose mobile applications kind of match mine. Overall, it's feasible if you are near a city, willing to commute, and can prove you know as much as a freshman student who they could hire instead.

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

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

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

Literally every part about this sounds like an up hill battle. Frankly, no matter what the course of action, a year isn't going to be enough. You've got to start tempering expectations with that now.

The challenge here is rewriting all that Web Forms logic, and this is the piece that is the biggest hurdle. I assume, that since you are working with web forms you don't have any test suite in place, so you're basically walking a tightrope without a net. I also assume that the actual business logic of the application is probably closely intertwined with web forms as well (which I'm assuming because that's how its been nearly every web forms app I've worked with).

Before you start wondering with MVC is the right fit for you, you've got to prepare your code base from moving out of Web Forms. You should pick up Refactoring by Martin Fowler. And begin to move as much code as you can out of code behind files, and into pure C# classes that you can test. Interfaces are your friend. Facades and Adapters are your friend. Unit tests are your friend. You need to have your business logic as portable as possible in order to move away from Web Forms and not be constantly chasing down bugs and unexpected functionality. The more your code-behind is a facade that just takes inputs and calls other classes with them, the better off you'll be

With that out of the way, now we can get in the framework discussion. First off, I don't think a SPA is a good approach here. It'll be too heavy of a lift for your team, and probably not worth the time and effort at this point in time. So you're pretty much left with MVC as an architecture, which is fine, but I think you're going to have some issues with "vanilla" MVC considering the load and the users you're going to have to service, so you're going to have to look beyond that to make this work.

One of the key components to scaling this will be a good cache. If every read needs to hit the database, then you're done. I would recommend using Redis for caching, but an in-memory cache will help you here as well.

I would also strongly recommend looking into CQRS. That stands for Command Query Responsibility Segregation. The high level idea is that requests that need to modify data gets handled by different classes than reading data. This makes it much easier to scale up/out the read side, and also makes it much easier to know when the cache on the write side can be invalidated (since that's coming from the read side).

The challenge with ramping up on CQRS is that its generally presented with a lot of other solutions; MongoDb/Document databases, Event Sourcing, event messaging. Those are good and interesting in their own right, but they are way more than you need right now and CQRS does not require using them.

The last thing I'll touch on here is that if you've got one big ball of mud, you're path to upgrading this going to be very tough. If you can find isolated parts of the application to split off, and test in a different framework, then you'll be much better off. The more isolated sales is from inventory (or whatever you have) the better off you're going to be in the long run. If you can find the time to isolate those components in the application now, rather than try and rewrite the big ball of mud, your future self will thank you.

Here's a short list of what I used:

• https://www.freecodecamp.org/ Use this for basics and just a general refresher from time to time. Also has lots of challenges you can use.
  
• https://watchandcode.com/ This one really made some basic things click for me and made me really understand some important concepts.
  
• The Modern JavaScript Bootcamp (2019) (Already mentioned by you, but funnily enough also one of my favorites)
  
• The Complete Node.js Developer Course (3rd Edition) (same guy as above, this time some node.js)
  
• https://developer.mozilla.org/nl/docs/Web/JavaScript , MDN docs are just great in general, but they also have some guides. Another way I like to use them is just make myself familiar with all the methods of for example an array. So I go to https://developer.mozilla.org/nl/docs/Web/JavaScript/Reference/Global_Objects/Array and just go through everything one by one. This way I have way more knowledge about all the options I have when I get to an array problem.
  
• Book: Secrets of the JavaScript Ninja
  
• Book: Refactoring: Improving the Design of Existing Code
  
• Book: Eloquent Javascript (not the biggest fan of the write style, but the content is still quite good)
  
• Preordered book: Professional JavaScript for Web Developers
  
  This is all the result of lots of googling and personal experience. I am not in any way affiliated with any of these links and I have paid for everything myself when I bought them.
  
  How I 'invented' my project idea is basically by adopting the strategy to write down every idea I had. So did something annoy me at work? Write it down. Did I need something and it wasn't available or reasonably priced? Write it down. Had a random idea? Write it down. Every few weeks review your list and see if you are still convinced it will work otherwise delete it from the list. Keep this up and you will end up with a lot of deleted ideas, some decent ideas and a few good ideas. Keep expanding on your best ideas and keep reviewing everything. In the end you will have an idea that has survived lots and lots of reviews and has a fighting chance in the real world.
  
  Some things I like about my current project:
  
  
• Doesn't need a huge investment besides my time;
  
• Achievable by a small number of people or even just myself;
  
• Can make a simple version first, but also have lots of opportunity to expand on this version;
  
• Doesn't need huge amount of support.

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

I think others have said what needed to be said, but I'll throw out one more piece of advice:

Get a teddy bear.

No, wait - hear me out!

A lot of people advocate code reviews with other developers, to keep themselves honest. When you're about done adding a feature to your project, you should review the code with another developer. After going through this a few times, many developers learn to clean their code a bit, before letting another developer see it. How you solve it, isn't how you should leave it.

Well, it turns out that this mental act of getting ready for a code review is where you get a lot of the benefit of code reviews. Meaning, for a lot of the value of code reviews, you don't even need the expense of a code review! Just the act of preparing for one, makes your code better.

So, I've heard of getting a code review teddy bear.

When you think you're about done, adding some new feature to your code, get ready to code review it with your teddy bear.

And then you have to explain all of your changes and new code to the teddy bear, aloud. Use English, and tell it what each line of code does.

And then don't add comments to explain the tricky bits! Rewrite your code so that the tricky bits are readable. And if you can't rewrite it so that it's readable, then encapsulate those tricky bits inside methods with simple names, simple parameters, and no access to global variables.

GOOD LUCK, AND KEEP TO IT! It'll make you a better software professional in your main career! Tinkering is good! Don't get frustrated!

Maybe try reading "Refactoring"

http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672

Just to get the mental wheels turning.

And maybe try: "Working Effectively With Legacy Code" to inspire yourself...

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!

Not Android, but, much of what konk3r said in his comment is packaged nicely and easily consumable in Refactoring by Martin Fowler. Before you begin coding Android, understand Java and what it takes to write maintainable code. Any mildly intelligent chimpanzee can write code; it takes a talented programmer to write code that others (or even the dev himself) can maintain.

Other things:

• Understand list views. They're ridiculously complicated but there are very few apps that don't need them, and I can count on one hand the number of developers in my company that I've come across that can implement them correctly.
  
  
• Model-View-Controller. If you don't know the paradigm, look it up. iOS/Objective-C does a lot better job of lending itself to the paradigm naturally, but that does NOT mean that it is not applicable in Java. Separating your UI from your business logic/data is crucial and will save you SO MUCH PAIN later in maintenance stages.
  
  
• Understand the Activity lifecycle. Re-read the documentation and experiment until you understand its ins-and-outs.
  
  
• Never use hardcoded strings. They're a nightmare to maintain and completely impossible to re-use. For Android, UI strings should go in strings.xml (this means, if text appears in your app UI, it better be a string resource). You may also opt to use them for non-UI things, but I prefer constants in well-named files.
  
  
• Understand when you need application context versus activity context. Understand the differences in the two. Use them appropriately.
  
  
• Android is open source and apps are extremely easy to unravel to their source code, so, don't be shy about pulling down someone else's app and dissecting it to figure out how they implemented that cool functionality. Google's apps especially. Obviously don't commit copyright infringement, but a good programmer knows when to write from the ground up and when to not reinvent the wheel.
  
  
• If you're passing information between activities, use Parcelable, or the Android Gods will smite thee. NOT serializable.
  
  
• Utilize Android's helper classes. Did you know they have a TextUtils class? It is great for String functions (like checking if a string is null or "" with isEmpty();).

I agree, I think software development skills are going to only further bleed into other stem disciplines in the future. Plus it can be a back up skill if traditional engineering ever gets tiring. That way you're not tied to only one employment source.

I'd also steer away from VBA or .NET and get better at python (for the data analytics in research) and learn C (for potential robotics applications). I normally wouldn't recommend C as a first language since it doesn't do as much for you as other languages, but this FREE edx Course does such a great job of teaching it interactively that I think it's worth it in your case: https://courses.edx.org/courses/course-v1:Dartmouth_IMTx+DART.IMT.C.01+1T2018/course/. I like this course because they have a in built C compiler and a visualizer that shows you what each command you type would do to the program.

CS definitely bleeds over into some disciplines. Especially since you have an interest in research and robotics. I think a combination of ME + a CS minor can get you a foot into some research and/or robotics internships.

As for books, I think a combination of Think like a Programmer and Head First C and Head Start Python would be great "beginner books"


Then if you find out you really like programming you can get into best practices and how to build bigger complex programs with a book like Code Complete.

But before all of that just get the basics with python, then move to C if you ever decide to move into robotics.

If this is your first programming language its a tad unfortunate that it has to be C++ but by no means does it mean it is bad or anything. In fact its the language most aspiring computer scientists started out with in college prior to the 2000s.

You can start off with
Programming: Principles and Practice Using C++ and then going onto The C++ Programming Language, 4th Edition after completing the first one. There is also C++ Primer that is also highly recommended as another book for starting out.

A book along with web searches when you have questions will get you pretty far. Having someone to ask questions if you get stuck on something conceptually is also useful. The best advice I can give you is to really play around with the language as you are learning and do most of the practice exercises too. Stroustrup also has solutions to the exercises from the first book I mentioned online. Hopefully you have some months available to learn the language. On top of that you might need to learn some computer science topics like data structures as well. You just can't rush these things but you can accelerate it a little.

As for me, my C++ knowledge is 'rusting away' by the day. I learned the STL with C++ when it was made official only a couple years after (like over 10 years ago). Nowadays you have Boost and the language itself has changed. I have not presently needed to update my C++ knowledge to what is latest and greatest but I shall.

Also worth pointing out is that In my experience, when you work with different companies you might find that you never use official C++ libraries and most current language features, but you are supporting legacy stuff that was first written maybe 20 years ago when not even built-in STL was available. This means either you are going to use some now-arcane implementation of someone's version of base libraries or the company rolled their own from the ground up many years ago, and because its so well entrenched in the code-base it continues to be used many years later. Not a big deal, but you might want to find that out for yourself, that if you are learning the latest and greatest of library and language features - you might or might not be using it in practice with your company.

You can PM me if you have questions but I'm not sure I can commit the amount of time you might need in a tutor role.

Objective-C is a fine first language, it won't be as easy as others would but unless your going to give up easy don't worry. The place I started was with this book, it really does a great job and if you go through the whole thing it can help you a lot! Use google, reddit, and stack overflow for any questions you have in addition. Then once you read the whole thing and feel okay about it here is a link to some free podcasts to help you get in the mind of making apps and for some additional support. I would definitely recommend reading all the book first though because those lectures move pretty fast, and that course is set up to be taken after a few of the intro to programming classes are out of the way. Also take advantage of this /r/iOSProgramming

You don't have to know anything about programming going in, as aixelsdi mentions. If you want to get ahead, here's some information which may help you do so. The rest is up to your own initiative. It can never hurt to know more about CS or more languages, as long as you don't waste time complaining about what's better in [insert language of choice].

I wouldn't recommend learning data structures and algorithm analysis before coming to UCI. Not because they aren't fundamental, they are. But because most people find it harder to learn those abstractions before learning the tools that utilize them (Python, C++, etc), which is why ICS 46 and CS 161 aren't the first classes taught. If you like math proofs more than math problems then maybe go that route, it could be helpful as iLoveCalculus314 mentions.

Languages: The CS introductory series (31-32-33) which you'll be taking first year is taught in Python. It switched to this because it's a good first language as a teaching tool. Right after you're done with Python, 45C will teach you C++ and 46 will use C++. The lower division systems core (51-53) generally use C or C++ but it differs by professor. Knowledge of Python will be useful in making your first year easier. Knowledge of the other two will make your next three years easier because they're common mediums for upper division courses. But you should be able to pick up a new language for a specific problem domain by the time you reach upper division.

Courses: If you want to get a head start on planning your courses, check the UCI Catalogue - Computer Science page. At the bottom it lists a sample of what your schedule over the 4 years might look like. That page is for the "Computer Science" major, for other majors in ICS see here.

Course Resources: You can actually view the Schedule of Classes without being a UCI student. Select a term (like Fall 2014) and a department (like I&C SCI) and it will list what classes were offered that term. Most lower div will be I&C SCI, most upper div will be COMPSCI. From the results you can go to the websites for those courses to see a syllabus, books used, etc. For example, here are the current websites for the introductory series ( ICS 31, ICS 32, ICS 33 ).

Your course professors and books and assignments will NOT be identical to those, but looking at what's currently taught will give you a pretty good idea of what the course entails so you can pre-learn anything that sounds difficult.

Books: If you have to pick one book to learn before coming to UCI, I would highly recommend C++ Primer, 5th Edition. It's very well structured as a self-teaching tool AND as a reference manual. You won't come away with any Python knowledge, but picking up Python as someone versed in C++ is easier than the other way around, and you'll find 45C much easier as well since you can focus on language quirks rather than fundamentals.

If you choose to learn Python first, Introduction to Computing Using Python: An Application Development Focus is the book currently suggested for ICS 31/32, and Learning Python (5th Edition) is suggested for ICS 33.

Another solid circlejerk book in the CS community is Code Complete, but I wouldn't recommend reading that until later on since it's more of a "best practices" book.

> Python with Github? Of course I can google plenty of guides, but the fact that I read many of them and still don't use it, shows me that I don't think the guides were good or sufficient (or I just suck at google). To me (for now) it feels like a big hassle with the commits, etc. for a very small profit (despite the sharing with other people). Is there a good and concise resource that you'd recommend?

Is it really GitHub you need help wrapping your head around, or is it git itself that causes the problem?

>101 of bad habits/beginner mistakes link/resource? I've seen plenty of links now that say "don't import *!" or similar stuff. But never a real compilation. Can also be about habits of programming or little shortcuts or tricks and tips, not only common mistakes people new to Python make. I know I'm asking for a lot but it might help and turn out to be very useful.

Well, there's the Zen of Python, which you can see for yourself at the REPL using import this. But for more concrete advice... if I found a compilation like that, I don't know that I'd trust it. A lot of these things are subjective. And anyway, if you're expecting to be able to read through something like that and magically get rid of bad habits, I can tell you it just doesn't work that way. You need to practice, and you also need to focus on the positives rather than negatives. Get used to the techniques by which code is improved. If you like physical books for this sort of thing (I don't), the best I can recommend is this one - you might be able to find online versions, but as far as legality goes, you're on your own to figure that out.

There are a ton of books, but i guess the main question is: what are you interested in? Concepts or examples? Because many strong conceptual books are using examples from java, c++ and other languages, very few of them use php as example. If you have the ability to comprehend other languages, then:

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1322476598&sr=8-1 definetly a must read. Beware not to memorize it, it is more like a dictionary. It should be pretty easy to read, a little harder to comprehend and you need to work with the patterns presented in that book.

http://www.amazon.com/PHP-5-Objects-Patterns-Practice/dp/1590593804 - has already been mentioned, is related directly to the above mentioned one, so should be easier to grasp.

http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/ref=sr_1_1?ie=UTF8&qid=1322476712&sr=8-1 - one of the most amazing books i have read some time ago. Needs alot of time and good prior knowledge.

http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_4?ie=UTF8&qid=1322476712&sr=8-4 - another interesting read, unfortunatelly i cannot give details because i haven't had the time to read it all.

Here's pretty much your most basic flow for problem 3:

1. Find the square root of your target number.
   
2. Starting at 2, check if target % loop counter == 0
   
3. If yes, store as a factor and divide your current target by that number. Use that as the new for loop end condition. Find the complement of that factor, and store that as well.
   
4. Go through all the divisors you found and test if they are prime.
   
5. The largest remaining number should be your solution.
   
   To troubleshoot, use a debugger (Eclipse's builtin is nice). If you feel it's taking too long, break the program's execution and check its state. Is the loop counter about where it should be? Are the found divisors plausible? Is the loop end target plausible? Set a breakpoint on the first line inside the loop and keep stepping through (either one line at a time if you like, or just hit 'resume' and it will break again at the top of the next loop iteration).
   
   I learned Java throughout college, as it was the primary teaching language. Honestly, the best way to learn is just to WRITE CODE. Solve problems that you don't know how to solve. Invent random things that are useful to you. Your code doesn't have to be perfect when you're learning (and it definitely won't be!), and what is important is that you constantly look for ways to improve. I want you to look back on code you've written a year ago, and think that it's absolute crap - that will show that you are learning and improving.
   
   Somewhat counter-intuitively, the best resources are books! I'll list some recommendations below.
   
   Keep these principles in mind:
   
   
6. Don't repeat yourself. If you're copying and pasting code, it is wrong. If there is not a single point of truth for each piece of information in your code, it is wrong. Find ways to keep your code clean and non-repetitive.
   
   
7. Document everything. Comments - comments everywhere. Explain what ever piece of your code does. Explain what each method's arguments are, what it does, and what it returns. If you don't know, then that's a big red flag to reevaluate your design. If a bit of code is doing something complicated, write inline comments explaining what each bit does. All this is for future you - I can hardly remember code I wrote last week, let alone a year ago.
   
   
8. Separation of concerns. Each piece of code should only work with what it is directly responsible for. UI code should deal with presentation. Application logic should deal with data manipulation. A persistence layer should handle any database or serialization of things. Keep your code loosely coupled!
   
   
9. Design patterns. There are dozens of semi-formal patterns used to solve common problems in software. Learn to recognize these problems, when to apply these patterns, and how to modify them to suit your goals. See Wikipedia, or Design Patterns by the Gang of Four.
   
   
10. Be pragmatic. What does your code really need to do? What is the minimum that it needs to accomplish, and how can you keep it extensible enough for future expansion? The answer to the last part is largely the previous points - well designed code is always easily changeable. The Pragmatic Programmer is another excellent book. It even comes with a handy summary sheet of its main points!
    
    
11. TEST! Write lots of unit tests. Make sure that every piece of your program is tested to be correct. Every time you find a bug, write a test for it so it never happens again. If a piece is difficult to test, it may mean that it is poorly designed - reevaluate it. This is guaranteed to save your bacon at some point - you'll probably hate the work, but the safety net is invaluable. Being able to instantly tell if you program is working properly is invaluable when making changes.
    
    Once you start getting a feel for Java, which I think you might be already, Effective Java is the book. You probably won't need any other resource for Java itself.
    
    If you need help with something, Reddit is a great place, but Stack Overflow is the programmer's mecca. The best resource on the web for just about everything software, and their sister sites cover other topics, from IT/sysadmin to gaming.

I'm not sure I'm quite over the gap yet but what's brought me this far is probably unhealthy levels of enthusiasm coupled with trial-and-error.

Truth be told it took a while, but we started out on different terms. I started learning Scala the same week I started learning C-sharp for a new employment some 3.5 years ago. Digging into the now a bit dated second edition of Programming in Scala was for me a timely decision as my hobby helped me in my professional work.

Scala and modern C-sharp have some similarities in that they use high level abstractions to process collections. Things like map, flatMap, filter (Select, SelectMany and Where in C#) are commonplace and the times I reach for foreach, let alone a lowly for-loop, are easily counted.

There are some details that differ in how collections are handled: .NET has them lazy by default and everything end up an IEnumerable<OfSomeType> whereas Scala is mostly eager. Both variants have pros and cons but I must say I prefer .NET here, it feels like the "more functional" way of doing things and also interestingly enough the way Java 8 has decided to do it. A lot of people like to argue about this, which is a good thing as it means we'll see development in both aspects.


Anyway, the message that I am trying to convey is that you need to know how it works, and why it works, before you can understand why it's slow. That Scala runs on the JVM by default doesn't mean its constructs are equal, no matter how similar they may seem. Scala's for-comprehensions, for example, are not analogous to a vanilla Java for or even foreach. Rather, they are literally a way of expressing flatMap, map and filter in a more linear fashion. They are functional and carry an overhead

I'll agree with both the enthusiasts and the pessimists and say that Scala gives you more than enough rope to shoot you in your foot. Maybe unfortunately so as we are much more likely to screw up spectacularly while transitioning from one language to a seemingly similar language, as we are a couple of years down the road.


To round off, getting over the gap is as much about taking in as it is about letting go. It is an investment in spare time: a worthwhile investment in my experience.

Finally a few tips:

• Use the REPL to explore snippets of code;
  
• Use worksheets in either IntelliJ or Scala IDE to explore slightly longer pieces of code, unless you're comfortable with copy/pasta;
  
• Try to get a good grasp of Scala's type system; learn to love higher kinded types;
  
• Do not be afraid of implicits;
  
• Daniel Westheide wrote an excellent guide to Scala. It is quite brief; there's also
  
• Twitter's Scala school, used internally I imagine. It might be coloured by how Twitter uses Scala;
  
• Look/ask on StackOverflow if you have concrete problems; it helps the knowledge base grow and be accessible in a beautiful way;
  
• Google the heck out of everything
  
  Sorry for the rant!
  
  addendum: Yes! I feel I am more productive in Scala compared to both Java and C#, even for bigger projects. The ability to try ideas and flesh out code is much faster once you get used to how the type inference works (and doesn't work in some instances)

I'd take a more tools- and methodology-driven approach. The programming language itself is secondary by a long shot. It's hard to be convinced of this when you're starting (hindsight is 20/20), but the fact is you don't need to spend hundreds of hours "learning a language." To a newbie, learning to program and learning a language is almost synonymous, but the latter is a far smaller subset of the former.

Here's how I would guide the younger me:

1. I would start by learning some of a language. The Pareto Principle (i.e., the 80/20 rule) applies here. In many languages you can spend a lifetime really exploring the details, but you'll largely forget these details through disuse. Why waste your time with that? It shouldn't take much more than a day to learn what you need to move past this step.
   
   
2. Learn very high level concepts of programming methodology. Engineering is about making complex systems easier to manage through things like encapsulation, information hiding, and abstraction layers. This is key to making software and is a lot more important than language-specific details.
   
   
3. Learn your tools inside and out. Learning a text editor is actually a great way to learn how to program. After all, a great text editor like vim is fully programmable. Things like snippets allow you to think about programming on a higher level beyond "do I need a bracket here?" etc. Another important tool is a debugger. There are some folks that advise against them, but it's incredible how much you'll learn by watching the way your code transforms your input. The third vital tool I'd suggest is using version control. Make a github account and use it in conjunction with your vim configuration files so that you may continually refine your environment (and never lose it, thanks to git).
   
   
4. Learn to use test frameworks, and then be adamant about writing tons of tests (preferably before writing any code).
   
   I think this is a great foundation. You don't need a lot of books, but I think Code Complete is a great one stop shop. I would probably also add something like Growing Object-Oriented Software because I feel Code Complete is a bit lacking when it comes to the actual practice of testing (though it provides a great overview of it).

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 agree. books and tinkering are the very best way to get introduced to programming.

i read my first programming book the summer between my sophomore and junior years in high school. (i don't recall how old that made me at the time. 16? bah, i'm getting old.) anyway, that book was Herbert Schildt's The Complete Reference: C++. i found it really interesting, but knowing what i know now Python (The Quick Python Book and Learning Python are good) or Java (I learned on Thinking in Java, but Effective Java is supposed to be good, too) are probably better places to start.

hopefully your parents support your desire to learn programming. $30-$50 for a programming book and access to a computer are a small price to pay for starting a child on a hobby that could turn into a good career!

good luck, and keep us posted! :)

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

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


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

Top Recommendations:

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

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


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

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

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

For Intermediates:

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

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

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

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

C# has excellent tutorials on the official Help site for Visual Studio 2013. You can download Visual Studio Community for free here. It is fully-featured and allowed for personal use (both non-commercial and commercial); you just are not allowed to use it on a development team of more than 5 people. After you become experienced with C#, learning Java is as easy as going through a textbook (also available in a physical version) and/or study guide (the latter might be a little too toy-ish for you if you're looking for job skills). If you are opposed to C# due to not liking Microsoft etc, then I'd use the previously linked Sedgewick and Wayne book and download Eclipse. Fair warning, C#'s tutorials are excellent and I've never found a better way to learn to code using a language with significant real-world use... if you choose the Java route to begin with it may be hard if you're not using a formal class. Once you know how to program, I'd say going through the MIT OpenCourseWare Intro to CS class would be a good idea to learn a different kind of language (Python, which has more scripting elements to it). C++ would make a good language to learn third, the best resources I've found so far for that are here, the book can be found as a PDF here or as a physical version here... warning, not all the material is available at all times due to the fact that it's an actively running class. A class on algorithms (book here, you may need to learn more math... probability, calculus, set theory, and the like... first, not sure what your background is on that) would be a logical step to take somewhere down the line. After that you will pretty much have most of the skills that someone with a minor in CS would get, learning the HTML/CSS/PHP chain and building a website would be a good way to round out your skill set. You should be able to get through quite a bit of this in the next 18 months. Good luck! Also, as others have said, try not to spend too much money... most of what you need can be found on the Internet, and the rest should only be a hundred dollars or so for a textbook. If another topic in CS that I haven't mentioned interests you as well, there's probably an OCW course for it, the sky is the limit once you have a firm foundation (I'd say the bare minimum for that is knowing Java and C++ and thoroughly understanding the material in the Algorithms class I linked above... still I've found C# is far easier as a first language though so if you try to shortcut it you might struggle... once you know one language the rest come pretty easily, especially if they are as similar to your first as C# and Java are, so your first goal is to learn C# [or Java if you are still that adamant]).

It depends on whether you're a beginner to C++, a beginner to programming or both. It also depends on whether you prefer a tutorial style -- where you read closely and walk step by step with the author, or a reference -- where you skim, go at your own pace, and follow up when you need more details.

Accelerated C++ is more of a short introduction that hits all the broad strokes. It's good for someone who's already very adept but just needs to get into the mindset of C++.

Principles and practice is a tutorial style book suitable for an introductory course, and isn't a bad choice. The C++ Programming Language is more of a reference style and would be good for people who really prefer that direction.

I've read parts of How to Program Java and definitely was not impressed -- not sure how 9th ed of C++ stacks up.

I'm assuming a beginner is new to programming, but by virtue of choosing C++ enjoys the technical details that allows you to make the most of the language. My recommendation for this kind of user by far and away is C++ Primer by Lippmann, Lajoie, Moo (not to be confused with Primer Plus). This book (3rd ed) was what made me fall in love with the language in university.

It's written by people who were deeply involved in the standards, wrote actual compilers, and know how to present the material in ways that are relevant to the student. The 3rd ed also had sections that went further and explain the underlying compiler mechanism for a given feature which I found so insightful. They somehow managed to marry a high-level tutorial style narrative with important low level technical details that very much mirrors the style of the language itself. The 3rd ed also explicitly called out C++ as a mutli-paradigm language where functional style was possible (which was my first introduction to the concept of functional programming).

I'm not sure how much of that book survives in the 5th ed, but either way I recommend you read the book yourself and see if it's something that resonates for you. I'm looking through a copy of 5th ed right now, and it looks like much of that spirit is still alive. The down side is it appear it's still on strictly C++11, which given the size of the language and intended audience, I don't think is a fatal weakness.

If you want a complement to C++ Primer, Stroustrop's reference is the most complete, but to be honest I prefer C++ Reference for a working programmer.

I highly recommend ditching IDEs entirely for learners precisely because they make it harder to detect and learn from your mistakes. Get a copy of a linux distro, or install XCode command line tools, and invoke GCC/Clang directly. By the time you need to move into larger projects you'll have developed your own opinions on build systems/IDEs.

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.

Modern C++ (C++11 or later) books are not nearly as plentiful as those for Classic C++, but there are a few notables.

Bjarne's college text may be what you are looking for:

Programming: Principles and Practice Using C++ https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784/ref=pd_sim_14_2/144-7765085-0122037

It is aimed at engineers, which makes it less general, but might be good for you.

Of course his general intro is also updated to C++11.

The C++ Programming Language https://www.amazon.com/C-Programming-Language-4th/dp/0321563840/ref=pd_sim_14_2/144-7765085-0122037

This is aimed at experienced systems programmers, so it may be a bit heavy for students, which makes the Primer (that you mentioned attractive).

C++ Primer https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/ref=pd_bxgy_14_img_2/144-7765085-0122037

Be certain to get the 5th edition.

Of Scott's books only the latest is Modern.

Effective Modern C++ https://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996/ref=pd_sim_14_2/144-7765085-0122037?_encoding=UTF8

This is less an introduction for students than for Journeymen (Journeypeople?) programmers.

For just plain good programming style consider Ivan's book.

Functional Programming in C++ https://www.amazon.com/gp/product/1617293814

Don't be put off by "Functional." This style of programming will make your students excellent programmers.

There are some modern books of high quality that are niche.

The ultimate guide to templates:
C++ Templates https://www.amazon.com/C-Templates-Complete-Guide-2nd/dp/0321714121/ref=pd_sim_14_1/144-7765085-0122037

The ultimate guide to concurrency:
C++ Concurrency in Action https://www.amazon.com/C-Concurrency-Action-Anthony-Williams/dp/1617294691/ref=pd_sim_14_1/144-7765085-0122037

Some library options:

Despite its name, this is mostly reference. A very good reference.
The C++ Standard Library: A Tutorial and Reference (2nd Edition) https://www.amazon.com/Standard-Library-Tutorial-Reference-2nd/dp/0321623215/ref=pd_sim_14_2/144-7765085-0122037

Arthur's book covers C++17, which makes it one of the most modern on this list:
Mastering the C++17 STL: Make full use of the standard library components in C++17 https://www.amazon.com/Mastering-17-STL-standard-components-ebook/dp/B076CQ1RFF/ref=sr_1_fkmrnull_1

To what extent are you teaching C++ and to what extent are you teaching programing?

Good luck and have fun!

Interesting comment on compiling it with VS, i tried it in VS 2012 with /W3 and only recieved

warning C4551: function call missing argument list

compiling with /W4

warning C4189: 'asnwer' : local variable is initialized but not referenced

This lack of warnings from the compiler is a bit disturbing heh. Compiling with /Wall spits out a bunch of other unrelated stuff. Perhaps try changing to /W4 in the project properties C/C++ tab.

I'm not surprised that Ask and Say where called a few times, stepping through your code Say i think would be called twice and Ask would be called 4 times. Rough guess heh. The reasons for this are how your code is written

On line 33 you call Operator(), which calls Say() on 22, Ask() on 23 and Ask() again on 24. This call returns and next Operator is called again on line 34, calling Say() again and Ask() two more times.

The issues with the program i believe arise from a lack of understanding of C++, learncpp is an ok site, but really all online C++ tutorials are crummy/mediocre at best. You should pick up a real book, a commonly recommended one for beginners to programming and C++ is C++ Primer Note: NOT Primer Plus, just Primer.

The only reason is that the return type signifies sort of signifies your intentions with what to do with what's being returned. If you return bool, you clearly wish to check if something occurred or didn't. However returning int or char could be used in many more things. What I'm trying to say is that char/int will work, but bool is far superior in this situation.

You could really do with a good book to learn from. If you'd like me to pick over each issue with this program and help you work out a working version I can, although I'll be heading to bed in about an hour and it'd probably be more helpful to get a good book than focus on this one program.

Most important: to truly learn C++ you'll need a good book.

> What is IDE really?

IDE stands for Integrated Development Environment. You don't have to use it and can write your code in notepad if you feel inclined to do so. However that's an annoying way to code. IDEs are toolsets made for a specific language in mind that offer:

• shortcuts for using a compiler
  
• syntax highlighting
  
• autocomplete
  
• ability to quickly jump to a given place in code (eg. when you see an unknown line and want to see where it originates from)
  
• tools for debugging your application
  
• and many other features
  
  You can think of an IDE as of just buying a premade wardrobe vs ordering an IKEA one and having to assemble it yourself from pieces. In some languages you see IDEs used more (eg. C++), in some it's less popular and a good text editor with some plugins can do the trick (eg. JavaScript).
  
  > What's the difference between using C++ on Netbeans, Eclipse or Visual Studio?
  
  Those 3 are IDEs. C++ works identically on all of them. Personally on Windows I find Visual Studio to perform best, on Linux I like CodeBlocks and CodeLite. CLion is also good. Honestly for a beginner - just choose any of the popular ones and stick to that for the time being. It doesn't make THAT much of a difference.
  
  > What's the difference between different compilers?
  
  You don't want to hear a detailed answer to this question yet. I will just highlight one thing however - stick to the most popular compiler for a given OS. For Windows it's one included with Visual Studio. Reason - libraries (extensions/packages) generally do not work with a different compiler than the one used to make them. You would need to download source code and recompile them and that can take hours.
  
  > What books is the best for begginers? I tried book of C++ creator but as soon as you begin with it, it's already confusing, there's no even a "Hello World" explained line by line, it's starting with vectors and some weird shit.
  
  Personally I find Lippman book to be a good one:
  
  https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
  
  But ultimately C++ is simply a HUGE language and it takes a loooong while to learn it. You will need to experiment a bit with resources to find one you like. Not a bad approach is to visit a nearby university bookstore and see what options there are, reading first chapter is enough to give you a glimpse on whether or you can use it.
  
  > What about Java? What is JRE? What is JDK? How when i install JDK and get to eclipse and go to new project i get create new class, new method bla bla. Why is there just no create source file and code something and run it?
  
  JRE is a Java Runtime Environment. It's necessary to RUN Java programs. JDK is when you want to develop a Java program. There's no "create source file" because in Java EVERYTHING is in a class.
  
  > Why do i need to learn 10x frameworks for JS if it's all JS just with shorter commands and even tho i have to learn it how do i find the right resources to learn it?
  
  It's not just "shorter commands". Current needs for Javascript are much, MUCH bigger than what they used to be say a decade ago. Nowadays an example task can be "write a Microsoft Word in Javascript". There are 3 big frameworks currently used for these sorts of jobs - React, Angular and Vue. React is most popular according to surveys. If you want to learn it then personally I found https://leanpub.com/the-road-to-learn-react to be an excellent resource - it only expects you to know core javascript first (which you can learn via stuff like Eloquent Javascript or You don't know JS) and provides a short yet useful introduction to JUST the React without any other stuff (which you might want to learn later on).
  
  > Now im on github and i look at some random project which containts all type programming languages files, it has soem C code, it has some python code, some java bla bla, how can someone compile all of that into single app and have it run?
  
  Look into documentation and build information if any are provided. I can guarantee one thing however - it's most likely MORE than just a "single" app (as in a single executable file). It's probably multiple modules. As for how these modules can talk to each other - that's a story for another time (if you want a very simple possible option - imagine that one writes to a text file and another one reads from there).
  
  Also - don't spread yourself too thin. ONE language first. Master it to sufficient degree to build a real life project of some kind (be it a small game, web app, desktop program, mobile etc). Then you can start exploring other options. You just confuse yourself right now and are trying to take in WAY too much information.

I would supplement your class with one of the many great C++ books out there, because there are many ways to learn C++ but few of them are good (or even "right") ways.

You should be careful to distinguish between best practices from C++ and the new ones in C++11, and I've found that many courses tend to teach C++ as if it's just C with some extra features.

Of note, some really good books are:

• http://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113
  
• http://www.amazon.com/The-Programming-Language-4th-Edition/dp/0321563840 (this one is brand new, so I have no reference for how good it is, but previous versions are usually at the very top of people's suggestions)
  
  At least as good starting points on the "new" C++, and I'm sure others have some really great suggestions too.

As the other posters have mentioned, I develop with Ruby as a day job doing web development on the Rails platform. That being said, I also used Ruby throughout college to do machine learning programs, genetic algorithms, and bioinformatics work. In general, Ruby's great for anything you want to just get done, without worrying about the contortions that some of the other explicitly focused languages put you through. Just having a REPL loop like IRB is great for very quickly trying things out.

That being said, Ruby is not good at any heavy computation. I don't care which version of Ruby it is, it's still slow for any heavy number crunching, so if you're going to be working with heavy datasets, it's best to pick your battles. As you've said you're just getting into programming, I would - rather than worry about if Ruby is the right language for you - just pick it up and learn with it. Certainly we aren't tied down to just using the bike on which we first learn to ride, and the same goes for languages.

If you have some *NIX / programming experience, I've heard great things about http://github.com/edgecase/ruby_koans

If you like to buy books, http://www.amazon.com/Ruby-Programming-Language-David-Flanagan/dp/0596516177 is the best and only Ruby book I'll bother owning. I have a short attention span (except when writing comments, apparently) and have found all other resources laud on and on about how great Ruby is, rather than tell you anything about it. Otherwise, they read like a dictionary. Not useful for me.

You've probably had it recommended, but if you like cartoon foxes, bacon, and a lot of comedic nonsense in your learning, check out http://mislav.uniqpath.com/poignant-guide/book/ - it's a quite fun way to get exposure to the language!

Ultimately the first steps are the hardest - and the best way to move forward is to set a goal. Perhaps write a program that takes a number n, and tells you what the _n_th prime number is. Certainly not the most exciting program, but something that can be improved on, etc etc.

I think things would be much easier with a small team of average developers, primarily because converging on any given set of things you want to do/want to avoid in the language is much cheaper from a communication-cost perspective. If the group is small enough (say 5-10 people), you can probably get 50,000-foot agreement, at least, over a nice lunch, and hash out the details on a Wiki or something.

Scala's great strength remains that it goes out of its way to accommodate you whether you're treating it as "Java without semicolons" or "Haskell without pervasive laziness and with much poorer type inference." Given that, your biggest question, regardless of the size of your team, is: what kind of software development culture do we have/want to create?

Let me sketch a few example scenarios:

1. You have a non-trivial existing codebase in Java and Spring. You're excited about Scala, maybe are reading Programming in Scala or taking a Coursera course, and this typifies your team. You've looked around for information about how to use Scala with Spring, and found that information is thin on the ground, at best, and when you ask in the #scala IRC channel or on mailing lists, the response is "Yeccch. Don't." Not very helpful with your existing codebase! For this, I would say: work at whatever comfort level with Scala you have, and take advantage of spring-scala (full disclosure: I took over maintenance of spring-scala from the folks at Pivotal Labs who did the actual heavy lifting).
   
2. You have the opportunity to do a greenfield project, maybe because you're refactoring your organization's monolith to be microservice-based, and you get to implement one of your organization's first microservices. You've heard great things about using Scala for microservices, but you still fall into the "reading books and taking Coursera courses" category in 1), so important factors here are availability of semi-pre-packaged solutions, community, documentation, etc. Here I would suggest looking at Lightbend's Activator and its templates for opportunities to quick-start a microservice, like the Akka HTTP microservice. Then you can gradually add functionality as requirements and/or your learning curve permit.
   
3. You've heard a lot about pure functional programming in Scala, maybe you're reading Functional Programming in Scala, maybe you have at least one team member who's an intermediate-to-advanced Scala developer and/or you have a clear direction in HR to find them. Your colleagues might look at you funny when you say that a REST microservice is obviously just a HttpRequest => HttpResponse that "does some stuff," so it's actually an HttpRequest => F[HttpResponse] where F is a Monad, but they don't run screaming into the night; they want to know more. You decide to do a Proof of Concept with http4s for the REST stuff and Doobie to talk to good ol' PostgreSQL (because not all of your tech choices can be totally nuts). You might have a look at this example to get you started, and one of the things you notice about it immediately is... how straightforward and unscary the code actually is, strongly resembling what you'd write in any other language. But when you change the code, the compiler, way more often than not, tells you how you screwed up, before your code even can run.
   
   All of these scenarios are, in my opinion, completely reasonable, even if I got a little tongue-in-cheek on the last one. :-)

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

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

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

The C Programming Language : ANSI C

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

C++ Primer : C++

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

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

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

Algorithms : Algorithms / Data Structures

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

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

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.

You can definitely learn, but don't think it'll be quick and painless. If you're a book guy This book will definitely get you going. However, I'll say it, starting programming in obj-c is a bitch. Syntactically it can be extremely overwhelming ( I tried to learn obj-c first ). If it becomes too much, take a step back and try good old C, or a much prettier language like Java, Python, or Lua which will help you understand all the concepts of programming before jumping into app development which can be extremely complex.

After being scared off by obj-c I officially started down my programming path by going through This book which was an absolute pleasure to read and a great "hold your hand" guide to basic programming. The great thing about this is that you'll be learning C concepts which all carry over to obj-C and you'll be getting very familiar with Xcode and the debugger which, again, carry right over into obj-C and app development.

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

It's perfectly fine in an isolated assignment like this, but it's also easy to start using exceptions as a part of code flow in larger software when you are writing programs for a living. And that's when bad stuff might happen, plus it is harder for your co-workers to decipher what your methods are supposed to do.

Effective Java by Joshua Bloch is probably the best book you can read if you want to improve your code. It's not that thick, and it's divided into "items" that are easily read in any order you like. For instance, there is an item about exceptions, just like your case, but probably way better explained than I did :)

Things like this might seem nitpicking, but in my opinion the easier it is to read your code, and the more robust your methods and classes are, the better. Otherwise you produce spaghetti that people have to maintain 10-15 years from now and they will curse their miserable lives every day. I've been there, it really opened my eyes :D

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

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

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

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

Recommended Reading:

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

I just resently started a carreer as a Java Developer myself (m/22), so I can remember the things I had a hard time with like it was yesterday.

What I had the most trouble with, carreer wise, is the configuration of a lot of frameworks. Java in itself is relatively easy (especially since you already are an experienced developer), it's the frameworks that require the most time to learn. A lot of them require a certain amount of configuration, mostly in XML. Learning how to set them up was mostly trial and error in my case. Like someone else said in the comments, pet projects are the best way to learn this. So, to answer your question about what I hate about Java: this configuring is it. Stuff like that is easier in, say, C#. However, if you join an already existing project, the configuration is already done most of the time (although not always very good).

Now for the resources. I really did a bad job with Java in my first year of college, but this guy really helped me with his tutorials (I got 100% percent when I took the exam again): [The New Boston] (https://www.youtube.com/playlist?list=PLFE2CE09D83EE3E28). I linked you the beginner tutorials, but he also has intermediate. [Effective Java] (http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683) is also a good resource, like mentioned in the comments. Another one I like is [The Well-Grounded Java Developer] (http://www.manning.com/evans/). It is a really balanced book, talking about important things like Threading, the JVM, Dependency Injection, Continuous integration etc.

I would suggest you first do some little projects to get a feeling with Java as a language, and then stepping over to frameworks like Spring and hibernate. Check the differences between Spring and Java EE, read about dependency injection (Martin Fowler has a great article about this), etc.

This turned out longer than I expected, so I'll leave it at this. If you still have questions, feel free to PM me or leave a comment.

> I am a relatively new to development

If you're new to development, it's hard enough just to learn Rails by itself. In addition to the Rails concepts (e.g. ActiveRecord, view rendering, etc.) there's Ruby, databases/SQL, servers, HTML, CSS and JavaScript. Even if you're already comfortable with all those things, it's pretty hard to throw testing into the mix. When I first got started my question was, "What do I even test?" Do I write unit tests? Integration tests? View tests? Controller tests?

My advice would be to forget about Rails for a little bit and just practice testing Ruby by itself for a while. Then, once you're comfortable with testing Ruby, it will be easier for you to go back and try to write some tests in Rails.

> What is your recommendation on if I should focus on rspec vs minitest?

A person could make technical arguments for either. Deciding which testing framework to use depends on your objectives. If you're teaching yourself testing to become a more marketable developer, then I would definitely recommend RSpec. Almost every Rails project I've worked on (20+ production projects) has used RSpec. Having said that, it's less important which tool you choose and more important that you have a solid understanding of testing principles. I personally chose RSpec and I'm glad I did.

Here are some testing resources I often come across:

Growing Object-Oriented Software, Guided by Tests (awesome book, highly recommended)

Rails 4 Test Prescriptions (just started it, seems good so far)

Working Effectively with Legacy Code (super good book and more relevant to testing than it might seem like)

Everyday Rails Testing with RSpec (haven't bought it yet but seen it recommended a lot)

Destroy All Software (just bought it today, seems good so far)

Lastly, I myself created what I call a Ruby Testing Micro-Course designed to make it easy for people like you to get started with testing. Feel free to check that out and let me know what you think.

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

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

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

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

Hope that helps!

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.

Pick up this book for $15 and work through it.

http://www.amazon.com/Objective-C-Programming-Ranch-Guide-Guides/dp/0321706285

This book is written for complete beginners so that you will learn the C programming language on OS X, and then more specifically Objective-C so that you can begin programming for iOS and Mac OS X.

It'll guide you through everything from getting your development environment (Xcode) to creating your first programs. There's also an active forum community at BigNerdRanch if you run into problems, although all of us should be able to help you as well.

In my opinion, not only do you not need Windows, but developing anything in Windows is much more difficult than in OS X. OS X is based on UNIX, which is a big deal for programming, because it gives you access to the terminal and a nix filesystem (which is identical to Linux's – most programmers would suggest you use a Linux variant such as CentOS or Ubuntu, but to be honest Mac OS X is just as viable for programming as any Linux variant).

As far as getting started goes, it's always a good idea to learn the granddaddy of most languages: C, and one of its extensions (C++ or Objective C). After that you're free to learn whichever language you want. Python is a popular choice because it's very simple (and powerful!), but I wouldn't make it your first language if you're serious about programming. Python is almost too simple for its own good. You won't learn many of the common language conventions, which you would* learn if you learned C or Java.

There are a few free C textbooks online, but none are as beginner-friendly and OS X tailored as the one I linked above. As far as development environments go, on Mac OS X there are two important environments: Xcode, which is Apple's own development environment. It will allow you to program in C, Objective C, and NASM. And then there's Eclipse, which is a multi-platform environment that supports a whole slew of languages.

Learning electronics is a lot like music. There is an insane amount of information, but if you get an economic working knowledge under your belt, you can really do some amazing things. In order for you not to get lost in the rabbit hole, I will provide you these methods of learning practical hobby electronics.

First, is simply just a suggestion. There are two "domains" of electronic thinking and analysis: digital and analogue. Fuck analog right in its dumb face. The math used in analog is fucking super duper hard, and analog circuits are prone to interference problems. Digital is where you want to be. It's vastly simpler to use programmable digital parts, and analyze digital circuits. Don't get lost in AC equations of capacitor, or the god damned transistor equation (seriously, fuck that. )

Okay here is how I learned hobby digital electronics:
First buy this, and go through all the examples in the workbooks. When you learn electronics you 100% HAVE TO DO HANDS ON LEARNING! DONT LEARN IT FROM A BOOK! MAKE CIRCUITS!
https://www.amazon.com/Radio-Shack-Electronics-Learning-20-055/dp/B00GYYEL8I

At the same time, read this (which is a good topical explanation, and free):
http://jacquesricher.com/NEETS/

And buy and read this (which is an EXCELLENT formal introduction into the physics):
https://www.amazon.com/Practical-Electronics-Inventors-Third-Scherz/dp/0071771336

Also you are going to learn how to program, which is an entirely different topic. Programming and hobby electronics make you a master of the universe, so it's worth it. I learned programming in the electronics domain and it was awesome. I made a microcontroller FM synthesizer:
https://www.youtube.com/watch?v=3TvuzTK3Dzk

So basically, the way I learned programming in general was self-teaching with books. Again, you have to do it hands-on. Actually complete the examples in the books, and you'll be fine.
First, learn procedural c programming using C primer plus. Buy an older version so it'll be super cheap:
https://www.amazon.com/gp/offer-listing/0672326965/ref=sr_1_3_twi_pap_1_olp?s=books&ie=UTF8&qid=1465827790&sr=1-3&keywords=c+primer+plus

Next, learn Object oriented programming using head first java. They do a great job of tackling OOP, which can be a difficult thing to learn.
https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_1?s=books&ie=UTF8&qid=1465827860&sr=1-1&keywords=head+first+java


You're overwhelmed because they're deep topics. But, seriously, its the most fun shit ever. You'll love learning how to do it.

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.

> Which of the three will give the best chance to telecommute?

From my experience, as a general rule, I have found that anything related to web development is especially suited for telecommuting, so your choice would be Ruby on Rails. You can telecommute with roles like Sharepoint developers, DBA, sysadmin, but my impression is that most of these roles are in traditional big companies and they may not always be open to 100% telecommuting.

But be aware that by choosing a field that doesn't require your presence on-site, you're competing with developers from developing countries who will be able to outbid you.

> Which of the three is the least challenging to be learned on your own (and if you have any good learning resources you can recommend, I'll take them all, thanks)?

I think all are equally challenging if your aim is to be really good in that field and difficulty is a subjective notion anyway.

As for resources: when I was dabbling in Ruby on Rails a few years ago, I found this tutorial very useful: Ruby on Rails Tutorial

You also need a good understanding of the Ruby programming language. I recommend Programming Ruby, though I liked The Ruby Programming Language because it was a lot more concise (if dated). You can ask /r/ruby for more suggestions.

You need to build up a foundational set of programming skills. Frameworks and libraries are important to know, but not as important as knowing how to program. The difference between a program/website/webapp that works, and a program/website/webapp that works AND has sensible code, is significant to a company. I've seen the simplest of features take weeks to implement in very poorly written code bases. This is valuable and expensive time that could have been spent building other features.

Companies are sensitive to this because very few companies are immune to the effects of poorly written and maintained code bases, so they are going to ask you code design questions and even have you do live programming challenges to see how think about the problem, and whether the design of a solution is important to you, or whether you're content to just shit out any old solution that works and move on.

To start, with, I would familiarize yourself with the basic mechanics of the language by reading the You Don't Know JS series: https://github.com/getify/You-Dont-Know-JS/tree/1st-ed

Next, I would read Clean Code by Robert Martin. It's based in Java, but the general principles are the same.

Next, I would read Refractoring: Improving the Design of Existing Code (2nd edition - which is JavaScript based). You can read the Java-based 1st edition for free.

Finally, I would read A Mostly Adequate Guide to Functional Programming.

Yes, it's a lot of reading, but these books will help you think about your code design choices, and in combination with practice, will help you write better code. But of course there is no substitute for practice. The more you write code, the better you'll be at it. The resources I linked to are just guides, not magic bullets.

In terms of other things that are necessary to learn, you'll need to learn how to use git (not to be confused with GitHub). Git is basically the industry standard version control system. You don't have to be an expert at it, but you do need to know the basics of it.

You're also going to want to get familiar with the basics of node and npm, because even doing front-end work, you'll be relying on 3rd party packages, and running builds, all of which are managed through node and npm (or yarn).

Absolutely, it's a very clean and easy to use language. It is object oriented and functional which allows someone who has never done functional programming to ease themselves in. Before I started learning scala I only knew python so it was nice that brackets and semicolons weren't really necessary. Higher-order functions are fantastic. /u/bananaboatshoes brings up a good point that scala builds on the jvm so it's usability is the same as java. It also allows you to use java libraries in scala pretty easily. Once you have learned scala going back and picking up java is fairly easy if you find it necessary.

 

I'll see if I can't conjure up a few resources.

Scala website

The book I read

A good book on functional programming

 

I hope this all is formatted correctly I'm fairly new to commenting on reddit.

*Edited my formatting

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

No, that book will teach you ruby, but not rails. Also, for learning Ruby the language, there are better choices. I highly recommend "The Well Grounded Rubyist" for any skill level that includes being able to find progit. ;-)
The Ruby Programming Language is also highly regarded, but more terse. If you know other dynamic langues already and prefer a quicker read, this might be a good choice also.

As for learning Rails, I have heard good things about this book/tutorial, available for free:

http://railstutorial.org/ruby-on-rails-tutorial-book

There are also accompanying screencasts and pdfs for pay, which have gotten good reviews. Also available on dead tree soon: http://www.amazon.com/Ruby-Rails-Tutorial-Addison-Wesley-Professional/dp/0321743121

If you do decide you want the Pragmatic Programmers Rails book, you'd probably be better served by waiting for the 4th edition to print or buying the pre-press ebook. http://pragprog.com/titles/rails4/agile-web-development-with-rails It's not a bad book for rails, but the 3rd edition is fairly outdated at this point.

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.
  

If I could make a recommendation based on time-tested experience, I'd recommend following the advice of 2 books, Refactoring: Improving The Design Of Existing Code and Growing Object-Oriented Software, Guided By Tests.

Basically, if you are committed to this codebase, you can rewrite bits and pieces of it (while covering them with tests to make sure you didn't break any functionality) and slowly migrate/transform the code to a point where it's more maintainable.

Of course, if you have a manager who you can't convince this is worth spending time on, you might point them to a resource like this about technical debt or perhaps this one to bring it down to dollars and cents (which every manager understands).

I'd also recommend reading this great piece by John Carmack (of id's DOOM fame, and now VR... He's a highly respected OO C programmer, I'm sure you've probably heard of him) about his excursion into 1 month of programming using a "functional style" (it's applicable to any language, actually, including PHP). It has great quotes like this one: "No matter what language you work in, programming in a functional style provides benefits. You should do it whenever it is convenient, and you should think hard about the decision when it isn't convenient."

I promise you that if you can follow some or all of the knowledge I've linked you to, your job will become both less frustrating and more enjoyable (down the line).

Feature tests! If you use artisan make:test without the --unit option, it creates a "feature" test instead of a unit test. The docs call these HTTP tests.

Using feature tests you can go "outside in", meaning you can test the outer layers first (acceptance/functional/integration tests), and use those to drive your code and eventually your unit tests. This is also sometimes known as "top down" because the test pyramid has the slower (integration, acceptance, functional) tests at the top, and the faster (unit tests) at the bottom.

Adam does a good job explaining the concept in his Test Driven Laravel course (not linking it because /u/ftiersch already did and they deserve credit!). If you'd like a book rather than a video course, I recommend Growing Object Oriented Software Guided by Tests.

Adam's course is worth far more than he's charging, though, and not only do you learn about testing, but he also refactors in the course and shows a ton of Laravel tools you likely didn't know about.

If for whatever reason you don't want that book or the course, there are some people (myself included) willing to do paid coaching sessions, but really, if you're a pretty seasoned dev, you should be able to read the HTTP test docs I linked earlier and good a pretty good start. Laravel makes testing so easy.

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.

First make sure you know well plain java. Do some sipmle programs, read web tutorials or beginners book. After that, read Effective Java from Joshua Bloch.
https://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683
You don't need to read every line of this book, but at least you should know roughly what is going on there.

Regarding the framewors. There are zillions of them so you have to be selective. It really depends on what you want to do.
Spring + sql is good for web applications. These are for example used as a administrative portals. It's kind of job safety since there are many of them and won't disappear soon. Go for that.

Now just a little advice for the job. The salary of the programmers goes down since it's becoming still easier to create generic things. To me it turned out to be really good deal to combine it with mathematics. Don't look to yourself only as a programmer, bring something more to the table.

Let me know if you need any help.

P.S.
I am thinking about flushing out some posts and examples related to computer vision in the next couple of months. Is this something you would be interested in to see?

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

First off I messed with a lot of languages before I think I really grasped the basics. I'll note that I used some Qbasic and Lua before starting my CS degree but I don't think they taught me good fundamentals because they are a little more "simple" and left me confused looking at lower level languages which is pretty much anything else.

I just started my CS degree recently and finished the first class which was in C#. I felt like this language really gave me a better grasp on the fundamentals.

More importantly than the language though I'd say get yourself a good book. For my C# class we used this book which is really good but kind of expensive. If you are interested in C++ many people recommend C++ Primer or The C++ Programming Language.

In taking my C# class I realized I thought I knew a lot about the basics of programming but actually didn't fully understand some very basic stuff, even things I had used a lot before.

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

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

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

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

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

Python is an easier starting point than C. I've tried to learn Python many times, but I always find myself gravitating toward C.

C Programming Language by Kernighan and Ritchie is a very good book to pick up.

C Primer Plus by Stephen Prata is another good one for the C language. I gravitate heavily toward C. Mostly because it interests me. Also the first programming language I've ever decided to pick up.

Do not give up denizen! Programming is an exciting experience when you get things to work properly. There is so much you can do with it.

Best piece of advice is to choose what best suites your interests, and goals.

To learn C++ as someone completely new i recommend this series on youtube: https://www.youtube.com/playlist?list=PLAE85DE8440AA6B83
This will introduce you to the language and alot of the concepts that carry over to other languages as well. After you go through that whole series as boring as it may sound i really recommend you buy a textbook and read through it, doing whatever programming projects / exercises that interest you. My recommendation for a textbook would be C++ primer:
https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113

Edit: Also, I would recommend as your first language you start with Python. Its becoming more and more popular as an introductory language and its well suited to get you past the initial learning curve. I personally haven't worked with the language too much myself so I cant provide you with any recommendations. Good luck, comp sci is an incredibly interesting subject and is useful in so many aspects of work. :)

Interesting!

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

Couple of suggestions:

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

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

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

Some other resources:

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

Refactoring: Improving the Design of Existing Code is ok. I don't know if it is as amazing as the reviews think, but it is pretty good. It is a little Java centric.

You really don't see many blog posts/internet articles about refactoring. It almost sounds like you are looking for help with design, refactoring is just the process of how to reach a better design.

The most important part is to write unit tests to make sure that you preserve the required behavior during refactoring.

I heard good things about this book. It's awfully expensive, but I'm sure you could find a free copy somewhere.

https://www.amazon.ca/Primer-5th-Stanley-B-Lippman/dp/0321714113

Other than that, I understand how you feel. Learning programming for the first time can be a bit rough. For now, go through a book like the C++ Primer (or a similar one) and try to understand at least the basic syntax and key aspects of programming. (object oriented programming can come a little bit later!)

I also highly suggest, actually typing out a variety of C++ code related to a concept you're interested in, that is not straight from the textbook, then compiling and running it. For example, make an array of ints, then an array of doubles. Or write a function that multiplies two argument values and returns a double, then write a function that returns void, but also multiplies two argument values and instead prints the output. Or write a program that does a combination of things like loops, calling functions, iterating over an array. It doesn't have to be anything amazing.

1. The bootcamps that get the media publicity focus on intro to programming to "full stack" developer path, which, depending on your CS curriculum, should be what you get anyways - with added diversions into heavier CS stuff. Most college programs I know of do stuff like Operating Systems, Algorithm Analysis, Systems Programming (C/Bash/C++), Programming Languages (normally several small assignments done in several languages - i.e.: 'Implement quicksort in Ruby, C and Java') and Theory of Computation (my personal favorite) in addition to your 'Intro to Programming/Software Development' courses which is normally 2 semesters of basically learning a language (and the abstract concepts that apply to all languages) and then a Data Structures course.
   
   
2. Anyone in the industry that has knowledge of hiring processes will tell you that a GitHub with many side projects and neat things you've done for either side money or personal growth is more important than a 4.0 GPA.
   
   I did Java as my language in my undergrad (for the intro courses) and for higher level courses I did a mix of Objective-C, C, Ruby, Haskell, Clojure - whatever really seemed interesting or suited to solving the problem.
   
   The only way you come to better understand a language and it's nuances, in my opinion, is to use it and use it a lot. Finding out the power of a language (and all common languages do have power -albeit different from each other) is awesome. The more you use it, you'll find what you hate.
   
   I also read a bunch of side material - Extreme Programming Explained, Objective-C Programming: The Big Nerd Ranch, and the ever popular Learn You a Haskell For Great Good! are some of the things I played with.
   
   If your curriculum doesn't require but offers a Capstone course, I would highly recommend it. Making a full product from start to finish is an amazing experience and it looks great on a resume.

I would strongly recommend The Ruby Programming Language over the pickaxe book at this stage. For a long time the pickaxe was the definitive book on Ruby so people tend to suggest it out of habit - but in the past year or so this book came out and in my opinion its substantially better. Check out the Amazon reviews if you have any doubts.

Additionally, if you want a fun intro to programming that's short, informative and funny, you can't go wrong with _why's poignant guide to ruby (give it a few pages, but trust me, its awesome.

First time see that site, but I would recommend reading:

• Clean Code: A Handbook of Agile Software Craftsmanship
  
• The Clean Coder: A Code of Conduct for Professional Programmers
  
• The Pragmatic Programmer: From Journeyman to Master
  
• Code Complete: A Practical Handbook of Software Construction
  
• Refactoring: Improving the Design of Existing Code
  
  This is a list of books I am intending to read as soon as I read through some other books.. A list I created from reading this and some other subreddits daily, so probably this should cover all your need on Clean Coding.
  
  If anyone know any more books well worth reading I would be really glad to hear about them!

Invest in Kochan's Programming in Objective-C. One of the best programming books I've ever read.

Then once you have good unserstanding of Objective-C's syntax and data structures, I recommend iOS Programming: The Big Nerd Ranch Guide.

I went from no experience with Objective-C to getting hired as an iPhone programmer in a month and a half reading these books.

After these, when I come across something I don't know how to do, I usually look here first: Ray Wenderlich. Their tutorials are very very current. I go through them just to learn about iOS/Xcode features I didn't even know existed (there are tons!!).

I've tried (sometimes successfully) learning programming languages from free online resources (especially when I can't find good books), but I really think you shouldn't miss out on these. The cost is pretty minimal considering you just bought an Apple computer.

This kind of object oriented programming is pretty different from the web languages you have gone through. I think the first two books should help you get a basic understanding of Model, View, Controller design.

Finally, use a better title when asking for help!

> I'm really only showing them the deep end

Fair enough.

> const correctness has less functional impact on what a program does than functions/arrays/pointers/OOP/many-other-concepts

True, it doesn't affect the behavior of the code. But code that works is not inherently good code. It's hard to write good code in C++ and I see a lot of bad C++ come through r/learnprogramming so I am of the opinion that best practices should be taught early. I can understand your argument with opportunity cost though.

Perhaps it's sufficient to say at the outset "if you don't expect something to change, mark it const; I'll explain further in the future". Then in your lectures you can mention it in passing, e.g. "This function should not modify this parameter so I am making it const". It's easier to remove a too-restrictive const than it is to insert a necessary one later. You can expose them to consistently good const usage before you explain in detail.

> I may ask for your feedback on that lecture specifically when I do it, if you're willing to participate.

Absolutely. Just let me know when.

> Movie editing is the problem

Oh, sorry; I misunderstood. Lightworks seems to be the best free editor comparable to Premiere.

> Any suggestions for good resources

In my opinion, C++ is always best learned from a book. The two that I would recommend right now are C++ Primer 5th ed and The C++ Standard Library 2nd ed. Though you will be able to skip around to the C++11 parts, both would also be good for your students.

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.

Objective-C is a superset of C and so has a C base, although the syntax is different (mostly).
There are a few frameworks in Apple's library which are written in C but you may not need those.

I would recommend you use a game engine to write your game - particularly Cocos-2d, as it makes development quicker and easier.
As a previous poster has mentioned, Ray's website is very good at learning IOS programming and it also has good sections on Cocos-2d.

As for books, I can recommend: (I'm in the UK so I'll use amazon uk links).

http://www.amazon.co.uk/Learning-Cocos2D-Hands--Building-Addison-Wesley/dp/0321735625/ref=sr_1_1?ie=UTF8&qid=1367517122&sr=8-1&keywords=cocos2d (Ray's own book)

http://www.amazon.co.uk/Learn-cocos2d-Game-Development-iOS/dp/143024416X/ref=sr_1_2?ie=UTF8&qid=1367517122&sr=8-2&keywords=cocos2d

Objective-c
http://www.amazon.co.uk/Programming-Objective-C-Automatic-Reference-Developers/dp/0321811909/ref=sr_1_5?s=books&ie=UTF8&qid=1367517200&sr=1-5&keywords=ios+programming

Plus there are LOADS of good tutorials online.

If you want to program in Java, I would also suggest IntelliJ Idea. Community edition^[1] is free. Oracle docs are fine^[2], javadocs^[3] are great and the source is free for OpenJDK and if you want to go pro I highly recommend Effective Java^[4] by Joshua Bloch. There is also Findbugs^[5] which is cool for static analysis and most of the popular IDEs have plugins for it. You should also check Concurrency In Practice^[6] for multithreaded programming. If you are into web programming, I highly suggest Head First Servlets and JSP^[7]. There are also very good libraries such as Google Guava, Apache Commons etc.

1. http://www.jetbrains.com/idea/features/editions_comparison_matrix.html
   
2. http://docs.oracle.com/javase/tutorial/
   
3. http://docs.oracle.com/javase/7/docs/api/
   
4. http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
   
5. http://findbugs.sourceforge.net/
   
6. http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601
   
7. http://www.amazon.com/Head-First-Servlets-JSP-Certified/dp/0596516681
   
   

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

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

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

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

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

Refactoring by Martin Fowler

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

The Pragmatic Programmer by Dave Thomas and Andy Hunt

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

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

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

To be honest, the vast majority of formal education classes (that I am aware of) at most CS universities are completely lacking in this area. Some of the resources available (such as that book I linked), are so much higher quality than you'll get at university, written and refined by some of the best in the field, that your best bet is probably to do a little reading. There are also good & free talks online, such as the ones by Google I/O ones.

Here are a few links I've saved on the subject of architecture and design.

• http://www.reddit.com/r/cscareerquestions/comments/2ath1x/favorite_resources_for_designingstructuring_code/
  
• http://htdp.org/2003-09-26/Book/curriculum-Z-H-2.html
  
• https://www.youtube.com/watch?v=heh4OeB9A-c
  
• http://pluralsight.com/training/Courses/TableOfContents/patterns-library
  
  If you're pursuing Java, I've also heard amazing things about this book:
  
  
• http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
  
  After you start working, you'll likely be continuously self-educating and learning from others on the job, so IMO, why not get paid to learn, rather than paying to learn.

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.
  

I had to learn for a class not but 4 months ago. Here are a few resources that helped me along the way.


Dive into Python is a free book, available in HTML and pdf formats. It can be found here: http://diveintopython.org/

If you don't mind spending some money, Head First Python is a new book in the Head First line, one of my personal favorites for learning a new language. Since it's new, I haven't been able to look at this one in particular, but if it's like their old stuff, it should be great: http://www.amazon.com/Head-First-Python-Paul-Barry/dp/1449382673/ref=sr_1_1?ie=UTF8&qid=1293597744&sr=8-1


For everything else, google is your friend.

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

It depends on taste. If you want the taste of functional while having the comfort of your object oriented world available, I'd recommend Scala, as it lets you do functional stuff while remaining sorta in the Java-sphere. A lot of people just use Scala as "Better Java". For learning Scala, I'd recommend "The Staircase Book" by Martin Odersky (https://www.amazon.com/Programming-Scala-Comprehensive-Step-Step/dp/0981531644). Looking at the cover, you'll probably figure out why it's known by that name.

If you want to properly try on functional programming, I'd go straight for Haskell with the help of a suitable book. Learn You a Haskell for Great Good is available online at http://learnyouahaskell.com/chapters and should work well enough for the purpose.

10000 limit again. Reserving this comment for the Programming section:

PROGRAMMING
Gray Hat Python: Python Programming for Hackers and Reverse Engineers
Beginning Python
The Python Standard Library by Example (Developer's Library)
Shell Scripting
Shell Scripting Recipes: A Problem-Solution Approach
Linux Command Line and Shell Scripting Bible, Second Edition
Wicked Cool Shell Scripts
sed & awk (2nd Edition)
The Ruby Programming Language
Beginning Ruby: From Novice to Professional
Ruby on Rails 3 Tutorial: Learn Rails by Example
Agile Web Development with Rails
Automating Microsoft Windows Server 2008 R2 with Windows PowerShell 2.0
Pragmatic Guide to Subversion
Programming Perl
C++ Primer Plus
The AWK Programming Language thanks sjhill
Modern Perl thanks three18ti
High-Order Perl thanks three18ti
The Art of Scalability thanks mr_chip
Scalability Rules thanks mr_chip
Continuous Delivery thanks mr_chip
The Varnish Book thanks mr_chip

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)

strictly speaking, it depends on the language, but probably you don't understand objects. given that you're in Python and it's got OO (or close enough), I'm going to escalate that from a probably to a very very probably. basically, if you move the stuff inside the ifs into methods on objects, in the absolute simplest case, you'll put each if inside a different object, and then your huge chain of ifs turns into:

object.method(arguments)

And instead of throwing all those ifs in there, you basically run through all the ifs ahead of time by just giving that block of code an object of the appropriate class.

The absolute best book on OO (in my opinion) is Refactoring.

http://www.amazon.com/gp/product/0201485672?ie=UTF8&tag=gilebowk-20&linkCode=xm2&camp=1789&creativeASIN=0201485672

I have a feeling the Head First book on OO is also very, very good. I haven't checked it but the series is a great series.

Code every day. Work on as many little interesting projects as you can. If you don't know any languages I'd suggest starting with Python, there are a million different tutorials and resources online, so getting started shouldn't be a problem.

Add to that, read some books to learn about how software development projects work, different techniques, best practices, pitfalls, etc. Here are my recommendations on books: The Pragmatic Programmer, Refactoring, Code Complete (a bit dated, but still solid), Rapid Development (slightly mis-titled, it's a good overview of different development practices), The Architecture of Open Source Applications, and Design Patterns. Code as much as you can, be ambitious, be analytical and introspective about the problems you run into, and read and understand those books too. There's a lot more you'll need to learn to become a good developer, but what I've described will give you a very strong base to build on.

Oh, and if you don't already know discrete mathematics you'll need to pick that up. I'd recommend this book.

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 don't know what is that book's style but these free programming books/courses will strengthen your knowledge of the basics and introduce you to more complex stuff :

• Introduction to programming in Java by Sedgewick and Wayne
  
• Think Java (pdf file) by Allen B. Downey
  
• Introduction to programming using Java, by David J. Eck, covers file I/O and multithreading.
  
• Data Structures and Algorithms with Object-Oriented Design Patterns in Java. Old, and I didn't read it, but covers advanced computer science subjects.
  
  Best commercial book in my humble opinion is Effective Java by J. Bloch. He wrote parts of the standard library. This book just makes you a better programmer.
  
  Also the most upvoted Java discussions on Stack Overflow will teach you a lot.

I taught myself bits in high school with "C++ for Everyone". Despite its rating, I thought it was good 'cause it has exercises, and I did a lot of them. Works really well for laying foundations. I didn't go through the whole book though, and knowing the language is only part of the battle. You need to know about algorithms and data structures as well. For graphics, trees seem really useful (Binary space partitioning, quadtrees, octrees etc).

After university started, I read parts of "C++ Primer", which was when the language really started making sense to me. You'll get more than enough time to learn the required amount of C++ by next fall, but CG is heavy in math and algorithms. If your CS minor didn't go over them (much), my old algorithms prof wrote a free book specifically for that course.

For using OpenGL, I skimmed the first parts of "OpenGL SuperBible". For general graphics, I've heard good things about "Mathematics for 3D Game Programming and Computer Graphics", and "Real-Time Rendering".

Careful with C++. It may deceptively look like Java, but honestly, trying to write good idiomatic C++ after years of Java took a major paradigm shift

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?

If you're 4 years into your career and you haven't been failing at it and getting fired, you probably don't need to go all the way back to the absolute basics. You just need to fill in holes and keep pace with change.

I like to read books/blogs on emerging technology and areas becoming relevant. Like I just read [Refactoring: Improving the Design of Existing Code] (http://www.amazon.com/gp/product/0201485672) because we were doing a huge refactoring project at my job. I read Ng-book and an .NET MVC right when I got my current job because I'd never worked with angular or MVC before. I'm currently looking at some stuff about .NET Core. It won't be relevant at most places for years, but it's nice to keep on the edge sometimes.

Blogs are also good things to read too. The Morning Brew is my favorite site right now for keeping up with .NET.

If you're worried about your fundamental skills I'd say work through something like codility. I think you'll find a lot of the problems trivial or easy to pick up and do with a little googling. Sites like this are usually the kind of questions you'll get asked in interviews, so if you can do them, then you're fine on that front.

Since you're experienced, the best way to learn Java is to start coding in it. Create a simple blog in Java using basic servlet + JSP hosted in Tomcat + JDBC connection to some free database (Postgresql / H2). You will find issues along the way which you can Google around. The best thing about Java is that most questions already answered in StackOverflow. After you've done with it, go and read Effective Java then refactor your project to follow the best practice mentioned in the book. After that you can try to learn more libraries / framework eg. create a new reporting system and communicate the blog with the reporting system through JMS. Adding dependency injection using Spring and many more.

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.

Awesome book for learning java, Thinking in Java by Bruce Eckel:

https://www.amazon.com/Thinking-Java-4th-Bruce-Eckel/dp/0131872486/ref=sr_1_1?s=books&ie=UTF8&qid=1467806510&sr=1-1&keywords=thinking+in+java

Also, when you are finished with that and you can move in Java rather comfortably, Effective Java by Josh Bloch is very useful:
https://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_1?s=books&ie=UTF8&qid=1467806715&sr=1-1&keywords=Effective+java

If you'd like an online course, Tim Buchalka on Udemy is fantastic (50$ though):
https://www.udemy.com/java-the-complete-java-developer-course/

John Purcell's introduction is also very good:
https://www.udemy.com/java-tutorial/

I wouldn't recommend any websites for C++ because most tutorial authors seem to be stuck in the 90s. Take a look at some good books.

A Tour of C++ is pretty short but gives you a good overview over the language and some STL-features.

Scott Meyers wrote some books about best practices.

If you have a bit more time to spend: C++ Primer 5th edition explains pretty much everything (except concurrency). I read the book (took me a month) and was then able to write solid C++11 code.

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

Ok, let's see. A few quick points:

Rooted in in standard, everyday mathematical notation? public static final volatile interface abstract class transient inner class inner anonymous class objects values boxed values..... etc...

Java Generics has drawn heavily from the functional programming camp which is based on lambda calculus. See google tech talk: Faith, Evolution, and Programming Languages

Extremely easy to read and understand? Go read Java Puzzlers and Effective Java to see how many easy mistakes you can make.

Static types enables blablabla...? Not possible without static typing...? Does he realize that tools like Eclipse grew out of a smalltalk project and that smalltalk pioneered automatic refactoring ages ago? Smalltalk is one of the most dynamic language around, and it's more than 30 years old.

Most bugs are found at development time with java? That's not my experience :-)

Simple puzzle: for which values for someInt does this code fail?
int myPositiveInt = Math.abs(someInt);
assert myPositiveInt >= 0;

Yours is better. You eliminated the temporary variable which is a very good refactor. Performance wise yours is better (for same reason) unless the compiler optimizes away the temp variable, then they are the same.

For some reason code that uses temporary variable like theirs takes me longer to read.

I will recommend the book refactoring by Martin Fowler.

Everyone here is going to give you a bunch of 30-days or head-first books - many of which will have the ostensible impremateur of big names like Crockford and Resig.

Let me be the first to tell you to basically ignore this crap.

Read the standard, get a good reference on browser differences, then focus on real programming books that are not language specific. That's the way to rise above making jQuery plugins and "HTML5 Game Demos" of Atari 2600 games.

The standard:

http://www.ecma-international.org/publications/standards/Ecma-262.htm

Good reference on browser differences:

http://www.quirksmode.org/compatibility.html

The kinds of books you should be reading (notice the used prices please):

http://www.amazon.com/Introduction-Algorithms-CD-Rom-Thomas-Cormen/dp/0072970545/ref=sr_1_1?ie=UTF8&qid=1313160060&sr=8-1

http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043/ref=sr_1_1?ie=UTF8&qid=1313160086&sr=8-1

http://www.amazon.com/Structure-Interpretation-Computer-Programs-Second/dp/0070004846/ref=sr_1_1?ie=UTF8&qid=1313160117&sr=8-1

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1313160130&sr=8-1

http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_1?ie=UTF8&qid=1313160138&sr=8-1

I'd throw in a rickroll if I could.

A deep knowledge of CSS will help. If Javascript is your hammer, CSS is your screwdriver; the two are very related in most cases (sure there are exceptions, like node servers, but they're not common.)

Like JS, the best way to learn CSS is the standard.

http://www.w3.org/TR/CSS21/

Happy hunting.

If you want an excellent whirlwind tour to computer science basics with a language you've probably never heard of, I'd recommend MIT's Structure and Interpretation of Computer Programs course. The video lectures and the course book are available free online. It's pretty tough going but will seriously expand your mind :)

For design stuff I'd recommend reading books about OO testing and refactoring, like this or this.

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.

I'm reminded of this Ira Glass quote:

https://www.goodreads.com/quotes/309485-nobody-tells-this-to-people-who-are-beginners-i-wish

Are you a professional developer? You might talk to your team lead, manager or other senior engineer on your team about making a plan to improve.

> Death by iteration or death by un-maintainability

Learn about refactoring. This is the classic book:

https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672

but it is a common idea now. Test-driven development could help with this.

> perfect response with a great code example way better than I could've done it given weeks or months

The key habit here is to ask yourself, "What would I have had to know to come up with this myself?" and then go learn that and internalize it so if you ever see this problem or a related one again, you can solve it. If you do this consistently, you'll have a powerful bag of tools and be able to solve lots of problems easily that you couldn't before.

Finally, it doesn't sound like you have a formal CS education. You might think of going through some undergrad CS courses online (edX, Coursera, MIT OCW, etc.) It takes long-term persistence that few have the patience for, but if you can make it through, they will transform your understanding of computers and development.

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.

1. storing activity references beyond their lifecycle:
   http://www.curious-creature.org/2008/12/18/avoid-memory-leaks-on-android/
   http://www.androiddesignpatterns.com/2013/04/activitys-threads-memory-leaks.html
   
   
2. Using Hashmaps when SparseArrayMaps would have sufficed
   
3. This is a heated topic, but using enums is apparently costlier than simple static final variables
   
   Less specific resources:
   
   
4. See the android developer performance tips page.
   
5. While the OP asked for Android specific ones, it's important to know the Java related operations too and for that one only has to look at Effective Java - Joshua Bloch - possibly the best book on Java tips.
   
   I vehemently disagree with the internal/getter/setter rules mentioned in android developer tips page. I personally use proguard and don't think twice about virtual setters etc. since they most definitely help with clarity

we worked through some items from Effective Java and Clean Code but that is more of an addition and good to know. The Principles we learned were just worked into the lessons and nothing from books. Here's the list of them so you can take a look at them, Wikipedia should give you more information (I linked them for you). However it is important to not just read them and add a checkmark, some of them really change the way you programm. You can't respect all of them cause some will exlude others. And finally not all are really principles some are more of a guideline.
Start with SOLID:

1. (SRP) single responsibility principle
   
2. (OC-Principle) Open/Close Principle
   
3. (LSP) Liskov substitution principle
   
4. (ISP) Interface segregation principle
   
5. dependency inversion principle
   
6. (DRY) don't repeat yourself
   
7. (CoI) Composition over inheritance
   
8. Effective Java Item 17 Design and document for inheritance or else prohibit it
   
9. Loose coupling
   
10. Test-driven development
    no real Principles from here on:
    
11. differ Information Hiding from encapsulation
    
12. Use speaking names for classes, methods and attributes
    
13. A lot of little units is better then one big (refering to classes)
    
14. Use Interfaces to abstract and decouple
    
    I just checked my notes and here is what I did not mention so far:
    We of course learned the Encapsulation (public, private, protected none). We learned about Collections ((Java Collection Framework) Map, Set, List and the different implementations). Threading, concurrency, Executor, Queue and Dequeue, MVC, Event/Listener Pattern, Exceptionhandling, Comperator, Hash and Equals, Polymorphism, casting.
    
    Please not that we are not professionals on all this we just learned the basics more or less.
    
    Hope this helps

Some book recommendations:

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

"The whole OOP side" is the most important thing for understanding how Rails works. I mean, apart from the object hierarchy, there's nothing to it. Rails is a framework, and you use it just like any other collection of objects.

I am inferring from your reading that you think of OOP as something hard to learn. It's not! It's really simple, though if you're brand new to all of this it may seem like information overload. But really, it's nothing compared to learning Rails.

If you're new to web development, learning Rails is going to be hard. There's a lot to it. In order to really understand Rails you have to understand HTML, CSS, templates and dynamic HTML, probably JavaScript, database access which means probably SQL as well, and any number of other things. The difference between a client and a server. It's not easy.

But that doesn't mean you can't learn it. Hell, every web developer today has been in the situation of feeling overloaded by all the different pieces, and they all got through it. So can you.

But it might be a lot to tackle if you're new to programming (by which I mean you've been coding regularly for less than six months). One thing at a time might be best to prevent burnout.

If you want to learn Ruby, what follows is the sort of advice that everyone gives and everyone ignores, but I'm posting it anyway because I really believe that it's the best thing you can do (it's what I wish I did when I was learning how to program):

Read The Ruby Programming Langage.

It's short.

It's co-written by matz, the creator of Ruby.

It describes everything in the language.

Read it once straight through. Expect to understand about 20% of it. That's okay. There's a lot of stuff like unicode support details that you really don't care about. That's okay too. Skim that. The point is that, after reading it, you will know everything in the language. There will be nothing that you've never heard of.

You probably won't understand the difference between a block and a lambda and a proc after one reading, but you'll know that there are things called blocks/lambdas/procs and they're similar but subtly different and later on when you encounter them in the wild you won't be surprised at their behavior. You'll be able to say "Hey, I know that thing. That's a block." And then you'll be able to google "ruby blocks" and find out more.

Once you've read it, you will have no unknown unknowns. You can go out and code away for a few months, maybe work all the way through Learn Ruby the Hard Way, and later on come back and re-read. This time you'll understand 90-100% of it.

Intimate familiarity with your language of choice is important if you're in this for the long haul.

Edit: I realized that I didn't really answer your question directly: you should learn all of Ruby. It is not as hard as it sounds. Now, you shouldn't necessarily learn all of Ruby and then start learning Rails. You'll be learning a lot of Ruby as you go along, and before too long you'll stop running into new concepts. But never stop improving your Ruby knowledge until you've learned everything there is to know. You'll never know "enough" Ruby until you know it all.

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

Honestly, if I may, suggest that you use C++ Primer as a reference book (not C++ Primer Plus, two different books).

Also, your voice is REALLY quiet in the video. It really needs to be boosted, a lot. If I turn my speakers up to where I can hear you normally, and then start anything else, I'll be blown away.

And I hope that your video is just a "demo" video, because if you start teaching a beginner C++ using structs and functions and console output, you are going to confuse them. You need to start from the beginning.

I would also teach them the basics of the command line and how to invoke the compiler and linker manually, and show them batch files and a super basic makefile. These are things that are very helpful to know and they are always skipped over in tutorials. Here is a makefile that I made that is really simple to use, fairly simple to understand, and has a decent set of features. Feel free to use it or distribute it. https://pastebin.com/qDTM1WNC

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)

Based on my previous experience with Head First books, I'd recommend Head First Python. Out of the three reviews on the main page on Amazon, the bad review is complaining about it not being "deep enough" for an experienced programmer. I have to say, the Head first series is kind of fun. (Geeky jokes, cool exercises, etc).

Python Programming for the Absolute Beginner, 3rd Edition seems to have decent reviews too.

Dive Into Python if I remember correctly assumes a little bit of experience from the reader. But it's a very good book.

I know that you are looking for something structured to pass on... but don't forget that the best thing you can "teach" is how to look things up.

Also, OCW (MIT) has a class on iTunes/YouTube on programming concepts with python. Definitely worth the time investment.

Its good to start with C++ it encompasses all the major programming concepts like pointers,polymorphism,inheritance,Object oriented programming. catch a good book i studied from Robert Lafore.
( http://www.amazon.com/Object-Oriented-Programming-C-4th-Edition/dp/0672323087 ) You can also try the C++ Primer ( http://rads.stackoverflow.com/amzn/click/0321714113 ) which is considered by far the best book for C++ by many programmers it delves deeply through the concepts all the best.

If you want to gain a bit of confidence in writing good Java code i'd start by reading Josh Bloch's Effective Java. It's a fantastic reference manual to have on your desk...

Check it out here

The gold standard in beginner C++ seems to be Lippman, Lajoie, and Moo's C++ Primer, and at < $40 USD on Amazon, why not just pay the money? It is a good book, and if you are serious about learning it, that is a great way to go about it. Plus the money spent might owrk as a little more incentive to actually do it.

I don't know about any good video tutorials, and haven't thought about the medium enough to comment on it. I don't do well with them, and in my experience, they tend not to have a lot of exercises, which will help make you a good programmer.

Programming in Objective-C by Stephan Kochen is an excellent intro/reference with detailed and clear explanation of Objective-C (the language you will be using).

You should also get the Big Nerd Ranch Guide to iOS programming for things specific to the iDevices.

Apple's developer reference/wiki covers everything else and is also pretty detailed. Stanford's iPhone development video lectures are okay, but I can see how they come in handy to someone who is just getting started.

You will need a mac (of course) and Xcode, and if you haven't used that before, you will need to get comfortable with it. You will need Xcode for many of it's features but if you are not a fan of the IDE and wish to use an editor for simpler things, many support Obj-C syntax highlighting.

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

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

I like these and would add:

3) Given how cheap they got lately, I would suggest to use at least two screens for work. More screen real estate equals more efficiency.

4) Master your tools. Memorize the shortcuts your editor provides (or learn Vim :) ), learn to take full advantage of your IDE's debugging capabilities, and so on.


...and regarding this...:
> Design patterns.

Refactoring - Improving the Design of Existing Code is a great book on this topic.