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.
2. Code: The Hidden Language of Computer Hardware and Software
- Microsoft Press
Features:
3. Computer Architecture: A Quantitative Approach
- 2,304 processor cores 284-bit memory bus Engine clock (base): 941 MHz, (boost): 993 MHz Memory clock: 6008 MHz
- DisplayPort 1.2 (4K ready) 2 x DL-DVI VGA (with included adapter) 1 x HDMI Quad simultaneous display capable HDCP compliant SLI bridge connectors (3-way SLI)
- NVIDIA GeForce driver Microsoft DirectX 11.1 (feature level 11_0) OpenGL 4.3 Microsoft Windows Vista/7/8 x86/x64
- ED 480p HD 720p HD 1080i Full HD 1080p Quad Full HD (4K)
- 700-watt power supply recommended 255-watt max power consumption
Features:
4. Design Patterns: Elements of Reusable Object-Oriented Software
- The space mouse compact was developed to deliver an intuitive, effortless and precise 3D navigation in CAD applications that cannot be experienced by using a standard mouse and keyboard.
- Six-degrees-of-freedom (6Dof) sensor - intuitively and precisely navigate digital models or views. Operating system - Windows 10, Windows 8.1, Windows 7 SP1,Apple macOS 10.14, Apple macOS 10.13, Apple macOS 10.12, Apple OS X 10.11, Apple OS X 10.10. Linux Red Hat Enterprise Linux Workstation 4, 5, Linux Novell SUSE Linux 9.3, 10, 11
- Each of the space mouse compact's two buttons opens its own 3Dconnexion radial menu. They provide direct access to up to 8 of your favorite application commands.
- With its iconic, pure design, the space mouse compact is small enough to fit on every desk while the brushed steel base ensures the device stability for precise 3D navigation.
- 2-Year manufacturer's warranty
Features:
6. Code Complete: A Practical Handbook of Software Construction, Second Edition
- Microsoft Press
Features:
7. The Elements of Computing Systems: Building a Modern Computer from First Principles
- MIT Press MA
Features:
12. Extreme Programming Explained: Embrace Change, 2nd Edition (The XP Series)
13. Clean Code: A Handbook of Agile Software Craftsmanship
- Prentice Hall
Features:
14. The Annotated Turing: A Guided Tour Through Alan Turing's Historic Paper on Computability and the Turing Machine
- John Wiley & Sons
Features:
15. Modern C++ Design: Generic Programming and Design Patterns Applied
- Used Book in Good Condition
Features:
17. Writing Solid Code (Microsoft Programming Series)
Used Book in Good Condition
18. MSI GS63 STEALTH-009 15.6-Inch Gaming Laptop GTX 1060 6GB, i7-8750H 6 Core, 16GB RAM, 256GB SSD, 2TB HDD, Steelseries RGB Per-Key Keyboard, VR Ready, Metal, Black, Win 10 Pro 64-Bit
- This refurbished product is tested and certified to look and work like new. The refurbishing process includes functionality testing, basic cleaning, inspection, and repackaging. The product ships with all relevant accessories, and may arrive in a generic box
Features:
19. Concrete Mathematics: A Foundation for Computer Science (2nd Edition)
- Extremely fast! It’s the fastest manual Santoku and 15 Degree style knife sharpener available
- Creates an ultra-sharp 15 Degree edge
- 2-Stages, sharpening and honing/polishing, for an arch-shaped edge that is stronger and more durable
- Uses 100% diamond abrasives in stages 1 and 2
- CrissCross technology for an extremely sharp edge with lots of “bite”
Features:
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.
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.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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
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
Clean Code
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.
Haven't read it yet, but I believe the "Gang of Four" is somewhat of a standard for learning design patterns.
Read this book: Code: The Hidden Language of Computer Hardware and Software
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.