Best products from r/AskComputerScience

We found 75 comments on r/AskComputerScience discussing the most recommended products. We ran sentiment analysis on each of these comments to determine how redditors feel about different products. We found 376 products and ranked them based on the amount of positive reactions they received. Here are the top 20.

Top comments mentioning products on r/AskComputerScience:

u/salamanderoil · 6 pointsr/AskComputerScience

It depends on what you already know.

​

Do you have any prior programming experience? If not, start there. My no. 1 recommendation here would be Allen B. Downey's free Think Python book. Others might come along and recommend something like SICP, which is a good book, but perhaps a bit hard for an absolute beginner. Downey also has a version of his book that uses Java, so if you know for a fact that this is the language your introductory programming class will be using, then that could be a better option (Python is a simpler language, which makes it easier for you to focus on the actual concepts rather than the language itself, but if you know that you'll be using Java, you might as well kill two birds with one stone).

​

If you do have prior programming experience, you have all sorts of options:

  • You could learn a functional language, like a Lisp (Clojure, Racket, Scheme, LFE, ...) or something in the (extended) ML family (Standard ML, OCaml, F#, Haskell, Elm, ...).
  • Or, you could go the other way and learn something low-level, like C. You could even learn about C and Lisp at the same time by building your own.
  • Or learn a logic programming language, like Prolog.
  • Or, if you really want to understand object-oriented programming (and how languages like Java managed to stuff it up), you could learn Smalltalk.
  • If you don't know what a unit test is or how to write one, you should learn.
  • Learn about data structures and algorithms. As a CS student, you'll be learning about them at some stage anyway, so there's no harm in starting early. Some people might recommended CLRS for this, but for someone just starting out, I'd recommend something a bit friendlier, such as this series of videos from Princeton (presented by Robert Sedgewick, author of one of the most popular books on the subject). If you'd prefer a book, this free one from Allen B. Downey (who also wrote the introductory programming text I recommended earleir) looks quite good.
  • Work your way through NAND2Tetris. It will take way longer than a month, but it will definitely set you apart from the rest of the class. Even if you don't do this now, you should definitely plan to do it at some point.
  • Learn about databases. Again, you'll have to study them eventually, so why not start early? You could start by trying to build something that uses a database, like a simple todo utility.

    ​

    Regardless of whether or not you have programmed before, I would also recommend doing the following:

  • Learn some basic Unix skills. It doesn't have to be too much – just enough to be able to sit down at the command line and have a vague idea of what you're doing is fine for now. You'll learn more as you use it more. That said, if you really want to dive in and learn how everything works, then something like How Linux Works could be a good read.
  • Learn some discrete mathematics. As a CS student, you'll be required to learn it at some stage – it's the mathematical backbone of CS, much like calculus is to physics – so you might as well start early. This free, book-length set of notes from MIT is very well-regarded (but don't expect to get through it all in a month!). There is also a set of video lectures if you prefer. If you're keen on learning functional programming, another option could be to integrate that with your discrete maths studies by reading Thomas VanDrunen's Discrete Mathematics and Functional Programming (if the physical book is a bit expensive for you, there's also a cheaper ebook version available).
  • For bonus points: learn to use either Vim or Emacs. There probably isn't a massive practical advantage to using these this early in your career (although they could certainly come in handy later), but if other students see you writing code in one of them, you'll look like an absolute badass. Your teachers will probably be quietly impressed, too.

    ​

    if you have any questions about my above suggestions, let me know, and I'll see if I can point you in the right direction.

    ​

    Good luck!
u/CSMastermind · 1 pointr/AskComputerScience

If you're looking to learn Python then Practical Programming: An Introduction to Computer Science Using Python 3 is what I recommend. How to Think Like a Computer Scientist: Learning with Python is also very good.

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/bhrgunatha · 6 pointsr/AskComputerScience

A famous artefact of early computing is the boot-strapping process where the goal is a self-hosting compiler - which lets you write the compiler for a new language in the new langauge. However to get to that point a lot of earlier innovations were needed.

Take all of this with a pinch of salt - the order and the details may be wildly inaccurate, but the overall ideas viewed from afar give an idea of how we got to the point that we can choose our own language to write a compiler for another language..

To start with, raw binary values had to be set in order to define and run a program. Those raw binary values represent instructions that tell the hardwaer what to do and data that the program needed to operate. This is now usually referred to as machine code.

At first you would enter values into computer storage using switches.

Since that's so tedious and error prone, puched cards were developed along with the necessary hardware to read them so you could represent lots of values that could be read toagether. They had their own problems but it was a step forward from switches.

After some time symbolic instructions were defined as a shortcut for several machine code instructions - now usually called assembly language. For example put the value 8 and store it into a memory location 58 could be written as ST 8, [58]. This might take 3 machine code instructions, one represents the store instruction, one the value 8 and one the location 58. Since now assembly language could be written down it was easier to understand what the computer is being instructed to do. Naturally someone had the bright idea to make that automatic so that for example you could write down the instructions by hand, then create punched cards representing those instructions, convert them to machines code and then run the program. The conversion from the symbolic instructions to machines code was handled by a program called an assembler - people still write programs in assembly code and use assemblers today.

The next logical step is to make the symbolic instructions more useful and less aimed at the mundane, physical processes that tells the computer exactly how to operate and more friendly for people to represent ideas. This is really the birth of programming languages. Since programming languages allowed you to do more abstract things symbolically - like saving the current instructions location, branching off to another part of the same program to return later, the conversion to machine code became more complex.Those programs are called compilers.

Compilers allow you to write more useful programs - for example the first program that allowed you to connected a keyboard that lets you enter numbers and characters, one connected to a device to print numbers and characters, then later to display them on another device like a screen. From there you are quite free to write other programs. More languages and their compilers developed that were more suitable to represent more abstract ideas like variables, procedure and functions.

During the whole process both hardware - the physical elctronic machines and devices and software, the instructions to get the machines to do useful work - were both developed and that process still continues.

There's a wonderful book called Code by Charles Petzold that details all of these developments, but actually researched and accurate.



u/NullEgo · 14 pointsr/AskComputerScience

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

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

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

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

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

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

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

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

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

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

u/Xxyr · 2 pointsr/AskComputerScience

If you have a reasonable handle on basic data structures and actually want a good text book I highly recommend Introduction to Algorithms, 3rd Edition (MIT Press) http://www.amazon.com/dp/0262033844/ref=cm_sw_r_tw_awdm_2BF-wb1BY0EY4 via @amazon

It was by far my favorite text. I didn't start using it until grad school but some schools use it in undergraduate work so it shouldn't be too advanced for a dedicated student.

Now if you don't actually want a nearly 2k page textbook but something to keep you engaged in programming I'd recommend https://www.nostarch.com/lisp.htm Land of Lisp is a very approachable book that teaches functional programming in the context of a text based game.

Lisp is pretty different from the C family of languages and still introduces a number of great concepts that will help with most other styles of programming. Specifically around immutability and side effects.

If you want to just dip your feet I recommend the 7 in 7 series from pragprog https://pragprog.com/categories/7in7 where they walk you through seven X over a seven week period.

If you want to solve bigger problems just start a project and see what happens :)

