#6 in Computers & technology books

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.

Code Complete: A Practical Handbook of Software Construction, Second Edition
Buying options
View on Amazon.com
or
    Features:
  • Microsoft Press
Specs:
Height9.125 Inches
Length7.5 Inches
Number of items1
Weight3.3510263824 Pounds
Width1.625 Inches

idea-bulb Interested in what Redditors like? Check out our Shuffle feature

Shuffle: random products popular on Reddit

Found 206 comments on Code Complete: A Practical Handbook of Software Construction, Second Edition:

u/samort7 · 257 pointsr/learnprogramming

Here's my list of the classics:

General Computing

u/Nezteb · 43 pointsr/compsci

Some book recommendations:

u/labmansteve · 42 pointsr/PowerShell

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

u/goldfire · 38 pointsr/javascript

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.

u/feketegy · 25 pointsr/PHP

Every quality software should have tests. So...

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

Also:

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


    There are a lot to learn and if you really like programming you will never stop learning.

u/cronin1024 · 25 pointsr/programming

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


u/abstractifier · 22 pointsr/learnprogramming

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.

u/brownmatt · 22 pointsr/programming

I think the two suggestions you'll see the most will be:

Code Complete

Pragmatic Programmer

u/chra94 · 19 pointsr/pythontips

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

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

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

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

name = "chra94"

n = 6

name_length = 6

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

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

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

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

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


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

u/raarky · 18 pointsr/programming

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

u/drakonite · 16 pointsr/gamedev

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

u/hell_onn_wheel · 13 pointsr/Python

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!

u/frenchst · 12 pointsr/cscareerquestions

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

u/dev_bry · 12 pointsr/learnprogramming

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:

u/enricopulatzo · 11 pointsr/programming

Code Complete (haven't yet read ed. 2, but the first edition was tremendous)

u/MeoMix · 11 pointsr/learnprogramming

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

u/william_fontaine · 11 pointsr/cscareerquestions

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

Applicable to any OO language you are using.

u/[deleted] · 11 pointsr/learnprogramming

These have been recommended to me a lot, although I haven't gotten around to them yet....
Code Complete

Code Craft

Programming Pearls

u/MuseHill · 10 pointsr/gamemaker

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

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

  • Within a script, you can open up additional tabs that let you write more scripts so that they're all bundled together under one script name. You can use this to break a complex script down into smaller and smaller sub scripts without cluttering up your resource tree.

  • Abolish "magic numbers." In your example, if there's a number that you use that could potentially change, make it a macro (constant), enum, or global variable with a descriptive name. Macros and enums are substituted at compile time, so they don't have any "look-up" overhead during run-time.

  • I think you've already discovered why a lot of developers use scripts as often as possible: because it's easier to find and fix them than delving into an object's various events (or a room's creation code). Other than drawing, I usually have an event call a script, and the scripts are named hierarchically, e.g. sc_Creature_player_move

    There are a lot of good practices such as encapsulation, information hiding, and idempotence, that are too in-depth to get into here. IMO, GameMaker makes it really hard to follow some of these good practices, so I hope these suggestions are helpful to you.
u/javelinRL · 10 pointsr/Python

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.

u/mcrask · 10 pointsr/learnprogramming

Code Complete and Pragmatic Programmer are great books about programming as a craft and are both language agnostic.

u/Karzka · 10 pointsr/gamedev

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

