writing

September 4, 2008 spout writing

Programming WPF goes into 3rd printing

March 22, 2008 spout writing

Nobody Knows Shoes: The Book — Pure Genius!

I friend of mine dropped a book with a funny cover in my lap and said, Hey, check this out.” I threw it on my pile and didn’t get back to it for a few days. When I did, I didn’t know what to make of it. It was like The Grapes of Wrath by Rory Blyth, with illustrations by a drunk Salvador Dali.

It took a few pages, but I eventually figured out that Shoes” was a cross-platform GUI framework for Ruby and this 52-page book was a tutorial for it. By page 15, I knew the major concepts. By page 20, I could write my first program. By the end, 30 minutes after I’d started reading, I knew the whole thing.

March 3, 2008 spout writing

Programming WPF: “Programming Book of the Decade”

February 21, 2008 spout writing

Programming WPF enters 2nd printing!

Wahoo! You love us, you really love us! : )

When a book goes to another printing, 100% of the time, there’s a list of errata” (aka mistakes”) that are fixed in the new printing. In this case, neither Ian nor I have any fixes to apply. So, it’s official — the book is perfect! : )

February 20, 2008 spout writing

Bridging object models: the faux-object idiom

My 1997 master’s thesis came online today (he says, trying not to flinch). Here’s the abstract:

Microsoft’s Component Object Model (COM) is the dominant object model for the Microsoft Windows family of operating systems. COM encourages each object to support several views of itself, i.e. interfaces. Each interface represents a collection of logically related functions. A COM object is not allowed to expose multiple interfaces using multiple inheritance, however, as some languages do not support it and those that do are not guaranteed to do so in a binary-compatible way. Instead, an object exposes interfaces via a function called QueryInterface(). An object implements QueryInterface() to allow a client to ask what other interfaces the object supports at run-time.

This run-time type discovery scheme has three important characteristics. One, it allows an object to add additional functionality at a later date without disturbing functionality expected by an existing client. Two, it provides for language-independent polymorphism. Any object that supports a required interface can be used in a context that expects that interface. Three, it provides an opportunity for the client to degrade gracefully should an object not support requested functionality. For example, the client may request an alternate interface, ask for guidance from the user or simply continue without the requested functionality.

COM attempts to provide its services in as efficient a means as possible. For example, when an object server shares the same address space as its client, the client calls the functions of the object directly with no third-party intervention and no more overhead than calling a virtual function in C+ +. However, when using COM with some programming languages, this efficiency has a price: language integration. COM does not integrate well with a close-to-the-metal language like C+ +. In many ways COM was designed to look and act just like C + + , but C + + provides its own model of polymorphism, object lifetime control, object identity and type discovery. Of course: since C+ + is not language-independent or location transparent. it was designed differently. Because of these contrasting design goals, a C+ + programmer using COM often has a hard time reconciling the differences between the two object models.

To bridge the two object models, I have developed an abstraction for this purpose that I call a faux-object class. In this thesis, I illustrate the use of a specific instance of the faux-object idiom to provide an object model bridge for COM that more closely integrates with C+ +. By bundling several required interfaces together on the client side, a faux-object class provides the union of the operations of those interfaces, just as if we were allowed to use multiple inheritance in COM. By managing the lifetime of the COM object in the faux-object’s constructor and destructor, it maps the lifetime control scheme of C+ + onto COM. And by using C+ + inline functions, a faux-object can provide most of these advantages with little or no additional run-time or memory overhead.

COM provides a standard Interface Definition Language (IDL) to unambiguously describe COM interfaces. Because IDL is such a rich description language, and because faux-object classes are well defined, I was able to build a tool to automate the generation of faux-object classes for the purpose of bridging the object models of COM and C+ +. This tool was used to generate several faux-object classes to test the usefulness of the faux-object idiom.

January 17, 2008 spout writing

Bookscan says “Programming WPF” is #3 .NET book!

January 8, 2008 spout writing

WPF Book Easter Egg

Does anyone have both the Anderson WPF book and the Griffiths/Sells WPF
January 6, 2008 spout writing

The Annotated Turing!

I just saw that Mr. Petzold is re-publishing the paper that started computer science and annotating it so that even I can understand it. I can’t wait!
January 4, 2008 spout writing

“So easy to read, it should be illegal”

Thanks very much
November 26, 2007 spout writing

C# 3.0 in a Nutshell, LINQPad and Pure Genius

I absolutely love what the Albahari brothers (Joe & Ben) have done with C# 3.0 in a Nutshell. Not only is their prose concise in a way that mine is not, but I have learned a bunch of stuff about LINQ I didn’t know, they built a tool (LINQPad) that lets you experiment with LINQ interactively in a way that the designers of LINQ themselves don’t support and the tool has all kinds of wonderful features that LINQ, SQL and Regular Expression programmers alike will want to use regularly long after they’ve read the book.