Ps. If you have a specific topic - not game dev - that you want a book recommendation on just ask. I read way too many of them.

u/Dylnuge · 3 pointsr/AskComputerScience

Might be biased, but I'm a big fan of Jeff Erickson's Algorithm Notes, which I think are better than a lot of textbooks.

If you really want a book, CLR Algorithms and The Art of Computer Programming both get recommended a lot, with good reason.

If you're interested in computational theory, the New Turing Omnibus and Spiser's Theory of Computation are two good choices.

Finally, I'd check out Hacker's Delight. It's a lot more on the electrical/computer engineering side of things, which might interest you, and it's very detailed while still being quite excellent.

u/ChrisAAR · 2 pointsr/AskComputerScience

I would recommend reading this book: https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook-dp-B000SEIBB8/dp/B000SEIBB8/

Extremely useful concepts to have and understand. I love the use-case the book uses (a portable, rich text editor) as a way to teach you what patterns to use (and not to use). I'm 8+ years in industry and I find coming back to it extremely helpful.

It's my want-to-be-productive-while-on-my-phone go-to book. IMHO definitely more worth it than reading a "coding" book and not having a machine to try it out (I find reading about coding without doing coding to be non-productive, at least for me).

u/JBlitzen · 1 pointr/AskComputerScience

clj, I'd recommend this book to you:

http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

It doesn't cover much math, but it concisely and entertainingly discusses the entire history of computation from semaphor flags and telegraph systems up through the earliest high level languages.

If you want to know how to code, or what to code, read something else. But if you want to understand why computers do what you tell them to do, and how they do it, this is an amazing and eye opening book.

It's like reading a book on autism. You might have read lists and summaries of how to communicate with an autistic person, but they may have glossed over WHY those methods work. This book teaches you how the autistic person thinks, and that will make every communication attempt that much easier and more fluid.

u/threechewz · 9 pointsr/AskComputerScience