u/SofaAssassin · 10 pointsr/cscareerquestions

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

  • I would look at online resources to start out, like Learn X in Y Minutes or codecademy. Start playing around a lot and doing exercises.
  • For a beginner, a language like Python or Ruby tends to be easiest to start with, as they are simple to install and experiment with.
  • Additionally, learn about databases. MySQL and PostgreSQL are database systems that are widely used and free. Learn about database modeling, schema design, and how to actually write SQL.
  • Understand that pretty much anything you write or make in the first year or so that isn't very simple will probably be horrible hack jobs. You may not think they are, but trust me, they will probably have poor design, use nasty hacks, employ bad practices, and so forth. This is where on-going improvement is a necessity, and why people read books like Clean Code, The Pragmatic Programmer, and Code Complete.
  • Also, a mark of a good developer - assessing whether or not you have to actually write that code or software. I am not familiar with student management systems, but is it really going to be necessary to write your own, from scratch? Think of the following implications:
    • You are now your own support for your software - anyone in the school that has a problem with your app, you become the go-to person for fixing it or answering their questions, no matter how dumb the questions may be.
    • You become the point person for issues in the supporting system of the software - the database and the machines it runs on, primarily. You may be lucky enough to have IT helping you in this aspect, so hopefully you have an IT department that can do things like back up the database, maintain it, and restore it if something breaks.
    • Your software will likely be a hackjob - I do like to stress this point again, because none of us, starting out, turn out good software of moderate complexity without a couple years of experience. Time and time again I look at code written by fresh graduates or junior developers that are basically hacks or need a lot of cleanup/rewriting. Who will look over your code to tell you that?
    • Someone will have to maintain this software - and this will be you, but eventually, you might leave this job, so who will take over for you? Your school should be prepared for this eventuality.
u/swenty · 10 pointsr/Python

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.

u/spoon16 · 9 pointsr/java

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.

u/cajun_super_coder2 · 9 pointsr/csharp

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.

u/0b_101010 · 9 pointsr/learnprogramming

Hi! I recommend the following books:

u/antininja · 8 pointsr/gamedev

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

u/enteleform · 8 pointsr/compsci

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

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