And if that weren’t enough, the tool comes with an integrated tree of samples that follow along with the material in the book, teaching the material from another angle and reinforcing it perfectly. It’s pure genius and if I ever write another book, it’s a model I’m going to follow. Very highly recommended.

October 19, 2007 spout writing

Fun With GridView*RowPresenter

Fun With GridView*RowPresenter

I was searching for advanced WPF tree samples the other day and ran into the tree-list-view sample:

Notice how the left-most column does the indenting, while the rest of the columns line up nicely. The code for the tree-view-sample is a little C# and a bunch of sophisticated XAML templates I didn’t understand, so I stripped it down to the bare nubbins to discover what was going on. Assume a simple class holding the data:

class Person {
  List<Person> children = new List<Person>();
  public string Name { get; set; }
  public int Age { get; set; }
  public List<Person> Children { get { return children; } }
}

The juicy bit that makes the tree-list view above possible is the GridViewRowPresenter:

<Window ...
  xmlns:local="clr-namespace:WpfApplication10"
  Title="GridView*RowPresenter Fun">

  <Window.DataContext>
    <local:Person Name="John" Age="13" />
  </Window.DataContext>

  <GridViewRowPresenter Content="{Binding}">
    <GridViewRowPresenter.Columns>
      <!-- NOTE: must explicitly create the collection -->
        <GridViewColumnCollection>
          <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}" />
          <GridViewColumn Header="Age" DisplayMemberBinding="{Binding Age}" />
      </GridViewColumnCollection>
    </GridViewRowPresenter.Columns>
  </GridViewRowPresenter>

</Window>

Here, we’re creating an instance of the GridViewRowPresenter, which is the thing that the ListView creates for you if you use the GridView. Here, we’re using it explicitly and setting the columns explicitly, binding it to our data and yielding the following:

Notice that we’re showing a single item, arranged as a row of values according to our column definition above. It’s boring and not at all interactive, at least because we don’t have a header, which we can get with an instance of the GridViewHeaderRowPresenter:

<Window.Resources>
  <GridViewColumnCollection x:Key="columns">
    <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}" />
    <GridViewColumn Header="Age" DisplayMemberBinding="{Binding Age}" />
  </GridViewColumnCollection>
</Window.Resources>

<StackPanel>
  <!-- NOTE: must share access to same column collection to get shared resizing -->
  <GridViewHeaderRowPresenter Columns="{StaticResource columns}" />
  <GridViewRowPresenter Content="{Binding}" Columns="{StaticResource columns}" />
</StackPanel>

Here we’re creating an instance of the row presenter, passing in a reference to the same columns collection used by the row presenter so that the column sizes and positions are shared between the header row and the row presenters:

If we want more than one piece of data, all we have to do is use an items control with an item template that in turn creates a row presenter for each item in the collection:

<Window.DataContext>
  <x:Array Type="{x:Type local:Person}">
    <local:Person Name="John" Age="13" />
    <local:Person Name="Tom" Age="12" />
  </x:Array>
</Window.DataContext>

<Window.Resources>
  <GridViewColumnCollection x:Key="columns">
    <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}" />
    <GridViewColumn Header="Age" DisplayMemberBinding="{Binding Age}" />
  </GridViewColumnCollection>
</Window.Resources>

<StackPanel>
  <GridViewHeaderRowPresenter Columns="{StaticResource columns}" />
  <ItemsControl ItemsSource="{Binding}">
    <ItemsControl.ItemTemplate>
      <DataTemplate>
        <GridViewRowPresenter Content="{Binding}" Columns="{StaticResource columns}" />
      </DataTemplate>
    </ItemsControl.ItemTemplate>
  </ItemsControl>
</StackPanel>

Now, we’ve got a stack panel that combines the header to the grid view rows with the grid view rows themselves, one per item in our collection:

Now on a rush of discovery and simplicity, I took the next step to show hierarchical data, hosting the data in a TreeView control and using a hierarchical data template so that I could build the tree list view shown above with the tiniest bit of XAML and code:

<Window.DataContext>
  <x:Array Type="{x:Type local:Person}">
  <local:Person Name="Chris" Age="38">
    <local:Person.Children>
      <local:Person Name="John" Age="13" />
      <local:Person Name="Tom" Age="12" />
    </local:Person.Children>
  </local:Person>
  <local:Person Name="Melissa" Age="39" />
  </x:Array>
