|How Software Works|
Author: V. Anton Spraul
With a subtitle like "The Magic Behind Encryption, CGI, Search Engines, and Other Everyday Technologies" this sounds like a book everyone should read. Is it?
No, but not for the reasons you might think.
This is an excellent book but it doesn't pull any punches. If you are looking for a light and fluffy read that takes you through a catalog of how wonderful computers are without actually telling you anything then this is not the book for you. It does go into the detail and if you are not at least a little bit of a programmer then it is going to be difficult for you to follow. On the other hand if you do program a little and are prepared to put some work in this book will tell you things that others just skirt around.
Chapter 1 starts a three-chapter look at security issues. First we find out about encryption. This starts from very simple substitution cyphers and works its way up to substitution cyphers of increasing sophistication. It ends with a fairly complete explanation of the AES encryption process. This isn't a vague sort of "you put the key in here, the data here and out pops the code". It really does explain it in enough detail that with some help from an exact specification you could actually implement it in your favourite language.
Chapter 2 moves on to consider passwords and associated topics. First we are introduced to the idea of a hash function and then the MD5 hash function in particular. Again the description is fairly detailed. Once we have a hash function the next topic is using it to solve the problem of storing or rather not storing a password for identification. On the way we take a close look at digital signatures, how to make passwords even safer and what the possible attacks are.
Chapter 3 is called "Web Security", but it is actually about public key cryptography which, while important on the web, has a wider relevance. After introducing the idea of a trapdoor function, the specific case of RSA encryption is described. Again, the description is detailed enough for you to almost go and code it. The idea of using RSA for key exchange is discussed along with the HTTPS protocol.
For me, these three chapters made up the most interesting part of the book. Each of the topics was small enough to allow a reasonably full exposition. The rest of the book tends to tackle much bigger topics, but in about the same sort of space.
Chapter 4 moves on to movie CGI. After a brief introduction to pixel graphics the main topic is ray tracing. This isn't covered in much detail and you would be hard pressed to actually implement the techique from the description. Chapter 5 continues the graphics theme with a look at game graphics. Roughly speaking this corresponds to rendering wire frames using transformations, lighting and texture mapping. Again it is too big a subject to allow for a complete coverage but at the end you will at least have some idea how things are done and what sort of shortcuts are taken to make real time rendering possible.
Chapter 6 explains data compression. It starts with run length encoding and Huffman optimal encoding and then jumps straight into JPEG and even a little about MPEG. This misses out on lossless compression such as ZIP and gets a tiny bit technical because of the need to cover Fourier transforms. For a future edition of the book it would be better to treat lossless compression in one chapter and have another for lossy compression such as JPEG.
Chapter 7 takes us into traditional computer science territory with a description of searching and sorting - the argument is that one way of finding things quickly is to put them in order so sorting is a prerequisite to searching. Selection sort and Quicksort are the two methods covered. Binary search and hashing are also covered. The chapter ends with a look at a very different topic - web searching. This really needs a chapter to itself.
I'm not at all sure why there is a chapter on concurrency. It is a very technical topic and not at all of obvious interest even to a beginning programmer. It is important but most programming tasks don't make use of it because it is difficult. In Chapter 8 we learn about deadlock, semaphores and performance issues.
The final chapter is about map routes - another topic that isn't an obvious candidate to go with the earlier chapters. It basically explains how sat navs find the best route between two locations.
Overall this is a very good book. Some of the chapters work better than others but I suspect that the chapters that a reader will find most interesting depends very much on the reader.
As already stated, the level of explanation is deeper than you might expect from a book that doesn't contain code. As long as you are happy to really discover how software works then you should find this one of the best reads you have had in a while. If I have a criticism it is that there should be more chapters and the topics should be spread out a little more.
|Last Updated ( Saturday, 13 February 2016 )|