-----

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

  • Clean Code: A Handbook of Agile Software Craftsmanship

  • Code Complete: A Practical Handbook of Software Construction

     
    The author of Clean Code, Bob Martin, has a ton of talks that are a great source of info, and has also produced the CleanCoders series.
     

    -----

     
    Also check out some Software UML Examples.  I find that mapping out an overhead view of your project before starting to code gives you a chance to make sure the majority of relationships, life-cycles, and high-level details are planned out correctly from the start.  You'll still have to make inevitable adjustments while coding, but it's much more efficient than figuring it all out from the inside while you're building it.
     
    yEd Graph Editor is a good freeware option for creating UML diagrams.
     
    If you find that you really like the UML approach, check out Enterprise Architect.  It's definitely worth picking up since it allows you to generate file structures from your UML diagrams, with all of the boilerplate filled out already (class/method/variable definitions, etc.).
     

    -----

     
    Also related, SourceMaking has some good wikis on:

  • Design Patterns

  • Refactoring

  • Anti-Patterns

  • UML

     
    (Although their UML material is pretty in-depth and may be overkill if you just want to use UML as a quick way to plan out code.  But it's legit if you want to go all-out UML mode)
u/shaggorama · 8 pointsr/learnprogramming

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:

  • Build your toolkit as you go. Don't just be trying to construct abstractions. You should be hunting for useful abstractions. Write code that is reusable. Whatever code you wrote is solving some sub-problem of your larger solution: are there related sub-problems you could attack with a similar strategy? Can you tweak some piece of code such that it can be reused to make your life easier elesewhere?

  • Code as documentation. You are not just writing code for the purpose of accomplishing some end-goal, you are writing code so that if something breaks down the line, you will be able to figure out what needs to be fixed. This means your code should explain itself. Even if you don't anticipate anyone other than yourself will ever see your code, it might be months or years before you revisit some old code and you should anticipate that you will have forgotten basically everything about how it works. How can you make "future me"'s life easier in the process of building some solution? You should always be trying to name and structure variables/functions/objects such that it's clear what your code is doing and how information and decisions flow through your program.

  • Solve for scalability early. Premature optimization should generally be avoided, but it's often the case that there are small changes you can make very early on to make your code orders-of-magnitude more performant. Are you choosing appropriate data structures for the problem? Are you factorizing your code and dependencies in a reasonable way? Are you excising unused dependencies from your code? Are you limiting i/o? Are you moving large chunks of data around? Can your code be containerized into microservices?
u/Gankbanger · 7 pointsr/learnprogramming

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

u/Kuytu · 7 pointsr/programming

[Code Complete] ( http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670) 960 pages, no fluff, essential reading to any programmer.

u/ZukoBestGirl · 7 pointsr/ProgrammerHumor

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

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

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

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

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

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

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

u/Tefferi · 7 pointsr/JobFair

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

u/autophage · 7 pointsr/IWantToLearn

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.

u/lsd503 · 7 pointsr/compsci

Code Complete by Steve McConnell

u/titsybox · 6 pointsr/learnprogramming

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

u/JavaTrainer · 6 pointsr/javahelp

There are a lot of different strategies.

  • UML/RUP (Rational Unified Process) Make lots of diagrams (UML) and lots of system requirements docs.
  • TDD - Test driven development. Make Unit Tests first and then make code that passes the unit tests.
  • CRC analysis - Napkin card type design that helps you figure out what classes you should have.
  • Service based design - SOA type stuff. Define some high-level service APIs that different parts of your application communicate. Great when multiple team members are implementing different layers of your application.

    Basically you asking a methodology question and not a programming question. If you are asking questions like this you should probably start reading books like Code Complete: A Practical Handbook of Software Construction, Second Edition
u/IRLeif · 6 pointsr/learnprogramming

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.

u/theootz · 6 pointsr/cscareerquestions

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

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

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

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

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

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

Things that helped me:

  • www.hackerrank.com - practiced a lot of questions on here
  • www.careercup.com - another great site for questions
  • Cracking the Coding Interview More help on questions, but also some great insights into the interview process for the larger tech companies and many hints and tips on how to go about solving the more complex problems
  • Code Complete A great book for helping you to refresh or learn about software design
  • Eternally Confuzzled Great resource to learn how to think about common data structures and algorithms

    Having trouble with Algorithm design/analysis? These are some of the go-to books for that:

  • The Algorithm Design Manual Probably the defacto for learning about algorithm design and analysis
  • Introduction to Algorithms A great book with many different algorithms and data structures to learn about
  • Algorithm Design A great book if you want to dive deeper into more complex subjects like graph theory, dynamic programming, search algorithms, etc.. etc..
u/EughEugh · 6 pointsr/programming

There are several good books on designing good software:

Code Complete

Design Patterns

Refactoring

u/quantifiableNonsense · 6 pointsr/java

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

u/Constantine_V7 · 6 pointsr/cscareerquestions

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

u/aogan · 6 pointsr/programming

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.

u/obeleh · 6 pointsr/compsci

Perhaps offtopic but... Some books you should read regardless of CompSci branch

u/PalmerDowneyJr · 6 pointsr/learnprogramming

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

u/molant · 5 pointsr/javascript

http://www.amazon.com/gp/aw/d/0735619670 code complete. One of the best books about coding in general that I've ever read.

u/zdubdub · 5 pointsr/cscareerquestions

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.

u/Stormtalons · 5 pointsr/learnprogramming

I've got some tips for ya!

  • If you find learning about things like local and global scope fascinating and devour info about coding, then I can confidently say congratulations on finding your calling! There are many, many programmers who never do any reading, find it boring, and, consequently, have limited perspective and suck ass.

  • In programming, no matter whether you're a novice or a veteran, the 'big picture' is like that hot girl in high school that you somehow talked into dating you off and on until you both graduated, and then she never spoke to you again. On large projects like games, it's highly unlikely that anybody truly knows the entire scope and can tell you how every piece works together. Even on smaller, personal projects that only you yourself worked on, you will probably have to read your whole codebase to remember what the hell you were thinking if you revisit it in 6 months. So, don't sweat it too much if you don't get the big picture, or if it takes you a long time to grasp, just relax and remember that all programmers spend the vast majority of their time simply understanding code.

  • My personal opinion on using C++ as opposed to Java or .NET - imagine an application is a physical building. If you use C++, you have to take the time to fabricate every single brick you're gonna use, forge your own plumbing pipes, and construct everything from scratch. Java or .NET will deliver all of your bricks, steel, drywall, shingles, cabinets, and appliances in regular shipments, so you can focus on the blueprints and management. In the time it takes you to build a house in C++, you could have built a whole apartment complex in Java/.NET and rented out most of the units already. Having said that, if you want to build a fortress in the heart of a mountain where the only access is a tunnel hidden behind a waterfall with a door that's unlocked by DNA signature, you should probably use C++.

  • When will it fall into place? It's impossible to tell. It's different for everybody and depends highly on what you are doing and what your goals are. For me, it took about 6 months to get a handle on the basics, and 2-3 years to become confident discussing higher level design principles intelligently, and to start nodding my head in agreement reading programming blogs. I knew that things had finally clicked when I realized I was no longer shackled to the language I learned first, and that using new platforms was merely an example/API skim away.

  • I highly recommend reading through pretty much all of the Coding Horror posts, as well as Code Complete 2. Find something to build that interests you and that you don't know off-hand how to accomplish, and then learn the pieces you're missing to get it done. Google every topic, acronym, or piece of terminology that you're not familiar with, rinse and repeat. If you are truly a good programmer you will never think of yourself as a good programmer, but you will wake up one day and realize that you have the ability to complete most any task thrown your way; and if you don't, you'll know how to learn what you need to get it done.
u/chengiz · 5 pointsr/programming

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.

u/TracerBulletX · 5 pointsr/iOSProgramming

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

u/h3st · 5 pointsr/programmingcirclejerk

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

u/NowTheyTellMe · 5 pointsr/UCI

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.

u/dehun · 5 pointsr/cpp
  1. use boost::filesystem instead of direct winapi calls


  2. make good names. It is completly unclear what game function do. And the comment will not replace some nice name. The same for aair.

  3. a lot of constants in code. move them somewhere and make a nice names for them

  4. global variables - pathcontainer. and indexes for operations on pathes?

    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.
u/TheEverHumbled · 5 pointsr/Unity3D

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.

u/sh0rug0ru · 5 pointsr/java

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:

u/videoj · 5 pointsr/learnprogramming

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.

u/Wazanator_ · 5 pointsr/learnprogramming

Code Complete is really good if you haven't read it yet.

u/eric_weinstein · 5 pointsr/learnprogramming

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

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

    If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.
u/Captain · 4 pointsr/programming

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

u/fajitaman · 4 pointsr/learnprogramming

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.

u/Neumann347 · 4 pointsr/gamedev

If you are doing any coding at all, you should read Code Complete

u/CSMastermind · 4 pointsr/learnprogramming

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

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

Job Interview Prep


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

    Junior Software Engineer Reading List


    Read This First


  10. Pragmatic Thinking and Learning: Refactor Your Wetware

    Fundementals


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

    Understanding Professional Software Environments


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

    Mentality


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

    History


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

    Mid Level Software Engineer Reading List


    Read This First


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

    Fundementals


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

    Software Design


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

    Software Engineering Skill Sets


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

    Databases


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

    User Experience


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

    Mentality


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

    History


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

    Specialist Skills


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

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

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:

  1. [Computer Organization and Design](http://www.amazon.com/Computer-
    Organization-Design-Fourth-Edition/dp/0123744938)

  2. The Structure and Interpretation of Computer Programs

  3. Un buon libro di Assembly

  4. The C programming language

  5. Compillers

  6. Code complete, The practice of programming

  7. Fai finta di aver letto tutto The art of computer programming

  8. Un linguaggio a oggetti, magari Programming Ruby

  9. O/E Python, Dive into Python

  10. Design patterns

  11. Impara un linguaggio funzionale.


    Da qui puoi partire e specializzarti in quello che ti interessa

u/ssentrep · 4 pointsr/csharp

Read "Code Complete, 2nd version". Its everything you'd learn in 10 years of experience, summarized into 1 book.

u/spookyrufus · 3 pointsr/learnpython

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.

u/super_thalamus · 3 pointsr/PHP

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

u/TheCodeSamurai · 3 pointsr/Python

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.

u/JacboUphill · 3 pointsr/UCI

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.

u/oconnor663 · 3 pointsr/Python

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.

u/hfaber · 3 pointsr/programming

Go read Code Craft or Code Complete to learn not the theory but the practice of programming.

u/varius86 · 3 pointsr/devblogs

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

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

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

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:

u/adeadrat · 3 pointsr/gamedev

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.

u/athousandcounts · 3 pointsr/programming

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.

u/Cgseif · 3 pointsr/learnprogramming

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!

u/uberhaxed · 3 pointsr/learnprogramming

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:

u/stdio_h · 3 pointsr/csharp

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

u/Luonnon · 3 pointsr/rstats

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.

u/halcyon44 · 3 pointsr/java

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!

u/_rere · 3 pointsr/cscareerquestions

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

u/jreborn · 3 pointsr/javascript

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.

u/errorkode · 3 pointsr/learnprogramming

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

  1. It's a generally accepted wisdom that the only thing harder than writing code is reading it. It's not just about syntax, algorithms and data structures. It's about understanding how another person or group of people approached writing this piece of software. Also, keep in mind that not even the developers themselves fully understand large codebases. They might have a better intuitive understanding of pieces they interact with regularly, but code is not something humans are good in remembering.
    With that said, here's my personal approach to it: Usually there's a reason to look at code. You need to figure something out. We're not interested in the whole repository of code, but just the one piece. So I start hunting for that, usually with some sort of search or just trying to understand the file structure.
    Once I find the approximate area I have a very top-down approach. If I can tell from the name of a function what it does (or the associated comment) there is no need for me to read the body of it. Only when I can't tell from the name or need specific details will I dig deeper. Understanding the structure is always more important than understanding every instruction.

  2. You won't really get a satisfying answer to this. There are hundreds of books out there related to this question. Not only does it depend on the kind of project you're working on, it also depends on the team, goal, language, framework and god knows what else. Also, while I don't want to sound condescending, 2000 lines isn't really much if you're talking real life applications. But as a quick primer: Think about structure. It turns out that algorithms are all nice and dandy, but one of the biggest challenges for programmers is structure. How can you split your code into components that are easy to understand and not needlessly interdependent in unexpected ways? In the end we come back to your first question with this: Your aim is always to write code that is easy to maintain and read. Keep your functions short. Give good names. Provide comments. Split up into files and classes. Group together what belongs together. Have a consistent naming and coding style. Think before you code.

    Most important, like so many lessons in life, no matter how many time people tell you not to touch hot things, you'll only really understand once you've burn yourself. There's no shame in that, especially not as a student. Just go for it, fuck up and learn from it. Talk to other students about the things you struggle with and how they deal with it.

    I don't really have any resource suggestions for you at the moment. Your questions is somewhat vague and most books I've read on the topic are quite specific and aimed at people with more scars than you have. Maybe I could recommend Code Complete which covers a lot of bases, but it's also quite the monster. I'm a firm believer that making mistakes and seeking ways to avoid them is better than following instructions without quite understanding why. But we each have to find our own way.
u/geodanila · 3 pointsr/coding

Great suggestions! I also highly recommend Code Complete: A practical handbook of Software Construction (Second Edition) by Steve McConnell

u/cheald · 3 pointsr/webdev

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.

u/enelsk · 3 pointsr/learnprogramming

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.

u/LoganLehman · 3 pointsr/learnprogramming

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!

u/jodythebad · 3 pointsr/cscareerquestions

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!

u/Milumet · 3 pointsr/learnprogramming

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

u/cannibalbob · 3 pointsr/cscareerquestions

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.

u/zoug · 3 pointsr/Omaha

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.








u/UpAndDownArrows · 3 pointsr/learnprogramming

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

u/alpha_hxCR8 · 3 pointsr/learnpython

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:

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

  2. Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
u/K900_ · 3 pointsr/Python

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.

u/tinbuddychrist · 2 pointsr/SoftwareEngineering

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.

u/timmyotc · 2 pointsr/cscareerquestions

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.

u/shhh-quiet · 2 pointsr/learnprogramming

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

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

  • Code Complete 2. Some good tips in here regarding code cohesion, and how to write functions and classes cleanly.
  • Clean Code. More on writing functions cleanly, along with design & testing.
  • How to Prove It. This is a great book that delves deeply into logic. Even just the first chapter or two could be incredibly useful to you. It discusses things like DeMorgan's Laws, which show up a lot in programming and electronics. It deconstructs common logical concepts and phrases into boolean algebra and set builder notation (which inspire Python's list comprehensions). The world of math and logic and proof is not completely isolated from the world of programming.

    EDIT: One other thing is to make sure you understand the limitations of how computers represent numbers. The need for this understanding will become clear very quickly on, say, Project Euler problems. Look into bits, values, integers, signed vs unsigned, IEEE754 floating point.

    And one other thing is that it's easy to compare your solutions against some of the best solutions that exist for those problems and think you're doing a bad job when in fact you're doing an alright job if you manage to solve the problems with decent runtimes. Mind your 80/20 rule here. The extra time it probably took those people to craft those solutions is not 0, which includes whatever time they spent over the years becoming an expert at that language, etc.