</Window.DataContext>
...
<StackPanel>
  <GridViewHeaderRowPresenter Columns="{StaticResource columns}" />
  <TreeView ItemsSource="{Binding}" BorderThickness="0">
    <TreeView.ItemTemplate>
      <HierarchicalDataTemplate ItemsSource="{Binding Children}">
       <GridViewRowPresenter Content="{Binding}" Columns="{StaticResource columns}" />
      </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
  </TreeView>
</StackPanel>

Unfortunately, that’s where we run into the limit of what we can do without cranking things up a notch:

 

Beside the border around the tree view (caused by focus), the worst part about our simple tree-list-view is that, while each grid view row has the proper column sizes and relative positions, because the tree does the indenting, all of the columns are offset, not just the first one. The key to fixing this problem is to put the styling for indenting into the template for the first column only using the CellTemplate property of the GridViewRowColumn, taking over the drawing of the tree view items, which is what the tree-list-view sample does.

August 28, 2007 spout writing

“Programming WPF” (finally) shipping!

John Osborn of O’Reilly and Associates had this to say in my morning email:

Congratulations, guys. The book is printed and shipping! Just got my copy this morning and it looks great. A very substantial body of work, to say the least.

Thanks for all of your hard work on this project. Now to crank up the PR machine and make sure no book shelf is without a copy.”

August 17, 2007 spout writing

How to write a book - the short honest truth

I found this on digg.com
August 14, 2007 spout writing

“How you doin’?”

I wanted to figure out how to emit a new CLR type at run-time using Reflection.Emit and Google revealed the following article: Generating Code at Run Time With Reflection.Emit in DDJ.As usual, I skip most of the initial prose to the first code sample (I don’t need some author’s fancy intro — I just want the code!). Then, I’m reading along and I find some phrases I enjoy, e.g.

If you plan on generating lots of calls to Console.WriteLine(), you should be aware that the ILGenerator class exposes a method for just that purpose: ILGenerator.EmitWriteLine() generates the exact same code as our example. (Could this be the first assembler ever devised that includes explicit support for creating Hello, World” sample programs?)”

July 17, 2007 spout writing

Programming WPF, 2e (RTM Edition) on Amazon!

Buy your copy today! : )

P.S. I read the QC1 (Quality Check 1), all 859 pages of it, in two solid days this weekend. I found a bunch of nits, all of which will be fixed before you see it in August. Wahoo!

May 28, 2007 spout writing

Why do we pick on journalism majors, so?

Here’s another one:

For example, if we had had a background in journalism, we might have used one-based indexing instead of zero-based indexing to…

May 28, 2007 spout writing

Sometimes I crack myself up

I forgot until the copy edit review process that I’d dropped this gem into a footnote:

On August 4th, 1997, the world’s oldest person so far, Jeanne Louise Calment, died at age 122, having taken up fencing at age 85 and out-lived the holder of her reverse-mortgage. Although I firmly believe that Ms. Calment is showing us the way to a richer, longer life, it’ll be a while yet before we need the full range supported by the Int32 class (2,147,483,647 years young).

April 29, 2007 spout writing

On becoming an empty nester…

I submitted the final manuscript for Programming WPF, 2nd edition, by Ian Griffiths and Chris Sells to O’Reilly and Associates this morning for publication. Of course, there’s stuff still to do (today we hit step 8 of 18), but this represents a major milestone in the life of any book.

I have mixed feelings when I finish a book. The last few have been especially intense, as I have a real day job on a Microsoft product-team-to-be, so it’s just been evenings and weekends. With this much work to do, you have to focus hard and the work becomes a part of you. This means that giving it up is also hard. My boys are just now becoming teenagers, so it’ll be a while yet before they leave home, but I imagine I’ll feel the same kind of melancholy I feel now — happy to see something you’ve put so much of your life into make its own way into the world, but hard to have the cord cut.

April 29, 2007 spout writing

Glyn Griffiths: Ian’s Dad and Damn Fine Reviewer

This was an email I sent to Glyn Griffiths, the final external reviewer on the WPF 2ed book before we submitted the final manuscript for copy edit and publication (and which has been posted here with his permission):

Mr. Griffiths, in chapter 7, you had a couple of comments about what happened in the 1ed of the book vs. what we’ve got now in the 2ed of the book. The first such comment was:

April 16, 2007 spout writing

My Foreword To ChrisAn’s “Essential WPF”

Now that Chris Anderson’s most excellent Essential Windows Presentation Foundation has transitioned to the physical world, I thought I’d share my foreword:

Thank God there weren’t more people like Chris Anderson when I was making my living outside of Microsoft.