Well, there's the classic, Clean Code, which I haven't read but have seen recommended as a great book on this topic. But, in my opinion, as with anything else in programming, you get better by doing, and that includes writing better code. The more code you write the more you'll see basic patterns crop up and you'll start to realize what does and doesn't work. Does inheritance make sense here or should I use some type of composition. Is it worth refactoring this piece of code out to a more general abstraction. When I write, I try to have the mindset that someone else will be using my code in the future and I should write my code in a way that is as accessible for them as possible.

u/jasonwatkinspdx · 2 pointsr/AskComputerScience

It varies in industry. I think it's a great idea to have a general understanding of how processors execute out of order and speculate, how caches and the cache consistency protocols between cores work, and how the language implementation transforms and executes the source you write.

The Hennesy and Patterson book covers almost everything hardware wise. Skim the areas that seem interesting to you. For language internals I like Programming Language Pragmatics. Compared to other "compiler course" textbooks like the famous dragon book it's got a lot more of the real world engineering details. It does cover quite a bit of theory as well though, and is written in a really straightforward way.

Skimming these two books will give people a pretty accurate mental model of what's going on when code executes.

u/chromaticgliss · 10 pointsr/AskComputerScience

Caclulus track is typically required. Linear algebra is pretty useful (and often required). If you really wanna go into CS specific maths.... pick up a book on Discrete Math and give it a go. If you want to be really hardcore, pickup Concrete Mathematics ... good luck, hard book.

Honestly, you're probably better off spending that time learning a programming language. Specifically, whatever language your school teaches mostly. Math in a CS bachelor isn't very intense until you get into senior/graduate level courses.

u/kirang89 · 2 pointsr/AskComputerScience
u/parkererickson30 · 1 pointr/AskComputerScience

