Not nearly as cheeseball as I expected. Not nearly as sexist as I expected. John Carter is actually a (mostly) decent guy. And this novel holds up welNot nearly as cheeseball as I expected. Not nearly as sexist as I expected. John Carter is actually a (mostly) decent guy. And this novel holds up well;I can see why it's a classic of the genre....more
Despite the fact that there's no real reason to be apologetic, I also haven't yet reached the point in my career as a software developer where I've stDespite the fact that there's no real reason to be apologetic, I also haven't yet reached the point in my career as a software developer where I've stopped apologizing for the fact that I have no "real" Computer Science Background.[^1] And/but that's exactly what draws me to books like Understanding Computation by Tom Stuart (O'Reilly, 2013). Stuart describes the books as for:
...programmers who are curious about programming languages and the theory of computation, especially those who don’t have a formal background in mathematics or computer science.
In other words, people like me. The people that Eric Miraglia described as the "liberal arts majors drafted into web-developer service during the dotcom boom".[^2] Yes: the liberal artsy non-computer science degree holders that wound up doing computer sciencey type software work just the same. Smart people that nevertheless are exploring some of these concepts for the first time.
For a taste of what I mean, observe the following quote:
In the end, syntax is only concerned with the surface appearance of programs, not with their meanings.
If that made you smile just a little bit, because you want to peel the onion layers away and get at the semantic questions underneath... then this book is for you.
Now before we go any further -- a couple words on what this book is not. This is not a book about software engineering. "Big O notation" does not make an appearance here in the text, not once. It isn't that we aren't concerned with "clean code" or efficiency or scalability or any of that -- but those are just implementation details that are not particularly interesting when you're otherwise diving into language semantics and finite automata.
Instead, the kind of questions this book poses are more like:
- What is a computer? - How do you create one? - How does a computer compute? - How would you go about designing a language? - Are there limits to computation? What are they?
These are fascinating questions, and reading this book was one of the first times where I really understood what separates "computer science" from "software engineering". The book is a fascinating read, even if it occasionally lapses into sentences like this:
The NFA class automatically takes account of free moves — we can see that when our NFA is started in state 3, it’s already possible for it to be in state 2 or 3 before it has read any input — so we won’t need to do anything special in NFASimulation to support them.
Awesome, but a little opaque.[^3] And/but, there's quite a bit of this; for a "simple" book about foundational computer science thinking, there's a lot of complicated material. ("But this is why you're here, right? To dip your toes into this particular pool?") It's often challenging, but also rewarding. (And there's plenty of humor along the way, if you're paying attention.)
A year from now, when I'm settling in to re-read this one, I probably won't remember the details about pushdown automata or what formalisms define a "universal Turing machine". However, I'm going to remember the in-depth discussions of static typing vs. dynamism and the trade-offs between them. I'll remember that we went through some engrossing exercises where we built up integers and arithmetic operators from scratch (even if I don't remember the details). I'll remember the flirtatious foray into language design. I'll remember The Halting Problem and most of the gory details around the limits of computation. And another thing I'll remember, statements like this:
The purpose of an expression is to be evaluated to produce another expression; a statement, on the other hand, is evaluated to make some change to the state of the abstract machine.
If you're "doing software" and you don't have a degree in computer science, I'm going to urge you to read this book. Even if you can't follow everything, you'll walk away with a lot of insight. (I'm particularly fond of the first and last thirds.) And if you do have a CS degree... Well, it's still worth skimming.
[^1]: The "full disclosure" footnote: I was briefly declared as a computer science major while in college. I performed... serviceably in an intro class (Common Lisp!) and in an "intro to AI" class (more Lisp!) but got ground to a frustrating halt in "Programming and Data Structures". I blamed Dr. Hunter, but I think I just wasn't ready to think that way. Call me a late bloomer. Call me a self-learner. Call me a frustrating bastard.
[^3]: Partly my own fault for doing so much of the reading as my too-late-night bedtime reading.
Real review at some point but, short version: Taleb describes systems that get stronger from volatility and mistreatment ("to a point"), and comparesReal review at some point but, short version: Taleb describes systems that get stronger from volatility and mistreatment ("to a point"), and compares them with our tendency to plan and predict and generally design systems that break down when things don't go according to plan. There is a lot of insightful stuff in here, and some excellent unconventional thinking, and/but his writing style is a bit glib and can get in the way of his point being made. Sometimes....more
If you've been programming in Grails for a year (give or take) and are ready to go deeper than the tutorials and docs usually take you, then Burt BeckIf you've been programming in Grails for a year (give or take) and are ready to go deeper than the tutorials and docs usually take you, then Burt Beckwith's book -- Programming Grails (O'Reilly, 2013) -- is going to feel like just what the doctor ordered. If asked to sum it up as a pithy one-liner, I'd describe it as a guided tour of the framework's guts by one of the field's seasoned experts. He goes beyond the basics, and dives headlong into those dark corners for (as he puts it) "developers who want to dig deeper into the architecture and understand more about how Grails works its magic".
If Beckwith's name is familiar, then you've probably been around the Grails block once or twice. He curates the This Week in Grails blog series and at least half the time seems to be the author of the accepted answer to that Grails question you found on StackOverflow. In other words: this is a guy that knows his way around the the framework.
Having worked in, with, around, over, under, and through Grails over the past couple of years, this book was exactly what I was looking for at this point in my relationship with the framework. Beckwith is specifically targeting developers that have gone past simply snapping together applications along the happy-path; this one is for the developers that find themselves regularly battling with some dark and thorny corner or rough edge of the framework. Beckwith does a fantastic job of introducing these "hidden" and "magical" parts of Grails, and breaking them down into easily-digestible sections. It's like a series of miniature epiphanies -- one right after the other. (The opening chapter on Groovy alone is worth the price of admission.)
There were a couple of things that could have made this one better. Most of them were small to the point of being ridiculous (e.g., I could have used a more specific definition for the purpose behind BootStrap.groovy), while others were arguably out of scope (e.g., an in-depth discussion of Groovy's metaclasses is... probably more appropriate for a book dedicated to Groovy). Then there was the chapter on plugin development which -- although I learned something on almost every page -- I found myself wondering: (1) why not discuss how to run with inline plugins right from start? (2) why wait so long to mention settings.groovy? (3) why not a better example of CLI tests?
(As you can see: even my "legitimate gripes" are little more than nit-picks. But I suppose the nit-picks add up?)
Would I recommend this one? In heartbeat. I'll continue to recommend Grails in Action as the best place to start (with the caveat: "as soon as the second edition comes out..."), but Programming Grails is required reading for anyone with six months or more of non-trivial Grails development under their belt....more
**spoiler alert** Those last couple of chapters are a bit rough for an almost-five-year-old, what with the Time-Turner and the ambiguous outcomes. ("D**spoiler alert** Those last couple of chapters are a bit rough for an almost-five-year-old, what with the Time-Turner and the ambiguous outcomes. ("Daddy, but Sirius was good?" "Yes." "So why is he hiding?" "Because he was convicted of breaking the law and there is no evidence to absolve him." "What does absolve mean?")...more