u/orbitalia · 2 pointsr/TheRedLion

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

u/gte910h · 2 pointsr/programming

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.

u/trashhalo · 2 pointsr/programming

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

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

Code you will actually be writing:

  • Glue code. Integrate Library X with Library Y.
  • Unit tests. To make sure your glue code works as expected.
  • UI code.

    Things you will be doing that CS degree does not prepare you for

  • Fleshing out incomplete requirements documents
  • Dealing with drama between teams
  • Estimation
  • Understanding that 80% is often good enough

    I would suggest reading books like Design Patterns, Mythical Man-Month and Code Complete
u/sleepybychoice · 2 pointsr/learnprogramming

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.

u/natedcorn · 2 pointsr/learnprogramming

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.

u/alterraun · 2 pointsr/learnprogramming

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

u/balloonanimalfarm · 2 pointsr/AskProgramming

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.

u/grandslammer · 2 pointsr/csharp

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.

u/synthsongs · 2 pointsr/webdev

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]

u/miguez · 2 pointsr/gamedev

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.

u/balefrost · 2 pointsr/AskProgramming

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!

u/turtlepot · 2 pointsr/AskComputerScience

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

u/athosghost · 2 pointsr/AskProgramming

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

u/gin_and_toxic · 2 pointsr/webdev

