Slashdot Mirror
Ask Slashdot: Books for a Comp Sci Graduate Student?
peetm (781139) writes "Having visited with me and my wife recently, the girlfriend of an ex-student of mine (now taking an M.Sc. in pure CS) asked me to suggest useful books for her boyfriend: '... He recently mentioned that he would love to have a home library, like the one you have, with variety of good, useful and must-have books from different authors. ... Mostly, I was thinking your advice would be priceless when it comes to computer science related books, but .. I would appreciate any sort of advice on books from you. ...' Whilst I could scan my own library for ideas, I doubt that I'm really that 'current' with what's good, or whether my favorites would be appropriate: I've not taught on the M.Sc. course for a while, and in some cases, and just given their price, I shouldn't really recommend such books that are just pet loves of mine — especially to someone who doesn't know whether they'd even be useful.
And, before you ask: YES, we do have a reading list, but given that he'll receive this as part of this course requirement anyway, I'd like to tease readers to suggest good reads around the periphery of the subject." I'll throw out Pierce's Types and Programming Languages (and probably Advanced Topics in Types and Programming Languages ), and Okasaki's Purely Functional Data Structures .
And, before you ask: YES, we do have a reading list, but given that he'll receive this as part of this course requirement anyway, I'd like to tease readers to suggest good reads around the periphery of the subject." I'll throw out Pierce's Types and Programming Languages (and probably Advanced Topics in Types and Programming Languages ), and Okasaki's Purely Functional Data Structures .
I don't think knuth's 3 volumes have dated at all- they're still the definitive computer science tomes.
A book on consise exposition without complex family relations; one that cuts right to the content. That would be a good start.
'We are trying to prove ourselves wrong as quickly as possible, because only in that way can we find progress.' RPF
Generally, the highly respected works for each subarea of CS are already well known. Someone studying at the graduate level should have no difficulty finding them on their own, one would think.
Moreover, at the graduate level, one is generally studying for some specialization. Without knowing what specialization this person has chosen, any advice we could give him would be unlikely to be of use.
Brooks - "The Mythical Man-month"
Yourdon - "Death March"
DeMarco & Lister - "Peopleware"
Of course he may change majors after reading them.
Cheers,
Dave
They that can give up essential liberty to obtain a little temporary safety deserve neither safety nor liberty.
Ben
nonsense, good books about OS and language design, compiler theory, algorithms, information theory: those are good for decades.
better to design a few types of languages and build compilers for them
Since most of the "Computer Science" we call today is actually "industrial science" with variations on things we already know, you shouuld go back and learn all of the fundamentals fo the science, which in my opinion was established by Knuth.
Which, I can assure you, you haven't learned them if you went to a typical University in the United States. For one thing, you spent way too much time reading about other things to cover the basics of the science of computing in 4 years at a University.
http://www.amazon.com/Computer...
This should be a graduation present for all University Students, and a cornerstone for those who want to avoid college because of cost/indoctrinized education and begin studying the topic yourself.
What I like about this set of books is, you can even as a beginner, skim the text and if you like, avoid the theory, and immediately start trying to write code and in many cases, the algorithms in the code point to an understanding to the process of many mathematical functions.
With this understanding, you can start trying to tackle some of the fairly formidable abstract ideas in the text which forms the foundations of computer science.
For example, I learned what integration was about from a computer algorithm this way when I was 14, and once I understood what was happening with the code the math was much simpler. I always thought Calculas at the time was big and scary. Not so scary when you do it in C code.
Calculas = Fancy Adding and Subtracting. :-)
But you won't touch any subject matter right now, or in the foreseeable future that Donald didn't already cover in these volumes.
Got Geometrodynamics? Awe, too hard to figure out? Too bad.
Code Complete has been one of the most useful texts that I have found.
Before learning any existing ones!
So you don't spoil your purity.
John McAfee 'It was like that time I hired that Bangkok prostitute; to do my taxes, while I fucked my accountant'
GoF's Software Patterns
LOL, What? This is what that makes your list look like: Hemingway's For whom the bell tolls; Faulkner's As I lay dying; Vincent & Burpo's Heaven is for real; Sinclair's The jungle
What a joke!
Required reading for internet skeptics
. . . from Gerald Weinberg: http://en.wikipedia.org/wiki/G...
Schroedinger's Brexit: The UK is both in and out of the EU at the same time!
to clarify your relationship to this guy!
Compiler construction teaches many different aspects of computer science, and this is a classic.
One of the best-written technical books, ever. On the practical side, but doing useful things (tm) is not illegal in computer science.
A good introduction to the fundamentals of theoretical computer science.
Stephan
I recommend "Design Patterns" by Gamma, Helm, Johnson, Vlissides
Uh, Linux geek since 1999.
a comp-sci grad student has already done that
It's an even bigger joke is when you get quizzed in interviews by mindless retards who expect you to have memorized all the worthless "patterns" in the book. And god forbid if you ever look at the code these same idiots write. They make the OpenSSL codebase look like the greatest thing ever. If you ever though C macros could be used for ungodly amounts of obfuscation and indirection one only needs to look at the AbstractFactoryFactoryBuilderFacades that these "patterns" people write.
Introduction to Probabilistic Automata - Azaria Paz
Anything by Claude Shannon
Information theory and statistics - Sollomon Kullback
http://www.edwardtufte.com/tuf...
anything they might say has been said a thousand ways on the internet
By people who once had a couple conversations with someone who took a class loosely based on the book (who probably ought not be saying much on the subject to those trying to learn it for real).
K & R
Effective C++
Object-Oriented Software Construction by Bertrand Meyer
The PostgreSQL manual
Structure and Interpretation of Computer Programs, 2nd Edition. This used to be an undergraduate text for a course at MIT. But, it is now optional even at MIT. This is shocking to me. We used the text in my sophomore year at the University of Utah. If you hear old timers (okay me) complaining about programmers these days, this is part of it.
Computer Architecture, A Quantitative Approach (5th edition). I need to update my copy, but this text really allows one to reason about scale and performance.
An Introduction to the Analysis of Algorithms, 2nd Edition. Again, I need to update my copy, but this provides the key mathematical foundations for algorithmic analysis and their performance.
Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition). This is much more practical of a book, but it gives key insights into framework design. Yes, it's about .Net, but it's really about large scale object oriented design applied in the real world and therefore useful to all.
Modern Operating Systems (4th Edition), Tannebaum. A great insight into OS internals, including key concepts that are useful in all sorts of programming.
Essentials of Programming Languages (3rd Edition). A deep dive into interpretation of programs. Provides a great start into programming language semantics.
Compiling with Continuations, Andrew Appel. Of course, the Dragon book is useful. But this book really gives some unique insights into program analysis. Combine this with Engineering a Compiler and you have insights into how code really is transformed into executable artifacts.
In fact, this reminds me, I need to go make sure I still have my copy. It's pricey to replace.
I'll make a final plug for Semantics Engineering in PLT Redex. There are lots of advanced books on programming language semantics, but this is only book I've found in which the rubber hits the road. It is rigorous in its coverage of major language models, but its an actual tool as well.
The Pragmatic Programmer: From Journeyman to Master - It's not a Computer Science book, but it really talks about essential things any programmer should know in order to excel in their career.
Other than the obvious Cormen, Leiserson, and Rivest (plus Stein these days, apparently): http://en.wikipedia.org/wiki/I... I found H. J. Tichy's _Effective Writing for Engineers, Managers, and Scientists_ very useful. I haven't finished _Hacker's Delight_ by Henry S. Warren, Jr., but there's some good stuff in there.
You seem to misunderstand what a citation is. A citation is not saying, "Here, this is true because Mr. XYZ said so," but, "Here, this is being accepted as true (or just considered even) because Mr. XYZ gave good argument/data in source ABC." It is not an appeal to authority, it is reducing redundancy by not re-deriving something already written about elsewhere. And this is a good science practice, as it is rare to be working on a topic where no one has already done some theory work or found some relevant experimental data.
You should have spent a lot of time deriving things in your undergrad and early grad courses, and you should double check the calculations of any citation central to your work to catch typos or actual mistakes. But by the time of writing actual papers or your doctoral thesis, you shouldn't be wasting reader's times by re-deriving things in detail beyond what is needed for outlining background and covering your premises. Unless your new contributions are a better way to present or derive the same solution, or showing a mistake in the derivation, you move on to deriving new things while cite others for stuff already done.
Graduate-level CS encompasses a lot of ground!
Knuth is of course a valuable addition to the book-shelf — as others have pointed out, it's a superb source for chasing up information, details and citations for algorithms and data structures one needs to justify or investigate, if nothing else.
Okasaki's Purely Functional Data Structures has also already been mentioned, and I'd add my endorsement!
I would recommend two other texts to add to a collection:
I would recommend a book on convex optimisation and probabilistic graphical models, but frankly I don't know of a single text on either topic that I could whole-heartedly recommend. Any suggestions?
Cite Knuth... This is, of course, good science.
Well at least Professor Knuth is still alive, and I don't [YET!] need to refer to the poor man as spinning in his grave.
AC posted an excellent response here.. In the event you're filtering AC's, take the time to read it, as it's completely on point.
I would add is this: if you've never completed a Masters thesis or Doctoral dissertation, just try submitting one to your committee without adequate citations. If you write somewhere "I used well-known algorithm ABC because of XYZ" and you don't have a citation for that algorithm, you'll be sent back for rewrites pretty quickly to add appropriate citations.
By way of example, in my Masters thesis several years ago, I mentioned Unix diff , without a citation. Why would this need a citation? It was mostly mentioned in passing, and every computer scientist under the sun knows what diff is, right?
Committee came back asking for further citations on a few things, including diff (which, for the record, is "Hunt, J. W., and McIlroy, M. D. An algorithm for differential file comparison. CSTR, 41 (1976).")
Using citations isn't an appeal to authority. It's akin to using an existing library call in programming. Just as you wouldn't roll-your-own quick sort algorithm when coding, someone writing a scientific paper doesn't re-invent every algorithm ever derived. You find someone who has already done that, and you cite them. The AOCP is useful in this regard due to the sheerly massive number of algorithms Knuth describes. It's hard to go through a Computer Science program and not use one of these algorithms. Knuth himself likewise cites all of the algorithms in the AOCP, so it's not an appeal to his authority, as he delegates that out to others appropriately. It's simply useful because instead of having to track down papers written in the 1960's on your own, you can cite Knuth who cites those papers for you. This is why the AOCP is useful for a graduate student.
FWIW, I cited Knuth. I needs an algorithm to calculate variance, and another on the Box-Meuller transformation. Art of Computer Programming had one for each, which I adapted for my needs, and cited appropriately.
Yaz
For me, it was "Thinking Forth" by Leo Brodie. Forth is a pretty unique language, barely above assembler level, but able to (quickly) build up code/data structures of Lisp-like complexity (and like Lisp, can self-modify). Brodie's Thinking Forth pulls apart how you'd solve problems with procedural language and completely re-factors them to take advantage of how Forth works.
Even if you don't ever use Forth (and most of us enthusiasts never did for anything but school and our own utilities), learning it changes your thinking. But I'd concede that Forth itself isn't the necessity - it's to learn languages and approaches that solve problems in whole different ways. There should be books on functional languages, APL, or Lisp.
I'm not sure what the classic list would be - but for me, Starting Forth I pull off the shelf decades later to peruse when I need to pull my head outside the box. (It's now available as a free PDF, by the way.)
If a civil case is being litigated in court there's very often a new question to be answered, because the relevant statutory and case law are unclear about the case at hand. Your job as a lawyer is to show the court how the pre-existing law applies favorably to your novel situation, when appropriately extended or amended. In the common law this is how the law slowly grows organically overtime.
Trial and lower appeals courts make new law all the time, and stare decisis demands that one trial court judge normally follow the rule of another trial court judge's opinion in his jurisdiction, even if the case never went up to a higher court, presuming no other rule from a higher court was issued in the mean time.
Take, for example, Judge Vaughn Walker's decision in Perry v. Schwarzenegger, which struck down Proposition 8 as unconstitutional. The case posed a novel question, and Judge Walker's bold decision created new constitutional law in California. But it was not yet binding on other courts. When the plaintiff's won, the state of California declined to appeal. A new litigant entered to take the place of the defendant, but ultimately SCOTUS said that the new litigant did not have standing. That meant that Perry v. Schwarzenegger reached the end of its rope, without any more avenues of appeal, solidifying Walker's opinion as law within his jurisdiction. Walker's decision is now binding precedent on all trial courts in Northern California, the jurisdiction of the court of which Judge Walker was a member. Only the Ninth Circuit Court of Appeals or SCOTUS can overturn that law; any other trial court in Norther California is technically bound by the principles of stare decisis. As more time goes on it becomes increasingly more likely that, if the issue came up again and the Ninth Circuit Court of Appeals heard a similar case, they'd likely adopt Walker's decision, in part or in whole, making it binding on all courts in the Ninth Circuit (basically the Western United States). That's because while Walker's decision is not binding outside his jurisdiction, the longer it stands the more society will orient itself around his ruling, and so the more persuasive it will become to other district courts.
One has to be prepared.
Computer Architecture: A Quantitative Approach by Hennessy & Patterson Helps you understand what goes on inside a computer at the hardware and OS level, as well as illustrating how you can reason about the performance of a system before you actually build it. Computer Graphics: Principles and Practice by Foley & van Dam A good starting point for learning about computer graphics. Not all of it is still relevant, but even if you skip the chapters about vector displays and user interfaces there is still plenty of useful material in there. Programming: The Derivation of Algorithms by Kaldewaij Teaches a way of constructing algorithms that are provably correct. Although I rarely follow this approach to the letter (it is very time consuming), elements of it are extremely valuable in everyday programming. For example, thinking in terms of preconditions, postconditions and invariants (design by contract) helps in designing good interfaces, finding bugs, placing useful asserts etc. Even just thinking to yourself "could I prove this program?" without actually doing it is useful, since if the answer is negative, the program is too complex and probably incorrect.
It would be more correct to say that it's "classically" misunderstood. GoF is fundamentally a dictionary, but too many people understand it to be a recipe book.
A 1000 times this. People seem to very frequently misundertand that GoF is a book on nomenclature. They give names to common patterns that exist in good software development. These patterns exist because they are useful and they come up time and time and time again. If you write software you will almost certainly implement a number of these patterns, and you certainly use software that uses them. But either way, these patterns exist in software with or without them being given names.
For the less experienced it gived examples of where such patterns might be used, but that's not the main point.
The main point is that I can call patterns by name and the person I'm talking to will understand what I mean. This is better than having to describe them each time.
SJW n. One who posts facts.
It was part of my required reading for a computer ethics course. Very entertaining. You really empathize with this college sys admin who is battling an unknown adversary trying to gain access to systems he is responsible for. Throw in the love story as a background and I still remember it to this day.
I suggest Richard Feynman's Lectures on Computation. People in the physics world will know the name, but the topics covered are great for CS/CE topics, and probably not things that were considered and/or covered in regular classes.
http://www.amazon.com/Feynman-...