I work at Microsoft now (two doors down from Chris, in fact), but not all that long ago, I was an instructor at a Windows developer training company. My brethren and I were led by a deep-thinking PhD candidate that applied the same rigor he applied to a scholarly pursuit that had to stand up to the crush or be crushed” mentality of academia. We learned how to think clearly as a defense mechanism and to communicate clearly as a survival technique. If we didn’t do it to his exacting standards, he’d sweep us aside and redo our work before our eyes (we learned to call it swooping” and you worked hard to avoid the phenomenon).

In a similar fashion, we learned to ignore the tutorial and reference materials produced by our vendor of choice, because it was clear that however clearly they may or may not be thinking inside their hallowed walls, it was certain that they weren’t up to communicating it with the rest of us. Arguably, our whole job for close to a decade was swooping” Microsoft itself, redoing their materials in the form of short course, conference talks, magazine articles and books. We called it the Microsoft Continuing Employment Act,” treating it like a pork barrel entitlement program that kept us in the style to which we had grown accustomed.

In fact, we made a nice living traveling the country saying things like, remember to call Release,” avoid round-trips” and ignore aggregation” because these were clear guidelines that distilled for developers what Microsoft couldn’t manage to say for itself. That’s not to say that there weren’t clear thinkers inside of Microsoft (Tony Williams and Crispin Goswell being two of my very favorites), but the gap between the beginner and the reader of such advanced writings was largely unfilled in those days.

With this book, that gravy train has run right off the track. Chris Anderson was one of the chief architects of the next-generation GUI stack, the Windows Presentation Framework, which is the subject of the book you’re now holding in your hands. You’d have thought that the very nature of the architecture job, that is, to make sure that the issues deep, deep inside were solved properly so that others could come along and build the trappings that made it into plain sight, would disqualify him from leading the developer from go” to whoa,” but that’s not the case. Chris’s insight allow him to shine a light from the internals of WPF to those standing at the entrance, guiding you through the concepts that form the foundation of his creation (and the creation of more than 300 other people, too, let’s not forget).

As the author of a competing book from another publisher, I can’t say that this is the only book you’ll ever need on WPF (or they’d have me in front of a firing squad), but I can say this with certainty: it belongs on your shelf within an easy reach. I know that’s where my copy will be.

April 14, 2007 spout writing

Best WPF Resources?

I’d like to provide a list of the best WPF resources, including real-world apps, free web resources, SDK docs, samples, blogs, etc. If you’ve got something that belongs on that list, I’d love to hear about it. Thanks!

March 10, 2007 spout writing

Programming WPF: Rough Cuts

If you can’t wait for Programming WPF to be on the shelves (I know I’m having trouble), then you can read the chapters as we write them
January 21, 2007 spout writing

Boogers and My Writing Process

I’m supposed to be writing today, but John (my eldest son) is also doing some writing as part of his homework. However, after watching him struggle with just the topic (the phrase Always aim for the moon. Even if you miss, you’ll end up among the stars” [which isn’t even the correct quote]) to try to write the fully-formed essay, I give him a little lesson about how I write. Plus, since I’m supposed to be writing, this blog post is an excellent avoidance technique.

When I write, I told my son, I have to write giant books starting from empty pages. I can’t just have a topic and start writing, I have to have something to break up the whitespace first. So, as a demonstration of this technique, I asked the fruit of my loins, an apple from my tree, for a topic. He said, without so much as a second of hesitation, boogers.”

September 5, 2006 spout writing

Congrats To Mr. Petzold on this WPF Review

In the world of Windows technical writing which has so much competition, there’s rarely any money involved, one dreams for reviews like these from KarstenJ:

Tim Sneath walked into my office the other day and laid Charles Petzold’s Applications = Code + Markup on my desk.  I’m only to Chapter 7 of 31 chapters and I am riveted.  I already have that feeling when reading a great novel when you don’t want it to end.  It actually does read like a novel to me, with a narrative arch as it negotiates its methodical way through the WPF jungle of APIs.”

August 15, 2006 spout writing

$33 On Bookpool: Windows Forms 2.0 Programming

The nice folks at Bookpool are running a special on Windows Forms 2.0 Programming: only $33! Enjoy.
August 13, 2006 spout writing

Get ’Em While They’re Hot

Even though the 1st printing was just in May of this year, Windows Forms 2.0 Programming just entered the 2nd printing. Thanks for reading!

August 11, 2006 spout writing

We Sold A Copy of ATL Internals!

You said it couldn’t be done, but ATL Internals, 2e, has a review! Thanks, W.

July 30, 2006 spout writing

Custom Settings Provider in .NET 2.0

