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

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

Job Interview Prep

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

   Junior Software Engineer Reading List
   

   
   

   Read This First
   

   
   

10. Pragmatic Thinking and Learning: Refactor Your Wetware
    
    

    Fundementals
    

    
    

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

    Understanding Professional Software Environments
    

    
    

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

    Mentality
    

    
    

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

    History
    

    
    

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

    Mid Level Software Engineer Reading List
    

    
    

    Read This First
    

    
    

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

    Fundementals
    

    
    

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

    Software Design
    

    
    

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

    Software Engineering Skill Sets
    

    
    

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

    Databases
    

    
    

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

    User Experience
    

    
    

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

    Mentality
    

    
    

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

    History
    

    
    

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

    Specialist Skills
    

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

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

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

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

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

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

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

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

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

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

https://www.amazon.com/gp/aw/d/1449388396/ref=mp_s_a_1_1?ie=UTF8&qid=1472937169&sr=8-1&pi=SY200_QL40&keywords=hackers+levy&dpPl=1&dpID=51Pbo5LEbFL&ref=plSrch

Description
Amazon.com Review
Steven Levy's classic book explains why the misuse of the word "hackers" to describe computer criminals does a terrible disservice to many important shapers of the digital revolution. Levy follows members of an MIT model railroad club--a group of brilliant budding electrical engineers and computer innovators--from the late 1950s to the mid-1980s. These eccentric characters used the term "hack" to describe a clever way of improving the electronic system that ran their massive railroad. And as they started designing clever ways to improve computer systems, "hack" moved over with them. These maverick characters were often fanatics who did not always restrict themselves to the letter of the law and who devoted themselves to what became known as "The Hacker Ethic." The book traces the history of hackers, from finagling access to clunky computer-card-punching machines to uncovering the inner secrets of what would become the Internet. This story of brilliant, eccentric, flawed, and often funny people devoted to their dream of a better world will appeal to a wide audience.
Product Description
This 25th anniversary edition of Steven Levy's classic book traces the exploits of the computer revolution's original hackers -- those brilliant and eccentric nerds from the late 1950s through the early '80s who took risks, bent the rules, and pushed the world in a radical new direction. With updated material from noteworthy hackers such as Bill Gates, Mark Zukerberg, Richard Stallman, and Steve Wozniak, Hackers is a fascinating story that begins in early computer research labs and leads to the first home computers.

Levy profiles the imaginative brainiacs who found clever and unorthodox solutions to computer engineering problems. They had a shared sense of values, known as "the hacker ethic," that still thrives today. Hackers captures a seminal period in recent history when underground activities blazed a trail for today's digital world, from MIT students finagling access to clunky computer-card machines to the DIY culture that spawned the Altair and the Apple II.



Amazon.com Exclusive: The Rant Heard Round the World
By Steven Levy


Author Steven Levy
When I began researching Hackers--so many years ago that it’s scary--I thought I’d largely be chronicling the foibles of a sociologically weird cohort who escaped normal human interaction by retreating to the sterile confines of computers labs. Instead, I discovered a fascinating, funny cohort who wound up transforming human interaction, spreading a culture that affects our views about everything from politics to entertainment to business. The stories of those amazing people and what they did is the backbone of Hackers: Heroes of the Computer Revolution.

But when I revisited the book recently to prepare the 25th Anniversary Edition of my first book, it was clear that I had luckily stumbled on the origin of a computer (and Internet) related controversy that still permeates the digital discussion. Throughout the book I write about something I called The Hacker Ethic, my interpretation of several principles implicitly shared by true hackers, no matter whether they were among the early pioneers from MIT’s Tech Model Railroad Club (the Mesopotamia of hacker culture), the hardware hackers of Silicon Valley’s Homebrew Computer Club (who invented the PC industry), or the slick kid programmers of commercial game software. One of those principles was “Information Should Be Free.” This wasn’t a justification of stealing, but an expression of the yearning to know more so one could hack more. The programs that early MIT hackers wrote for big computers were stored on paper tapes. The hackers would keep the tapes in a drawer by the computer so anyone could run the program, change it, and then cut a new tape for the next person to improve. The idea of ownership was alien.

This idea came under stress with the advent of personal computers. The Homebrew Club was made of fanatic engineers, along with a few social activists who were thrilled at the democratic possibilities of PCs. The first home computer they could get their hands on was 1975’s Altair, which came in a kit that required a fairly hairy assembly process. (Its inventor was Ed Roberts, an underappreciated pioneer who died earlier this year.) No software came with it. So it was a big deal when 19-year-old Harvard undergrad Bill Gates and his partner Paul Allen wrote a BASIC computer language for it. The Homebrew people were delighted with Altair BASIC, but unhappy that Gates and Allen charged real money for it. Some Homebrew people felt that their need for it outweighed their ability to pay. And after one of them got hold of a “borrowed” tape with the program, he showed up at a meeting with a box of copies (because it is so easy to make perfect copies in the digital age), and proceeded to distribute them to anyone who wanted one, gratis.

This didn’t sit well with Bill Gates, who wrote what was to become a famous “Letter to Hobbyists,” basically accusing them of stealing his property. It was the computer-age equivalent to Luther posting the Ninety-Five Theses on the Castle Church. Gate’s complaints would reverberate well into the Internet age, and variations on the controversy persist. Years later, when another undergrad named Shawn Fanning wrote a program called Napster that kicked off massive piracy of song files over the Internet, we saw a bloodier replay of the flap. Today, issues of cost, copying and control still rage--note Viacom’s continuing lawsuit against YouTube and Google. And in my own business—journalism--availability of free news is threatening more traditional, expensive new-gathering. Related issues that also spring from controversies in Hackers are debates over the “walled gardens” of Facebook and Apple’s iPad.

I ended the original Hackers with a portrait of Richard Stallman, an MIT hacker dedicated to the principle of free software. I recently revisited him while gathering new material for the 25th Anniversary Edition of Hackers, he was more hard core than ever. He even eschewed the Open Source movement for being insufficiently noncommercial.

When I spoke to Gates for the update, I asked him about his 1976 letter and the subsequent intellectual property wars. “Don’t call it war,” he said. “Thank God we have an incentive system. Striking the right balance of how this should work, you know, there's going to be tons of exploration.” Then he applied the controversy to my own situation as a journalism. “Things are in a crazy way for music and movies and books,” he said. “Maybe magazine writers will still get paid 20 years from now. Who knows? Maybe you'll have to cut hair during the day and just write articles at night.”

So Amazon.com readers, it’s up to you. Those who have not read Hackers,, have fun and be amazed at the tales of those who changed the world and had a hell of time doing it. Those who have previously read and loved Hackers, replace your beat-up copies, or the ones you loaned out and never got back, with this beautiful 25th Anniversary Edition from O’Reilly with new material about my subsequent visits with Gates, Stallman, and younger hacker figures like Mark Zuckerberg of Facebook. If you don’t I may have to buy a scissors--and the next bad haircut could be yours!
Review
"A remarkable collection of characters . . . courageously exploring mindspace, an inner world where nobody had ever been before." -- The New York Times
About the Author
Levy is a senior writer for Wired. Previously, he was chief technology writer and a senior editor for Newsweek. Levy has written six books and had articles published in Harper's, Macworld, The New York Times Magazine, The New Yorker, Premiere, and Rolling Stone. Steven has won several awards during his 30+ years of writing about technology, including Hackers, which PC Magazine named the best Sci-Tech book written in the last twenty years and, Crypto, which won the grand eBook prize at the 2001 Frankfurt Book festival.
From The Washington Post
"Fascinating . . . A huge job hugely well done."

Programming is a tool. I suggest finding another interest that you can apply it to. Robots, graphics, music, animation, sports, economics -- the possibilities are endless. Pick your favorite area, look at what kind of problems there are in that area that people use programs to solve, figure out how those sorts of programs work, and try to solve some of those problems yourself.

A few interesting examples:

• Project Euler has a set of challenges relating to both math and computer science that will stretch you to learn more about both.
  
• Python Challenge is basically a series of puzzles that challenge you to do new and interesting things with Python. Granted, several of the puzzles are quite similar and some of the libraries they reference are deprecated, but it's a place to start for programming challenges.
  
• Programming Computer Vision With Python talks all about using programs to do things like find objects in pictures and track them even at different sizes and angles. Lots of great examples.
  
• Programming Collective Intelligence talks about putting together data from different sources (primarily websites) and finding patterns. It deals with many machine learning concepts in ways that are practical and interesting. Things like modelling and predicting, optimizing, clustering (finding similarities), searching and ranking, and pattern recognition.
  
• Arduino Robotics describes many robots you can build with relatively common parts that can be programmed using the inexpensive, C-based Arduino microcontroller platform. I've made several of these myself.
  
• Digital Signal Processing is all about writing software that takes advantage of advanced math to manipulate signals in many ways. It's invaluable for audio, but you see it used with graphics, digital communications, and many other areas.
  
• There is a subset of sports fans that really enjoy statistics and software can be very valuable for them. Things like comparing players across eras, predicting future performance, and helping to find high-value players. The general field is called Sabremetrics. I looked deep into it in relation to major league baseball. Two books that I found valuable are The Book: Playing the Percentages in Baseball and Baseball Between the Numbers.
  
• Programmable games are cool too. Things like CROBOTS, CoreWar, RoboWar, and Robot Game. It's just as fun building the simulation environment as it is building the bots that compete within them.
  
• Pick up any book on algorithms. Learn to apply the basics like binary search, insertion sort, radix sort, memoization and linear programming, Dijkstra's algorithm, and Newton's method for root finding.
  
• Grab another book on data structures. Make sure you understand the differences between arrays, linked lists, hash tables, and trees. Learn about unique and useful things like binary trees, radix trees, heaps, and queues.
  
• Learn how to write better code. I recommend books like Code Complete and The Pragmatic Programmer.
  
  Whatever you do, as you clearly pointed out, you have to be interested in it or you'll grow bored and give up. Find something that is interesting to you and pursue it as wide and deep as you can.

While being a self taught sys admin is great, learning the internals of how things work can really extend your knowledge beyond what you may have considered possible. This starts to get more into the CS portion of things, but who cares. It's still great stuff to know, and if you know this you will really be set apart. Im not sure if it will help you directly as a sys admin, but may quench your thirst. Im both a programmer and unix admin, so I tend to like both. I own or have owned most of these and enjoy them greatly. You may also consider renting them or just downloading them. I can say that knowing how thing operate internally is great, it fills in a lot of holes.

OS Internals

While you obviously are successful at the running and maintaining of unix like systems. How much do you know about their internal functions? While reading source code is the best method, some great books will save you many hours of time and will be a bit more enjoyable. These books are Amazing
The Design and Implementation of the FreeBSD Operating System

Linux Kernel Development
Advanced Programming in the UNIX Environment

Networking

Learning the actual function of networking at the code level is really interesting. Theres a whole other world below implementation. You likely know a lot of this.
Computer Networks

TCP/IP Illustrated, Vol. 1: The Protocols

Unix Network Programming, Volume 1: The Sockets Networking API

Compilers/Low Level computer Function

Knowing how a computer actually works, from electricity, to EE principles , through assembly to compilers may also interest you.
Code: The Hidden Language of Computer Hardware and Software

Computer Systems: A Programmer's Perspective

Compilers: Principles, Techniques, and Tools

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

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

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

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

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

Heh, sure.

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

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

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

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

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

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

Good luck!

I'm going to go against the grain here with my recommendation. I'm a guy who was in a similar position years ago. I've since transitioned from web development to game programming and have working knowledge of 7+ languages.

Dude, don't sweat these feelings you're having. You're just at a wall. We all reach different kinds of walls in this career and they're really the best thing ever. It means you're about to jump ahead in skill by at least 10x. You just got to find the trigger for it. Be patient and try different things. Go check out Udacity and do some courses on there. Also this is the time to start reading books. Not just any cheap book you find. Good books that will give you the perspective of an industry professional. Books like JavaScript: The Good Parts, Code Complete, The Pragmatic Programmer, or The Little Schemer. Also it doesn't matter what language the books are in to enjoy it. 98% of all programming languages are the same anyways, which you'll soon learn. For the most part, they just have moderately different ways and syntax to do the same thing.

I would recommend not switching platforms from the web. One of the most important skills guys like us can have is seeing where technology is heading and betting on the right horse. It's very clear that webapps are going to be even more important in the future. You can already make desktop apps with web technology naively in pretty much all major OSs now.

I say learn JavaScript front and back. Read JavaScript: The Good Parts and JavaScript: The Definitive Guide cover to cover. Once you learn JavaScript it'll be very easy to transition to any C-based language, which is most of them. In fact I credit JavasScript for giving me the basics to jump to just about any language comfortably and pick it up in a few weeks.

After that, learn a good server side language like Java, Python, or C#. (C# is in very high demand, and has many applications) Or learn all three and you'll be very well positioned career wise. Well, make sure to get some experience with SQL too for good measure.

Also if you want to have a good challenge instead of being bored on those easy things, like drawing shapes, why don't you try Udacity's fine WebGL course? Jumping in the deep end isn't bad as long as you don't expect it to be easy.

One of the biggest issues I see with some of the dev's I work with is that they easily get lost in their work. We refer to it as shaving a Yak. Let's say you need to go pick up some milk at the store, but before that you need to fill up your gas tank. But before that you need to change the oil in the car. But before that you need to help your parent access their email. The next thing you know you're in your living room shaving a Yak asking yourself how you got into this situation. All you wanted to do was get some milk.

You would be better off identifying the core features of your project and concentrating on them, one at a time. What are these core features, what is the value of this feature, and what is the minimum amount that would satisfy that feature. If you're creating a car, you would need a motor to drive the wheels, but a a motor has nothing to do with how to steer a car. You've identified two separate features, one for the motor and one for the steering. I'm not talking about sitting down and writing out full specs and requirements. Just get a basic idea of what are the different parts of what you are building. You'll miss some but that's ok. Find a few features, pick one, and start.

Stay focused on that feature. Hack it together, make it work. But make sure that what you're hacking together is only for that feature. The code you're writing at the time should be responsible for solving that feature, alone. Even if you think that what you're creating can be used for another feature, or that you're repeating something that you made earlier, or you've discovered some new feature that you missed initially (and you will), ignore the impulse to optimize or start adding new features in the middle of your task, you will come back to it later. Just make sure you make notes about those things discovered.

When you're code does what it is supposed to and you've proven it with unit tests (you do have unit test right?), then you can start refactoring. Clean it up, move it around, optimize it, look for areas that a design pattern can fix. Give it a good S.O.L.I.D. overview (if you're working in an OOP language). As long as you have unit tests covering the core responsibilities of your features, you can make changes with confidence.

Once you're satisfied, you can move on to the next feature and repeat. As you complete more features, you can re-address some of the completed code during subsequent refactors. Working like this will ensure that
a) your code works as intended because you've proven it with unit tests
b) your code will be loosely coupled because you were forced to work on a single responsibility at a time.

