#1 in Networking & cloud computing books
Use arrows to jump to the previous/next product
Reddit mentions of Code Complete: A Practical Handbook of Software Construction, Second Edition
Sentiment score: 119
Reddit mentions: 206
We found 206 Reddit mentions of Code Complete: A Practical Handbook of Software Construction, Second Edition. Here are the top ones.
Buying options
View on Amazon.comor
- Microsoft Press
Features:
Specs:
Height | 9.125 Inches |
Length | 7.5 Inches |
Number of items | 1 |
Weight | 3.3510263824 Pounds |
Width | 1.625 Inches |
Here's my list of the classics:
General Computing
Computer Science
Software Development
Case Studies
Employment
Language-Specific
C
Python
C#
C++
Java
Linux Shell Scripts
Web Development
Ruby and Rails
Assembly
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
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...
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.
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:
There are a lot to learn and if you really like programming you will never stop learning.
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
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.
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:
I think the two suggestions you'll see the most will be:
Code Complete
Pragmatic Programmer
Code Compete or maybe Code
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 justn
. 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 recommend code complete 2 as a must read for getting the fundamentals right.
http://www.amazon.com/Code-Complete-Second-Steve-McConnell/dp/0735619670
You may want to narrow that down a bit, but okay, here are some highlights, with amazon links to help disambiguate.
http://www.amazon.com/Game-Programming-Gems-Adam-Lake/dp/1584507020/
www.amazon.com/Game-Engine-Architecture-Jason-Gregory/dp/1568814135/
http://www.amazon.com/Game-Engine-Design-Second-Edition/dp/0122290631/
http://www.amazon.com/Game-Engine-Architecture-Engineering-Applications/dp/012229064X/
http://www.amazon.com/Artificial-Intelligence-Games-Second-Edition/dp/0123747317/
http://www.amazon.com/AI-Game-Programming-Wisdom-CD-ROM/dp/1584500778/
http://www.amazon.com/Real-Time-Rendering-Third-Edition-Akenine-Moller/
http://www.amazon.com/Real-Time-Cameras-Mark-Haigh-Hutchinson/dp/0123116341/
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.
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!
Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.
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.
Then there are these books that aren't really "CS books", but are geared more twoards practitioners.
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:
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.
Code Complete (haven't yet read ed. 2, but the first edition was tremendous)
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 :)
Code Complete: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
Applicable to any OO language you are using.
These have been recommended to me a lot, although I haven't gotten around to them yet....
Code Complete
Code Craft
Programming Pearls
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:
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.
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.
Clean Code
vs
Code Complete
Code Complete and Pragmatic Programmer are great books about programming as a craft and are both language agnostic.
Not game-specific, but these books are definitely industry essential books when it comes to anything related to software development.
In no particular order (though Code Complete should probably be first):
> So something that would take in excess of 3 years to master is out, if you catch my drift.
You seem to be misguided on this point - while you can pick up the basics/fundamentals of programming pretty quickly, if you're so inclined, the actual practice of writing software, and writing it well, is going to take a lot of time investment. I look back at code/software I wrote when I was just starting out professionally, and while they worked, I know how poorly they compare to what I can write/design now.
Having 3 years of software development experience when starting from zero would probably leave you at 'junior' or 'mid' level at the end, and if you don't have a more experienced developer mentoring you throughout the process, you may be at a disadvantage. From the sound of it, your school has no actual programmers/developers.
With that said:
The key to building bigger systems is writing modular code. I don't mean just code made of modules, I mean code in which the module boundaries are in the right places. Code divided into the most meaningful and distinct chunks.
You want to divide areas of responsibility into separate modules, in such a way that each module has a clear, distinct and succinct area of responsibility and the interfaces between modules (the function calls and data passed) are simple and minimal. Finding the right boundaries takes thinking deeply about the problem, and considering different ways to model it. When you get it right, you will find that changing implementation of one part of the code is much less likely to cascade into other areas.
The idea that this is an important way to think about designing a program is called the separation of concerns principle.
Patterns that can help with this include dependency injection which is often required for unit testing, and which forces you to separate modules and aspect oriented programming which deals with modularizing cross-cutting concerns, things like caching, logging and error handling which often show up in many different places in your code and undermine modularity.
Code Complete by Steve McConnell addresses these issues and has lots of helpful advice for dealing with large projects and large systems.
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.
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.
Hi! I recommend the following books:
You can find other similar books here and here.
One that I especially liked (although closer to an algorithms textbook, but also had very cool "War Stories") is called The Algorithm Design Manual.
Have fun reading! :D
Code Complete 2nd Edition is what you want.
> I first build a very simple prototype that has some basic actions and game principles I want to have in my game. I do not care for design nor code quality.
IIRC, this technique is highlighted in Code Complete. The key point the author made there was that it's OK to take shortcuts while prototyping, as long as you're willing to throw all that code away before doing the real work. (Of course, it's not that black and white.)
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:
 
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:
 
(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)
Probably the best book on "thinking like a software engineer" is Code Complete.
For now, here are a few general tips off the top of my head:
Code Complete
These are the coding conventions every Java developer should follow:
Oracle's Code Conventions for the Java Programming Language
If there are industry-wide coding conventions for the particular language, follow those. (i.e.: Java , C#); otherwise, most companies will enforce some conventions (i.e. most companies have their own C++, C coding conventions); otherwise, establish some, and stick to it. This book has general guidelines on coding conventions and best practices: Code Complete 2
[Code Complete] ( http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670) 960 pages, no fluff, essential reading to any programmer.
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
overhow 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.
Two things: The coursework from my CS degree, and reading books about software engineering.
I've spoken in other places about the former, and for the latter, I recommend The Pragmatic Programmer, Code Complete, and Design Patterns: Elements of Reusable Object-Oriented Software
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.
Code Complete by Steve McConnell
Perfectly normal. After 15 years of amateur programming I still make stupid mistakes and have dumb days and weeks when I get or seem to get nothing done. But like the saying goes it's only a problem if you don't learn from your mistakes. I can write a class get it working and come back to it in a week and can't for the life of me figure out why I'd done something a certain way. So my approach now is to break the program into modules and then classes which are independent as possible. Test those classes and finalise them as much as possible so I never need to modify them again and make notes on how they work. In fact I seem to make notes on everything I do. From theory to how classes in an API works to my own code. I've read somewhere programming is one of the most mentally intensive activities a human can do, so don't be surprised if you find it difficult at times, every programmer does I'm sure. Good luck 👍 oh yeah I forgot I'd strongly recommend reading code complete it helped me out more than any other programming book and it's lessons apply to any language. Think it even has a chapter on human factors
There are a lot of different strategies.
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
Code: The Hidden Language of Computer Hardware and Software
Clean Code: A Handbook of Agile Software Craftsmanship
Code Complete: A Practical Handbook of Software Construction
Algorithms
Types and Programming Languages
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.
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:
Having trouble with Algorithm design/analysis? These are some of the go-to books for that:
There are several good books on designing good software:
Code Complete
Design Patterns
Refactoring
The stuff you are learning in CS class is definitely important, but it's orthogonal to the things you will need to learn in the industry.
Read "Code Complete" to get a head start on this stuff. - https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
As far as some fun interviews with famous programmers, another great book is https://www.amazon.com/Practice-Programming-Addison-Wesley-Professional-Computing/dp/020161586X
Code Complete: A Practical Handbook of Software Construction is often recommended
This list isn't about "coding" per-se but is more focused on concepts, sw.en., practices, etc.
Thinking in Java is one of my favorites, the definitive introduction to object oriented programming and design.
Code Complete, Don't know anyone who hasn't heard of this so far
The Pragmatic Programmer: From Journeyman to Master
I can't believe that no one mentioned Code Complete: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&s=books&qid=1267359531&sr=8-1
It totally changed my perspective on writing applications, no matter what the language or scenario. HIGHLY recommended - every programmer should read it.
Perhaps offtopic but... Some books you should read regardless of CompSci branch
Hmmm...
Like everyone said, it depends. Deep nesting can often be a code smell. This book will help answer your questions:
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
But more importantly, please don't call yourself (or others!) a bad programmer! I'm sure you're just joking, but there's this weird vibe in the scene where people's worth is evaluated on their code. It kinda sucks. You're not your code.
A better question would be: does this pattern indicate poorly written code? The answer is GOTO: Hmmm...
Code Complete
Big Java Late Objects
The Pragmatic Programmer: From Journeyman to Master
The Mythical Man-Month
Android Programming: The Big Nerd Ranch Guide
cracking the coding Interview
Introduction to Algorithms
Thinking in C++
http://www.amazon.com/gp/aw/d/0735619670 code complete. One of the best books about coding in general that I've ever read.
That depends how adept you are at programming in general and what you want out of the book. If you have experience with other languages you could get by with a cheaper 'handbook' or just visit cplusplus.com. If you want a more comprehensive 'how to program' book I would suggest reading the definitive C++ book guide and getting yourself a copy of Code Complete.
I've got some tips for ya!
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.
I spent a lot of time learning specific architectures and patterns that were in common usage when I first started, but the specific patterns in vogue are constantly changing. I'd recommend reading all 3 of these books at some point earlier in your career, I think a lot of the popular software design practices are based on the foundation of ideas in here and if you read them you will start to naturally make the right choices when it comes to organizing your code.
https://www.amazon.com/Pragmatic-Programmer-journey-mastery-Anniversary/dp/0135957052/ref=pd_sbs_14_t_0/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0135957052&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=pd_sbs_14_t_2/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0735619670&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sbs_14_t_1/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0132350882&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D
>> 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.
>To me the two samples of code are identical except the second is more frustrating because I have to tear through unnecessary characters to see what is really happening with the operators. Maybe if the variable names were extremely short I could better understand your position, but in your example they are not.
>It takes all of 10 seconds to get a handle on the first set of code. I would have to sit down and really study the second set, because its syntax is so completely less apparent. To me tldr sums up my thoughts completely on your second set of code. I guess I can see why that code would make more sense to you, but typically I don't have that kind of time and with big names like that I can imagine my frustration would increase in proportion to the increasing underlying code base. This frustration is just in reading the code. I believe the second code sample likely took you far longer to write than the first.
>I never got into programming to read novels or dissertations.
\>I never got into programming to read novels or dissertations.
master troll
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.
Copy(6, 12);
Copy(11, 13);
Copy(10, 16);
Copy(2, 3);
Copy(4, 5);
This looks like a complete mess.
Try to read this book and then rewrite this code if necessary
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670 this one.
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.
Read lots of code and read books to get multiple viewpoints. This is a deep topic which will require more than superficial online reading.
Check this out.
Books I have found useful:
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.
Code Complete is really good if you haven't read it yet.
Seconding The Pragmatic Programmer and Cracking the Coding Interview. I'd also recommend:
If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.
> In other disciplines, engineering in particular, there > exist treatises on architecture. This is not the current case in software,
Gee I better throw out all those books on architecture since clearly they don't exist.
We can also ignore Fowler's book, GOF, SICP, and TAOCP since clearly they are treatises on software either.
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.
If you are doing any coding at all, you should read Code Complete
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
Junior Software Engineer Reading List
Read This First
Fundementals
Understanding Professional Software Environments
Mentality
History
Mid Level Software Engineer Reading List
Read This First
Fundementals
Software Design
Software Engineering Skill Sets
Databases
User Experience
Mentality
History
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.
Per testare le acque velocemente puoi usare https://rubymonk.com/ (introduce Ruby in modo basico). Anche Coursera, Khan, Udacity e simili hanno corsi introduttivi sulla programmazione.
Mentre se vuoi imparare a programmare, il percorso deve toccare almeno tutte queste tappe, in ordine:
Organization-Design-Fourth-Edition/dp/0123744938)
Da qui puoi partire e specializzarti in quello che ti interessa
Read "Code Complete, 2nd version". Its everything you'd learn in 10 years of experience, summarized into 1 book.
I enjoyed Code Complete.
http://www.kalzumeus.com/2011/10/28/dont-call-yourself-a-programmer/
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
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.
Oh man. You need to work on your coding conventions and formatting. I assume you've never worked on a team before. You will make people very upset. It's really hard to follow the logical blocks and flow of your code. You should buy this book and work your way through it. You will be 1000 times better at this. https://www.amazon.com/gp/aw/d/0735619670?pc_redir=T1
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.
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.
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.
McConnell's Code Complete: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&s=books&qid=1250308729&sr=8-1
Go read Code Craft or Code Complete to learn not the theory but the practice of programming.
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:
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:
These three books have strongly influenced me as a developer
Code complete 2, is the best programming book I have ever read. I would however recomend a year or two as a programmer before you read it.
This is what Steve McConnell calls the Pseudocode Programming Process in Code Complete. He dedicates a whole chapter to it.
See http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670 chapter 9.
This is all you need.
Code Complete
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!
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:
Pieces of your app should be able to change without considerable changes to the whole.
research solid principles:
http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29
research a layered architecture:
http://layersample.codeplex.com/
try this link for sqlite:
http://brice-lambson.blogspot.com/2013/06/systemdatasqlite-on-entity-framework-6.html
also, if you are in school, complete your assignments, but other than that
do not write another line of code until you have checked out (at least read the chapters on writing classes and functions):
Clean Code
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
and Code Complete
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
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.
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!
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
The C Programming Language is a good one too. Although it's specific to learning C, reading through it and doing all the exercises is something every programmer should do at least once.
Also, Code Complete 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.
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.
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.
Great suggestions! I also highly recommend Code Complete: A practical handbook of Software Construction (Second Edition) by Steve McConnell
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.
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.
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!
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!
>Where can I start with those?
Book recommendation: Code Complete. Can be a bit dry sometimes, imho.
Less dry: The Practice of Programming. The examples are mainly in C though.
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.
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.
First time see that site, but I would recommend reading:
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!
Object oriented programming is a deep topic.
If you are looking for a simple introduction, I found Chapter 8 of this book, which is also used for the MIT
Intro to Programming using Python
pretty good.https://mitpress.mit.edu/books/introduction-computation-and-programming-using-python-0
If you want to dive deeper, these 2 books have good descripts of OOP and other fundamentals of Programming. However, these are not specific to Python, but are probably the most recommended books in programming:
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.
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.
I would recommend reading articles/books on good code/ code reviews. McConnell also had a section on them in Code Complete.
Here's a reasonable guide
http://haacked.com/archive/2013/10/28/code-review-like-you-mean-it.aspx/
This article also has some reasonable opinions. Ignore the product plugs.
http://blog.fogcreek.com/effective-code-reviews-9-tips-from-a-converted-skeptic/
Remember that the person that you are reviewing spent several hours on this problem and probably has a greater appreciation for the hidden problems.
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:
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.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Essential reading:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&ie=UTF8&qid=1426600164&sr=1-1&keywords=clean+code
http://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073/ref=sr_1_2?s=books&ie=UTF8&qid=1426600164&sr=1-2&keywords=clean+code
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_4?s=books&ie=UTF8&qid=1426600164&sr=1-4&keywords=clean+code
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_5?s=books&ie=UTF8&qid=1426600164&sr=1-5&keywords=clean+code
Yeah I heard about Hinkley Point C, wonder if it will happen as it needs a hike in Electricity prices. No role for me, being in Sweden and all.
Glad you asked for recommendations - read the Mythical Man Month, it is a classical piece of literature on Software Development , its from the 60s 70s but holds true even today,
http://www.amazon.com/The-Mythical-Man-Month-Engineering-Anniversary/dp/0201835959/ref=sr_1_1?ie=UTF8&qid=1375051342&sr=8-1&keywords=mythical+man+month
and Code Complete, by Steve Mcconnell (I have met him in the US a few times)
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?s=books&ie=UTF8&qid=1375051372&sr=1-1&keywords=code+complete
probably enough with those two to start with..
Do not read any of the stuff this poster put out there :OD
Design Patterns: A book written in the early 90's to get around problems of early 90's languages. It's as old as you are practically.
Mythical Man Month: This is about working on software in large organizations. It is not at all related to what you're going to be doing for a number of years:
Code Complete: This is out of date. You should...at best....be reading Code Complete 2. I would say you should wait a couple more years to read that, as while it goes through all the correct sort of ways to build software, most of it will fly right over your head while it maters, and additionally you will likely take them as dogmatic rules.
Now estimation, in a year or so, I'd think about reading the Estimation book by the Code Complete guy....but only think about it...as it will help you budget your time a little better, but you'll really benefit from reading it most once you've had an internship or two.
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:
Things you will be doing that CS degree does not prepare you for
I would suggest reading books like Design Patterns, Mythical Man-Month and Code Complete
In no particular order:
Structure and Interpretation of Computer Programs
Code Complete
C Programming Language(K&R)
The Pragmatic Programmer
The Mythical Man Month: Essays on Software Engineering
Introduction to Algorithms and/or Algorithms
Code Complete is a good start.
"Useful" and "safe" are interesting criteria, and delve into software engineering topics such as good requirements gathering practices and software processes.
You can find any algorithms book, video, or online course for writing efficient code, since that's one of the things curriculums stress in Computer Science. Here's a start.
If you're running into problems with a method with so many local variables that the names are colliding; perhaps you should consider writing shorter methods that each do a single, simple task, then chain those together. Here's more on that code smell.
That being said, Code Complete by Steve McConnell has an entire chapter (11) on naming things, I highly recommend it.
On top of those, I would recommend this. It's a very comprehensive book, touching on many aspects of software development, and is quite readable.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
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.
Thanks, but this is one 7.5 hour course and does not seem anywhere near a complete path to being job ready.
I have a Udemy account and would buy Mosh's courses on Udemy if I thought that they would form a concise package when put together. I would supplement this learning with books if necessary - specifically the following:
https://www.amazon.co.uk/dp/0735619670/?coliid=I3G8SYORH393ZR&colid=1IRAIWB2MBRLH&psc=0&ref_=lv_ov_lig_dp_it
https://www.amazon.co.uk/dp/0132350882/?coliid=I1ZCBXMO9SV7S2&colid=1IRAIWB2MBRLH&psc=0&ref_=lv_ov_lig_dp_it
https://www.amazon.co.uk/dp/0984782850/?coliid=I1OZDYM4OMN8N7&colid=1IRAIWB2MBRLH&psc=0&ref_=lv_ov_lig_dp_it
But a course where everything fits together (such as a bootcamp I can't afford) is really what I'm looking for.
Code Complete!
Buy and read this book as soon as you can. It's the gold jewel of software development, I guarantee that if you read and understand it, you'll be better than 80% of programmers out there. ^[citation ^needed]
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.
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!
Highly endorsed, first book I read out of school:
Code Complete - Steve McConnell
Bonus, engineers at my office were just given this book as recommended reading:
Clean Architecture - Robert C. Martin
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
Some highly recommended books:
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.
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 :\^).
It's not a website but a book like Code Complete contains this kind of information.
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)
Focus on other aspects. Reading and being able to talk architecture has gotten me a lot further than the “cracking the code”, leetCode type of stuff.
(None of these are affiliate links)
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
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.
I just chose some books that looked good from this list and this one.
The one's I got:
Clean Code
(already read)
Cracking the Coding Interview
Code Complete
Peopleware
Don't Make Me Think
Code (currently reading)
Regular Expressions Cookbook
Head First Design Patterns
C++ Primer
Working Effectively with Legacy Code
Elements of Programming Interviews in Java
The Mythical Man-Month
The Design of Everyday Things
JavaScript and JQuery
I figure that's enough reading material to last me until I graduate.
If you're looking for reading material, you're at the right stage of coding to read Code Complete. It'll change the way you write code. It'll make your code more manageable when you start coding with a team. It'll teach you good coding practices. I highly recommend it.
For what it's worth, the purpose of the post is to flesh out ideas and see whether there's an unmet need for a userscript that I might be able to work on in my spare time.
I also wanted to get some practice with Code Complete's suggestion of starting a project with a simple, pure, documented "problem statement" which is entirely devoid of any potential implementations (whether implied or explicit).
But letting people know the purpose, and framing it this way, could distort the answers people are willing to give. I might be able to do something with a script that others might deem impossible, and I don't want their notion of what's possible and what isn't to cloud the answers I get.
I think the best way to learn OOP and MVC (and programming in general) is to write a large program from scratch without thinking about any of that stuff. When you have it working, read a book like Code Complete, and you'll be introduced to all kinds of concepts that make your life much easier.
Edit:
I forgot the most important part. If you get into OOP and really feel like you don't need it, or that it makes your life more difficult, simply don't use it. Many people like to get religious and dogmatic about certain ideas in programming, but there's absolutely no reason to not just go with what works for your situation.
Learning a language is mostly about doing. Often times you'll want to add some sort of functionality that you assume is fairly commonly implemented, so you'll google it or browse the documentation, then you'll read examples, and finally you'll use it in your own code. This is probably Skill #1 when it comes to hacking things up: googling.
That said, though, this is a very short-sighted approach to programming. You should try to look at coding more expansively, and see how languages differ from each other and also how they're largely the same. You may be surprised to find that modifiers like "protected" don't even exist in most languages, which begs the question: why are they there in the first place? You're playing with a very finicky language (C#), but most of those unusual constructs (whose usage isn't immediately apparent) are there to enforce the idea that your code is like a black box whose details can only be accessed on your terms (encapsulation. Static typing (e.g., specifying that a certain variable is of type 'int') serves a similar purpose of allowing for better and more immediate error detection. These are features that are meant to be of service to you in large projects with lots of entry points and lots of collaboration with other programmers.
To get at the real core of programming, though, these types of things don't need so much focus and are more of a distraction for you than anything. You should take a step back and read something that's more language agnostic like Code Complete or any number of books from this list given here on stack overflow.
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:
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.
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.
> 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.
I often see the suggestion for this book next to a suggestion for Code Complete. Anyone have thoughts on Code Complete?
If you're looking to expand your knowledge and learn some of the more advanced concepts, then read the following books:
I was probably thinking of Code Complete but I checked and it's actually formal code reviews which are better (where several people meet to go over the code in person); informal code reviews as usually practiced are slightly worse than unit tests. Still, according to What We Have Learned About Fighting Defects informal code reviews find more than half the bugs in the projects they considered.
That is a good book. I also like Code Complete
I don't know of any books or longer-form material that covers this.
Part of the hard part is that there are a lot of programming languages, and new languages can gain popularity rather quickly (like Rust) while others have been around a long time but are a bit different today than they were 10 years ago (true of Java, JavaScript, and C++) while others have quite similar pros/cons to 10 years ago (like Python).
This is a good answer on scripting vs not-scripting:
http://stackoverflow.com/questions/17253545/scripting-language-vs-programming-language
Here's a good one on static vs dynamic and strong vs weakly typed:
http://stackoverflow.com/questions/2690544/what-is-the-difference-between-a-strongly-typed-language-and-a-statically-typed
Object-oriented is tougher, because the vast majority of languages let you write object-oriented code. A few don't really (like C), a few kind of force you to (like Java), but most of the rest are in-between - objects are there if you want them but you don't have to use them. There are a bazillion articles on object-oriented programming, and plenty of books on that.
Finally, as to writing clean and logical code, consider Code Complete, but really there's no substitute for just practicing a lot.
I'm only now getting into "proper" planning before I start writing code and although I'm no veteran, my method(s) come straight from Code Complete.
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.
> From experience, one book is barely enough to get your feet wet
Ha! Definitely. I keep getting ideas for other books I should write.
I'd recommend the following as good general books to read. They're all good no matter what type of programming you do:
Code: The Hidden Language of Computer Hardware and Software
Code Complete: A Practical Handbook of Software Construction, Second Edition
The Pragmatic Programmer: From Journeyman to Master
The Mythical Man-Month
In the Beginning...was the Command Line
Secrets and Lies: Digital Security in a Networked World
User Interface Design for Programmers
Don't Make Me Think
That should keep you busy. :)
EDIT: Oh, also, you can read my other two Python books. One is on graphical games with Pygame and the other is on classical ciphers and how to crack them. http://inventwithpython.com
> I'm having a super hard time just getting the environment setup...
Just wait until you try to host your website publicly. :) I recommend using a Rails hosting service like Heroku.
> I'd love to hear from those who use it...
I used it for about 6 months on a professional contract, and hated it. My main issues:
For instance, I spent a day and a half troubleshooting an issue caused by Rails deleting constants and one of its libraries monkey-patching a MIME library. Just shameless code and an unholy nightmare to debug.
On the plus side, when it works it's unbelievably terse. You will never find a framework that does more with less code (see #1 above). But that doesn't make it easy. When the abstraction leaks, and it will, you better know what you're doing.
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 :
>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.
Go search for threads like http://programmers.stackexchange.com/questions/127466/best-practices-in-comment-writing-and-documentation on StackOverflow, and read Code Complete http://www.amazon.com/gp/product/0735619670
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.
I just graduated with a CS degree, but here are some resources that I found useful:
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.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/
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 ;)
Code Complete has been recommended to me by several different people. I was also asking around for a software design patterns book.
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.
"More focused" is the key point for me. I have a different opinion what that means, that's all.
See here for the following quote:
> The following subjects would be off-limits: Technology, devices, software, operating systems;
For me, operating systems are relevant to coding: they define the framework that I must navigate in order to get my code to do what it is supposed to. But I can find my OS-related programming content elsewhere, I don't need to have it present in /r/coding. But I would rather exclude too much than allow too much in - noise is distracting, and simplicity stimulates focus. If people really miss something, it will find its way in.
Regardless, I can recognize a losing battle - the idea of code reviews seems to have many supporters and few opponents, so it will happen anyway if someone wants to risk and endure not-so-constructive criticism, puns and potential fame on TheDailyWTF.
I think the whole idea will be short-lived. The comment threads will provide some helpful remarks (e.g. read Code Complete, Beautiful Books, or other books, learn about various algorithms and their computational complexity to figure out better approaches, etc.). The comments will become redundant after a while, and then people will realize that they are doing somebody's homework, and that learning good style is largely a self-study, and can't be passed on in a couple of sentences. And we'll have a new rule for "no newbie code reviews here".
But I've been proven wrong by Reddit many times before, so I won't bet on my version of events. So, who's gonna be the first one to submit code for a review?
I wish someone had told me to read Code complete.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&s=books&qid=1255606772&sr=8-1
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.
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).
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
Great. Lol when people arguing and become not so dependable in the project, that's what exactly simulate real-life project. Adding more people on your project will only add more problem ;). Read some insight about the world of computer scientist/programmer:
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?ie=UTF8&qid=1293546772&sr=8-1
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&qid=1293546790&sr=8-1
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
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.
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
Code Complete by Steve McConnell goes over this topic a bit. Great read. https://www.amazon.com/dp/0735619670
Read Code Complete.
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.
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.
For learning how to write better code, regardless of language, check out this book:
http://www.amazon.co.uk/Code-Complete-Practical-Handbook-Construction/dp/0735619670
Read Code Complete
I have most of these books.
The Art of Computer Programming
The Art of Computer Programming is dense. It is deep. You can likely put off this one. It should be a goal to be able to get through it though.
Introduction to Algorithms
Introduction to Algorithms, I don't have it. All I know is that it does come highly recommended.
Code Complete
Code Complete is excellent. Well written, it feels a lot shorter than it is. It will get you thinking about every step of the software development process.
The Pragmatic Programmer
Another one I don't have but gets recommended time and time again.
The Mythical Man Month
The Mythical Man Month is less directly relevant. It will go over meta issues in software development.
Don't Make Me Think
Don't Make Me Think is also not about code itself, but about design. Because if no one uses your application, does it matter if you made it?
Code Complete is often recommended on /r/programming
Code Complete
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 would argue the reference is actually Code Complete (https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670)
IIRC, some of the recommendations in Clean Code are pretty draconian. For example, I always remember there being a recommendation that functions should be 5 lines or less, which strikes me as a bad recommendation.
Code Complete 2
EDIT: wow this book is 10 years old already!
These two books were the best programming books I have ever read:
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.
Most language style guides are broadly similar so there are generally accepted standards for how and when to indent code. Generally speaking indentation is used to denote control flow blocks. Each nested block is indented.
So for example you would indent any time you have one of the following:
There is a VB6 style guide available.
>Because many programmers still use VGA displays, screen space should be conserved as much as possible while still allowing code formatting to reflect logic structure and nesting.
>Standard, tab-based, nested blocks should be indented four spaces (the default).
>The functional overview comment of a procedure should be indented one space. The highest level statements that follow the overview comment should be indented one tab, with each nested block indented an additional tab.
If you look at the style guides for most other languages they will generally give the same advice.
In certain languages, such as Python, it is particularly important to be familiar with this as correct indentation is used by the interpreter to run the code correctly (for example, there is no
End If
orEnd Function
, the interpreter knows when the control block has ended by the change in indentation).It may seem like a pedantic thing for me to have even brought up (and it may well have been) but when you are used to reading code to certain conventions it makes it significantly easier to parse a function at a glance.
Many would argue that vertical whitespace should be restricted to separating only blocks of related code but others (myself included) would argue further still that this should be a redundant argument as your code should follow the Single Responsibility Principle and thus if your function/method is doing more than one thing it should be broken down into constiuent function/methods anyway.
I highly recommend Code Complete and Clean Code
for a more in-depth dissection of these principles.
Thanks guys. I'm going to start with An Embedded Software Primer and Code Complete by McConnell, a book my former professor strongly recommends. I'm a little concerned that they'll teach me good practices but not C or C++ itself, but I'll start with those books and then try to fill in the gaps in my raw programming knowledge. One thing at a time.
If you have further recommendations though, keep them coming!
Diese Themen werden in jedem Informatikstudiengang behandelt, je nach Prof und Ausrichtung der Uni mal besser und mal schlechter. Wenn du solange Selbststudium betreiben möchtest, schau dir mal Code Complete sowie Clean Code an, die bringen dir vermutlich aktuell am meisten.
Try reading THIS Code Complete and / or any of the well reviews books in the "you might also like" section of that page.
Every team have its own set of guidelines of what code conventions to use. Pick any and you'll be fine. A few:
A good book on the subject is Code Complete.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&qid=1416639826&sr=8-1&keywords=code+complete+2
That book along with lots and lots (and lots) of coding.
That's probably a good way to organize it then.
Here are a few good books to check out, if you care:
These all helped me a lot when I started.
I have the first of these and plan to get the second two soon as they have come highly recommended by /r/programming at one time or another.
Also look into:
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.
Are there any books that you would recommend?
Nearly-irrelevant fact: I am currently reading Code Complete, so far it's excellent.
This is agnostic as possible, the joy of cooking for programming;
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&qid=1409644270&sr=8-1&keywords=code+complete+2nd+edition
Thanks for the recommendation!
What do you think about his books on Rapid Development and Software Estimation?
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
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:
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'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.
Why is output part of a DB access method? that's really weird. And why are there limits and offsets on a get_item method call (singular)?
Give CodeComplete2 a read.
As everyone else has mentioned, you're limited to the language which you are coding in as well as the team.
Consider reading the book Clean Code and The Pragmatic Programmer.
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.
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.
This is not an authoritative guide -- it's a collection of opinions. However, the opinions are based on lots of experience and they're worth considering. Additionally, the author prods you to think about the right set of problems. It's a great place to start. At least it was for me when I was just getting started.
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
waste of development time? all one has to do is take one method, copy that method and paste that method or comment one thing in a if-statement. If that is a waste of development time, the programmer should have a look at this.
Also, if risk is such a big problem, remove the drop option from phats.
This is the bible for Software Engineeering
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
http://www.amazon.com/Coding-Standards-Rules-Guidelines-Practices/dp/0321113586
Also if you want something really challenging:
http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043
http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
Free below:
https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html
Code Complete (2nd ed)