I updated the SDK RegistrySettingsProvider to implement IApplicationSettings and built a sample to demonstrate how to integrate it (or any .NET
July 23, 2006 spout writing

An Embarrassment of WPF Riches

I just realized that Avalon is getting a book treatment unlike any other topic in my memory:

June 27, 2006 spout writing

When to ship a book is hard to know these days…

Mr. Petzold beat me to the punch on the Windows Forms 2.0 book and he’s going to do it again on the RTM Avalon book. However, such a thing is dicey, as Mr. Petzold points out.

It was in researching the Windows Forms 1.0 book when I grew to be scared of finalizing a book before the technology was finalized; that’s when they added AllowPartiallyTrustedCallersAttribute and it screwed up the entire No-Touch Deployment story. Toward that end, we didn’t ship the WinForms 2.0 book til after the .NET 2.0 bits went gold and we won’t ship the paper copy of the Avalon 1.0 book til then, either (although I understand ORA is going to be shipping early electronic drafts of our work as we do it). I have to sacrifice 2-3 months on the shelves to my competitors, but I get to be less scared of big, last minute changes.

May 22, 2006 spout writing

Post an Amazon review and you get my royalties

Update: Whoops — didn’t think of the ways to abuse this system. I’ve updated the offer here.

If you post a legitimate review on Amazon for Windows Forms 2.0 Programming before the 4th of July, 2006, I will personally send you my royalties for that copy of the book ($4.77 — don’t spend it all in one place : ).

May 19, 2006 spout writing

WinForms 2.0 book @ the printer

WinForms 2.0 book @ the printer

The one where the brothers Sells and I travel to Ann Arbor, MI to see Windows Forms 2.0 Programming being printed. It’s well worth the trip, if you can talk the publisher into arranging it.

May 12, 2006 spout writing

A C# Bedtime Story Updated for C# 2.0

Seeing a reference to A C# Bedtime Story as a generic definition for .NET delegates in a recent DDJ article inspired me to post the new and improved version that takes into account C# 2.0′s anonymous delegate support. Enjoy.

May 9, 2006 spout writing

ATL Internals, 2e, available for pre-order

ATL Internals, 2e, this time with ATL 8, is available for pre-order on Amazon.com. For those wondering what the world needs with such a book, I refer you to the preface:

.NET has hit the Windows programmer community like a tornado, tipping over the trailer homes of the ways that we used to do things. It’s pretty much swept up the needs of most web applications and service applications, as well of most of the line-of-business applications for which we previously used Visual Basic and MFC.

However, a few stubborn hold-outs in their root cellars will give up their native code only at the end of a gun. These are the folks with years of investment in C++ code who don’t trust some new-fangled compiler switches to make their native code managed.” Those folks won’t ever move their code, whether there are benefits to be gained or not. This book is partially for them, if they can be talked into moving their ATL 3/Visual C++ 6 projects forward to ATL 8 and Visual Studio 2005.

Another class of developers that inhabit downtown Windows city aren’t touched by tornados and barely notice them when they happen. These are the ones shipping applications that have to run fast and well on Windows 95 on up, that don’t have the CPU or the memory to run a .NET application or the bandwidth to download the .NET Framework even if they wanted to. These are the ones who also have to squeeze the maximum out of server machines, to take advantage of every resource that’s available. These are the ones who don’t have the luxury of the CPU, memory or storage resources provided by the clear weather of modern machines needed for garbage collection, just-in-time compilation, or a giant class library filled with things they don’t need. These developers value load time, execution speed, and direct access to the platform in rain, sleet, or dark of night. For them, any framework they use must have a strict policy when it comes to zero-overhead for features they don’t use, maximum flexibility for customization, and hard-core performance. For these developers, there’s ATL 8, the last, best native framework for the Windows platform.

April 18, 2006 spout writing

WinForms 2.0 book just about ready

Mike and I submitted our last round of comments to the WinForms 2.0 book last night. The way it works is, after we submit the final” manuscript, the copy editor has his/her way with it. Then Mike read all 1300 pages, making sure that the copy editor didn’t change the meaning of anything. After that, the publisher moves everything from Word to Quark so that they have the control they need to produce photo-ready copy for the printer and sends us a set of PDFs.

With the PDFs in hand, we both read the ~1000 pages again (the move to Quark puts in the final styles), looking for things that got messed up during the move between software packages or new things that we notice. Theoretically, we’re only checking for formatting, but I always take this opportunity to read the entire book all the way through with fresh eyes (which is why I made Mike do the copy edits — so I had some time away from the book to get fresh again). That yielded about 50 pages of comments for the publisher to apply, including dropping about 5 pages of content that didn’t add enough value to be worth the space.

January 31, 2006 spout writing

Japanese version of Avalon book

I thought someone might be interested in the Japanese version of our WPF book. Personally, I love
January 31, 2006 spout writing

Pre-order “Windows Forms 2.0 Programming”

I just noticed that Windows Forms 2.0 Programming,” by Michael Weinhardt and Chris Sells, is available for pre-order. I’ve had a lot of requests for info on this book, so now folks can watch this space. Mike and I have finished the copy edit rounds, but we still haven’t seen the final PDFs, so it’s still going to be awhile (hopefully no later than early April).
January 16, 2006 spout writing

A Toast to WPF

A Toast to WPF

Here’s a review you don’t get very often:

Your WPF book is excellent. So good that I actually chose to read it instead of watching in flight entertainment from my trip to London in Dec… I liked it so much that I asked for some champaign, and continued to read it non-stop till I reached London from UK. Here’s a photo. Good job!”

January 12, 2006 spout writing

Survey: The Future of Publishing

Karen Gettman, my editor at Addison-Wesley, called and asked me a bunch of questions about the future of publishing yesterday. After our discussion, she asked if I knew anyone else and I volunteered to put a survey up on my web site.

To answer this survey, send the questions below and your answers to Karen.Gettman@AWL.com. Also, include your phone number so Karen can call to follow up (she finds the phone conversations to be most illuminating when it comes to really figuring out how people want to get to info — we spent a bunch of time talking about hardware and software for ebooks). Thanks from Karen for your help!

December 29, 2005 spout writing

Dirty Publishing Secret: Indexes Suck

I hate to say it, but indexes are the one place where I skimp when writing a book. I go round and round on sentence structure, figures, story, flow, coverages, what to cover, what to leave out, section headings and all of the other minutia that goes with writing a book, but I never bother with the index.

The index is one of those things where, as an author, you can write the index yourself, complete with page numbers (added manually) or your can let the publisher outsource it (although be careful when signing the contract — some publishers will charge the author the outsourcing fee!). So, for no work, I can get something that’s OK, but generates some complaints (maybe 1 out of 20 is about the index) and let Safari, Amazon and Google be the full-text search equivalent (even good indexes suck compared to that) or I can do a *ton* of work to reduce the number of complaints to 1 out of 30 (this is just a guess but it nicely justifies not doing the work, don’t you think? : ). As it turns out, the publisher will let you proof an index, but I have yet to figure out how to do that.

December 16, 2005 spout writing

Windows Forms 2.0 Book Samples Posted

Mike did some last minute clean-up and checked in the files, so I’ve uploaded the code sample for the Windows Forms 2.0 book. Enjoy.

December 16, 2005 spout writing

Windows Forms Programming 2005 in C# Submitted!

I packaged off the final chapters, figures and PDF files for submission of the WinForms 2.0 book this morning. Michael made it easy by fixing all the last minute nits I found, producing the PDFs and bundling all of the figure files together (he separated the graphics from the Word docs using a WinForms 2.0 program, of course!).

In spite of the fact that I’ve been working on long-lead prototype coding for the last month and Mike’s been moving to the US from Australia, we managed to get the book submitted a full 15.5 hours early (they meant midnight when they gave us a 12/16 deadline, didn’t they?!?).

October 8, 2005 spout writing

Wise Advice from Tyler Brown

How can you argue with someone so obviously intelligent?
September 26, 2005 spout writing

Programming WPF Samples & Change Notes Posted

September 18, 2005 spout writing

Please Post Reviews of Avalon Book

For those of you that reviewed or got free access to our Avalon book while we were still writing it, please please please post a review on Amazon.com
September 15, 2005 spout writing

WPF Book Sold Out Again, More Coming on Friday

You can also order them online. I find that even Thanksgiving is good for gift giving, as is Halloween! What could be better than the gift of knowledge
September 14, 2005 spout writing

Programming WPF: Sold Out @ the PDC, More Coming

All of the initial copies of Programming the Windows Presentation Foundation have been sold out at the PDC. That’s a double edged sword, of course. On the one hand, it’s nice that so many people wanted a copy that they were gone by the time I got to see the remaining display copy on Tuesday after lunch. On the other hand, I want the publisher to have provided enough copies to feed a longer buying frenzy.

The good news is that another, larger shipment of the book will be available @ the PDC in the Marketplace store Thursday afternoon. Please form a line in an orderly fashion and keep the sleeping bags out of the normal aisle of traffic. : )