Refactoring is probably the main take away. But being able to pick specific milestones along the way is important. If you leave it all up to the last minute, it will be easy to get overwhelmed.

So book recommendations:
Martin Fowler's Refactor - https://martinfowler.com/books/refactoring.html
Uncle Bob's Clean Code - https://www.oreilly.com/library/view/clean-code/9780134661742/
Steve McConnell's Code Complete - https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

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

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

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

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

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

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

Things that helped me:

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

It's never too late, I too started when I was 27. My advice is to meet others, both starting out like you are and very experienced. Also reach out to companies you like, Ruby/Rails speakers, even DHH answers emails he gets. But don't go for the bootcamps. They cost an arm and a leg, don't teach you anything you can't learn by yourself and are very demanding (i.e. 60h/week).

A bit about me, to show you it's perfectly possible to get where you want to be:


I had some basic knowledge like you did but was very much outdated on most stuff web (last time I did HTML was when tables were a good way of laying your page out...)

I had 4 months where I couldn't work so I decided to put this time towards turning my life around and getting proficient enough to get paid to write webapps.

I started with M. Hartl's tutorial and this book: http://www.amazon.com/Agile-Development-Rails-Facets-Ruby/dp/1937785564/ but I was quickly overwhelmed.

So I took a step back and spent some time to learn Ruby first with rubymonk, the Ruby Koans and by asking a lot of questions on #ruby @ freenode. The people there were very helpful and I found this IRC channel to be crucial in my learning.

At the same time, I was getting up to speed on CSS and HTML with treehouse. Although their acting is a bit annoying at times because you feel a bit like a child and the things they teach are a bit outdated, you still can get a solid grasp on CSS and HTML in a few weeks.

Then I tried diving into Rails again. And again, it was too much. I was getting frustrated because a lot of things in Rails are automagical and you don't really understand where they come from.

I was fortunate enough to have a very active Ruby/Rails meetup group in my city. It took a few missed meetups to build up the courage to finally show up. There, I discovered that they were planning to run a railsbridge event where, for one weekend, volunteers assemble classes of about 10 persons and teach you Rails. There were 3 levels, complete beginner, intermediate and advanced. I took the intermediate class (which was actually an intro to Rails) and it gave me enough ammo to finally get on with M. Hartl's tutorial.

Over that weekend, I also met another guy who was also getting started with Rails. We eventually did the edX course together: https://www.edx.org/course/engineering-software-service-uc-berkeleyx-cs169-1x, helping each other out and doing the required "homework" together. Railscasts were also helpful. It hasn't been updated in a very long time now and probably won't be ever again but some of the stuff is still very relevant. The pause button is very helpful because Ryan explains quite a lot of stuff over a short period of time.

By going regularly to the meetup, I also befriended much more senior devs who I could come up to with questions. One of them knew of a junior position at a startup that needed to be filled and asked me if I was interested. And this is how I got my first paid job as a developer.

The takeaway is this: don't hesitate to reach out. Most people in this field love what they are doing and are very happy to give you some of their time either by giving advice, recommending you for a job etc. The key is motivation. If you can put 4-5 hours a day for the next 6 months, you can definitely get to a point where you have enough knowledge to be a junior dev. Don't forget to build things in the process and put them on Github.

Good luck!

so everyone seems to be giving some good but general answers so here's a few specifics. They'll be most useful for learning unix but will also give you a good overview for any administration.

The Design of the UNIX Operating System
http://www.amazon.com/Design-Operating-System-Prentice-Hall-Software/dp/0132017997/ref=sr_1_1?ie=UTF8&qid=1344385714&sr=8-1&keywords=the+design+of+the+unix+operating+system
Very good book to understand how a kernel works and interacts with different functionality of an operating system.


TCP/IP Illustrated
http://www.amazon.com/TCP-Illustrated-Vol-Addison-Wesley-Professional/dp/0201633469/ref=sr_1_1?s=books&ie=UTF8&qid=1344385781&sr=1-1&keywords=tcp+ip+illustrated
Basically the bible of anything tcp/ip related. Volume 1 is the most important. Volume 2 and 3 are good as well but require knowing some calculus.

Really anything by W. Richard Stevens is great, though some of it is more on the programming side
http://www.amazon.com/W.-Richard-Stevens/e/B000AP9GV4/ref=ntt_athr_dp_pel_1

Then there's the man pages.
Go into /bin/, /sbin, /usr/bin/ and /usr/sbin/ and just read the man page for every command.

If you want to learn how mail works, learn how (buy books or whatever you can find online) the protocols work not the applications. So learn how smtp, pop3, imap all work. Read what you can find, read RFCs for the protocols, etc. Then once you know how the protocols work you can read how an application like sendmail or qmail works. Books by oreilly are usually pretty good for this as well.

Set up linux systems, slackware is a great distro to learn linux from, and just setting up things like a lamp server, mail server, etc. Don't install applications from a repository, compile applications when you want to install them.

If you search my comments far enough back (maybe a month?) I posted something for someone asking a similar question and went into a lot more depth and a lot more chronological of what to do to become a unix sys admin.

edit: oh the two most important things about being a sysadmin.

• It's not about how much you know, it's about how fast you can figure out what you need to know.
  
• A good sysadmin has automated everything. Sysadmins are inherently lazy and hate to have to do anything twice.

You may want to narrow that down a bit, but okay, here are some highlights, with amazon links to help disambiguate.

• Game Programming Gems series -- (8 books currently) Lots of snippets and articles contributed from developers across the game industry.
  http://www.amazon.com/Game-Programming-Gems-Adam-Lake/dp/1584507020/
  
  
  
• Game Engine Architecture by Jason Gregory -- Great intro to the details of how game engines are built. It's a good balance for detail and readability for a beginner. Even for someone just using engines such as UDK or Unity3d I would recommend this to understand what is going on under the hood.
  www.amazon.com/Game-Engine-Architecture-Jason-Gregory/dp/1568814135/
  
  
  
• 3D Game Engine Design -- More technical and detailed descripting of designing and developing a game engine, but not as noob friendly as Game Engine Architecture
  http://www.amazon.com/Game-Engine-Design-Second-Edition/dp/0122290631/
  
  
  
• 3D Game Engine Architecture -- Follow up to 3D Game Engine Design that goes in to lower level detail and general updates.
  http://www.amazon.com/Game-Engine-Architecture-Engineering-Applications/dp/012229064X/
  
  
  
• Artificial Intelligence for Games by Millington / Funge -- I believe this is the current "must read" for game AI. The only book I've seen that goes in to Behavior Trees and other modern concepts.
  http://www.amazon.com/Artificial-Intelligence-Games-Second-Edition/dp/0123747317/
  
  
  
• AI Programming Wisdom series -- 4 books, like Game Programming Gems but for AI. Not a must have but I'd recommend them. They seem to be out of print though, so good luck finding them.
  http://www.amazon.com/AI-Game-Programming-Wisdom-CD-ROM/dp/1584500778/
  
  
  
• Real Time Rendering -- One of the better books on rendering. I'm not a big render guy but this is the book that everyone recommends to me.
  http://www.amazon.com/Real-Time-Rendering-Third-Edition-Akenine-Moller/
  
  
  
• Real Time Cameras -- THE book on how to implement cameras well, written by THE guy when it comes to video game camera systems.
  http://www.amazon.com/Real-Time-Cameras-Mark-Haigh-Hutchinson/dp/0123116341/
  
  
  
• Code Complete -- The only book not game related I'm listing, it's basic stuff to help you learn to write better code. There are parts that I (and many others) disagree with but in general it's a lot of good advice.
  http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/
  
  
  There are many others, but looking at my shelf these are the big ones that stick out for recommendations.

For more foundational stuff, I'd look at:

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

Well, most of them you will find are just like the one you have very heavy reading and slow. If you are a real glutton for punishment, the real meat of everything is spelled out in the RFC's(Request for Comments). This one is pretty short and to the point, if you can understand it, it will help you understand most other networking jargon:

-----
http://www.ietf.org/rfc/rfc1180.txt

it is described thusly:

1. Introduction
   
   This tutorial contains only one view of the salient points of TCP/IP,
   and therefore it is the "bare bones" of TCP/IP technology.
   
   ------
   
   So, its just the nitty gritty, but most times, I find that is the best place to get started. Some of the things you will want to learn/study are the different networking layers specifcally layer2(switched/VLAN) and layer3(routed) networking. You will want to learn about SNMP and ARP as they are both very important to networking and network management. If you are interested in the nitty gritty details of how packets get pushed around the network, you will want to learn about some of the dynamic routing procotols used, such as BGP, OSPF, EIGRP, and RIP. There are others as well, but these will definitely get you started.
   
   My suggestion is this, if you can, study the RFC"s as they will give you a nuts and bolts understanding of what needs to happen. That will soften the blow going into any networking books you might run into. If you are specifically looking for networking books, you can almost never go wrong with O'reilly books. However, I always poke around on Amazon reviews before buying a book as if there is a better book, it will often be mentioned.
   
   Here are a few that adorn my bookshelf:
   
   http://www.amazon.com/TCP-Illustrated-Vol-Addison-Wesley-Professional/dp/0201633469
   
   being that I am in network mgmt, SNMP is crucial, here are some good ones:
   
   http://www.amazon.com/Practical-Guide-Snmpv3-Network-Management/dp/0130214531/ref=sr_1_6?s=books&ie=UTF8&qid=1322060915&sr=1-6
   
   http://www.amazon.com/SNMP-Management-Sidnie-M-Feit/dp/0070203598/ref=sr_1_5?s=books&ie=UTF8&qid=1322060915&sr=1-5
   
   and for the true masochist:
   
   http://www.amazon.com/Understanding-SNMP-MIBs-David-Perkins/dp/0134377087/ref=sr_1_4?s=books&ie=UTF8&qid=1322060915&sr=1-4
   
   for the routing protocols:
   
   http://www.amazon.com/Networking-2nd-Jeffrey-S-Beasley/dp/0131358383/ref=sr_1_11?s=books&ie=UTF8&qid=1322061108&sr=1-11
   
   Let me know if you have any specific questions and I will see if I can point you in the right direction! Good luck.
   

I just graduated with a CS degree, but here are some resources that I found useful:

• I'm currently reading this book. It's commonly recommended and I now know why. Great resource for building a solid foundation of SE knowledge.
  
  
• Algorithms are always important. This class and lecture series, along with the recommended text book for the class are really well done. I own the text, it was well worth the money for me. There are other free algorithms classes (i.e. Coursera), but I found these lecture to be the best, YMMV.
  
  
• Lastly, this is the class that goes along with the SICP book mentioned previously.
  
  I learn best by incorporating a variety of mediums - watching video/lecture, reading books, doing examples by hand/programming. I recommend looking at some of the Coursera classes, other classes on the MIT open courseware, edX, or Udacity.
  
  

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.

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

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

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

I've been coding for a few years and for a while was just focused on getting things to work.  Now I'm at a point where I know I'll figure out any given problem with my accumulated knowledge and/or additional research, and I'm noticing that not planning ahead is the most significant (lack of) action that will set me back at this stage in my practice.

 
To remedy this, I've been looking into architectural patterns (MVC, MVP, MVVM, etc.), and UML diagramming.
 

-----

 
Architectural patterns were initially difficult to grasp, as many of the explanations available online dig into topics that might not make sense yet if you are inexperienced with architecture.  The MVC Java Tutorial by Derek Banas is the best introductory explanation of architectural patterns that I've come across (he also has some great videos on design patterns & other topics).
 
Some books that cover code structure & architecture in more detail:

• Clean Code: A Handbook of Agile Software Craftsmanship
  
  
• Code Complete: A Practical Handbook of Software Construction
  
   
  The author of Clean Code, Bob Martin, has a ton of talks that are a great source of info, and has also produced the CleanCoders series.
   
  
  -----
  
   
  Also check out some Software UML Examples.  I find that mapping out an overhead view of your project before starting to code gives you a chance to make sure the majority of relationships, life-cycles, and high-level details are planned out correctly from the start.  You'll still have to make inevitable adjustments while coding, but it's much more efficient than figuring it all out from the inside while you're building it.
   
  yEd Graph Editor is a good freeware option for creating UML diagrams.
   
  If you find that you really like the UML approach, check out Enterprise Architect.  It's definitely worth picking up since it allows you to generate file structures from your UML diagrams, with all of the boilerplate filled out already (class/method/variable definitions, etc.).
   
  
  -----
  
   
  Also related, SourceMaking has some good wikis on:
  
  
• Design Patterns
  
  
• Refactoring
  
  
• Anti-Patterns
  
  
• UML
  
   
  (Although their UML material is pretty in-depth and may be overkill if you just want to use UML as a quick way to plan out code.  But it's legit if you want to go all-out UML mode)

Do you have an academic adviser in the department or a professor you are friendly with? They could be a great resource. If you get your hands on the textbook / slides / notes from the better taught classes through a professor or student, that could help quite a bit.

You can also try the websites of some of the big name CS departments, there may be some openly available projects, slides, or notes.

It may suck, but books can actually be a fantastic resource.

This book isn't bad for algorithms and such, and you can pick up c++ with it too.

http://www.amazon.com/Data-Structures-Algorithm-Analysis-Edition/dp/032144146X

The price is pretty nasty though, maybe you can get it at your library.

I've had employers rave about this one:

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

But I have to be honest, I haven't checked it out myself.

Here is an OOP and design pattern one:

http://www.amazon.com/books/dp/0471744875

Google is also your friend and there are many great wiki pages on software engineering related topics.

Your college is a great resource, use the TAs, professors, lab and library to their fullest. You can get a lot of material very quickly there.

Hope this helps, sorry I didn't have any direct links to sites for you.

Hey man. Good to hear that you are interested in programming. :)

I don't think "books" is a good suggestions. There is a lot to read and not a lot of time in the world. Plus, programming tends to be more fun.

That being said, however, I am going to go ahead and recommend reading Code Complete. I think that book should be required reading for every programmer. You will learn a lot and it is also a fairly amusing / interesting read.

I would also like to suggest that you use StackOverflow and follow interesting conversations in it. One of the tricks to programming is to become very engrossed in it. Find things you find interesting and read/learn just for the sake of it. If you think you know language 'X' well -- go to StackOverflow, sort by votes, filter by tag and tag the language you want to read about. I guarantee you will find a lot of "Woah, I did not know language 'X' could do that."

One last thing w.r.t all the 'what languages should I learn' hullabaloo. Start a little higher level. It sounds like you want to learn an Object-Oriented language. Do you know what your other options are?

http://en.wikipedia.org/wiki/Comparison_of_programming_paradigms#Main_paradigm_approaches

There's a quick overview of the different 'types' you'd expect to see. OO is a clear one, especially for industry development, but functional languages and others may also end up being used for your job. :)

EDIT: A little more on topic. I started with C++ in school. Some concepts were difficult -- pointers, references/pass-by-reference/de-referencing, and to a lesser extent garbage collection / memory allocation.