Some highly recommended books:

u/dunston_chexin · 2 pointsr/pornfree

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

u/mcdronkz · 2 pointsr/PHP

It's not a website but a book like Code Complete contains this kind of information.

u/cruachanmor · 2 pointsr/programming

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)

u/ChrisFingaz · 2 pointsr/learnprogramming

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.

u/cajun_super_coder · 2 pointsr/programming

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.

u/SalemBeats · 2 pointsr/mturk

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.

u/serious_face · 2 pointsr/PHP

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.

u/caindela · 2 pointsr/learnprogramming

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.

u/ReverseEngineered · 2 pointsr/learnprogramming

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

A few interesting examples:

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

    Whatever you do, as you clearly pointed out, you have to be interested in it or you'll grow bored and give up. Find something that is interesting to you and pursue it as wide and deep as you can.
u/kirang89 · 2 pointsr/AskComputerScience
u/ivraatiems · 2 pointsr/learnprogramming

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.

u/riscuit · 2 pointsr/GradSchool

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

u/capoeirista13 · 2 pointsr/learnprogramming

I often see the suggestion for this book next to a suggestion for Code Complete. Anyone have thoughts on Code Complete?

u/kubalaa · 2 pointsr/programming

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.

u/composer314 · 2 pointsr/goodprogramming

