Top products from r/AskComputerScience
We found 76 product mentions on r/AskComputerScience. We ranked the 376 resulting products by number of redditors who mentioned them. Here are the top 20.
1. Introduction to Algorithms, 3rd Edition (The MIT Press)
Sentiment score: 9
Number of reviews: 11
Hard Cover
Show Reddit reviews2. Code: The Hidden Language of Computer Hardware and Software
Sentiment score: 6
Number of reviews: 10
Microsoft Press
Show Reddit reviews3. Head First Design Patterns: A Brain-Friendly Guide
Sentiment score: 3
Number of reviews: 5
100% Satisfaction Guarantee. Tracking provided on most orders. Buy with Confidence!A brand-new, unused, unopened item in its original packaging, with all original packaging materials included.High seller positive feedback for the seller!Lowest price on amazon!
Show Reddit reviews4. Computer Architecture: A Quantitative Approach
Sentiment score: 3
Number of reviews: 4
Show Reddit reviews5. Clean Code: A Handbook of Agile Software Craftsmanship
Sentiment score: 2
Number of reviews: 4
Prentice Hall
Show Reddit reviews6. C Programming Language, 2nd Edition
Sentiment score: 2
Number of reviews: 3
Prentice Hall
Show Reddit reviews7. Code Complete: A Practical Handbook of Software Construction, Second Edition
Sentiment score: 3
Number of reviews: 3
Microsoft Press
Show Reddit reviews8. Types and Programming Languages (The MIT Press)
Sentiment score: 2
Number of reviews: 3
Mit Press
Show Reddit reviews9. Design Patterns: Elements of Reusable Object-Oriented Software
Sentiment score: 3
Number of reviews: 3
Show Reddit reviews10. Gödel, Escher, Bach: An Eternal Golden Braid
Sentiment score: 1
Number of reviews: 3
Godel Escher Bach An Eternal Golden Braid
Show Reddit reviews11. The Elements of Computing Systems: Building a Modern Computer from First Principles
Sentiment score: 3
Number of reviews: 3
MIT Press MA
Show Reddit reviews12. Effective Java (2nd Edition)
Sentiment score: 2
Number of reviews: 2
Prentice Hall PTR
Show Reddit reviews13. The Pragmatic Programmer: From Journeyman to Master
Sentiment score: 1
Number of reviews: 2
Save up to 15% when buying these two titles together.The Pragmatic Programmer cuts through the increasing specialization and technicalities of modern software development to examine the core process--taking a requirement and producing working, maintainable code that delights its users.It covers topi...
Show Reddit reviews14. Modern C++ Design: Generic Programming and Design Patterns Applied
Sentiment score: 2
Number of reviews: 2
Show Reddit reviews15. Concrete Mathematics: A Foundation for Computer Science (2nd Edition)
Sentiment score: 2
Number of reviews: 2
Show Reddit reviews16. Algorithms (4th Edition)
Sentiment score: 1
Number of reviews: 2
Addison-Wesley Professional
Show Reddit reviews17. Compilers: Principles, Techniques, and Tools (2nd Edition)
Sentiment score: 2
Number of reviews: 2
Show Reddit reviews18. The Art of Computer Programming, Volumes 1-4A Boxed Set
Sentiment score: 2
Number of reviews: 2
Volume 1: Fundamental AlgorithmsVolume 2: Seminumerical AlgorithmsVolume 3: Sorting and SearchingVolume 4A: Combinatorial Algorithms
Show Reddit reviews
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:
​
Regardless of whether or not you have programmed before, I would also recommend doing the following:
​
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!
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
Junior Software Engineer Reading List
Read This First
Fundementals
Understanding Professional Software Environments
Mentality
History
Mid Level Software Engineer Reading List
Read This First
Fundementals
Software Design
Software Engineering Skill Sets
Databases
User Experience
Mentality
History
Specialist Skills
In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.
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.
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.
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.
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.
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).
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.
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.
Bitcoin mining programs are pretty advanced pieces of software, especially due to the rise of ASICs and other esoteric hardware that must be supported. You might want to consider an easier project for the time being.
Fundamentally, you need to have a good grasp on data structures before you can really get going with Merkle trees and cryptocurrency mining in general.
Here are some free resources to get started
If you want to consider grabbing a book, Algorithms (4th ed) is generally regarded as a decent book to get started on thinking with and using algorithms and data structures.
edit: depending on the time you have, you may also want to consider reading this on set theory. It tends to make later algorithms a bit more clear as a lot of it draws from set theory.
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.
We wrote a compiler for one of my CS classes in college. The language was called YAPL (yet another programming language).
First thing first, as other's have mentioned, a compiler translates from one language to another...typically assembly...but could be any other language. Our compiler compiled YAPL, which was a lot like Pascal, into C, which we then fed to the C compiler...which in turn was fed to the assembler. We actually wrote working programs in YAPL. For my final project, I wrote a functional--albeit VERY basic--web server.
With that said, it's quite a bit different for an interpreted language, but the biggest part for each is still the same. By far, the most complicated part of a compiler is the parser.
The parser is what reads a source code file and does whatever it's going to do with it. Entire bookshelves have been written on this subject, and PhD's given out on the matter, so parsing can be extremely complicated.
In a theoretical sense, higher level languages abstract common or more complicated tasks from the lower level languages. For example, to a CPU, variables don't have sizes or names, neither do functions, etc. On one hand, it greatly speeds up development because the code is far more understandable. On the other hand, certain tricks you can pull of in the lower-level languages (that can vastly improve performance) can be abstracted away. This trade-off is mostly considered acceptable. An extra $500 web server (or 100 for that matter) to handle some of the load is far less expensive than 10 extra $100,000 a year x86 assembly developers to develop, optimize, and debug lower level code.
So generally speaking, the parser looks for what are called tokens, which is why there are reserved words in languages. You can't name a variable
intin C becauseintis a reserved word for a type. So when you name variable, you're simply telling the compiler "when I reference this name again, I'm talking about the same variable." The compiler knows anintis 4 bytes, so does the developer. When it makes it into assembly, it's just some 4 bytes somewhere in memory.So the parser starts looking for keywords or symbols. When it sees
int, the next thing it's going to expect is a label, and if that label is followed by(, it knows it's a function, if it's followed by;it's a variable--it's more complicated than this but you get the idea.The parser builds a big structure in memory of what's what and essentially the functionality. From there, either the interpreter goes through and interprets the language, or for a compiler, that gets handed to what's called the emitter. The emitter is the function that spits out the assembly (or whatever other language) equivalent
a = b + c;happens to be.This is complicated, but if you take it in steps, it's not really that hard. This is the book we used. There's a much newer version out now. If I can find my copy, I'll give it to you if you pay shipping. PM me.
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.
Programming is language agnostic; it sounds like you're looking for breadth rather than depth, so:
Those are the only books I ever used, and I've had no problem programming in any (serious) language I've come across.
Scala, Mozart, etc. cover more "programming paradigms" than C++, but there are more resources for C++ than those languages, so it is a good balance between breadth and support. If you would rather learn a few languages than one language then I would suggest the combination of an ML, C, Python, XSLT, and Scheme. Spend two weeks in each language and make sure you've implemented something nontrivial in each, and make sure that implementation is idiomatic.
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.
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.
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.
Computer Science is a pretty big field, so "strong foundation" can mean different things to different people.
You will definitely want the following:
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.
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.
My compilers course in college used the Dragon Book, which is one of the more quintessential books on the subject.
​
But you might also consider Basics of Compiler Design which is a good and freely available resource.
​
I'd also suggest that you have familiarity with formal languages and automata, preferably through a Theory of Computation course (Sipser's Introduction to the Theory of Computation is a good resource). But these texts provide a brief primer.
I'm partial to Hopcroft and Ullman. I'm usually not the "open a book, read the explanations..." type of learner but Hopcroft&Ullman is very clear and concise, so I found myself doing just that. No need to skip ahead to figure out the point of it all, they just explain it in logical order. This text goes quite a bit deeper than most algorithms courses will go but it's a great way to pump iron with your brain and everything you learn will be applicable to whatever curriculum is taught in your algorithms course.
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.
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.
If you only read one work on the topic, it should be The Art of Computer Programming by Don Knuth: https://www.amazon.com/dp/0321751043/
The textbook for MIT's 6.001 (introduction to computer science) is the much loved Structure and Interpretation of Computer Programs by Abelson, Sussman, and Sussman: https://www.amazon.com/dp/0262510871/ . Originally it was in Scheme but the 2nd edition is in Python.
Finally, because people asking about computer science are often asking about something a bit broader than pure computer science, I recommend Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. It is a thorough tour of computing in practice at every level, top to bottom. https://www.amazon.com/dp/073560505X/
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
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.
You may like these two books and the associated lectures
The Elements of Computing Systems: Building a Modern Computer from First Principles-
[Book] (http://www.nand2tetris.org/book.php)
[Lectures] (https://www.coursera.org/learn/build-a-computer)
Computer Systems: A Programmer's Perspective-
[Book] (http://csapp.cs.cmu.edu/)
[Lectures] (http://www.cs.cmu.edu/afs/cs/academic/class/15213-s16/www/schedule.html)
Honorable mentions
[Computer Architecture, Fifth Edition: A Quantitative Approach] (https://www.amazon.com/Computer-Architecture-Fifth-Quantitative-Approach/dp/012383872X/ref=sr_1_1?s=books&ie=UTF8&qid=1468739653&sr=1-1&keywords=computer+architecture+a+quantitative+approach)
[Inside the Machine: An Illustrated Introduction to Microprocessors and Computer Architecture] (https://www.amazon.com/Inside-Machine-Introduction-Microprocessors-Architecture/dp/1593276680/ref=pd_sim_14_5?ie=UTF8&dpID=51naTOjysjL&dpSrc=sims&preST=_AC_UL160_SR121%2C160_&psc=1&refRID=X1KV7PFRWJVZ11YZ0TJ7)
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.
Thanks, I already have a book on this I was planning on reading: Introduction to Automata Theory, Languages, and Computation. I just started reading CLRS though, do you think it would be helpful to finish it or are the two mostly unrelated?
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.
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.
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.
>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.
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
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.
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.
As someone who hated math, this turned out to be one of my absolute favourite books in college:
http://www.amazon.co.uk/gp/product/1408263238?psc=1&redirect=true&ref_=oh_aui_detailpage_o06_s00
Probably not what you're looking for though.
Are you looking for pure computer science or do programming books count?
The pragmatic programmer is a great book, and an enjoyable read:
http://www.amazon.co.uk/Pragmatic-Programmer-Andrew-Hunt/dp/020161622X/ref=sr_1_1?ie=UTF8&qid=1422386669&sr=8-1&keywords=pragmatic+programmer
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.
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
> Or, books about efficiently tackling code. Interview questions.
http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1331233973&sr=8-1
You might also be interested in
http://en.wikipedia.org/wiki/Cellular_automaton
http://en.wikipedia.org/wiki/Rule_30
http://en.wikipedia.org/wiki/Rule_110
and Godel, Escher, Bach.
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/
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.
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
https://www.amazon.com/gp/product/0735611319/ref=ppx_yo_dt_b_asin_title_o00_s00?ie=UTF8&psc=1
Haven't read it yet, but I believe the "Gang of Four" is somewhat of a standard for learning design patterns.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_lpo_sbs_14_img_0?_encoding=UTF8&psc=1&refRID=AEMGS8RSDRVGGBS0TPW9
This is a must read for every developer.
Clean Code
Read this book: Code: The Hidden Language of Computer Hardware and Software
Gödel, Escher, Bach: An Eternal Golden Braid
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.