June 13, 2005 spout writing

Love Reviewers; Hate Reviews

I took a quick glance at some reviewer feedback for the Avalon book and already I’m trying hard not to hate the folks that send it in. Mean, hateful things like who is this guy?!?” and well, he’s never written a book” spring immediately to mind.

The thing is, reviewer feedback, especially harsh, blunt, spit-in-your-face reviewer feedback, is an extremely critical part of the book writing process (although, ironically, I most hate the reviews that sound like stuff I would write when I review…). Without reviews, authors don’t have any idea how their writing will be received til it’s published and we’re bound to do all kinds of stuff that’s reader or subject hostile that need correcting. Please, feel free to hit me with both barrels when you’re reviewing my stuff; I won’t promise to act on all the feedback, but I promise to consider all of it seriously.

May 30, 2005 spout writing

URLs in the Footnotes?

Here’s a question for folks. Right now, the 1st edition of the WinForms book has several footnotes like the following that include URLs:

The ntcopyres.exe tool can be obtained from http://www.codeguru.com/cpp_mfc/rsrc-simple.html.”

April 24, 2005 spout writing

Status of ATL Internals 2e

More people than you’d expect have been asking, so here’s an update on ATL Internals 2e.

This effort actually started in 2003, when Kirk Fertita updated the first 9 chapters to ATL7 as provided in VS 2002. Then he had to go work on his start-up, which represented his only income stream and would’ve gone belly up w/o him (selfish bastard! : ).