That is a good book. I also like Code Complete

u/dmazzoni · 2 pointsr/learnprogramming

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.

u/gadorp · 2 pointsr/learnprogramming

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.

u/BrigadierWilhelm · 2 pointsr/compsci

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.

u/AlSweigart · 2 pointsr/learnpython
WHY DO YOU ASK MAINTAINS THE PROPER ATTITUDE OF A DECENT THING?

)

> 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
u/EricTboneJackson · 1 pointr/learnprogramming

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

  1. It takes convention over configuration to a ridiculous extreme. For instance, its ORM works by catching errors regarding undefined symbols, parsing them, and turning them into code. It's impossible to figure out what the fuck is going on just by looking at how code is wired up (my preference; I happen to like code), because it's wired up in spooky-action-at-a-distance way and your stack traces end up being 100 layers deep, so you have to spend more time RTFMing with Rails than any other framework I've used.

  2. The reason for #1 is that it's obsessed with being clever, which generally represents immaturity ("Programming is not like being in the CIA, you don’t get credit for being sneaky.") Dynamic languages can be incredibly expressive and productive, but they allow downright evil practices like monkey-patching. It takes maturity to resist doing stupid shit like that, but it's rampant in the Rails community, I think because Rails shameless abuses these things itself.

    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.

  3. Gem hell; like DLL-hell on steroids.

    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.
