Author: Rebecca M. Riordan
Publisher: Sams, 2011
Aimed at: Beginners
Pros: Gimmicky style, does a reasonable job of teaching C#
Cons: Form and format of book hinders understanding
Reviewed by: Mike James
You always need to put a new spin on an old idea. What good is a book if it just has some words and pictures that tell you how things are in a simple and clear way? That's what all books do!
You need a gimmick, something to separate you from the pack. Dummies books have a way of doing it. The Head First series does it another way. Now we have Fluent.
If you are not a beginner then it is important to say that the use of "Fluent" here isn't a reference to the Fluent style of coding, so that method calls can be chained together, but presumably to achieving a level of fluency in the language in question.
The Fluent series aims to present the information in yet another way but why the ancient parchment look and the strange old fashioned fonts? This is a computer book - it should ooze up-to-date styling, not steam punk retro. Of course steam punk retro is a style that some technophiles like. What could be better than a wood and brass keyboard?
I suppose the appeal of the Fluent style depends a lot on how much you like this retro fantasy style. My guess is that even if you do like it there will be times that you really regret the choice. For example, when you try to read the example programs, which are sometimes set using a script font and light brown ink! Yes another triumph of design and style over clarity and common sense. Does it make the programs easier to read? No. The same is true of the screen dumps in light browns to produce a "sepia" effect - you can make them out if you look hard enough. The whole book is made difficult to read by the style adopted.
Now all this would all be forgiven if the content did the job and taught you C# but the author seems to want to avoid actually getting started with programming topics for as long as possible. We have about 100 pages of reading around the subject before we get to programming. You might consider some of the reading around to be useful background information - UML, compilers v interpreters - but it really isn't going to make any sense to a beginner. After you have introduced some coding, perhaps it is a good idea to go over these more abstract topics, but this is not the place to start.
When we do get to teaching the language it isn't too bad, but once again the style of the book gets in the way. We have section of the book called Nouns, transitive verbs and intransitive verbs - while this might be cute it doesn't help with understanding. It does introduce the basic ideas of programming - types of data, objects, classes and the flow of control. This might have been a good attempt at explaining the language, but it is a bit too quick and reads more like an attempt to classify everything.
There are also quite a few small errors and the language used to explain ideas tends to be imprecise - something I can mostly forgive if it helps the reader understand, but in this case I'm not at all sure it does. There are enough straightforward typos to mean that the beginner could have a tough time making it all work.
The last two sections of the book are on Best Practices and WPF. The best practice section is a lightening overview of object-oriented methods including the Liskov Substitution principle, and a few patterns. Given the size of the book, it is reasonable that it should cover wider issues, but there is also a lot of C# that isn't covered in sufficient depth and one or two topics that aren't covered at all. Perhaps this space should have been used for something more practical with just a overview provided.
The section on WPF covers all the usual topics: XAML, controls, graphics, templates and databinding. Currently the position of WPF in the Microsoft world is a little in doubt due to a shift in emphasis to WinRT and DirectX. While WPF is going to be important for some time, there really isn't any pressure to introduce this more difficult framework to the beginner - Windows Forms will mostly do and it illustrates the basic ideas. The description of WPF isn't bad, but again it is spoiled by imprecise English and enough small typos to give the beginner problems.
Overall this book is a mistake. It is a mistake to present technical ideas using a style that makes it harder to read. It doesn't look particularly good and it doesn't suit the material - at best it is an attempt at some sort of joke. You can almost hear the design department selling the idea based on wrapping up high tech stuff that they have no knowledge of in a Victorian pastiche of sepia, old photos and a difficult to read script font. Sometimes you have to wonder what madness allows people who don't know the subject matter and clearly don't know their audience to have such influence on a project? Ah well, book publishing is an art form and sometimes we just have to put up with excess art and not enough form.
This isn't the worst book attempting to teach a language I have ever read, but it is the worst presentation of a book attempting to teach a language. As a result I don't think it stands much chance of working. My advice is to avoid it and any other books in the Fluent series unless you have actually physically looked at them (on-screen samples are easier to read then the real thing) and found them acceptable. There are so many better books introducing C# than this one.