April 24, 2005 spout writing

Status on Windows Forms Programming 2e

Jose heard” that I’m working on an update for the first edition of Windows Forms Programming in C# for Windows Forms 2.0 (we’re not updating the VB.NET version due to poor sales for VB.NET-related titles in general). I didn’t mean to keep it a secret; it’s been listed at the top of my writing page for a year or more. : )

While we’ve been working closely together on the update, the bulk of the writing work is being done by Micheal Weinhardt, my main writing partner for the last coupla years or so. He’s got 90% of the book updated for VS05b1 already and is in the process of updating the whole thing to b2. After that, we pass it back and forth between ourselves for review-edit til we’re both happy. By the end of May, hopefully the whole thing will be out for review. After that, we apply reviewer comments and update at each successive beta/release candidate until the Whidbey team decides they’re done, at which point we send it to the publisher and 3-4 months later, it hits the shelves.

October 11, 2004 spout writing

All The Fun, Half the UK Price

Curt Johnson, my marketing guy at Addison-Wesley, has let me know this morning at the UK Amazon is having a 1/2 price sale on my Windows Forms book this month. Plus, the UK
October 7, 2004 spout writing

You Too Can Be A Technical Writer!

June 30, 2004 spout writing

#1 Windows Forms Book

June 6, 2004 spout writing

MikeDub On Solving An Instance of Writer’s Block

It has been my pleasure to spend the last 2+ years writing with Mike Wienhardt. I remember fondly his first piece. When I give feedback, I work very hard to let the author know just exactly what I think so that they can bring their work to its highest possible potential. When Mike sent me his first draft, I was as careful as I could be to point out the parts that I liked to let him know that he had real potential, but basically, I ripped it apart. I have literally caused authors to tear up reading my feedback in the past, but I give Mike credit — he turned his piece around and came right back for more. We did this 5 or 6 times, but by the end, his first piece was better than most of the experienced authors filling magazines and web sites. It has been a real pleasure watching him grow into his writing talent and it made me very happy when he accepted the major writing duties on the 2nd edition of Windows Forms Programming in C# and when he took over my Wonders of Windows Forms column.

In his most recent blog post, it was very interesting to read about Mike working his way through the worst part of writing: writer’s block. Nearly all authors get this occasionally and it’s a real killer (and a pox on those authors that don’t suffer from it). It makes me proud to see him so concerned about his writing that he’s willing to share these kinds of experiences with the world. I wish more engineers took that kind of pride in their work. You’re setting an example for us all, Mike.

May 28, 2004 spout writing

Great Minds…

Here.

I love Luke’s RSS Aggregator [1]. He loves my book. For what more could a man ask?

April 29, 2004 spout writing

Safe, Even Simpler Multithreading in Windows Forms

Mike Weinhardt adds a 4th installment to my series on threading in Windows Forms by illustrating the BackgroundWorker component from Windows Forms 2.0. I have to admit that after I saw this component, I felt very silly for not wrapping my own code up in this form. Thank goodness for .the Windows Forms 2.0 team. : )
April 26, 2004 spout writing

Marc Clifton is a Prolific SOB

I first heard about Marc Clifton on his work with MyXaml, a declarative UI language that shares a name and some principles with the XAML declarative language in Longhorn, but that works on .NET now. Until today, I had missed his earlier work on this subject: The Application Automation Layer: Introduction And Design, along with the rest of his 51 articles on CodeProject.com (wow).