The main argument for learning C++ first is that it gives you good fundamentals. Every programmer should know what a pointer is. And a double pointer, for that matter! The main argument against learning C++ is that you can blow your foot off much easier than in Python. And that's no fun. And if you're the type of person who isn't ...tenacious enough to try and repair your own blown off foot -- perhaps a higher-level language would be a better choice. In this way you can become more accustom to the frustrations of coding (and how to cope) before introducing more complex issues.

That isn't to say you can't create just as large a clusterfuck with Python. You can. It has its own nuances. It's just that the library support (code already written for you) is going to be more extensive. A good comparison would be driving an old car vs a new car. The engine is harder to repair in the new car (can't get at the parts), runs better, but you don't get a feel for whats in the engine. Its more of a black box. That old '57 Chevy (C++) has its engine laid bare (not as much as C), but if you're no mechanic you might break your car and abandon it.

Just do what you find fun! You're still young :)

Are you thinking about this in the context of a particular language or framework? Sometimes that will help steer you as to how you might organize your code on a high level. For example, the Model-View-Controller paradigm is implemented on an api level in Ruby on Rails, and you'll also find it in practice if you build an iOS app.

If I'm working on something that doesn't rigidly dictate architecture, I still like to frame the project with MVC in mind. That means you're going to have classes that make up your data layer, your controller-like classes that implement business logic, and some classes that represent visual representation. Sometimes your views may not be code at all, and it's some type of markup like HTML or XML.
I'm linking this since I'm using it myself as I learn a new web framework, Express. Express isn't very opinionated with how you organize your projects, but I think Peter gives a pretty good explanation as to how to do it with Express, and it could be extrapolated to fit other projects:
https://github.com/focusaurus/express_code_structure

For an example of a mature, larger project, Discourse is an open-source web forum. I particularly like how code is organized in this project.
https://github.com/discourse/discourse/tree/master/app

Lastly, if you're interested in a book, look no further than Code Complete. Probably my all time favorite, I make a point to try to re-read parts of it every year. It's a book about code construction, and offers invaluable insight as to how you should strive to organize your code, and more importantly, why you should organize it that way.

EDIT: I should mention I'm speaking with Object Oriented Programming in mind. Of course, if you're using something procedural like C, it's a fundamentally different programming model with routines and functions operating on and transforming data structures. Systems programming, something like a driver, is going to be organized differently. Again, the answer is somewhat domain specific.

Speaking as someone who was great at reading but bad at retaining, learned to retain while in college getting a liberal arts degree, and has been reasonably successful at teaching himself programming languages since graduating...

Read things twice. Not necessarily the whole book, but for each paragraph you come across, think about what it's saying. If it is introducing something new, then read it a second time.

Read things out loud. Not even stuff you're trying to learn, and not necessarily to an audience. But (if you're taking my advice about reading things twice) do your second go-through out loud. You'll find that often your intonation is wrong - you didn't catch that something was a question, or you thought you were on the last clause of a sentence but you were wrong. Dedicate some small part of your brain to listening as you read out loud, and fixing these problems. This will help you get the structure of a thing - which parts are introductory, cursory, or parenthetical, and thus can be skipped over; which parts are REALLY IMPORTANT, which parts are actually pretty damn funny but you missed the joke the first time...

Don't just read. Explain to people what you're reading. My housemates and girlfriend have probably sponged half the stuff I've taught myself (about programming, musical instruments, bicycles, pretty much anything I've decided to learn about) because I'm constantly asking if they mind if I explain a concept to them. It helps that we're all young, intelligent, curious people.

Have a conversation with the book. When you come across something that seems wrong, don't just plow through - see if you can figure out why it just said what it did. Maybe you read it wrong. Maybe you misunderstood an earlier concept. Maybe you thought the dude was speaking when it was the lady. The point is that after that initial moment of confusion, you'll have a moment when it Suddenly Makes Sense - cultivate your enjoyment of that moment. It's one of the greatest pleasures of reading.

Do the stuff you're reading about. In the case of programming, do the exercises. If you're reading a book about a foreign language, acclimate yourself to the rules of pronunciation. In a work of fiction, hand the part of you that experiences emotions over to the author and let him or her shove you around to whatever he or she wants. If there's a math concept that doesn't quite make sense, pull it up on Wikipedia and read the links that describe any of the fundamental elements that you're missing.

If you want to get into programming, read one of the Head First books. They talk a lot about effective ways to learn things, in addition to putting those principles into practice in how they teach programming. This book started me on my current routine of reading a chapter of (whatever computer book, currently Code Complete) when I first wake up in the morning.

Apologies for the wall of text, I hope that was helpful. I'll edit to add anything that I think of.

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

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

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

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

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

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

Honestly, I would say you are already qualified. I work in this field. I have my MS in Applied Math, was a ML research assistant in grad school, and have a couple years of experience in software engineering.

Software engineering skills are pretty much the only thing that you may lack you would want to work on, however a lot of that you can learn on the job.

A company would probably let your inexperience in software engineering slide because you are very strong on the data analysis / ML side and you have demonstrated you know how to code. The main thing you need to do is work WITH software engineers on integrating your work with a product.

Some skills/technologies you may want to know about that haven't been mentioned as far as I know :

1. SQL -> e.g. MySQL, Transact-SQL
   
   
2. Java -> Hadoop is written in Java
   
   
3. If you end up working at a web company, PHP/Javascript/HTML are useful to know.
   
   
4. Of course, Linux/Unix command line. Very important.
   
   
5. Python -> You mentioned it but I'd say start using it more. Check out iPython Notebook as that might be something that catches your interest.
   
   >edit: Thanks a ton for the advice so far, the consensus seems to be start learning how to deal with big data using Hadoop or some other similar app and learn some software engineering, however that part seems a little ambiguous still.
   
   Learning software engineering is basically learning best practices and design patterns. The goal is to make clean code and avoid hard to find/fix bugs as well as to use the best design paradigm for your problem. "Clean code" means "readable" and "maintainable". Readable code is code that any other software engineer who has never seen it before can pick up and understand reasonably quickly. Maintainable code is code that is relatively easy to refactor, make changes to, add features, and fix bugs within. "Clean" code saves a lot of man hours down the road.
   
   For an example of software design, in programming a video game OOP class inheritance isn't always the best thing to use because it can lead to a confusing, non-intuitive tree of classes. Someone invented the "component entity system" to address the problem.
   
   Read about this, as it's a fairly intuitive example of "Software design", i.e. using the best approach for a particular problem.
   
   Writing clean, well-designed code comes with experience, but there are some books on it.

Not all programming books are tutorials. There are definitely books that exist which talk about concepts and ideas, ways of thinking.

A udemy course, YouTube video medium article, or any other typical internet resource are great sets of instructions but there's more to it than that.

I was recently recommended Code Complete which i think will have a great impact for myself, despite the fact that it's moreso a textbook.

I also believe books like Eloquent JS are amazing. I would consider it the lighter side of books but is amazing for new devs.

I get where you're coming from but don't discount books entirely! There's a lot of great knowledge out there.