u/antisyzygy · 1 pointr/MachineLearning

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

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

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

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

  1. SQL -> e.g. MySQL, Transact-SQL

  2. Java -> Hadoop is written in Java

  3. If you end up working at a web company, PHP/Javascript/HTML are useful to know.

  4. Of course, Linux/Unix command line. Very important.

  5. Python -> You mentioned it but I'd say start using it more. Check out iPython Notebook as that might be something that catches your interest.

    >edit: Thanks a ton for the advice so far, the consensus seems to be start learning how to deal with big data using Hadoop or some other similar app and learn some software engineering, however that part seems a little ambiguous still.

    Learning software engineering is basically learning best practices and design patterns. The goal is to make clean code and avoid hard to find/fix bugs as well as to use the best design paradigm for your problem. "Clean code" means "readable" and "maintainable". Readable code is code that any other software engineer who has never seen it before can pick up and understand reasonably quickly. Maintainable code is code that is relatively easy to refactor, make changes to, add features, and fix bugs within. "Clean" code saves a lot of man hours down the road.

    For an example of software design, in programming a video game OOP class inheritance isn't always the best thing to use because it can lead to a confusing, non-intuitive tree of classes. Someone invented the "component entity system" to address the problem.

    Read about this, as it's a fairly intuitive example of "Software design", i.e. using the best approach for a particular problem.

    Writing clean, well-designed code comes with experience, but there are some books on it.
u/TurdFurgis0n · 1 pointr/IAmA

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.

u/JustJolly · 1 pointr/learnprogramming

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

  • I'm currently reading this book. It's commonly recommended and I now know why. Great resource for building a solid foundation of SE knowledge.

  • Algorithms are always important. This class and lecture series, along with the recommended text book for the class are really well done. I own the text, it was well worth the money for me. There are other free algorithms classes (i.e. Coursera), but I found these lecture to be the best, YMMV.

  • Lastly, this is the class that goes along with the SICP book mentioned previously.

    I learn best by incorporating a variety of mediums - watching video/lecture, reading books, doing examples by hand/programming. I recommend looking at some of the Coursera classes, other classes on the MIT open courseware, edX, or Udacity.

u/sixfootGeek · 1 pointr/learnprogramming

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 ;)

u/taybul · 1 pointr/programming

Code Complete has been recommended to me by several different people. I was also asking around for a software design patterns book.

u/volandkit · 1 pointr/cscareerquestions

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.

u/lazyout · 1 pointr/coding

"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?

u/nom-de-reddit · 1 pointr/vba

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.

u/chadcf · 1 pointr/web_design

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