I’ve never met Marc, but I’d sure like to. He seems like an interesting guy, both because of his work and because of this statement in his CodeProject bio: Having no formal education in software development, he feels exceptionally qualified to inflict his opinions on the community at large regarding how programming should be done.” Now that’s the kind of attitude I like!

April 21, 2004 spout writing

What’s New in Windows Forms 2.0

Mike and I write our first cut and what’s new and cool in Windows Forms 2.0 in this month’s MSDN
April 10, 2004 spout writing

I’m Loving the .NET Fx ARM

Here.

The one where I learn a bunch of interesting stuff reading all of the annotations from The .NET Framework Standard Library Annotated Reference in one sitting.

March 10, 2004 spout writing

WinForms Programming in C# 3rd Printing Ships

Here.

I find it unbelievable that after umpteen books, I finally seem to have blended quality with quantity as the C# version of my WinForms book enters it’s 3rd printing after only 8 months in publication. Wahoo!

February 29, 2004 spout writing

Suggestions for WinForms Programming 2/e

Here.

My co-author for the 2nd edition of Windows Forms Programming, Michael Weinhardt, doesn’t have enough to do to with the new features in Whidbey or all of the stuff that I wished that I added to the 1st edition but didn’t. No, he wants more, so he asked me to ask you nice folks what you’d like to see.

February 22, 2004 spout writing

Adding Ref-Counting to Rotor

Here.

Well, I can’t put it off any longer. I wanted to wait til Chris Tavares and I were able to figure out what the problem was, but after months of help from the Compuware guys using a complementary hunk of their latest and greatest profiling software, we’re no closer to finding out what causes the massive slow-down in compiling Rotor when we add our ref-counting implementation to it. The problem, of course, is that if we can’t figure out what the problem is, we can’t optimize our implementation to fix it.

October 23, 2003 spout writing

MSDN Wants You

Here. Want to write for MSDN
October 20, 2003 spout writing

ASP Alliance reviews WinForms Programming in C#

Here. I don’t know why an ASP
October 20, 2003 spout writing

Every Vain Author’s Best Friend

Here. Rory built me an RSS
October 10, 2003 spout writing

Amazon giving 30% off WinForms Programming in C#

Here. I think those Amazon guys knew I was talking about them…
October 9, 2003 spout writing

Nice WinForms Reviews in the Blogesphere

Here. I’ve noticed that lots of folks have nice things to say about
September 29, 2003 spout writing

Creating Doc-Centric Apps in WinForms, part 1 of 3

Here. This 3-part series really belonged as a chapter in my WinForms book, but after doubling the estimated size of the book (not to mention the amount of time it was supposed to take to write it), my publisher was anxious for me to stop writing. For those folks accustomed to the document management support in MFC
September 29, 2003 spout writing

A *royalty* check from Pearson!

Here. Whoa. I just got a royalty check from Pearson today. Right now, it lists my advance for the WinForms book (which may turn into positive money some day), but also includes money from ATL
September 12, 2003 spout writing

“Move over Petzold, Sells is here.”

Here. I’m sure it won’t last, but the WinForms book has broken 1000 (908) and has an average 5-star rating with three reviews, saying very nice things like: “This book rocks! … All chapters are brilliant.” “The localisation and resource usage in the managed world are clearly described and you won’t lose hours trying to access resources in your code anymore!” “I stayed up all last night reading Chris’ new book… I enjoyed every single page.” And, of course, the quote that makes my life complete: “Move over Petzold, Sells is here.”
September 2, 2003 spout writing

Holy Cow!

Here. Apparently my book has sold out on BookPool.com already. Cool…
September 2, 2003 spout writing

Windows Forms Programming in C# Sample Chapter

Here. AW
September 2, 2003 spout writing

977!

Here. According to JungleScan.com, Windows Forms Programming in C# has been as well as 977. That’s as well as any of my books in the last year (except Essential .NET
September 2, 2003 spout writing

Book of the Week at ASPExperts.com

Here. I don’t know why ASPExperts.com would designate a WinForms book as
August 29, 2003 spout writing

Windows Forms Programming in C# on Shelves

Here. My WinForms book for C# programmers should be on the shelves today. I’ve set up the site where you can download the source and report problems. The VB.NET version should be out at the PDC
August 21, 2003 spout writing

VS.NET 2003 + Mastering VS.NET

Here. Buy VS.NET 2003 on Amazon.com and get a special deal on Mastering Visual Studio .NET
June 11, 2003 spout writing

.NET Rocks Interview — Chris Sells (Again!)

Here.
June 2, 2003 spout writing

MSDN Article: No Touch Deployment

Here. From JosephCooney: Chris has a new MSDN