I personally really like my MSI GS63. (https://www.amazon.com/dp/B07C6Z864X/ref=sspa_dk_detail_1?psc=1&pd_rd_i=B07C6Z864X&pd_rd_w=B3j5P&pf_rd_p=8a8f3917-7900-4ce8-ad90-adf0d53c0985&pd_rd_wg=nqqDw&pf_rd_r=PKM0CZJH9DMNX0DSBH3P&pd_rd_r=56f85497-6ae9-11e9-aa29-13293a7f6817) It has served me very well for 1.5 years now and shows no signs of slowing down. I was able to dual boot Ubuntu onto it for programming. The GTX 1060 does well in casual games such as CS:GO and Rocket League, as well as train ML/AI algorithms pretty darn fast. If you are interested in ML/AI, make sure to get the version with 6 GB of VRAM instead of the 3 GB version.

u/thechao · 1 pointr/AskComputerScience

Programming is language agnostic; it sounds like you're looking for breadth rather than depth, so:

u/tryx · 1 pointr/AskComputerScience

There's also Knuth et al's Concrete Mathematics. The writing style is very loose and casual but it quickly moves from fairly easy intro level stuff to graduate level mathematics, so whether you find it useful as an intro book depends on your background. It is however, and excellent discrete book if you work through it slowly and methodically.

u/Rikkety · 6 pointsr/AskComputerScience

Check out The Annotated Turing by Charles Petzold. It's Turing's paper on the Entscheidungsproblem which introduces Turing Machines, annotated with a lot of background information and some stuff about Turing's career. Very interesting stuff.

I can also recommend Code, by the same author which describes how a computer works from basic principles. It's doesn't have a lot of material on Turing, but it's certainly an interesting read for anyone interested in Comp Sci.

u/MerlinTheGerman · 1 pointr/AskComputerScience

Headfirst Design Patterns (pardon the ugly cover), this book easily illustrates and explains software engineering patterns that many would consider essential to writing good software. I'm currently in my senior year of Computer Engineering with a Software Emphasis and patterns are very important for writing manageable, maintainable, and readable software. (apologies for ugly link)

Amazon: https://www.amazon.com/gp/aw/d/0596007124/ref=mp_s_a_1_1?ie=UTF8&qid=1487231105&sr=8-1&pi=AC_SX236_SY340_FMwebp_QL65&keywords=head+first+design+patterns&dpPl=1&dpID=61APhXCksuL&ref=plSrch


Something else I recommend is buying a raspberry pi and setting up a basic home web server, you can Google easily how to so this. This is a fantastic introduction to full stack development and the possibilities are endless.

Hope this helps, good luck!

Edit : I also work as a software developer and will be working there full time when I graduate.

u/falafel_eater · 3 pointsr/AskComputerScience

Computer Science is a pretty big field, so "strong foundation" can mean different things to different people.
You will definitely want the following:

  1. Introduction to Algorithms and Data Structures
  2. Introduction to Computability
  3. Introduction to Operating Systems

    For algorithms and data structures, a very commonly used textbook is Cormen.
    For computability, Sipser.

    Operating Systems I don't remember off the top of my head.
    That said, you are probably much better off finding a high-quality university course that is based on these textbooks instead of trying to read them cover-to-cover yourself. Check out lecture series from places like MIT on youtube or whatever.

    After that, you can take an Intro to Artificial Intelligence, or Intro to Communication Networks, or any other intro-level course to a more specific sub-area. But if you lack basis in computability to the point where you don't know what an NP-Complete problem is, or have no idea what a Binary Search Tree is, or do not know what an Approximation Algorithm is, then it would be hard to say you have a strong foundation in CS.
u/UrbanPizzaWizard · 3 pointsr/AskComputerScience

I thought Coders at Work: Reflections on the Craft of Programming was a really enjoyable read.

It's just a collection of interviews. The book features some really interesting programmers such Ken Thompson, Joe Armstrong, Peter Norvig, and Donald Knuth. I had a great time reading their stories.

u/theobromus · 2 pointsr/AskComputerScience

The "Spot the bug" posts here are like that although I think they are c++ (http://blogs.msdn.com/b/rsamona/).

Books like Writing Solid Code (http://www.amazon.com/Writing-Solid-Microsoft-Programming-Series/dp/1556155514) are also helpful if you're going to be writing a lot of C or C++ code. It has some helpful ideas about how to build C code that is debuggable.

u/asdff01 · 11 pointsr/AskComputerScience

The book that allowed me to do this is the legendary "Gang of Four" Design Patterns book. Code examples are in C++ and it was written a while ago, but is still recommended as a fantastic resource for learning how to design software well.

There is also the SOLID principles, for object oriented design.

u/claytonkb · 2 pointsr/AskComputerScience

Course: UC Berkeley OS & Systems Programming

The Art of Unix Programming

There are many similar resources out there. Extract keywords, web search, repeat. Best of luck!

u/beatbrot · 1 pointr/AskComputerScience

If you maybe need a book recommendation you can take a look at:

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

Hands down the best book in the business.

Even the Java Developers used this exact book to improve their algorithms.

u/childintime9 · 1 pointr/AskComputerScience

pseudo code and understanding well the cormen . I never did a lot of exercises but I knew well all the properties of the algorithms, the complexity, the invariants. One thing useful is visualizing the algorithms by drawing on paper, see how all the numbers shift etc.

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/umib0zu · 5 pointsr/AskComputerScience

You should probably start with this book called Code and work your way up from there. It's actually pretty hard to find a single book that describes the history and the concepts, and even if you did find one, most of the topics would be hard to grasp on a first read. Code is usually a great starter book and might give you a few pieces of what your looking for. After you finish it, maybe check out a software book and dive into some of the concepts.

u/f-algebra · 3 pointsr/AskComputerScience

This is what everyone will say (and they're right): Types and Programming Languages, it should be on every CompSci's shelf.

When you've learnt System-F read this: Calculus of Constructions, because it's beautiful, and subsumes System-F.

EDIT: Also, after learning System-F, read this: Recursive types for free, because it's cool.

u/thelowhangingfruit · 2 pointsr/AskComputerScience

A book I recently read that helped me understand the important and implementation of design patterns was [Head First: Design Pattern](Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.ca/dp/0596007124/ref=cm_sw_r_cp_apa_i_3hEdBbDFGPCP6) . The book introduces the concept in an informal way and makes the learning experience fun and worth it.

u/CastigatRidendoMores · 4 pointsr/AskComputerScience

When you start building a large piece of software, it's easy to get to the point where you think "Well this is starting to suck. I wish I had started building it like this instead." Those hard-earned lessons are design patterns. If you use the right one, the code you have in the later parts of the project will be easy to scale, easy to adapt to new requirements, and generally painless compared to how it would be without careful planning. Design patterns exist because the same problems tend to pop up repeatedly, so it's worth learning about them (before you need them).

It's difficult to give a general example because design patterns typically serve to solve involved technical problems you don't encounter until deep in a project. However, if you're looking for a good place to start I recommend checking out the Decorator Pattern. It's relatively easy to understand if you're coming from an OOP background. If you really want to learn them, I recommend checking out Head First's book. There are other good sources explaining them, but a lot of them tend to hurt your brain.

u/Arrgh · 2 pointsr/AskComputerScience

Read this book. The first half, in which it shows you how to design and instantiate (in an included simulator) flip-flops, registers, an ALU and RAM, are extremely enlightening.

The second half is about software, so I didn't bother to continue. But the first half is well worth the price of admission. Oh, related to /u/panda_burgers' comment below, this is the book for the NAND2Tetris course. But their site is throwing malware warnings at the moment.

u/unknowngp · 7 pointsr/AskComputerScience

>I want to be able to understand how computers work

Code: The Hidden Language of Computer Hardware and Software

I was on the search for the same as you a couple of weeks ago and people recommended the book above. I just recently started reading it but hopefully someone who has read it can chime in with their opinion.

u/juliansorel · 8 pointsr/AskComputerScience

Yes, but computer architecture is way more than just a set of instructions. If you wanna learn computer architecture, I would recommend the Patterson book: https://www.amazon.com/Computer-Architecture-Quantitative-John-Hennessy/dp/012383872X

u/9us · 1 pointr/AskComputerScience

A good intro book might be Programming Language Pragmatics:

http://www.amazon.com/Programming-Language-Pragmatics-Third-Edition/dp/0123745144


A more theoretical treatment that builds a language from the lambda calculus can be found in Types and Programming Languages:

http://www.amazon.com/Types-Programming-Languages-Benjamin-Pierce/dp/0262162091


Lastly, I think Practical Foundations for Programming Languages strikes a nice balance between theory and practicality:

http://www.amazon.com/Practical-Foundations-Programming-Languages-Professor/dp/1107029570

I've read most of the last two books, and they're both excellent resources for learning how to think rigorously about programming languages. They're challenging reads, but you'll walk away with a higher understanding of programming language constructs as result. A draft version of the latter book can be found on the author's website, here.

u/jhartwell · 2 pointsr/AskComputerScience

When I took an algorithms class for my MS we used Introduction To Algorithms and I found the book to be helpful. That said, it isn't cheap, right now $47 is the cheapest used option on Amazon.

u/PastyPilgrim · 4 pointsr/AskComputerScience

Ah. I would start with computer architecture before getting to systems programming then. Hennessy and Patterson is the book that (I think) most Computer Architecture classes use to teach the material. Before that, however, you may want to learn circuit basics and introductory computer organization though.

It's going to be pretty difficult material to teach yourself unfortunately. Computer Architecture is hard and requires a lot of foundational knowledge (circuits, organization, logic, etc.), but once you understand how hardware works, then you should be able to move into systems programming with more ease.

u/brettmjohnson · 7 pointsr/AskComputerScience

Pick up a copy of K&R (ANSI edition). It is thin and the definitive reference. You can burn through the exercises pretty quickly, especially if you have used Java, C++, or C#.

Ridiculously-priced hard copy (IIRC, I paid about $20 for my copy.)

E-book PDF

u/hamishtarah · 1 pointr/AskComputerScience

Charles Petzold's book "Code" gets recommended a lot for understanding how computers work, from a very basic level.

http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

There are even several people that have built relay computers similar to those discussed by Petzold.

http://nablaman.com/relay/

http://web.cecs.pdx.edu/~harry/Relay/

u/complich8 · 8 pointsr/AskComputerScience

I don't think you'll find just one -- computer science is too broad, even in the scope of what you're asking for.

You can probably find a reasonably readable algorithms book that'll introduce things like Big-O, Big-theta, Big-omega, graphs, trees, etc. Some of that bleeds into the "data structures" topic area (and vice-versa). This one is highly-regarded, but I couldn't say whether it's "for you" or not -- it's a bit textbooky.

u/superAL1394 · 2 pointsr/AskComputerScience

Introduction to Algorithms, also commonly called CLRS (the authors) is the go to for most. Assuming you have knowledge of basic structures this will bring you through the more complicated heaps, trees, hash tables, etc. And their associated algorithms.

I have found in college most textbooks are useless. I had to buy this book 2 years ago and I still reference it regularly.

http://www.amazon.com/gp/aw/d/0262033844?pc_redir=1396075349&robot_redir=1

Also, wikipedia is your friend: http://en.m.wikipedia.org/wiki/List_of_data_structures

u/UmbraVeil · 1 pointr/AskComputerScience

Haven't read it yet, but I believe the "Gang of Four" is somewhat of a standard for learning design patterns.

u/red-hedder · 1 pointr/AskComputerScience

Came here, all excited to mention the Pragmatic Programmer but it's already at the top of the list. My upvote can't even help it get higher.

Then I came for the Mythical Man-Month, but you got me there too.

FinalSin, you're killing me here :)

That said, there is one more on my list that isn't covered here:

Head First Design Patterns taught me more about software design than any other book ever, arguably comparing to Pragmatic Programmer.