u/juckele · 1 pointr/learnprogramming

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

u/MaximusBiggusDickus · 1 pointr/learnprogramming

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

u/ZeroBugBounce · 1 pointr/learnprogramming

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.

u/jlnazario · 1 pointr/AskProgramming

Code Complete by Steve McConnell goes over this topic a bit. Great read. https://www.amazon.com/dp/0735619670

u/HiRezWeiss · 1 pointr/Smite

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.

u/lethargilistic · 1 pointr/java

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.

u/jaynoj · 1 pointr/GameStudioLive

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

u/bautin · 1 pointr/cscareerquestions

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?

u/Vauce · 1 pointr/learnjavascript

Code Complete is often recommended on /r/programming

u/kurple · 1 pointr/webdev

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.

u/Tawagoto2 · 1 pointr/learnprogramming

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.

u/QAOP_Space · 1 pointr/learnprogramming

Code Complete 2

EDIT: wow this book is 10 years old already!

u/Iconate · 1 pointr/PHP

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

u/Senipah · 1 pointr/vba

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:

  • For...Next
  • If...Else...End If
  • While...Wend
  • With...End With
  • Select Case...Case...End Select
  • Function...End Function
  • Sub...End Sub

    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 or End 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.
u/Hedryn · 1 pointr/embedded

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!

u/Lizard · 1 pointr/mentors

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.

u/bookon · 1 pointr/csharp

Try reading THIS Code Complete and / or any of the well reviews books in the "you might also like" section of that page.

u/vz0 · 1 pointr/learnprogramming

Every team have its own set of guidelines of what code conventions to use. Pick any and you'll be fine. A few:

u/austincrft · 1 pointr/MechanicalKeyboards

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

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

u/sotopheavy · 1 pointr/webdev

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.

u/MrDiSante · 1 pointr/csharp

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.

u/Cregaleus · 1 pointr/JobFair

Are there any books that you would recommend?


Nearly-irrelevant fact: I am currently reading Code Complete, so far it's excellent.

u/Enigma3613 · 1 pointr/programming

Thanks for the recommendation!

What do you think about his books on Rapid Development and Software Estimation?

u/Asaaj · 1 pointr/unixporn

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

u/MissMaster · 1 pointr/learnprogramming

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

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

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

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

  • dev blogs (a google search for "best <insert your field here> blogs" should give you some good ones

  • books for the basics. I can particularly recommend Code Complete 2, The Pragmatic Programmer, Head First Design Patterns, Design Patterns: Elements of Reusable OO Software and Algorithms in a Nutshell

  • Tutorials. I love a good tutorial. The trick is to find one written by a professional (usually on a blog you trust or from a tutorials site that vets the content, like tutsplus). Unfortunately, any asshat can throw up shitty code and call it a tutorial, so be careful googling and look at the comments first to look for people calling out issues. As you get more experience, you'll be able to spot 'code smell'.

  • pair programming. I hate pair programming. I instantly lose my ability to type or form coherent thoughts when someone is lurking over my shoulder. I am constantly terrified that someone will think I'm stupid. But it works.

  • fellow devs. Nothing really replaces direct communication with another dev. Find someone or a community online or at work who you are comfortable with. Someone you can go to when you're stuck or don't get something. The difference between needing babysitting and needing help is having specific questions. Instead of saying "I don't understand x", approach them with a more specific question like "I'm trying to get comfortable with closures so I set up a simple counter, but instead of counting to 10, I get 10 printed 10 times, can you help me spot where my error is?"

    I hope that helps.
u/SuperDuckQ · 1 pointr/learnprogramming

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

u/g1i1ch · 1 pointr/explainlikeimfive

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.

u/ircmaxell · 1 pointr/PHP

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.

u/hectron · 1 pointr/minimalism

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.

u/tragicshark · 1 pointr/dotnet

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.

u/rocketsocks · 1 pointr/askscience

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.

u/WereCoder · 1 pointr/gamedev

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

u/Spieler42 · 0 pointsr/runescape

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.