I don't know if there is a rails for node developers but they definitely come from two different perspectives on application development. Having written apps in both ecosystems I can say you'll be hard pressed to write an app faster with any framework other than rails, that being said it is convention over configuration and you need to do things the rails way to get results. If your looking for a starting place, there is a book called Agile Web Development with Rails 4 ( link: http://www.amazon.com/gp/product/1937785564 ). Its written in part by one of the inventors of the framework and is definitely worth the read. If your more familiar with NoSql I'd also recommend checking out mongoid, its an ORM for MongoDB and RoR and its pretty robust.

EDIT: While ruby and javascript have similar syntax ( if you can look past the curly braces and semi-colons ), learning about using ruby before starting with rails will be very helpful. Ruby is a wonderful language with a relatively easy learning curve but it does have its own idoms and caveats that are unique to it.

Code Complete.

The fantastic blog Coding Horror (written by one of the founders of StackOverflow) has this to say about it:

> Steve McConnell's Code Complete 2 is the Joy of Cooking for software developers. Reading it means that you enjoy your work, you're serious about what you do, and you want to keep improving. ... Do yourself a favor. Make this the first book you read, and the first book you recommend to your fellow developers.

This book has made balloonanimalfarm a much better programmer. It will save you time by making your designs better at the start of the project, helping you do good defensive programming so bugs come out right away, refactor well when the project becomes too big, choose the right scale of algorithms for your project, and make high quality software.

Hello! I had this exact problem, plenty of syntax books etc but I wanted to know why things were being done the way they were being done. So I asked my CS lecturer. He recommended Code complete. http://www.amazon.co.uk/Code-Complete-Practical-Handbook-Construction/dp/0735619670
Its a fantastic book and I found when reading a section that I found interesting it would have side notes recommending other pages that expand on that particular topic in greater detail. Which is awesome, best money I've spent on a book since Harry potter and the philosophers stone ;)

Long post ahead.

LEARN YOUR OSI LAYERS. Learn what's at Layer 2 (Ethernet), Layer 3 (IP), and Layer 4 (TCP/UDP/etc.)

I feel like throwing in the beej bible is necessary here (even if you never want to learn how to do network programming; it's still interesting, i.e. how the kernel opens a socket, translates network addresses, etc.): http://beej.us/guide/bgnet/. This is what I used in my Network Programming course 5+ years ago; still relevant today.

Then there's also the classic W. Richard Stevens tome: TCP/IP Illustrated: here. It's dated as fuck (telnet and rlogin were still prevalent and it still discusses classful routing (Class A, Class B, Class C) which hasn't been relevant for at least 20 years) though it does talk about CIDR which is current) but it's the most comprehensive explanation of how TCP/IP works there is. It does a GREAT job explaining how TCP and UDP work; TCP is a challenging protocol to really understand. It also goes into other application-layer protocols like DNS and HTTP but not in depth (and not relevant to the question at hand). It doesn't discuss IPv6 unfortunately (it's referred to as IPng, which is what it was called back in '94).

There's an updated version of this book that's been edited by a CCIE somewhere; I haven't been able to find it but it's quite good. I heard some of the edits are inaccurate, though.

Then there's the tcpdump manpage and tutorial to teach you how to inspect packets; you'll NEED to know how to do this. (Lots of folks like to use wireshark in the first instance but it's not on every box whereas tcpdump almost certainly is; the biggest differences lie in the filtering language)

More specific to #devopslife are software-defined "cloudy" routers like Neutron, Hyper-Vswitch (if on a Hyper-V virtualization backbone, I believe Azure uses them as well) and OpenVSwitch (from which Neutron descends). Neutron docs here.

Most CCNA material descends from these resources. CCNP and higher cover more specific details that you probably won't care too much about unless you really want to get into networking (which is a career in its own right, networking is HARD)

Unfortunately, if you spend a lot of time on cloud infrastructure, you won't deal with networking too much as an admin unless you get into tweaking kernel parameters or troubleshooting the (very) rare network-fucked-up occasion. Still good knowledge to have though.

You'll pass a Google SRE interview (in networking) if you read these; almost guaranteed.

I highly recommend Masters of Doom, it covers the story of John Carmack and John Romero from their pre-id years up until around 2002 or so and goes over the development of early id games like Commander Keen, Wolfenstein 3D, Doom and Quake as well as other companies at the time like Apogee/3D Realms and Softdisk and of course Ion Storm, Daikatana and the issues with its development.

If you find that interesting i also recommend Jordan Mechner's Making of Karateka and Making of Prince of Persia. These are unique in that they are the journal that Jordan Mechner kept while making these games (start with the Karateka one, the PoP one continues more or less where the Karateka one ends) back in the 80s and early 90s up until he started working on The Last Express and give a unique look not only at how development was done at the time, but also how a very known at the time publisher - Brøderbund - was running during their later years (which sadly ended up collapsing in the midlate 90s just when The Last Express was released, which ended up with TLE becoming a commercial failure despite the critical praise it had, in large part because the marketing team left the company weeks before the game's release and nobody was around to market it :-P). Also there are several bits about Mechner's attempts on movie writing since that is another passion of his, although that wasn't as successful (he did write the Prince of Persia movie though and was a moderate success).

Another interesting book is Hackers. This is an older book, written in early 80s about the "computer hackers" that influenced modern computing. A large part of the book is about the earlier communities, like those at MIT from where the free software and open source movement began, but there is also a sizeable part about the early days of gaming companies that would later become powerhouses like Sierra and - again - Brøderbund. This last one is very interesting because you can see the shift from the early Brøderbund days in Hackers towards the more boureaucratic and sterile environment in their later days as shown in Mechner's journals. This also makes me curious about their last days and i'd like to see Mechner writing about the development of The Last Express if for no other reason than that.

Finally a book that i also liked a lot, although this one focuses more on a single genre and the games that make it up, is Dungeons and Desktops which focuses on the development of CRPGs from the early attempts at mainframes down to modern RPG games.

Computer and computer gaming history are favorite topics of mine and i tend to buy books about them (and i really like finding common pieces in different books).

A fine idea, Bruce.

It's nice to know that there is still some interest in books, especially among incarcerated community pillars and narcissistic spectres of Silk Road. The fact that you've cleverly referenced both Herman Melville and J.D. Salinger this evening doesn't at all surprise me, given what I know about you; however, it never ceases to amaze me, just a little bit, to find that there are still people like you in existence--and inside this den of dopers & thieves, of all places.

Have you read the YouTube comments lately?

You never responded to the last message I sent your pen name's account. I can't imagine that I offended you ... unless ... you're not a Frolf-loving LARPer, are you Bruce?

At any rate, I don't think that anyone here would worry about you absconding with the book mobile's coffers. At least I wouldn't. Don't sell yourself short. There's a certain underlying aura of decency about you, Bruce--which is made even more apparent by your long-standing concern for and support of SSBD. I never had the pleasure of knowing him.

I should write him a letter.

Yeah. He can certainly have copies of my books, for whatever that's worth. He might dig them.

Finally, here's a suggestion for a book that I believe he or anyone else in this community would appreciate: Hackers: Heroes of the Computer Revolution by Steven Levy. It's the compelling story of how over the course of several decades, computers were liberated from universities and big businesses and placed into the hands of the people. What's even more interesting is that when the book was published in 1985, the revolution was already concluding and a good number of modern-day DNM enthusiasts hadn't even been born yet.

It's a good book.

Stay groovy, Bruce.

--Ed

13 year old? I've started programming around the same age. Wow, I'm only 27 and I suddenly felt old :)

Anyway, I don't know if you want some tips, but here are a few I wish someone told me when I was starting:

1. Start small - even a simple game, like Tetris or something, 100% complete (with UI, menu, sounds, gfx etc.), will take a lot more time than anticipated.
   
2. Finish things - it's not always fun and games, there is a lot of boring work involved, you have to stick it out. After all is said and done, a one finished game will feel better than 10 started projects, no matter how interesting they are.
   
3. Learn about code design. Code readability is really important. I would say it's only second to making working code. After the initial stage of any project, you won't be writing new stuff, you will be expanding already existing codebase. How fast you write/modify/debug/etc., will depend on how readable and manageable is your codebase. The worse codebase, the more you will be inclined to leave it and start something new, fresh (with a "better code"...). Leaving code behind or rewriting it because it's "bad" is a huge timewaster. Read Clean Code and Code Complete for starters.
   
4. I lost a lot code too in my time. Use something like bitbucket or github for your code. Remember to keep your directory tree nice and tidy. As with point 3. - It's a lot easier to come back to nice and tidy project than to some kind of tangled monstrosity.
   
5. Have fun. Creating software/games is a hell of a ride.
   

Automate the Boring Stuff taught me the basics and I recommend it highly. It's free.

If you encounter an error spend about an hour trying to solve it before asking for help. If you get an error with an error message from running the program you copy and paste the error message into a search engine and look for answers there. If the program behaves differently than you expect it too without giving you an error message you have probably made a mistake in your instructions to the program and these can be hard to find.

r/learnpython is great when you can't solve your problem(s), they're helpful as long as you say what you have tried, upload your code to pastebin.com and say what you want the program to do.

also when giving variables names please give them describing names. look at this example:

name = "chra94"

n = 6

name_length = 6

clearly name_length describes itself better than just n. Many beginners me included make the mistake of naming variables poorly which makes the code harder to read. good variables makes reading the code easier.

Be prepared to read documentations for both python but also tools (they're called modules or libraries) written in python for python. One day you might want to make a program that modifies or creates spreadsheets. There are libraries for that and even if you just watch a tutorial on how to use it it's easier to be able to search and read the documentation for the module than finding a tutorial specific for that one little thing you want to do that the other tutorial didn't cover.

Following the Automate the Boring Stuff book you will be able to make a rock, paper, scissors-game, making a number guessing game and such. Should you want more excercises you could look at codingbat over here at CodingBat for that.

Some day you might want to do a project. A program that's useful. Maybe it'll download the ten best wallpapers from r/wallpapers each day. Maybe you'll make a chatbot Slack or Discord or IRC. Anwyay. After having made a couple of programs that can be used over and over again by someone else than me I have realized that I have to plan much, much more ahead. My programs got messy, difficult to read, difficult to change and honestly I've lost control over them. I wish I had read Code Complete earlier. It praises planning your program thoroughly. According to some stats in the book mistakes uncovered after planning are between five to ten times more costly to fix than if they were discovered while the requirements for the program were figured out. (Theses stats are for small companies. Bigger companies can be as much as 100 times more expensive to fix.) TL;DR: Time spent planning is between three to ten times better spent than fixing stuff because you didn't bother to plan enough.

*TL;DR:** Do Automate the Boring Stuff untill you want to make stuff on your own and read chapter three of Code Complete.


Best of luck buddy and remember: Plan your projects ahead.

I went trough a really long phase of this. Not saying this will work for you, but for me what snapped me out and allowed me to set my own path was heavy doses of proper, formal game design.

It took forever for me to discover that's what I needed. But the structure and the fact that it forced me to think through every aspect of a game idea before any line of code was written made me realize I could do it. It showed me the individual steps, it compartmentalized it so that I could eat the elephant one bite at a time.

Plus, it was a LOT easier to stay motivated, because I had a pretty good idea of the big picture, so it was easy to track overall progress and distance from the finish line.

Finally, with the help of Code Complete: A Practical Handbook of Software Construction, I'm now quite proud of the code I put out, which is another motivator.

What are the position's responsibilities? What is the environment like (number of workstations/servers)? Is there already an SCCM environment in operation? If so, is it 2007/2012/2012 SP1/2012 R2? Is there a team supporting SCCM or would it just be you?

If you're going to be the admin, packaging expect, deployment admin, and sole tech support and you have no experience yourself...that'll be a big learning curve. It's not impossible, but it'll be a lot of research.

Microsoft's Virtual Academy is great.

If you like books, the "Mastering" and "Unleashed" books are two of my favorites. There's a lot of great blogs out there for System Center, too--System Center Central is my default stop, but of course /r/sccm is great too!

And for any questions that you can't get answered via any of those methods, the Technet forums are invaluable. You'll get to be on a first name basis with some of the MVPs, they're phenomenal.

Yes - knowing how to write a great sort algorithm is fairly useless in the real world. You're better served learning good programming and principles of software design. Please get a copy of Code Complete and absorb it, as well as finding out your company's particular methodology.

The biggest problems with fresh-out-of-the-womb coders is you make mistakes that make your life more difficult down the line - use functions, don't write code in-line. Don't make everything global variables. Name your functions and variables carefully. Understand scope. If you're doing something complex and hacky to achieve a goal, take a step back and think if you can solve your problem a different way. Don't hesitate to ask for advice, online or at work. It is not a sign of weakness, but instead a sign that you're willing to learn.

For scripting this kind of thing is not nearly as important, but you may as well start trying to write nice code there. Ask for a coder to look it over and give you tips. Make sure everything you write is well documented and readable!

Good luck, have fun!

Find out what language the class is using. If it is Java, then I've heard that Thinking in Java is a good book (the 3rd edition is free while the 4th is not).

Here are some books you should read, the sooner the better:

Code: The Hidden Language of Hardware and Software - This is a great book that is technical while being a fairly light read. It answers the question "how do computers physically work?" with just enough theory to understand, and it doesn't have, like, metaphors of pictures of trains carrying 1s and 0s around.

Don't Make Me Think and User Interface Design for Programmers which are also light-but-still-technical books on user interface design, which gives a good idea of how to create software that people actually use.

At some point after you've done some coding, read these books:

Code Complete - A great tome of the non-programming aspects of being a good software engineer.

Pragmatic Programmer is a technical book, and probably a good one to read towards the end of your first year maybe.

Also note: You don't need to know a lot of math to program. High school level algebra and basic arithmetic is fine for the most part.

Here's my list of the classics:

General Computing

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

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!

OK, got it. Perhaps the low level details aren't exactly what you need. BTW, I've tried reading some of these books e.g. this one: http://www.amazon.com/TCP-Illustrated-Vol-Addison-Wesley-Professional/dp/0201633469/ref=pd_sim_b_2 and they are not for the faint of heart.

What's worked better for me are online articles like the one above. While I'd love to grok TCP/IP at a deep level, I really don't need to know that much about it. Although I could see how it would be extremely useful if I worked at a networking company.

tl;dr good luck! I find Charles to be a bit easier to use than Fiddler.

Still, if it's their first time learning programming, Effective Java probably isn't the best fit. Most of its tips are the kind where you hear something for the first time, recognize it as common sense, then wonder why you didn't do it that way in the first place. However, its tips won't really be of use to someone who hasn't grasped object oriented programming yet.

Chapters 3, 4, 7, and 8 (of 10) are probably the ones that a beginner would get the most use out of. (Amazon's Look Inside has a TOC, which actually lists out all the tips in the book, so you can verify this yourself.) The other chapters are fairly specific to Java, which may be "in the weeds" and a bit too specific to Java to be immediately useful to a first-time learner. That criticism also somewhat applies to Chapter 3, but your friend is probably already working with methods inherited from the Object class (such as toString()), so that one would be useful to them.

Also, Effective Java is available freely online from an .edu extension, so (more than likely, but can't really verify) legitimately. I do own a copy, myself, but that's something to consider.

For a book that is entirely general programming advice (and thereby more useful to a beginner), I'd instead recommend Code Complete, second edition by Steve McConnell. You can open up that book to practically any page and find tips and best practices that can be applied to writing code in any lanaguage. It's also usually at least a bit cheaper than Effective Java.

Indeed. I recently read The VDI Delusion, and was pretty astounded by it.

They basically took all of the very worst-case scenarios, and presented them as if that were all that there was, completely ignoring the best-case scenarios. Sure, if you fit those worst-case scenarios, they're right. But for some scenarios, it is an absolute DREAM.

In our call center, specifically, we were in a position where we had to upgrade all of the desktops. VDI, including some additional networking, ran us about 20% more up front than simply replacing the desktops - but we reduced our support by about 90%. Not just in a "we don't do as much" sort of way, but in a "We eliminated our desktop support person" sort of way. He moved on to other stuff, and I spend about an hour each weak on the VDI installation. User experience for them, thanks to running the VMs on SSDs, is quite snappy and pleasant.

Staffing increases are a dream. The call center can buy their own PCoIP clients and plug them in. Within a few minutes, they have talked to the config server, updated their firmware, set admin passwords, updated config, rebooted, and they're ready to roll. I no longer even have to touch desktop hardware for them. So, last year when they expanded by nearly twice as much as projected, my only extra efforts were to create twice as many user accounts, and set the View Horizon provisioning pools to a larger number of VMs.

The power savings have been enormous as well, and I have measurements to back it up.

But, on the flip side, I HAVE NOT moved the rest of my company to VDI - and probably won't. They're not the right use-case for it.

Ideas:

• How about learning programming? Learn Objective-C, then you could develop both mac and iOS apps on your iMac. They're great for coding!
  
• Even better, you could learn ruby, a modern and relatively easy to learn programing language and develop web applications with rails (A big part of the ruby community is using macs).
  
• Start learning Flash and make some good flash games.
  
• Or become an expert in Photoshop!
  
• Download and watch a few good HD movies. They look amazing on the iMac screen.
  
• Learn something new by taking an online Stanford class, for example computer science, anatomy or game theory.
  
  
  If that's not enough, browse the App store. I'm sure you'll find some inspiration.

Looks like most of your knowledge and experience so far is with imperative/object-oriented programming. You might want to have a look at functional programming, just to get some perspective. Scala, Erlang or Haskell could be some good choices here, or even Ruby (if you make use of blocks and don't use mutable data). Actually, Ruby is pretty cool and very versatile and practical, that could be a good language choice as well, and you would also be able to make use of your prior knowledge with OO programming.

One other thing that you could do with this time is to read some books! There are some wonderful "generic" titles that every programmer should read, in my opinion. Have a look at The Pragmatic Programmer, Clean Code and Code Complete, for starters. These might get you really inspired and pumped up for the undergrad college and computer science classes, as well as give you some good tips on new things to learn.

MDT (Microsoft Deployment Toolkit) is your best option. Free and a large user community. Get a book to help you understand the concept. https://www.amazon.com/Deployment-Fundamentals-Vol-Deploying-Microsoft/dp/9187445212 is a great book to get you started. You DO NOT need a deployment server. Just a network share will work. You then use your workstation to create the deployment. The boot media will boot and point to the network share. Look at the Deployment bunny and other MDT focused sites for more help.

15 is really young. If you're relatively presentable, you might want to try Hyvee.

That said, it looks like from your profile that you have an interest in math and coding.

If this is something you're naturally skilled at, you shouldn't be working in fast food. You should be ignoring temporary financial gains to put yourself in the best place possible for college and technical internships.

The primary way to do that is to double down on your academics. At 15, you'll probably be going into your sophomore year? Don't accept any grade but an A from here on out. There's just no reason for it. You're obviously not retarded and school is easy.

Grab an ACT/SAT prep book. Take every practice test you can find until you get your scores into the absolute highest percentile you're able to.

If available, join a cyber academy, coding, math or robotics club at your school.

Go to things like this:

http://siliconprairienews.com/2014/08/meca-challenge-2014-preview/

Read books like these:

http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/The-Pragmatic-Programmer-Journeyman-Master/dp/020161622X
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882


You'll lose a few thousand dollars over the next few years from working a shit job but you'll also be able to get a technical internship as soon as you turn 18 making double/triple minimum wage, while you gain proficiency in a relevant field.

You'll also go from $Texas in student loan debt to a free ride, saving you 30,000 to 100,000+ depending on what school you can get into on scholarship.

You may be 15 but I have to disagree with anyone else that you're only worth minimum wage. Everyone has skills they can work on and if you really want to help your family in the long term, work on what will make you successful.

If you have any questions regarding any of this, PM me.

It doesn't matter what you do, so long as you actually finish and ship whatever it is that you're working on. If I'm an employer and you send me a URL, it should point to a finished project that I can use and critique. Don't show me your current, unfinished projects. Talk about those in the interview when I ask you what you're up to.

College isn't going to teach you how to program in the real world. It's going to teach you computer science. It's up to you to figure out how to write code that doesn't suck. I'd suggest you start by reading Code Complete, The Pragmatic Programmer, and Programming Interviews Exposed. I should mention that all of these books are on Safari Books Online. If you read a lot of tech books, a subscription is a great investment (your future schools might even pay for your subscription like mine does).

Also, be sure to learn as much as you can about the tools that are out there. Sure, a programmer might be impressed if you coded up a simple Ruby on Rails application and talked about it on your resume. However, they would be a lot more impressed if you coded up a simple Ruby on Rails application, and gained experience with Apache, Mercurial, Thin, SSH, Test-Driven Development, Linux, PostgreSQL, Rake, and delayed_job in the process. Your resume should show that you've used a fair amount of the technology that's out there in the real world. A lot of fresh graduates can't code for shit. If you haven't graduated, but you can demonstrate that you can code yourself out of a paper bag, employers will want to hire you, regardless of whether or not you have a degree yet.

Also, don't let the CC thing hold you back. Like I mentioned in my previous post, I'm currently taking courses at a community college and have only managed a 3.5 GPA so far. I also have an interview next Monday for a full-time development position that "requires" a Bachelor's degree and professional experience. If you can code, and have projects to show for it, send out resumes. Getting a job after school will be a whole lot easier if you put any effort into finding a job during the 4 years that you were in school.

This goes without saying, but you should be professional as possible. Get your resume reviewed, buy a custom domain name and set your e-mail to john@johndoe.com, etc.

Also, be sure to try really, really hard in your courses (especially the CS ones). If you don't have a degree, your references are that much more important.

The lowest-level Windows API is called win32. It's been the same foundation of Windows from Windows 95 all the way through Windows 7. Everything that's possible in Windows can be done via win32. Today there are many other layers on top of that - C++ libraries, C#, VB.NET and the Common Language Runtime, and much more...but win32 is still there under the hood, and if you really want to understand everything that's what you should learn.

This is as good a reference as any:

http://www.amazon.com/Programming-Windows%C2%AE-Fifth-Microsoft/dp/157231995X/

However, once you have a better understanding and can write some simple Windows apps, you may want to consider a higher-level tool.

Most people don't write win32 anymore.

In C++, you could use MFC, Microsoft's C++ library on top of win32. Or you could use wxWidgets, which is slightly similar in design but more generic and actually works on Mac & Linux too. Or you could use Qt which is similar to wxWidgets but gives you an even higher level of abstraction. All of these will feel more like Java's API.

If you don't need to use C++, consider C#,F# and the other CLR/.NET languages - most Windows-specific development is moving there because of a lot of tools you get to enable more rapid development.

Still, learning a little win32 will help understand how Windows works under the hood, which will be pretty helpful.

My own Amazon tech book wishlist shares a lot of those on Petri's list, but I'd have to include Code Complete as one of the best books on software development that I've read.

Petri has written some of the most helpful articles on Spring tech that I've read online.

You have some really awesome in-depth Hibernate articles, Vlad. Thanks for your hard work!

Maybe you like

• anappaday
  
• GoogleCodeUniversity
  
• if you want to learn something new w3schools
  
• I like codingHorror. It's not really about the code itself but more about coding.
  
• If you're interested in a book. CodeComplete Will really give you some great pointers on how to write better code. It's a big one (800 pages) but it's worth it!!! And you can pick the topics you like.

I'm like you - also in high school and casually building my programming skills. I'm not really sure what you are looking for, or what your previous experience is. Have you looked into design patterns, object-oriented programming principles, etc? Do you make mini projects for yourself to complete? I recommend definitely looking into OOP (if you haven't already), design patterns, refactoring to improve your code, etc. Have you tried contributing to any open-source projects? Those might be useful for gaining more experience.

Code Complete is a must read (IMO) for any programmer.

Head First Object-Oriented Analysis & Design is one I'm a fan of as well. Taught me how to look at the bigger picture when coding.

Hope this helped somewhat!

BS in computer science. My track / focus was network systems. I was always good at tshoot and I'm very curious. I worked for a vendor that makes 3gpp radios and did a lot of protocol and transport work (tshoot, configuration, band planning, scheduler analysis). My biggest skills that help me here are knowing Linux really well, understanding low level hardware, and traffic algorithms. This book and the next two volumes got me interested in this stuff. I'm an architect at a tier 1 ISP and my job description is best described as network systems integration. I know Sandvine from architecting solutions numerous times across several ISPs. I'm 20 years into my career and started out as an IT help desk tech, moved into systems admin, and just kept learning and searching for bigger better jobs. I got my first ISP job from a cold approach at a job fair at a college.

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

Honestly if you aren't sure how to create an application deployment in SCCM I would suggest picking up a good SCCM book for reference as there is likely lots of other stuff to figure out too.

Plus SCCM is a bitch at times as it gives you lots of options and things to change and tinker with and quite a lot can easily break stuff in new and interesting ways - you get get to learn about all 100+ different log files SCCM creates.

The book I like to recommend is this one:

https://www.amazon.com/dp/9187445085/ref=cm_sw_su_dp

As it provides a good real world walkthrough (including hard won tips and recommendations), from doing the initial sizing and install through to each major SCCM component - including creating an application in SCCM to run a Powershell script (and lots more beside this!).

It's well worth the money and can help you get things right the first time and avoid causing even more problems down the road.

Nothing is every really outdated, as you never know what you are going to encounter in a target / assigned environment and even have to continue to deal with legacy OS, PS versions and now cross platform. That cross platfomr bit, as far as in depth stuff, no refrence really exists, yet.

​

Why are not all the built-in help files and ps1/psm1, etc., not a good reference point and well as all the docs on the MS PowerShell GtiHub and docs site as well as these handy resources and one of the other top PS books that been around: for years now:

Windows PowerShell in Action, Second Edition Second Edition

​

And coding in general -just becasue the more your script , eventually understand real coding practices is paramount. Look to this reference. It's not PowerShell specific, but for wrapping you head and goals around coding practices.

Code Complete (Developer Best Practices)

​

PowerShell Documentation

https://docs.microsoft.com/en-us/powershell

https://docs.microsoft.com/en-us/powershell/module/?view=powershell-6

​

Other free eBook references

https://leanpub.com/u/devopscollective

http://www.powertheshell.com/cookbooks

​

Windows PowerShell Survival Guide

https://social.technet.microsoft.com/wiki/contents/articles/183.windows-powershell-survival-guide.aspx

​

DevOps Collective Videos

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

​

Cheet Sheets

https://github.com/PrateekKumarSingh/CheatSheets/tree/master/Powershell

​

PowerShell Best Practices

• https://blogs.technet.microsoft.com/heyscriptingguy/tag/best-practices

• https://blogs.technet.microsoft.com/heyscriptingguy/2014/05/28/powershell-best-practices-simple-scripting

• https://www.digitalshadows.com/blog-and-research/powershell-security-best-practices

• https://ptgmedia.pearsoncmg.com/images/9780735666498/samplepages/9780735666498.pdf

• https://www.digitalshadows.com/blog-and-research/powershell-security-best-practices

• https://github.com/PoshCode/PowerShellPracticeAndStyle

• https://gallery.technet.microsoft.com/scriptcenter/PowerShell-40-Best-d9e16039

• https://www.microsoftpressstore.com/store/windows-powershell-best-practices-9780735666498

​

​

​

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.

No worries about the text-wall! I tend to be rather verbose, too.

Yeah, you're in kind of a tough spot. I think that a CS degree is pretty valuable, both because it gives you a lot of the skills and knowledge that you need, and because it helps you get your resume on the short list.

However, it's not strictly necessary. But if you decide to go without it, be prepared to absolutely bust your butt to get the skills and experience you need. There are good online courses, but if you're serious about making this work, you'll have to combine that with reading the classics (The Pragmatic Programmer, Code Complete, and Design Patterns are a good place to start), and working on your own projects. Interviewers love to see candidates who take the initiative, and even more than that, they love to see finished projects.

I'd be happy to take a look at your site. Feel free to PM me or ask more questions, and I'll try to be of as much help as I can!

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

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

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

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

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

There are two books I would recommend to you as I think they address what you are looking to improve upon. First I would recommend

Clean Code: A Handbook of Agile Software Craftmanship

followed up by Code Complete

Both deal with project management, etc., but have fantastic sections on code style and presentation. I really liked "Clean Code" and would recommend it to anyone. What you are describing in your last paragraph is one of its main goals. Both books present principles that are language agnostic (though usually have examples in Java/C formatted languages).

I've got some tips for ya!

• If you find learning about things like local and global scope fascinating and devour info about coding, then I can confidently say congratulations on finding your calling! There are many, many programmers who never do any reading, find it boring, and, consequently, have limited perspective and suck ass.
  
  
• In programming, no matter whether you're a novice or a veteran, the 'big picture' is like that hot girl in high school that you somehow talked into dating you off and on until you both graduated, and then she never spoke to you again. On large projects like games, it's highly unlikely that anybody truly knows the entire scope and can tell you how every piece works together. Even on smaller, personal projects that only you yourself worked on, you will probably have to read your whole codebase to remember what the hell you were thinking if you revisit it in 6 months. So, don't sweat it too much if you don't get the big picture, or if it takes you a long time to grasp, just relax and remember that all programmers spend the vast majority of their time simply understanding code.
  
  
• My personal opinion on using C++ as opposed to Java or .NET - imagine an application is a physical building. If you use C++, you have to take the time to fabricate every single brick you're gonna use, forge your own plumbing pipes, and construct everything from scratch. Java or .NET will deliver all of your bricks, steel, drywall, shingles, cabinets, and appliances in regular shipments, so you can focus on the blueprints and management. In the time it takes you to build a house in C++, you could have built a whole apartment complex in Java/.NET and rented out most of the units already. Having said that, if you want to build a fortress in the heart of a mountain where the only access is a tunnel hidden behind a waterfall with a door that's unlocked by DNA signature, you should probably use C++.
  
  
• When will it fall into place? It's impossible to tell. It's different for everybody and depends highly on what you are doing and what your goals are. For me, it took about 6 months to get a handle on the basics, and 2-3 years to become confident discussing higher level design principles intelligently, and to start nodding my head in agreement reading programming blogs. I knew that things had finally clicked when I realized I was no longer shackled to the language I learned first, and that using new platforms was merely an example/API skim away.
  
  
• I highly recommend reading through pretty much all of the Coding Horror posts, as well as Code Complete 2. Find something to build that interests you and that you don't know off-hand how to accomplish, and then learn the pieces you're missing to get it done. Google every topic, acronym, or piece of terminology that you're not familiar with, rinse and repeat. If you are truly a good programmer you will never think of yourself as a good programmer, but you will wake up one day and realize that you have the ability to complete most any task thrown your way; and if you don't, you'll know how to learn what you need to get it done.

Build a lab.

​

Build a lab.

​

Build a lab.

​

Build. A. Lab.

​

SCCM is a HUGE beast in and of itself...just learning the various ways to deploy applications/packages (and knowing the difference between the two and when to use one over the other) takes a bit of practice. Then understanding Task Sequences (a bunch of steps for completing a job...useful in imaging machines), and then finally going into learning Reporting...how to build queries and groups of users and pcs, based on certain parameters you define.

​

And that is just for the PC side. SCCM also can manage Macs as well as Mobile Devices.

​

And it has it's own Powershell module.

​

Intimidating? Yes.

​

Here are three tips, off the cuff I can give you (I am a current SCCM admin for a global firm).

​

1 - Build a lab. Make sure your pc has lots of processor cores, lots of RAM, and a decent size hard drive because all of your lab machines will be VMS. Plan on hosting about six to ten machines (with at least two being pc vms. You want to similate an environment.

​

2 - Take a video course from Udemy or another suitable online provider. I recommend this one. If you hop on the sale right now, it's $12 bucks. https://www.udemy.com/system-center-configuration-manager/

​

3 - Buy some SCCM books. Two that I recommend are:

System Configuration Manager Current Branch

System Configuration Manager Reporting Unleashed

Excellent to go over the basics of SCCM as well as more in depth stuff.

​

4 - Take your time, learn what you can, show it off...volunteer to take on SCCM tasks at your current place. If they don't want to let you in, because of security issues or protocols, dust off the resume and go to town!

​

​

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

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

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

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

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

Somebody in another comment mentioned Kevin Mitnick.

In addition to Mitnick's book, I'll also recommend:

Steven Levy's Hackers. It's a classic exploration of the birth of the computer age and hacker culture, with a lot of insights into the mindset of computer people, both white-hat and black-hat.

The Cuckoo's Egg by Cliff Stoll, which is an account of him tracking down some serious hackers waaay back in the day. It's kind of vintage now, but I remember it being very well written and engaging. It's more like reading a novel than some dry academic piece.

In similar vein is Takedown, by Tsutomu Shimomura, which is Shimomura's account of pursuing and catching Kevin Mitnick. Also quite good, as it was co-written by John Markoff. There's a whiff of Shimomura tooting his own horn in it, but you definitely get a feel for the chase as it was happening, and learn a lot about the details of what Mitnick (and others in the underground hacking world) were actually doing.

Weird fact: I had no idea at the time, of course, but during some of Mitnick's last days before they nabbed him, he lived in an apartment building in my neighborhood in Seattle, right across from the grocery store where I always shopped. And about a year later, I ended up dating a girl who lived in that same building at that time, though of course she had no idea Mitnick was there either or even who he was. Still, I always wonder if I ever happened to stand next to him in line at the grocery store or something like that.

Coding:

• Code Complete 2. It is language agnostic BTW, most recommendations and guidelines apply to several languages, if not all. I would definitively start by this one if you are a beginner. The lessons from this book will help you for the rest of your career.
  
  Object Oriented Programming (OOP):
  
  
• Applying UML and Patterns. In my opinion the best book on UML in the market. Excellent illustration of step by step process to getting an idea from concept to code while thinking Object-Oriented. Just keep in mind the book has some embedded propaganda for IBM's Rational Unified Process(RUP). OOP works just as well outside the RUP; i.e.: using agile methodologies.
  
  
• Design Patterns If you are only starting now, save this book for later. It covers more advanced design subjects. Read this one when you are already VERY comfortable with OOP.
  
  EDIT: People who are downvoting this are doing you a disservice out of ignorance. You must read Code Complete 2.
  

Is there a point to doing this early? When you get an entry level position you will learn all of this and more. Also you seem to be missing a small detail. A team doesn't just consist of engineers. There will be a set of non-engineers on your team whose sole purpose will be planning, issuing work, documentation, etc.

That said:

> I would like to learn how to work on a software development team and whatever that entails.

The only place you can get this is on a software development team in industry. Much of the industry have agile processes for scrum, issue tracking, etc. but those are really to manage large teams for largely divided projects. If you are working with a couple of friends then the best thing to do is peer program when you can and code review when you can't. If you plan to make a start-up, then it might be best to get some one to do the managerial work. If you're insistent on doing it yourself, then you'll really end up spending most of the time manage the project rather than writing code, which means you're basically just a manager anyway.

But if you insist anyway, here's some books:

• Clean code
  
  
• Code Complete

> how to incorporate best software/coding practices

I think most of that is gained from experience writing software, especially in a team of developers, though some CS specific curriculums may cover them. I would be surprised if a bioinformatics program specifically covered software engineering.

There are books out there about good coding practices (I recommend Code Complete) that are worth reading. There's also design patterns like Model-view-controller you can apply to better organize your code.

If you are starting from an amateur background as a developer on C# centric stack, I'd argue that Code Complete has strong to potential to protect against your weaknesses/blind spots than just about any book about software development. It doesn't go deep, but it will introduce you to breadth of fundamentals. Feel free to skim past the ones you are already familiar with.

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

​

The particular techniques described evolve over time, but the principles endure. e.g. One poster commented of making backups. Tools in the C#/MS ecosystem have evolved considerably, but git based source control is pretty popular tech at moment. Github is popular for hosting source of open source projects - Azure Repos and Azure Devops suite has more depth for larger teams and complex processess.

One of the best ways to learn is by studying other people's code. Using book references like the one you have on C# is a great start. Make sure you ask questions to yourself and really study the code. Questions to keep in mind: why is this line before that line? What would happen if these two lines were swapped? How could I make this easier to read? Do all of these lines make sense when grouped together in a function? How can I break this down into a simpler class/object?

Those are the kinds of questions professional developers ask themselves on a daily basis. If you start asking yourself those kinds of questions early, you'll become a very competent programmer.

I highly recommend new programmers to read Code Complete: http://www.amazon.com/dp/0735619670/ref=cm_sw_r_tw_awdm_ZlAbvb1GP04MC

The fact that you've submitted this question indicates that you're on the right track. You just need practice.

You can read Code Complete by McConnell which is a must have for software engineering and has several sections on writing and documentation etc.

The number 1 rule of thumb is to think as if you are not the one writing, but the one reading it later. Take commit messages - there are far too many "fixed a minor bug" on one end, and wall-of-text-about-how-you-found-and-fixed-the-bug-but-little-useful-info on the other. Write what the bug was and what the fix is, and its side-effects if any.

If you want to improve your writing, identify people who have done it well, and seek to follow them, and practise. Just reading good writers, commenting on forums etc. will also improve your writing skills.

Self taught professional software engineer here.

Which language you learn is not as important as learning about data structures and complexity analysis. Code organization is also very important.

Pick one high level scripting language (like Python, Ruby, Perl, etc) and one low level systems language (C, C++, Rust, etc) and learn them both inside out.

A couple of books I recommend:

• Code Complete
  
• SICP
  
  As far as practical skills go, you need to learn how to use git (or whatever VC system the companies you are interested in use). You need to learn how to use Unix systems. A great introduction is The UNIX Programming Environment. You need to learn how to read other peoples' code, open source projects are great for that.
  
  When you are getting ready to interview, there is no better resource than Cracking the Coding Interview.

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

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

Seconding The Pragmatic Programmer and Cracking the Coding Interview. I'd also recommend:

• Code Complete: verbose and somewhat self-congratulatory, but extremely good.
  
• The Mythical Man-Month: a little dated and weirdly religious at times, but has great insights into how software problems are actually people problems and how large projects are (mis)managed.
  
• Design Patterns: a.k.a. the Gang of Four book. This one's a classic.
  
• Pro Git: you mentioned version control systems. IMHO, you should learn Git if you don't know it, and this book is a great resource.
  
  If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.

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

I own all of Robert C. Martin's books, except for UML for Java, as well as Martin Fowler's Refactoring (the white one), PEAA, DSL and Analysis Patterns. I also have Refactoring to Patterns, Code Complete and Design Patterns (aka go4) and a few others.

I would suggest Refactoring to Patterns is the one you are looking for, but that expects you have a working knowledge of what the patterns are already (likely with your experience though you may not know them by name). I don't think that is strictly necessary but it will help you understand why you might want do do things the way being suggested in the book. The examples are in Java, but they apply to C# just as much. His site is here: https://industriallogic.com/xp/refactoring/ and he has the code up behind an online course / paywall (I have not looked into this).

In a greenfield environment, tdding up an application from a blank project Uncle Bob or Fowler's pattern books are probably better, but from the perspective of an existing codebase I think Kerievsky's Refactoring to Patterns and Fowler's Refactoring are best.

If it's just Internet access you'll be supporting, don't worry. Most of your calls will be like 'My email is working, but my internet is down'. You might never have to learn what all those acronyms mean, but you'll become an expert in explaining the concept of double clicking. Yes, enterprise customers too (unless that ISP only caters to very large enterprises. You'll be having BOFH moments when explaining complex issues to customers and advising them to engage an consultant while suspecting you are talking to their consultant.

That said TCP/IP Illustrated, Vol. 1: The Protocols is an excellent start to expand your knowledge.

There are two other books I would recommend. Code Complete by McConnell covers a lot of best practices. Thinking about best practices changes how you think about writing code. Also Software Architecture in Practice looks at how to design a system to meet quality attributes (AKA non-functional requirements) as opposed to trying to fulfill the attributes late in a project's lifecycle. Both books will change how you look at creating and writing software.

Incredibly oversimplified, but not entirely inaccurate. Good job. You might be interested in a book I posted above, it's called Tubes.

http://www.amazon.com/Tubes-Journey-Internet-Andrew-Blum/dp/0061994952

Edit: I'm impressed that you were able to come up with such a clear explanation of networking given your age. You might have the type of mind that would do well in the networking industry. Do yourself a favor and seek out more information on the intricacies of network design and implementation.

If you're looking for more than tutorials or picking up a project as a learning experience, Code Complete by Steve McConnell and (though getting a bit dated) The Pragmatic Programmer are classics in improving your development skills. I'm also looking at Clean Code next, looks very useful for those of us in the trenches who often have to throw out some code with limited time and ever changing requirements.

Also if you're going to be digging into any rails stuff by chance, I can highly recommend Rails AntiPatterns as a great reference for more than the basics, as well as the Destroy All Software podcasts (which cover more advanced topics than most podcasts).

The C Programming Language (aka K&R)

Everyone should have a copy of this book on the shelf. Sure there's arguably better books for learning C, and K&R hasn't even been updated in 28 years (the code in the book is not valid c99). But it's like the holy bible of programming books.

Hackers: Heroes of the Computer Revolution is worth a read.

All of Kevin Mitnick's books are good.

I'd honestly not really bother buying any books for learning actual programming from, since most stuff moves so fast, and there's so much material online to learn from.

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

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

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

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

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

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

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

FYI, both of your links lead to the same Comer book. I'll assume that your "ccnaguide" link was intended to link to either the CCENT/CCNA OCG by Wendell Odom, or Todd Lammle's CCNA guide as well.

Personally, I would choose to at least read through the CCENT/ICND1 OCG first. It tends to do a good job of introducing a beginner to the world of networking in general terms. You may even find it helpful to pursue the CCENT certification afterwards!

Then, if you're still interested in TCP/IP specifically, I would pick up the Comer book. There's also a few others you might be interested in: TCP/IP Network Administration, TCP/IP Illustrated, and maybe Cisco Press's Routing TCP/IP (although it might be a bit advanced for what you would want.)

As far as your courses go, the best book I can recommend is Algorithms in a Nutshell. It is a small book which quickly introduces you to most of the core algorithms you will use throughout University. It also covers measuring efficiency through "big O notation" - a very important concept in CS.

If your University's SE program is anything like the one I am familiar with, you will also be focusing on software engineering principles. The most important SE books I ever read are:

• Code Complete
  
• Design Patterns
  
• Clean Code
  
  These three books have strongly influenced me as a developer

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

I was an engineer at Groupon. I don't know how they treated their sales staff, but the engineers were treated pretty well. During the development of "Groupon 2.0" (when the major shift in form and function occurred), they catered in breakfast lunch and dinner for all of us. Once the project was over, they rented a bus and rented out this fancy restaurant.

The people there were very friendly, and many of them really knew their shit. People coming from companies like Facebook, Google, Microsoft, etc. Probably the most impressive resume of anyone working there: Brian Totty, the SVP of Engineering wrote the book on HTTP, and was part of the team that invented the CDN. I learned a lot.

By the way, "Derrick" is actually CEO and Founder Andrew Mason.

If you like reading about computer history, I really enjoyed Stephen Levy's Hackers: Heroes of the Computer Revolution. (There's a pdf floating around if you google search it, but I don't think it would be good form to directly link it since the book is still in print.) It's a really fascinating look at the early hacker cultures in MIT and Silicon Valley from the late 1950s through the early 1980s.

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

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

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

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

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

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

I suggest this book, Code Complete. It has nothing to do with Python and it's pretty old at this point but by reading it, I know for a fact that it has a lot of the same ideals. knowledge, values and tips that my college teachers tried very hard to impose upon me in what is considered one of the best IT college courses in my country https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

You can also procure your HR department (or your boss) and share the situation. Tell them you'd like to enroll in some courses to get up-to-speed with everyone else around you, since you don't have the same training as them. Most companies (or at least a lot of them) will offer to pay the entire thing for you too.

When I started learning it, I just setup a spare PC running Windows 7 as the server, and followed a bunch of random guides I found online. It was confusing as hell at first, but then suddenly one day it just clicked and i "got" it, but here's a list of resources that I know I've used for learning

/r/MDT and /r/sysadmin

https://msadministrator.com/guides/mdt-2012-step-by-step-guide/

https://mdtguy.wordpress.com/getting-started/

(both of those guides talk about capturing a custom image and importing that, but as mentioned above I like to just use the .wim file from the Windows 10 ISO and use that)


https://deploymentbunny.com/


https://deploymentresearch.com/

At one point I had an older volume of this book which was also really good

https://www.amazon.com/dp/9187445212/ref=cm_sw_su_dp


If you have any questions or anything you get stuck on, definitely feel free to shoot me a PM and I'll try to help at least push you in the right direction, otherwise /r/mdt and /r/sysadmin both have some very knowledgeable people in MDT as well

Generally I go here if I want a good overview and operational view.

TCP, UDP.

If I want to go for the long haul and depth....I start here (I used this list as it's nice and abbreviated of what does what in RFC land). Reading through those will give you a much better idea of how things were "supposed" to work. How they work with a vendor will always be up to interpretation, but the vendors are interpreting those RFCs.

There are quite a few books on Amazon that will teach it to you as well. I honestly would consider getting them too. This, this, this, this.

There's so many good books but those should give you that deep understanding.

Code Complete.

The examples are given in C++/Java, but it's a goldmine; I believe that every serious software developer should read it. He may be beyond most of it, but it's easily my favorite book on my bookshelf, and I recommend it to everyone who wants to become a better developer.

Someone else said the issue would be getting a job, not learning. I tend to agree and I think it can go together with your question.

Different places will look for different things. Major software companies (Google, Amazon, etc.) select using algorithm programming companies. Get a copy of Cracking the Coding Interview or something sinilar and make sure you understand all of the topics in it well enough to reimplement a heap or a breadth-first graph search, etc., in 20-30 minutes. Read up on this stufff further outside of that book when you aren't sure on the "why" and it'll help.

Other places will look at your resume more to see proof you can perform, so you will want to fill it with links tp your Github where you show off meaningful work. Have at least one full-stack CRUD app, i.e. a database of [whatever] with an API to manage the entries and a web-frontend that exposes the API functionality to end-users. That's the bread-and-butter of profrssional software development. (Sounds like you are working on that.) A few meaningfully complex projects that aren't just CRUD apps to round it out will be nice - the games you mentioned, for example.

For good general engineering skills - writing maintainable code and so forth, stuff that will make your work shine and make it easy for you to collaborate with other professionals - there are a few books that a lot of people read and reference, such as:

Code Complete
Refactoring
Clean Code

(Personally I find Martin to be a bit much, but you'll hear his ideas referenced anywhere.)

Can I see some of your existing work? That would help me understand where you are in your journey thus far.

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

There are a lot of great answers here so I just wanted to add one thing: the book Code Complete is a fantastic read that will teach you to write better once you've learned to write something :)

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

You may want to look into picking up Deployment Fundamentals, Vol. 6: Deploying Windows 10 Using Microsoft Deployment Toolkit. This book really helped me stand up MDT, and understand what's going on. Especially with drivers, creating new TS, golden images, etc . You may also want to check out their website https://deploymentresearch.com/ . A lot of good info there.

Like /u/Raynefire said, I would follow their Total Control Method of Driver Management. Letting that get out of hand will cause plenty of headaches in the future.

Also, check out BTNHD. He has a lot of good info on MDT. He also covers Total Control Method of Driver Management.

Honestly, I'd go with Windows Powershell Best Practices instead. PSIAMOL is nice, but this one focuses more heavily on ensuring you not only get the syntax, but the proper script structure, code re-usability, high performance, and just a ton of other stuff.

PSIAMOL Teaches you how to use PowerShell. WPBP teaches you how to be good at PowerShell.

Once that's done, it wouldn't hurt to check out Code Complete which had such an impact I ended up re-writing several of my larger scripts after reading it...

If you are looking into anything regarding these technologies and VMWare, this book is great: Storage Implementation in vSphere 5.0. I didn't have any exposure before my recent VMWare training. I didn't even know what a LUN was. After the book, I feel much better about being able to not only work with several storage technologies but also knowing what they are doing and why.

edit: Also, definitely look into whatever you can to track and compare metrics across the various technologies. It helps to understand the strength/weaknesses of each type of solution, where they should be used in your business and scalability/bottlenecks/SPF.

Not specifically for Python, but one of the bibles of good software practices is -in my opinion- Steve McConnell's Code Complete (Amazon: http://www.amazon.co.uk/gp/product/0735619670/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1).

It covers pretty much every aspect of software construction. A really good read.

There are a lot of different strategies.

• UML/RUP (Rational Unified Process) Make lots of diagrams (UML) and lots of system requirements docs.
  
• TDD - Test driven development. Make Unit Tests first and then make code that passes the unit tests.
  
• CRC analysis - Napkin card type design that helps you figure out what classes you should have.
  
• Service based design - SOA type stuff. Define some high-level service APIs that different parts of your application communicate. Great when multiple team members are implementing different layers of your application.
  
  Basically you asking a methodology question and not a programming question. If you are asking questions like this you should probably start reading books like Code Complete: A Practical Handbook of Software Construction, Second Edition

Disclaimer: This may not be true for your job, but it has been for every job I have worked at.

That everything they are teaching you about algorithms will not be useful to you when you get into the field. Your education starts day one at your first job. Clients don't pay us to innovate in algorithms. They pay us to find and glue together other peoples libraries and to use this to present them the requested information.

Code you will actually be writing:

• Glue code. Integrate Library X with Library Y.
  
• Unit tests. To make sure your glue code works as expected.
  
• UI code.
  
  Things you will be doing that CS degree does not prepare you for
  
  
• Fleshing out incomplete requirements documents
  
• Dealing with drama between teams
  
• Estimation
  
• Understanding that 80% is often good enough
  
  I would suggest reading books like Design Patterns, Mythical Man-Month and Code Complete
  

I'd recommend New Turing Omnibus, which briefly covers various topics of CS and Hackers: Heroes of the Computer Revolution, which gives you a pretty nice narrative of the history of the original hackers.

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

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

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

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

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

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

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

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

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

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

Great response, for those looking Andrew Blum has an interesting book [Tubes](Tubes: A Journey to the Center of the Internet https://www.amazon.com/dp/0061994952/ref=cm_sw_r_cp_api_LkXMybX93FKGH) which is basically a full book ELI5 if anyone is interested in reading more. It looks like it can be had on amazon used for about $2.

Before attempting to give an answer to your questions there is something I feel is important you understand: it's okay to not understand it all yet. You only just started your journey as a programmer and no master has ever fallen from the sky. The most important factor for both your questions is experience, which is not something you can get from a book or lecture. It comes from making mistakes and failures. There will be a lot of them and they won't stop coming, so don't beat yourself up about them, they happen to everyone. Take them as an opportunity to learn.

1. It's a generally accepted wisdom that the only thing harder than writing code is reading it. It's not just about syntax, algorithms and data structures. It's about understanding how another person or group of people approached writing this piece of software. Also, keep in mind that not even the developers themselves fully understand large codebases. They might have a better intuitive understanding of pieces they interact with regularly, but code is not something humans are good in remembering.
   With that said, here's my personal approach to it: Usually there's a reason to look at code. You need to figure something out. We're not interested in the whole repository of code, but just the one piece. So I start hunting for that, usually with some sort of search or just trying to understand the file structure.
   Once I find the approximate area I have a very top-down approach. If I can tell from the name of a function what it does (or the associated comment) there is no need for me to read the body of it. Only when I can't tell from the name or need specific details will I dig deeper. Understanding the structure is always more important than understanding every instruction.
   
   
2. You won't really get a satisfying answer to this. There are hundreds of books out there related to this question. Not only does it depend on the kind of project you're working on, it also depends on the team, goal, language, framework and god knows what else. Also, while I don't want to sound condescending, 2000 lines isn't really much if you're talking real life applications. But as a quick primer: Think about structure. It turns out that algorithms are all nice and dandy, but one of the biggest challenges for programmers is structure. How can you split your code into components that are easy to understand and not needlessly interdependent in unexpected ways? In the end we come back to your first question with this: Your aim is always to write code that is easy to maintain and read. Keep your functions short. Give good names. Provide comments. Split up into files and classes. Group together what belongs together. Have a consistent naming and coding style. Think before you code.
   
   Most important, like so many lessons in life, no matter how many time people tell you not to touch hot things, you'll only really understand once you've burn yourself. There's no shame in that, especially not as a student. Just go for it, fuck up and learn from it. Talk to other students about the things you struggle with and how they deal with it.
   
   I don't really have any resource suggestions for you at the moment. Your questions is somewhat vague and most books I've read on the topic are quite specific and aimed at people with more scars than you have. Maybe I could recommend Code Complete which covers a lot of bases, but it's also quite the monster. I'm a firm believer that making mistakes and seeking ways to avoid them is better than following instructions without quite understanding why. But we each have to find our own way.

If you want to read a great book that explains it you should read Hackers: Heroes of the Computer Revolution. There's a great movie about it also Pirates of Silicon Valley.

For your own work, I suggest Code Complete.

As for getting your co-worker to change, don't bother wasting your time, as life is too valuable to deal with stuff like that.

Just do your own work to the best of your abilities and let that speak for you.

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

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

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

Haha guess I saw the "tipsy" and checked out after that! My focus is functional programming, so most of my recommendations are around that.

LambdaCast and The REPL are good and worth listening through (full disclosure I was on the REPL).

Other casts that I cherry-pick through:

• Software Engineering Daily
  
• Future of Coding
  
• The Accidental Engineer
  
  Some good books:
  
  
• The Phoenix Project
  
• The DevOps Handbook
  
• Release It
  
  You should also check out hillelogram and his talks/podcasts/writing on TLA+ if you're not familiar.
  
  Do you have any good recommendations?

This problem is super easy to solve:

• Read book "Hackers: Heroes of the Computer Revolution" by Stephen Levy ^[[0]]
  
  
• Come to the realization that you are incompetent when compared to CompSci pioneers.
  
  
• Keep doing what you're doing.
  
  Every cliche has morsels of truth: "Rome wasn't built in a day", comes to mind. Most folk, like you and I, are just not geniuses. However, that doesn't mean we can't work toward being very proficient in a subject and become contributors.
  
  Your coworkers are light years ahead of you, even if they started a few months ago. The growth of knowledge is exponential and they just spent more time at "The Craft". As time goes on, levels will even out between proficient coworkers.
  
  Also, please note, there are 18.2 million developers world ^[[1]]. Every time I can't get something or doubt myself, I always ask if I'm dummer then the whole group who already achieved what I'm trying to do. Usually, the answer is "No" and I continue to Google to fill my gaps of knowledge.
  
  Presiden Abraham Lincoln once said:
  
  > "If I only had an hour to chop down a tree, I would spend the first 45 minutes sharpening my axe."^[2]
  
  That means as a programmer, you will spend 75% of your time learning/reading/searching and 25% coding.
  
  
  Edit: formating
  
  
  [0]: https://www.amazon.com/Hackers-Heroes-Computer-Revolution-Anniversary/dp/1449388396/ref=sr_1_3?ie=UTF8&qid=1465623565&sr=8-3&keywords=hackers
  
  [1]: http://www.computerworld.com/article/2483690/it-careers/india-to-overtake-u-s--on-number-of-developers-by-2017.html
  
  

Hackers: Heroes of the Computer Revolution. I read this book in the early 90's and it was fascinating. It traces the origins of hacking in an interesting narrative style. It's the most interesting book on the topic I have yet read.

http://www.amazon.com/Hackers-Heroes-Computer-Revolution-Anniversary/dp/1449388396/ref=sr_1_1?ie=UTF8&s=books&qid=1279897212&sr=8-1

The TCP/IP Guide

The Illustrated Network

A bit dated, but pretty well respected:
TCP/IP Illustrated (There are 3 volumes)
----------------------------------
You can find most of this info freely on the web though.

Well TCP/IP is an entire protocol suite. In addition to IP, TCP, and UDP, it includes higher level protocols like HTTP (uses TCP), DNS (UDP more commonly than TCP), and ICMP (uses IP, not TCP or UDP).

My understanding is that it's called TCP/IP because those were the first protocols and everything else coalesced around/on top of them. Microsoft offers a pretty decent chart showing examples of the layering/encapsulation of the protocols in the suite here.

If you want to dive deeper, Steven's three-volume TCP/IP Illustrated is the de facto reference manual for the Internet -- though dated, it's still very useful and available for cheap used. Alternatively, No Starch came out with a tome of their own called TCP/IP Guide which I've heard a couple colleagues recommend.

Interconnections: Bridges, Routers, Switches, and Internetworking Protocols (2nd Edition)

Internetworking with TCP/IP Volume 1 (5th Edition)

TCP/IP Illustrated, Volume 1: The Protocols (2nd Edition)

are the three 'vendor neutral' books that are recommended by INE as resources for all CCIE tracts.



Cisco CCIE book list contains the following:

Other Publications

Cisco Documentation

Configuring IPv6 for Cisco IOS (Edgar Parenti, Jr., Eric Knnip, Brian Browne, Syngress, ISBN# 1928994849)

Interconnections: Bridges & Routers, Second Edition (Perlman, Addison Wesley, ISBN# 0201634481)

"Internetworking Technology Overview" Available through Cisco Store under doc # DOC-785777

Internetworking with TCP/IP, Vol.1: Principles, Protocols, and Architecture (4th Edition)
(Comer, Prentice Hall, ISBN# 0130183806)

IPv6: Theory, Protocol, and Practice, 2nd Edition (Pete Loshin, Morgan Kaufmann, ISBN# 1558608109)

LAN Protocol Handbook (Miller, M&T Press, ISBN# 1558510990 )
Routing In the Internet (2nd Edition) (Huitema, Prentice Hall, ISBN# 0130226475)

TCP/IP Illustrated: Volumes 1, 2, and 3 (Stevens/Wright, Addison Wesley, ISBN# 0201633469, 020163354X, 0201634953)



edit1:
I own the first three and recommend them for vendor neutral network engineering books, with Perlman's book being the best switching book I've personally ever read.


edit2:
also I find wikipedia articles on computer related topics to be top shelf. I would recommend many of the references and papers referenced in the https://en.wikipedia.org/wiki/Network_theory
article.

This doesn't answer your question, but there was a great book called Hackers about the people at the inception of programming. I highly recommend it. It touched on a whole mess of people who answer your question.

For example, I had always heard Gates was a really good programmer, but I didn't know how highly regarded his coding was when he was younger.

Clean Code http://amzn.com/0132350882

Code Complete 2 http://amzn.com/0735619670


Both are great books. I just finished reading Clean Code and I highly recommend it.

This was awesome, thanks. I work just a few blocks from 60 Hudson and 32 6th (My company gets their internet from Rainbow Broadband, streamed from the antenna on the top of 32 6th) and have always wanted to see what the data centers and switch infrastructure inside actually looks like. But I'm not holding my breath.

If anyone else is interested in this stuff, I recommend reading Tubes by Andrew Blum. He worked for years to get exclusive looks inside the workings of these exchanges, and then tells you all about it. According to his book, the main entrance for network cables into 60 Hudson is a hole a few feet wide in the basement that every tenant has to pay for space in, making it the most expensive tiny sliver of real estate in Manhattan.

These two books were the best programming books I have ever read:

• Code Complete (2nd Edition)
  
• The Pragmatic Programmer
  
  Code Complete is focused more around OOP, however both of these books will teach you how to become a better programmer.
  
  I recommend these timeless books for all programmers of any experience level.
  
  

Before you look into trying to optimize your code, beyond the basics anyway, I think it's more important to learn how to write readable and maintainable code first. Code that is easier to change, maintain, and write, is much much better than code that runs slightly faster.

Two books that are highly recommended for this are Code Complete and Clean Code.

Sometimes I believe that most books are wastes of paper, because everything relating to programming can be found online.

There is one exception although. If you can get your hands on "Code Complete 2nd Edition," that is a bible for a lot of programmers(me included).

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

There is the link for you. It has some incredible conceptual basics, as well as some advanced techniques of software design and architecture, which WILL help you now and down the road. Good luck!

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

Learn about...

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

Software Engineering: Code Complete by Steve McConnell

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

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

Why we love Joel: Joel on Software by Joel Spolsky

Problem Solving: The Pragmatic Programmer by Andrew Hunt

Common Code Solutions: Head First Design Patterns by Eric Freeman

Pearls!: Programming Pearls by Jon Bentley

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

Yes, this is what i used. Excellent stuff. This guy also has a really great series of videos on microsoft Channel 9: https://channel9.msdn.com/Search?term=Johan%20Arwidmark#pubDate=all&ch9Search&lang-en=en

He also literally wrote the book on MDT Windows 10 deployment: https://www.amazon.com/dp/9187445212/ref=cm_sw_su_dp

RoR will be very useful to create a website like that, just use the devise gem for the user logins. The databases are easy on rails, just follow a few tutorials and you will get started in no time. I would also recommend to use the screencast Railscast and the books Pragmatic Agile Web Development with Rails and Ruby on Rails 3 Tutorial as they helped me get started.

Netsec is a pretty wide topic, which makes your question somewhat hard to answer. In all honesty, I think the best place to start right now for a high-level introduction to networking is this Wikipedia article. There are, of course, many books you can read for a deeper understanding; as well as the RFCs for a definitive explanation of every Internet standard.


Another recommendation would be to install Linux (try Ubuntu or Fedora), and just run it. Add users and groups, configure SSH and Apache, etc. Linux will come with several different programming languages (Perl, Python, bash), and you'll be able to install many more with very little effort.


Don't worry about having a formal background in computers, because that's not very important. Besides, no one can teach you the curiosity you'll need to get really deep into this stuff. Just expect to spend countless hours in front of a computer, and expect to never stop reading and learning.

Has only been about a month this streak, but during this time I've established the longest term goal I have: to be a good father. To some, this may sound trivial, but it is an enormous step in my life. I didn't have a father, and for most of my life I didn't think I would have children of my own because of that. I'm still many years away from that day (not married even) but this overarching umbrella goal enables me to set short term goals and reach those, which give me the dopamine I referred to in my post.

I'm a software developer by trade, so being a good father would involve being good at my job to provide stability. So, two goals I'm working towards today are: read 75 pages of this book daily

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

and finish all the free (no subscription required) practice problems here:

https://leetcode.com/problemset/all/

Another goal coming soon is: get to the gym 3 days per week. No progress on that goal yet; still at 0 per week :\^).

I see that, I suppose I just read it wrong. I found syntax here, and the best textbook my classes used was Code Complete by Steve McConnell. Good book, though huge and often too in-depth. But really, there are more than enough resources online, no need to buy a book. The benefit of it is that the textbook uses C++ to describe more advanced programming practices. It's a focus on how to program well and professionally, rather than just teaching basic syntax

For the overall picture (vSphere only), you can't go wrong with Scott Lowe's Mastering vSphere 5.

Epping and Denneman wrote a technical deepdive book on clustering which really gets into the nitty gritty.

And for storage, Mostafa Khalil wrote the bible.

Also, if you want to really dive into the virtualization arena, definitely check out the VMware community site. Follow people on twitter, join the live podcasts (community podcast and vBrownBags), etc... Listening to recorded podcasts is also a great way to learn.

I second this, Code Complete is a great book for intermediate programmers. It covers practical issues that go beyond the normal issues covered in programming languages books, e.g. how to comment code.

Another good one is The Practice of Programming

A good "meta" book is The Pragmatic Programmer

What you probably want to look at is HTTP. It should be language agnostic. I'm still learning about HTTP myself, but GET requests should get you sorted for now. I haven't found any good free tutorials online for HTTP, but this book is great.

One of the most important lessons in Code Complete is that you don't code in a language, you code into a language. That is, your understanding of the parts of your program needs to be independent of the language you happen to be using. Language features can help you be less verbose, or more efficient, or whatever, but good abstraction is what really matters, and it's always up to you. Highly recommended book for professionals or future-professionals.

If you have an Amazon Prime account.

https://www.amazon.com/Stealing-Pride-Vol-Customizations-ConfigMgr/dp/9187445034/

https://www.amazon.com/Deployment-Fundamentals-Vol-Deploying-Microsoft/dp/9187445212/

Links I found useful

https://mdtguy.wordpress.com/

https://deploymentresearch.com/

https://deploymentbunny.com/

When you inevitably go down the rabbit hole of customsettings.ini and bootstrap

https://docs.microsoft.com/en-us/previous-versions//bb490304(v=technet.10)

Driver Injection and all the fun that comes with it

https://community.spiceworks.com/how_to/116865-add-drivers-to-mdt-all-versions-total-control-method

It's a lot of links but I think all of them are worthwhile. Either way, Google is your friend when learning MDT. These are all pertinent links if you are serious about learning MDT.

​

I love Tubes: A Journey to the Center of the Internet. It’s great in that it goes to physical locations that are important to the Internet, and described them. If you’re a Service Provider Engineer, many will be familiar but described through the eyes of someone fairly non-technical. If you’re an enterprise Engineer, some will be familiar, and some will be all new. Really fun, quick read.

Hi there, fellow EE.

We should make a club :)

I believe you can do a crash course into software development and catch up later when it comes to be a better software developer, since you've already been in the market for 4 years I'm sure you know exactly what I'm talking about (job has nothing to do with education, and you can learn as you go), and I know its the same in CS, a lot of companies just want you to do specific thing, and they don't really care about your theoretical knowledge or your full knowledge with software development life cycle.


Since you are an EE graduate I think you can relatively easily land a c++ software development job, but the problem with c++ is that there is a lot of theoretical knowledge is expected from you.

Still I believe if you set aside 3 months of your lifetime and study the following:

Programming: Principles and Practice Using C++

Code Complete

introduction to algorithms

Optional:

Software Engineering

Java Heads first

C# in a nutshell

Note, half of these books will bore you to death, but you have to power through.
Also there will come times where you don't understand what you are reading, I find it best is just to keep going, eventually things will make sense.

I personally find books is the fastest way to learn, and give you the deepest knowledge and always access to awesome tips and tricks that you can't learn at class or from a video.

If you pick those books, you can read from them in parallel, make a habit of finishing a chapter per 24/48 hour and practice 1-2 hours of programming (of what you've learned) I'm sure by the end of the 3 months you will be better than a lot of CS graduates

Sticking to specific design principles in code is a recipe for pain. It's easier to adapt to pre-existing style in the case of something like UE3 than it is to adapt UE3 to specific design principles. While it's certainly good to be familiar with common patterns (Design Patterns and Code Complete are two of the more common books I see in this regard), being flexible and ready to adapt to a pre-existing code style is going to be infinitely more useful.

In that situation, you're still going to learn more on the job than in school, and that's hard to avoid.

As a software engineer at a DoD-funded company, I learned about this disaster at work when taking training on how software should be accounted for at each stage of a mission.

I feel like so many problems like this could be avoided if we just teach everyone software engineering fundamentals. I'm surrounded by some of our country's brightest engineers, scientists, researchers, and analysts but they still don't get the value of input validation! That one hurt my heart when I heard it.

Software engineering isn't even that hard. There are facts that we've been taking for granted for decades in the software industry. Everyone at this company depends on software and most people at least write the occasional script to help them. They should all know what's involved in making quality software.

(Of course all of these resources should be taken with a grain of salt, but it never hurts to gather more information to consider when making mission-critical decisions.)

Anyway this 'everyone should learn software engineering' thing is the hill I'm gonna die on at this company, wish me luck.

I understand that. There's a definite stigma around the word "hacker" which I try to avoid. When I talk about going to Defcon I call it an "Infosec conference" instead. Given most of the content, that is the focus of the conference so it's pretty close to the truth and gives people a good idea of what is discussed.

That having been said, I definitely wouldn't let a 14 year old go unattended. You may be able to begin an information campaign with your parents to convince them to take you.

First, you'll have to remove the stigma around the word. Hackers: Heroes of the Computer Revolution predates the modern usage of the word "hacker" and is what my dad had me read when I took AP Computer Science in high school. Getting your parents to read this book could be a double edged sword though - a lot of the actions of the people discussed in the book were outright illegal.

Another, possibly more workable option may be to get into the Maker scene. A lot of people there may use the word "hacker" and "hack" because those words also refer to someone who gets a system to operate past its perceived limits or a way of doing so. That may get your parents to think more broadly about the word.

I honestly don't know how well either of those recommendations will work because I never had to deal with this. Both of my parents are tech savvy and early adopters.

Hackers by Steven Levy is the best back-in-the-day programming story collection that I ever read. It really changed me. I recommend it highly for a good read.

http://www.amazon.com/Hackers-Computer-Revolution-Anniversary-Edition/dp/1449388396

> I like video tutorials the most.

That's nice.

I like videos too.
But there arent any sets of video instructions that compare at any real level to the quality of that book.

You will be very hard-pressed to find another reference as solid as this:

TCP/IP Illustrated, Vol. 1: The Protocols (Addison-Wesley Professional Computing Series)

And I say that with a straight face & all sincerenty, even though it was written in 1993.

If you really want to understand this subject make yourself read this book.
If you can't read this book, (for reason other than an actual disability of some sort) then you might not be as well suited to this career field as you think.

> and the company equipment isn't even close to standard, it's what's on sale.

That is the most incompetent company I have ever heard of. You standardize on laptops because it makes service, support, inventory management, budgeting, and forecasting easier. You use WDS/MDT to create a corporate image and inject the appropriate drivers using driver groups and the specific laptop model.

Frankly- if you aren't doing it this way you need to read up on best practices. Pick up a copy of Deployment Fundamentals:

http://www.amazon.com/Deployment-Fundamentals-Vol-Deploying-Windows/dp/9197939080

If you only have one IT guy setting up a WDS/MDT server and standardizing your system models will save him so much time it isn't funny.

Some highly recommended books:

• The Pragmatic Programmer
  
• Code Complete
  
• Clean Code
  
  Bonus JS Book: JavaScript: The Good Parts
  
  Note: Software development is a very wide field. You don't need to learn everything, it's okay to focus on your strengths. Don't be discouraged if you find a particular subject too difficult to learn.
  

I'm in a class that uses Code Complete right now, and it's very good. One of the best "textbooks" (it's not really a textbook) I've ever had for computer science. Lots of useful takeaways even if you don't have a chance to write the code offered in it.

What most consider the original is actually titled:

• Hackers by Steven Levy
  
  More recently, there have been several excellent titles. My suggestion is stick to non fiction as it will truly scare the yell out of you.
  
  
• Kingpin by Kevin Paulsen
  
  
• Hackers and Hacking by Margaret Haerens
  
  
• Cyber War by Richard C Clarke
  
  
• Schneier on Security by Bruce Schneier ---
  Almost everything by Bruce
  
  
• The Art of Intrusion by Kevin Mitnick. He has a couple of books as you may know. The advantage is he offers the perspective of a "former" hacker.
  
  I can recommend more but these are good starting points. Fiction is fun but for pure terror, grasping what these authors are revealing is the key.

I would first of all gather the IP addresses of those system and then verify that those IP's are within the range of IP subnets listed in your SCCM Boundaries. Also turn on Client Push Installation. basically you need to get the client installed on them before they report data back data. You will probably need to configure your Hardware Inventory in Client Settings as well, like I said turn on all the Asset Intelligence classes. Sounds like you have some work cut out for you. It will come together with time. You might want to go get a copy of this book. https://www.amazon.com/System-Configuration-Manager-Current-Unleashed/dp/0672337908

Read some easy beginner's book like Head First C# to get initial grasp of a language and after you finished with it read C# in Depth. If you really want to understand what is happening pick up CLR via C#.
Also always follow Code complete religiously and you will be better than most.

The world of networking is huge. It's a marathon not a sprint. Huge repositories of information exist. Take your time to go through them.

Start with these -

https://www.amazon.com/TCP-Illustrated-Vol-Addison-Wesley-Professional/dp/0201633469

https://www.amazon.com/TCP-IP-Illustrated-Implementation-Vol/dp/020163354X

Use this to help supplement your studies -

https://www.amazon.com/Network-Warrior-Gary-Donahue/dp/1449387861/

As always Cisco has a ton of white papers -

http://www.cisco.com/c/dam/en_us/about/security/intelligence/urpf.pdf

Free Presentations from Cisco Live -

https://www.ciscolive.com/online/connect/search.ww



If you wish to look at things from a different vendors perspective look into Juniper Day One -

http://www.juniper.net/us/en/training/jnbooks/day-one/

Finally RFCs are good place to get the nitty gritty of the protocols/standards -


OSPF

Code Complete 2 gets recommened a lot and I personally enjoyed it. Flip through the sample pages they give you on Amazon and read through the table of contents. It does a good job of breaking down both how and why you should organize your code along with a lot of other good info so that even 5 years from now you or anyone else could look at your code and recognize what each section is supposed to be doing.

Every quality software should have tests. So...

Read the unit tests / features tests first. Those will show you how a specific piece of the code works.

Also:

1. Play with composer packages.
   
2. Learn about PHP SPL
   
3. Learn about design patterns and beyond
   
4. Learn TDD, setup PHPUnit, Behat, Mink, PHPSpec
   
5. Read PHP The Right Way
   
6. Learn about clean code, EBI, DCI and how to put MVC on a shorter leash here: http://ikke.info/clean_code.html and here http://ikke.info/todo.txt and check out the #cleancode IRC channel on freenode
   
7. Read a couple of books like: PHP Objects, Patterns and Practice or Code Complete or Clean Code or The Pragmatic Programmer or The Mythical Man-Month
   
8. Start an open-source project or contribute to one
   
   
   There are a lot to learn and if you really like programming you will never stop learning.
   
   

Something I hawk whenever I can: Code Complete by Steve McConnell is a huge recommendation. I never learned anything besides like 100-line programs before this, and I basically divide my programming journey into before and after reading this. It's seriously worth reading: you can skip chapters that don't apply to you, but it is one of the best resources on how to manage the complexity shift between small and large codebases.

I'm a big fan of Pirates of Silicon Valley. I can't find a source, but either Jobs, Gates, or Woz said something like "Yeah, that's pretty much just how it went."

When the movie came out, I was really into the history of computers. I had just read "Hackers" (no relation to the movie "Hackers"), so it was exciting to see things I had read about in a movie. Unlike a lot of movie adaptations, there was practically nothing about it that I found disappointing.

Woz Talks about the accuracy

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

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

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

edit: Updated up to redline6561

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

I'd say whatever point you are in your learning, it's never too early to set some modest practice goals and actually just sit down with an editor (just a basic text editor) and a compiler and just try to make something work.

Getting a real hands-on feel for the things you know - no matter how 'basic' it seems, is going to serve you well.

At first, you should follow your interests in this practice, but as you go on, you should try to be more deliberate in what you learn (i.e. whether it's 'fun' or not). You might start to form some bad habits - this deliberate practice stage is a good place to break yourself of them.

At some point into your learning, I'd recommend getting your hands on this book: Code Complete - there's a lot of great ideas in there on how to code.

If you haven't read it, I recommend Code Complete. It's a classic for a reason.

You read code far more than you write it, so do whatever you think is necessary to make the code more readable. You seem to be beyond the basics (self-documenting code, etc), so a few advanced tips:

• Within a script, you can open up additional tabs that let you write more scripts so that they're all bundled together under one script name. You can use this to break a complex script down into smaller and smaller sub scripts without cluttering up your resource tree.
  
  
• Abolish "magic numbers." In your example, if there's a number that you use that could potentially change, make it a macro (constant), enum, or global variable with a descriptive name. Macros and enums are substituted at compile time, so they don't have any "look-up" overhead during run-time.
  
  
• I think you've already discovered why a lot of developers use scripts as often as possible: because it's easier to find and fix them than delving into an object's various events (or a room's creation code). Other than drawing, I usually have an event call a script, and the scripts are named hierarchically, e.g. sc_Creature_player_move
  
  There are a lot of good practices such as encapsulation, information hiding, and idempotence, that are too in-depth to get into here. IMO, GameMaker makes it really hard to follow some of these good practices, so I hope these suggestions are helpful to you.

If you're moving from academia, chances are any code you've written has been to get the computer to do something. Software development is more about writing code for other people to read and work with... which also happens to do what you want it to do. You might want to make sure you have the basics of software engineering practices down by reading Code Complete and Clean Code: A Handbook of Agile Software.

Beyond that, if you have a solid project or two that you can talk about the ins and outs of, it shouldn't be hard to convince a company that you can analyze data and write code to automate or otherwise help with that process.

You're done when you can write the code for any piece you don't have a more detailed plan for in under 5 minutes.

If you're looking for more guidance on how to do this stuff, read Code Complete http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ - it's written with C in mind, but translates perfectly well to most software projects. Especially chapter 9 - Pseudocode Programming Process.

Linked clones (persistent or non-persistent) come with the issues of being about to correctly thinapp all applications not on the base image, and handling user profiles (with persistent disks, or persona mgmt). Dedicated VMs avoid these issues and allow for more flexibility at the cost of more disk space and management (manage them like PCs). I am currently trying to talk my boss out of using thin clients with linked clones instead of full PCs, because it adds extra management and user interruption, not decreasing it.

I'm going to buy this book: The VDI Delusion: Why Desktop Virtualization Failed to Live Up to the Hype, and What the Future Enterprise Desktop will Really Look Like

Anyway, it sounds like they are using View for remote users, which is a decent idea. PCOIP is supposed to be much better for WAN performance, so it might be a good idea (if you have extra time) to see if you can get that working and demo it.

Where do you live? Check if there is a Ruby User group nearby, if there is that would be a good a place to start as any.

Also, have you tried to learn by yourself using the internet or a book as guidance? Agile Web Development with Rails is pretty darn good, and is currently priced at less than what an hour long private lesson would be.

Not sure if it's related to this book, but

Hackers: Heroes of the Computer Revolution https://www.amazon.com/dp/1449388396/ref=cm_sw_r_cp_apa_i_1b.yDbKR0N261

is one of my favorite non-fiction books of all time.

Hackers starts after Turing and other pre-computers (at least what we think of as a computer), but it is a pretty good narrative history beginning with the formation of the Model Train Railroad Club at MIT through to the PDP-7, Apple Mac and beyond.

edit: a letter

This book is not Python, but it is great for building more complex stuff. This book covers advanced Python specifically. You should probably read both.

Well first you never use tables you only use views.

Secondly, this book is a good starting point to learn reporting for SCCM.

https://www.amazon.com/System-Configuration-Manager-Reporting-Unleashed/dp/0672337789

Also MMSMOA is a great conference to learn SCCM and reporting.

https://mmsmoa.com/

Buy and read this book. It's like the joy of cooking for programming. I wish I had read it earlier in my career. http://www.amazon.co.uk/Code-Complete-Practical-Handbook-Construction/dp/0735619670

That's probably a good way to organize it then.

Here are a few good books to check out, if you care:

• Code Complete: A Practical Handbook of Software Construction
  
• Clean Code: A Handbook of Agile Software Craftsmanship
  
• The Pragmatic Programmer: From Journeyman to Master
  
  These all helped me a lot when I started.

TCP/IP Illustrated, Vol. 1: The Protocols

Yes it is very dated but still one of the best networking books ever published. This book got me started on my way to becoming a dual CCIE.

Edit: Just saw Disruptpwnt's post and didn't realize that it has been updated. I will have to go get a new copy!

The term Hacker comes from the MIT model train club... which amusingly became the computer club... the specific incident where the term was coined is described in detail in this book... it was achieved by jamming a screwdriver between two contacts giving a computer an extra register it was not originally designed with... You want to read a great book about the microcomputer revolution, this is it...

https://www.amazon.com/Hackers-Computer-Revolution-Steven-Levy/dp/1449388396

You've probably come across it already, but if not Code Complete is similarly old, but still well worth your time (I actually found it better than Pragmatic... first time I came across it)

If you're looking to expand your knowledge and learn some of the more advanced concepts, then read the following books:

• Domain-Driven Design: Tackling Complexity in the Heart of Software
  
• Patterns of Enterprise Application Architecture
  
• Design Patterns: Elements of Reusable Object-Oriented Software
  
• Code Complete: A Practical Handbook of Software Construction

The bottom line is that, whatever your rationale might be, this code is extremely difficult to read and understand for anyone who isn't you. I had to just skip over the entire tokenizer because I wasn't getting anything out of trying to read it, except for frustration. The algorithm portion isn't much better.

Good names are one of the best ways for an author to communicate how their code works to other programmers. They provide the foothold that the person reading the code needs so that they can begin understanding the algorithms. With what you've got here, the reader must already understand the algorithms before ever seeing the code, so that he can map the concepts he already has in his head onto the uninformative variable names.

I'll give you an example that I paraphrased from Code Complete, which, if you haven't heard of it, is one of the absolute classic works on the topic of how to construct good code. What do you think this code fragment is doing:

a = a - b;
c = d + sales_tax(d);
a = a + late_fee(e, a) + c;
a = a + interest(e, a);

Despite the good function names, it's still extremely difficult to figure out what this code is trying to accomplish; if I have to make a change in something that relates to this module, I don't know where to start. But, after we name the variables:

balance = balance - last_payment;
monthly_total = new_purchases + sales_tax(new_purchases);
balance = balance + late_fee(customer_number, balance) + monthly_total;
balance = balance + interest(customer_number, balance);

See how much easier it is now to see that this code is computing a customer's bill based on their outstanding balance and a set of new purchases from the current month?

Using good variable names allows anyone to just read your code and understand immediately what it is doing. Without good variable names, anyone reading your code has to already know what it is doing.

Data structures and Algorithms Write code to impleement every (or even most) and you'll be well preparped.

Design and Testing here.

Programming Languages here.

Also look for an open source project that needs help and provides you with experience in one or more of these areas (or start your own). Code is always a good way of showing you know something.

As another poster said, you don't necessarily need a SAN, these days you would be best off starting with storage connected over your network (VLANed and QoSed), you could start with a NAS device and use NFS datastores.


If you wanted to go for a SAN you can get an iSCSI SAN as also already mentioned Dell EqualLogic is a good option

A couple of books to read :

Scott Lowe et al. Mastering VMware vSphere 5.5

http://www.amazon.com/Mastering-VMware-vSphere-Scott-Lowe/dp/1118661141

Storage Implementation in vSphere 5.0

http://www.amazon.com/Storage-Implementation-vSphere-VMware-Press/dp/0321799933/

The latter book is a good in depth look at storage from VMware press.

The main thing to be aware of for storage is IOPs and latency, these are the biggest performance killers as you scale. So design around desired IOPs (Input/Output Operations Per Second).