April
23,
2002
I see that China Mieville has a new book coming out soon, so I figured I
should read the Mieville book I already own (Perdido Street
Station) to find out if I like his writing well enough to buy the next
book on sight.
Then I decided that I wasn't in the mood for another dark, quirky urban
fantasy -- but I did like my initial goal of reading an author I haven't
had a chance to check out yet. So, I ended up picking up James Alan
Gardner's Expendable
.
The book has an immediate high-concept hook: You know the red-shirts on
Star Trek? The ones who get killed on the away team missions? This is
their story. The Explorers (chosen from the ugly, deformed, and misfit)
go down to potentially dangerous new planets, and scout things out -- and
Our Heroes have just been sent on a mission to the one planet that no
Explorer has ever come back from.
This is precisely the kind of book that I enjoy -- it's got a solid,
interesting background; it's got a reasonably twisty plot; it's got
puzzles that keep you reading, looking for the solution; and it's got some
fun characters. If I hadn't already referred to Lois Bujold as Dave
Duncan In Spaaaace, I might use that phrase to describe this book.
Quibbles? Okay, a few: there are a few too many coincidences for my
liking, though still well within the bounds of reasonability; and the
solution to all the puzzles aren't quite as satisfying as one might have
hoped.
Those are quibbles, though, because this was a smashingly fun book; I just
hope that Gardner didn't blow all his creative energy on his first novel,
because I definitely intend to read his other stuff.
| :::
April
21,
2002
Our untimely summer weather turned back into winter again this weekend,
and I was thus looking for proper winter fare: light, humorous reading.
This is a task that gets increasingly difficult with the passage of time,
because there's a finite amount of good light reading out there, and it
gets read quickly. My best bet for light reading would probably have been
P.G. Wodehouse's Something Fresh, but I have that secreted away in
my pile of books to bring with me on my incipient move to Detroit (plus,
Wodehouse is forever associated with summer reading in my mind); something
else was required.
I knew I was reaching a little when I picked up William Browning
Spencer's Résumé with Monsters
, but I didn't
realize how much I was reaching.
The high concept of the book, as I understood it, is that it mixes humdrum
office life with Lovecraft's monsters in a humorous way -- Dilbert crossed
with Cthulu. Well, that's largely accurate, but the book is rather darker
than that description makes it sound. In a lot of ways, in fact, it's
very like The Wasp Factory -- you've got the calmly insane
protagonist with a messed-up family history, and a madness involving magic
rituals in the everyday world.
It's not quite that bleak, though. For one thing, it's
deliberately ambiguous throughout the book whether or not the protagonist
is insane or describing reality accurately; for another, the book has
passages of sly, witty humor -- the kind of passage that makes you want to
turn to the person next to you and read aloud for a bit. (The kind of
passages, moreover which would be ideal to type out here if I weren't a
bit too lazy to transcribe long passages of text, and if most of them
didn't depend on too much context.)
This is unquestionably an excellent book, and I have no hesitation about
recommending it to all and sundry; but do be aware that it's not quite as
fluffy as all that.
| :::
April
20,
2002
Okay, here's a technical book in which I'm not even going to attempt to
interest my non-technical readers. If you're not somehow involved in the
design of computer software, you simply do not want to read Alan
Shalloway and James Trott's Design Patterns Explained: A New
Perspective on Object-Oriented Design
. Quit reading now.
If you are involved in that field, it might be worth a shot, though.
Basically, I read this book because I was looking for a quick and easy
intro to design patterns, with more motivation than is presented in the
standard Gang of Four text. It largely succeeded in that role, even
though the authors occasionally came across as faddish twits.
This isn't an essential book, and if you're a master of design patterns,
you can skip it easily; but if you want to ease into the big blue book o'
Smalltalk examples, this is a perfectly reasonable place to get your
bearings.
| :::
April
8,
2002
Around Christmas-time, I saw a copy of Vernor Vinge's True Names and
the Opening of the Cyberspace Frontier
, and picked it up without
another thought. I'd been waiting for this book for years, as it had been
apparently caught in some kind of publishing limbo, and I wanted to read
Vinge's stories.
I should have taken a closer look before buying. It turns out the book
only contains the one Vinge story ("True Names"), and is otherwise padded
out with a bunch of "futurists" rambling on about the Internet.
Futurist drivel about the Internet is annoying enough, but it gets worse:
since the book's publication had been pushed back so far, a lot of the
essays are from 1997. So it's dated futurist drivel. Joy.
Well, just because I bought a book doesn't mean I need to read it cover to
cover. I skipped all the essays (except for a forgettable little thing by
John M. Ford, which I figured might be good, because, hey, John M. Ford)
and only read the story.
The story's a precursor to the cyberpunk genre (which is why someone
got the idea to put it in a book with all those essays), and it's good.
The characters are interesting, the plot brisk, and the concept... no
longer novel, these days, but if you put yourself back to 1982, it's
incredibly imaginative.
Vinge fans should definitely read this story, but -- unless they really
want to read all those essays that I skipped -- they might want to see if
they can find it elsewhere, as $14 for a single short story is pretty
steep.
| :::
April
6,
2002
While at that comic shop a week ago, I also picked up Jeff Smith's
Bone: Ghost Circles and Rose
(the latter illustrated by
Charles Vess). The Bone series -- of which Ghost Circles is the
seventh collection, and to which Rose is a prequel -- came highly
recommended to me by multiple sources, but after reading all the available
material so far, I'm not sure why. It's a perfectly fine comic -- the art
is professional, if not quite beautiful; the characterization and writing
are very good; the setting is original; and the plotting is competent --
but that's all it is.
In the first book, we get our basic setup: the three Bones (who are, in
fact, something akin to walking, talking bones) are kicked out of their
home, and wander into a magic valley with quaint medievalesque
inhabitants, dragons, and nasty (but stupid) rat-creatures. Things start
off fairly light, but as the series progresses, the plot darkens
considerably -- and not entirely satisfactorily. The first few books,
where the story was the lightest, are the most enjoyable part of the
series; the later darkening only serves to move them from a uniquely
whimsical niche into a more crowded epic fantasy arena.
If you're not a big comics fan, you can safely skip these. If you are,
it's worth picking up at least the first Bone book, and deciding from
there if you want to keep reading. For my part, I'm a total sucker for
the medium (a competent graphic novel is nearly as satisfying to me as an
excellent novel), and Bone is good enough to keep me buying indefinitely.
| :::
April
4,
2002
(Okay, this is a review of a technical book, but since I know that most of
my readers are non-technical people (or, at least, people who are
technical in a different area), I'm going to do my best to keep things
interesting to a general audience up until the part where I have to get
into details.)
If you pay even vague attention to computer-related news, you've probably
heard of Microsoft's .NET initiative by now. And if you pay anything less
than extremely-detailed attention, you probably have minimal idea what the
heck .NET is. Part of this is because Microsoft's badly overused the term
(for marketing reasons) to apply it to just about everything they're doing
now, and part of it's because there are several parts to .NET.
One of the parts (.NET My Services) refers to Microsoft's "Web Services".
What are web services, you ask? It doesn't matter, I say. Web services
may or may not become a big thing, but until they do, you don't need to
pay attention to them (unless you're a software developer, there's no
using paying attention to the Big New Thing before it actually hits big;
otherwise, you'd've spent all your time learning up on push technology and
peer-to-peer, and what a waste that would have been). Web services are
kinda vaporish right now. It's possible to create and use them, but I've
so far not seen any compelling -- or even really interesting -- web
services in actual use.
The other part, and the part I'm going to talk about here, is the .NET
Framework. At a fundamental level, the .NET Framework is a dull and
technical thing that you'll never deal with -- it's a collection of
programming interfaces that software developers will use to create
applications. Like I said, dull. Except to developers.
And that's where things get interesting for you, Good Non-Technical
Reader. Because, see, in recent years, Microsoft's development
environments have been taking it in the shorts. Programming for Microsoft
operating systems has been a pain in the ass, as Microsoft's programming
interfaces and languages have pretty much sucked compared to the biggest
competition out there, Java. For the last few years, Java's been so far
ahead of Microsoft in the developer productivity front that it wasn't even
a competition, and Microsoft pretty much had only its huge monopolistic
installed base to keep it in the game.
That's not the case any more. .NET is a whole-scale, ground-up rewrite of
Microsoft's programming interface, and it's very, very good (and, not at
all coincidentally: very, very Java-like). Java's advantage is, just like
that, entirely gone -- and in a lot of respects, Java is now lagging.
Microsoft has used its monopoly powers and huge cash reserves to once
again come from behind, steal the leader's good ideas, and dominate.
With the release of .NET, your chances of ever living in a world free of
Microsoft's domination just got a lot smaller. The worst part about this
is, the Java folks don't even seem to realize that they've just been
lapped -- they're still acting as if Microsoft is still back there tying
its collective shoes, and they have all the time in the world to cavort
and frolic without real competition. It's frustrating, honestly.
But hey, silver lining: At least things under the rule of Microsoft will
be better for software developers post-.NET.
Anyway, I was talking about a book here, wasn't I? The book in question
is Jeffrey Richter's Applied Microsoft .NET Framework
Programming
. With any technical book, there are two important
questions: First, is it deep?, and second, is it objective? Regrettably,
most .NET books have failed both of those two tests; thankfully, this one
passes both with flying colors.
(By the way, any non-technical readers who've gotten this far can probably
start skimming, or just stop reading entirely.)
With regard to depth, there's a real danger with new technologies that
books about them will be shallow, simply because nobody's had time to
really use them much or find out things in depth. Richter gets around
that by virtue of writing for Microsoft Press, and having inside access to
the .NET development team. This means that he's able to explain not only
how things are in great detail, but also why they're that way. Richter
displays a fine command of relevant detail; any aspiring .NET programmer
will be far more grounded in the fundamentals of the .NET Framework after
reading this book.
In fact, I'd go so far as to say that this book (or one very much like it)
is essential reading for any real .NET programmer. You can do cargo-cult
programming without understanding things at a real level, but if you want
to do real programming, you need to know what's really going on. If you
read this book, you'll know. The quality of information presented is
excellent here -- this book is good enough that it could be published by
O'Reilly, which is the highest compliment I can pay a tech book.
So, what about objectivity? This was my biggest potential worry going
into the book. After all, it is a Microsoft Press book, and the
author does seem to know the .NET development team, so there's definitely
a potential lack of objectivity there. More, it seems like most of the
books out there that cover .NET technologies do so with a complete
blindness to all non-Microsoft technologies, which is patently ridiculous
-- .NET owes so much to Java that it's inconceivable it'd exist as it
currently exists without Java's example to look to, but authors write
about .NET as the natural evolution of COM without any reference to its
non-Microsoft predecessors. The creeping suspicion one gets is that the
author isn't actually familiar with any non-Microsoft technologies, which
makes you wonder just how much they really know.
Richter doesn't make you wonder. Somewhat frustratingly, he doesn't talk
much about Java, but he does reference other technologies, and (most
importantly) isn't afraid to point out shortcomings of .NET, even going so
far as to highlist some aspects as egregious bugs or just poor design.
There's no suspicion that Richter is in Microsoft's pocket, or that this
book has been sanitized for PR purposes.
In fact, the only real fault I can find in this book is that it does
neglect Java. The most irritating effect of this neglect is that the book
is clearly written for an audience of Windows C++/COM programmers coming
to .NET, not for Java programmers looking to .NET. In large part, this
isn't a big deal, but it does lead to unnecessarily long and introductory
chapters on strings, exceptions, and garbage handling (I wondered at first
why Richter spent so much time on these topics, which are very familiar to
Java programmers, before remembering that C++ programmers wouldn't be
nearly as familiar with them).
Still, that's not a big deal, and it probably had to be written that way,
as there's a huge audience of C++ programmers out there, and they need to
know this stuff. It leads to a few skimmable chapters for the Java
programmer, but the rest of the book more than makes up for it; and even
the Java-similar chapters contain enough .NET-specific stuff that Java
programmers could stand to learn a bit from them.
If you're a real programmer (say, someone who knows what polymorphism is,
which excludes most VB monkeys) and are, or expect to be, programming with
the .NET Framework, buy this book and read it.
| :::