My friend (and former officemate!) Cory Doctorow is launching his latest novel, Makers, tonight at the Toronto Public Library at 239 College Street (east of Spadina). The fun happens in the Merrill Collection room, located on the third floor at 7 p.m. tonight. Cory will be doing a reading, taking questions and signing books. There will be books for sale at the event courtesy of our local science fiction and fantasy bookstore, Bakka Phoenix.

Here’s the publisher’s blurb about the book:

From the New York Times bestselling author of Little Brother, a major novel of the booms, busts, and further booms in store for America

Perry and Lester invent things—seashell robots that make toast, Boogie Woogie Elmo dolls that drive cars. They also invent entirely new economic systems, like the “New Work,” a New Deal for the technological era. Barefoot bankers cross the nation, microinvesting in high-tech communal mini-startups like Perry and Lester’s. Together, they transform the country, and Andrea Fleeks, a journo-turned-blogger, is there to document it.

Then it slides into collapse. The New Work bust puts the dot.combomb to shame. Perry and Lester build a network of interactive rides in abandoned Wal-Marts across the land. As their rides, which commemorate the New Work’s glory days, gain in popularity, a rogue Disney executive grows jealous, and convinces the police that Perry and Lester’s 3D printers are being used to run off AK-47s.

Hordes of goths descend on the shantytown built by the New Workers, joining the cult. Lawsuits multiply as venture capitalists take on a new investment strategy: backing litigation against companies like Disney. Lester and Perry’s friendship falls to pieces when Lester gets the ‘fatkins’ treatment, turning him into a sybaritic gigolo.

Then things get really interesting.

It should be noted that while 3-D printers of the sort in Cory’s novel are still the stuff of science fiction, simpler versions exist today. In fact, at the Hacklab, where I spend many a working day, we’ve got a MakerBot Industries “Cupcake” 3-D printer that can “print” plastic objects.

Here’s what the Cupcake looks like:

A computer connected to the Cupcake controls it. The big loop of plastic to the upper left of the machine is the material from which objects are printed. Here’s a closer look at its internals:

We have a small gallery of objects that were created using the Cupcake:

If you’d like one of your own, the fine folks at Makerbot Industries would be more than happy to sell you a kit.

This article also appears in The Adventures of Accordion Guy in the 21st Century.

The Empire’s been fine-tuning ASP.NET, SQL Server and the .NET runtime from the get-go, so ASP.NET is a pretty snappy platform. Even so, the fastest of platforms will still run like molasses in January if you don’t do things right. With any platform, there’s a body of best practices for getting the best performances, and with far too many platforms, these best practices haven’t been gathered into a single place.

ASP.NET developer are in luck: I just got notified by Apress of the release of a new book, Ultra-Fast ASP.NET. Here’s the blurb:

Ultra-fast ASP.NET by Rick Kiessig presents a practical approach to building fast and scalable web sites using ASP.NET and SQL Server. In addition to a wealth of tips, tricks and secrets, you’ll find advice and code examples for all tiers of your application. By applying the ultra-fast approach to your projects, you’ll squeeze every last ounce of performance out of your code and infrastructure, giving your site unrivaled speed.

Learn How To:

• Think about performance issues that will help you obtain real results.
• Apply key principles that will help you build ultra-fast and ultra-scalable web sites.
• Use the ultra-fast approach to be fast in multiple dimensions. You’ll have not only fast pages but also fast changes, fast fixes, fast deployments and more.
• Use techniques that are being used by some of the world’s largest web sites.
• Structure your HTML and CSS to create pages that load ultra-fast.
• Utilize tips and tricks for optimizing your ASP.NET and SQL Server code for performance and scalability.

You can order the dead-tree edition of Ultra-Fast ASP.NET online (it sells for USD$49.99, which at today’s exchange rate is CAD$52.32), or if you’re like me and try to get the electronic version when possible, the PDF version sells for USD$34.99 (CAD$36.62 at the time of this writing).

This article also appears in Canadian Developer Connection.

“This book is about finding fulfillment and happiness in your career” is the first line of the introduction to The Passionate Programmer, Chad Fowler’s book for software developers. If that goal wasn’t bold enough, the first line of the following paragraph is “The book is also about cultivating the desire to live a remarkable life.”

The Passionate Programmer is actually the second edition of a book that went by another title: My Job Went to India: 52 Ways to Save Your Job. When that book was released back in 2005, the threat of having one’s job outsourced to lower-wage countries was the topic of many articles and conversations. My Job Went to India provided a collection of strategies to take control of one’s high-tech career, build a plan to keep skills up to date, make the right choices, stay relevant and not be the expendable sort whose job would be outsourced.

The bogeyman may have changed from outsourcing to the economy, but the concerns that developers have about their careers remain the same. Chad saw the need for a new edition of his book, and with the new version came a new tone. He gave it a more positive-sounding (and less alarmist) name and changed its focus from surviving to thriving.

The Passionate Programmer is split into five chapters, each covering a different aspect of a developer’s career:

• Choosing Your Market: “Which technologies should we invest in? Which domain should we develop expertise in? Should we go broad or deep with our knowledge?”
• Investing in Your Product: In this case, your product is yourself. How do you become better at what you do?
• Executing: Tactics and habits for getting things done.
• Marketing: Not Just for Suits: As the title implies, marketing skills aren’t just for the business people – developers need to market themselves.
• Maintaining Your Edge: How stay relevant and not be a one-hit wonder.

The chapters are themselves divided into sections, each one covering a specific approach or bit of advice. This arrangement lets you treat the book as if it were an agile project, picking and choosing a section at a time to read and put into practice instead of doing “big reading up front” from start to finish. It also makes the book easier to revisit when the need arises.

In the end, the message of the book is to find and follow your passion, and do so with intention. In the final section of the book, appropriately titled Have Fun, Chad closes with:

Ultimately, the most important thing I’ve learned over the journey that my career in software development has been is that it’s not what you do for a living or what you have that’s important. It’s how you choose to accept these things. It’s internal. Satisfaction, like our career choices, is something that should be sought after and decided upon with intention.

The Passionate Programmer is an engaging, fascinating book, and it will have a longer shelf life than most of the technical books in your library. I know many people who own a copy and have recommended it to their friends, and the Amazon and Dr. Dobbs reviews have been nothing short of glowing. No matter what platforms, programming languages or technologies you use, The Passionate Programmer should be in your technical library.

Book Details

The Passionate Programmer by Chad Fowler

• Publisher: Pragmatic Programmers
• Published: May 2009
• ISBN: 978-1-93435-634-0

The book is available directly from the publisher in the following formats:

• Paperback book: USD$23.95
• Ebook (DRM-free PDF, epub and mobi formats): USD$15.00
• Paperback/ebook bundle: USD$29.95

You can also order the book from Chapters/Indigo, Amazon.ca and Amazon.com.

This article also appears in Canadian Developer Connection.

This article also appears in Canadian Developer Connection.

Manning Publications have a great variety of books on .NET development. There’s the stuff you’d expect, such as books on C#, ASP.NET and SharePoint, but they’ve also produced books on IronPython and IronRuby (not many books on these languages), functional programming is both F# and C# and doing brownfield development and building DSLs using .NET. Many of their books have helped me get up to speed with .NET development, and I’m currently working my way through The Art of Unit Testing.

Another great thing about Manning Books is that they’re available in both paper and electronic form. This is great news for me, as I have disk space aplenty, but I’m running short on shelf space. There’s also the fact that while technology-specific books are useful, their shelf life is rather short. I’ll still buy paper editions of books that are longer on theory and technique, but when it comes to specific versions of languages, libraries or frameworks, I’ll take the ebook version.

One more great thing about Manning Books is that they’re generous with the discount codes. Their discount codes are often for 33% to 50% off the regular price, and they announce them on their Twitter account, @ManningBooks. If you’re looking to build your tech library and save money at the same time, you should follow them.

(Just so you know: Neither I nor anyone at the Developer and Platform Evangelism team at Microsoft have any kind of arrangement to promote Manning’s books. I just like their books, and getting a discounts on them is a bonus.)

This article also appears in Canadian Developer Connection.

As a rule, Chapter One of most programming books seems to leave me with a vague, unsatisfied feeling. I usually finish them with either:

• A “Hello World”-style application that provides an initial “It compiled!” rush, but little else, or
• A “Trees dies for this?” sort of indignation, if the chapter is one of those perfunctory one with a name like “Getting Started” that provides the same information you gathered while deciding whether to buy the book.

Based on these experiences, I think I can be excused for being a bit skeptical when I read the announcement that Chapter One of Professional ASP.NET MVC 1.0, published by Wrox, was being made available for free download. Of course they’re giving it away for free, I thought, it’s the chapter that’s worth nothing!

A quick aside: If you haven’t heard of ASP.NET MVC, it’s Microsoft’s answer to the MVC-based frameworks that are all the rage these days, such as Ruby on Rails and Django. It’s not a replacement for ASP.NET, but an alternative; if you want to build applications following the REST paradigm, with fine-grained control over the flow of your application and HTML and want to do things “the web way” as opposed to a more “desktop app” way, you should seriously consider trying it out. (For more detailed pros-and-cons considerations of ASP.NET versus ASP.NET MVC, see this article in Nick Berardi’s Code Journal.)

Luckily, curiosity got the better of me and I downloaded the chapter. I got my first sign that wasn’t your garden-variety Chapter One when I looked at the file size and page count. 14 megabytes? 196 pages? Something strange was going on here. Perhaps a glitch during the download?

Once I scrolled past the cover page, the standard Wrox cover featuring the authors and their impressively receding hairlines (hence the nickname for the book, “The Gang of Foreheads”), I hit the introductory paragraph:

The best way to learn a new framework is to build something with it. This first chapter walks through how to build a small, but complete, application using ASP.NET MVC, and introduces some of the core concepts behind it.

That’s right: rather than provide some long-winded perfunctory history of the Model-View-Controller framework, the backstory of how the ASP.NET MVC framework came to be or some simple “Hello World”-style example app of little consequence and requiring less effort, the authors decided to get right down to business and show you how to build an ASP.NET MVC web app. This was a surprise – but a very welcome one!

The application that you build is called “NerdDinner”, a site that lets techies declare Meetup.com-style gatherings and RSVP for them (you can see the finished product in action at NerdDinner.com). You start at ground zero,  “File –> New…”, and from there, you build the app with just enough asides to explain a few vital concepts and very few of those false detours that some tutorials lead you down. NerdDinner may be a simple app, but it covers a lot of ground:

• From the basics of CRUD application design in an MVC web framework
• to matters of input validation,
• to registering, authenticating  and authorizing users
• to integrating Ajax-enabled forms and an Ajax map
• to the built-in unit testing features of ASP.NET MVC.

By the end of the chapter, you’ve got a nice little application that lies in the “sweet spot”. It’s small enough for you to be able to learn from quickly, yet big enough to show you the ropes behind building the important parts of a CRUD web application that’s ready for public consumption.

I’ve tried out a number of ASP.NET MVC tutorials, and this one’s my hands-down favourite. It’s written by the people behind ASP.NET MVC, it covers a lot of ground, the finished app is an excellent basis for your future projects, there’s a working version online that you can use as a guide and  the code works! Even better, this single chapter that packs all this value is free-as-in-beer. I’m sure I’ve paid  for whole books that have imparted less knowledge than this single free chapter.

If you’re interested in learning about ASP.NET MVC, download Chapter 1 of Professional ASP.NET MVC 1.0 [13.8 MB PDF] and give it a try. It’s the fastest way to get both a working ASP.NET application and up to speed on Microsoft’s new web application framework. And be sure to tell me how it worked out — if you have any questions or comments, or run into any difficulty with the chapter, let me know – drop me a line via email, send me a tweet or give me a shout-out in the comments.

This article also appears in Canadian Developer Connection.

It’s easy to point to books on understanding and improving the inner workings of your code, the software and hardware platforms on which it runs and even the processes used in developing it. It’s much harder to find one on understanding and improving the programmer, or more specifically the programmer’s “wetware” – that is, the brain and mind. A few books aimed at programmers give a little space to the topic: Tog on Interface has a section and exercise on building your intuition, the first edition of Code Complete devotes a small chapter to character, and Cocoa Programming for Mac OS X reminds the reader that getting extra sleep when learning new material is essential. For a whole book on the topic, we’ve had to wait until Andy “The Pragmatic Progammer” Hunt’s Pragmatic Thinking & Learning: Refactor Your Wetware.

The first few chapters of PT&L form a quick introduction to the theories of cognition, learning and neuroscience on which the rest of the book is based. Among these are the Dreyfus Model, which explains how we progress from novice to expert and the steps along the way and a model of the brain in techie terms, shown below:

Once PT&L has laid out these foundations, it dives into the brain-refactoring, including:

• Taking advantage of R-mode (often called the “right brain” in pop psychology), which often gets ignored because of its non-linear, non-linguistic, unpredictable and even “artsy” nature. It’s actually an amazing problem-solver, so much that PT&L suggests that you should “lead with R-mode and follow with L-mode”, or more colloquially, “write drunk; revise sober”.
• Working around the bugs in your brain. And there are many, from the primitive “lizard brain” that likes to override our higher cognitive functions to cognitive biases to generational affinity.
• Learning deliberately: what learning is and isn’t, how to plan to learn, figuring out what your learning style is and how to best take advantage of it, and harnessing mind maps, documentation and teaching in order to learn.
• Gaining experience, which includes understanding the importance of fun and how pressure kills cognition, learning the “inner game” and why your mantra shouldn’t be “learn to build”, but “build to learn”.
• Managing focus, a very important topic since there are so many things vying for it, from office interruptions to the siren song of the internet, with email, IM, Twitter, Digg, Reddit and LOLcats. One of my favourite bits in this section was some research whose results indicated that constantly checking your email lowers your effective IQ more than smoking a joint.

PT&L does a great job following its own advice by presenting its material in ways that best take advantage of how our brains work, reinforcing its with anecdotes, metaphors and visuals and using the enjoyable style for which Andy Hunt’s other projects, such as The Pragmatic Programmer and his various training sessions have become famous.

As with any book that proscribes a new way of doing or perceiving things – think of books on Agile programming or “Getting Things Done” methodologies – you’ll have to pick and choose which ideas and techniques work best for you. In his review, O’Reilly editor Nat Torkington found the section on generational affinity a little too “Malcolm Gladwell”-ish in the way that it treats anecdotes about generations as data (personally, I think there’s some truth to the generational affinity thing). I do agree with Nat that some of the exercises, such as “Morning Pages” that seem a bit too new-agey/hippie even for me – and I’m the kind of guy who’d go to Burning Man.

This is the only book of which I’m aware that covers how to improve the tool that really develops code: not your platform, language or editor, but your mind. It’s worthy of several readings, first straight through and subsequent dives into specific sections. I took it with me on my flight from Toronto to TechDays Calgary and found it both not only informative, but engaging and entertaining as well. Best of all, barring some quantum leap in cognitive science that invalidates what we know today, PT&L will probably have a much longer shelf life than most of the tech books in your library.

It’s my favourite geek book of 2008.

Pragmatic Thinking & Learning is available in both dead-tree (US$34.95 direct from the publisher, CAD$30.69 from Chapters/Indigo online) and PDF formats (US$22.00). It’s a finalist in the “Books General” category of the 19th Annual Jolt Awards.

Would you be interested in hearing more from PT&L’s author, Andy Hunt, himself? Let me know either via email or the comments, and I’ll see what I can do about arranging an interview in some format with your questions!

While following the exercises in the book Teach Yourself ASP.NET Ajax in 24 Hours – one of the few books I’ve been able to find on Ajax for ASP.NET 3.5 – I found an error in the “Hour 9” chapter in the example that covers client-side error-handling (it starts on page 137). I’ve reported this error to the publisher and with any luck, they’ll post a corrected version on their support web page for the book.

I’ve done some searching and haven’t found anything covering this error so I thought I’d cover it here. Better still, I’ll also cover the fix, which turns out to be quite simple. If you’ve been trying out the code in the book and wondering why it doesn’t work, relax: at least in this case, it’s not your fault.

In the course of covering the error and how to fix it, I’ll also talk about how ASP.NET handles exceptions raised by asynchronous postbacks and how you can make use of it to make better user interfaces. Even if you don’t have a copy of Teach Yourself ASP.NET Ajax in 24 Hours, you should find this article an interesting introduction to client-side error handling in ASP.NET Ajax.

Unhandled Exceptions and Asynchronous Postbacks

In ASP.NET Ajax, if an exception is raised during an asynchronous postback and isn’t handled on the server side – that is, in the code-behind – it gets passed along to the client side. What happens on the client side depends on which version of ASP.NET you’re using:

• In ASP.NET Ajax 1.0, the server-side exception object is serialized into JSON. The JSON is sent to the client, which displays the exception’s message property in an alert box.
• In ASP.NET Ajax for .NET 3.5, the server-side exception is still serialized into JSON and the JSON is still sent to the client. However, instead of displaying the exception’s message property in an alert box – a presumptuous design decision, if you want my opinion – the client throws the exception, which gives you the opportunity to handle it on the client side as you please.

(In this article, I’ll stick to covering ASP.NET Ajax for .NET 3.5.)

This is quite different from most other web application frameworks, where an exception raised as the result of an XMLHttpRequest call to the server results in some kind of “error” page from the server (or a blank page, if you’re suppressing error reporting).

To illustrate this, let’s put together a simple ASP.NET Ajax application. It’s a single page with a single button, that if clicked, throws an exception.

Here’s the code for the page layout. It’s pretty straightforward:

Listing 1: Default.aspx – Layout for the page of our simple ASP.NET Ajax application.

<%@ Page Language="C#" AutoEventWireup="true"
CodeBehind="Default.aspx.cs" Inherits="WebApplication1._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Error Handling Demo 1</title>
</head>

<body>
    <form id="form1" runat="server">

        <div>
            <asp:ScriptManager ID="ScriptManager1" runat="server" />
            <asp:UpdatePanel runat="server" ID="UpdatePanel1">
                <ContentTemplate>
                    <asp:Button runat="server" ID="Button1"
                    Text="Click Me" OnClick="Button1_OnClick" />
                </ContentTemplate>
            </asp:UpdatePanel>
        </div>

    </form>
</body>

</html>

Some notes about the code:

• The ScriptManager control at the top of the form enables Ajax by ensuring that the JavaScript needed to support ASP.NET Ajax on the client side is downloaded to the browser.
• The UpdatePanel control determines the controls that trigger asynchronous postbacks and defines the region of the page that can be updated via Ajax.
• Button1 is the button control that we want to throw an exception when clicked. We’ll set it to call the Button1_OnClick method, which will contain the exception-throwing code.

The code-behind is very simple. In it, we define a single method: the event handler Button1_OnClick, which is called in response when the user clicks Button1. All we want it to do is throw an exception that uniquely identifies itself:

Listing 2: Default.aspx.cs – Code-behind for the page of our very simple example app.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace WebApplication1
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Button1_OnClick(object sender, EventArgs e)
        {
            throw new Exception("Click!");
        }
    }
}

Running with Debugging vs. Running Without Debugging

Listing 1 and 2 give us enough to make our simple app work. It’s time to take it for a spin.

Here’s something that doesn’t get covered in Teach Yourself ASP.NET Ajax in 24 Hours: what happens when you try to run this app with debugging (starting it by hitting F5 in Visual Studio or “Start Debugging” under the “Debug” menu)?

Here’s a screenshot of what happened for me:

With debugging on, the unhandled exception thrown in Button1_OnClick is caught by the debugger. Normally, this sort of error-catching behaviour is welcome, but in this particular case, it gets in the way of what we’re trying to achieve: having an exception on the server side and passing it along to the user’s browser to handle.

If we run the same app without debugging, we get the effect we want: the exception is raised on the server side, but the server-side part of the application doesn’t halt with an error message. Instead, the client shows the error message.

Here’s a screenshot. Note that the error message includes the string “Click!”, which is the argument in the throw statement the Button1_OnClick event handler. Thanks to this, we can be pretty certain that the error message is the result of our deliberately-thrown exception:

Now that we have the exception that we threw on the server side being handled on the client side, let’s do something with it. 

Handling Exceptions Passed from the Server on the Client Side

Let’s do something simple – let’s catch the exception caused by the button click, and instead of having a JavaScript error box pop up, let’s make a couple of changes to the button:

• Change its text to “This button has been disabled for your safety.”
• Disable it.

To handle exceptions on the client side, we need to write some client-side JavaScript. Luckily, this is made simple by the number of handy utility classes defined in the scripts downloaded to the client by the ScriptManager component. In this case, we’re going to make use of the Sys.Webforms.PageRequestManager class to deal with the exception because it provides us with the following:

• The endRequest event, which is raised after an asynchronous postback has completed and control is returned to the browser.
• The add_endRequest method, which specifies a method to call when the endRequest event is raised.

Here’s the JavaScript, which we’ll put in a file called ErrorHandler.js:

Listing 3: ErrorHandler.js — Client-side error handler for our very simple example app.

Sys.WebForms.PageRequestManager.getInstance().add_endRequest(EndRequestHandler);

function EndRequestHandler(sender, args)
{
    if (args.get_error() != undefined) {
        $get('Button1').value = "This button has been disabled for your safety.";
        $get('Button1').disabled = true;
        args.set_errorHandled(true);
    }
}

The script performs the following:

• It registers the method EndRequestHandler as the method to call whenever the endRequest event is raised.
• It defined the method EndRequestHandler, which does the following:
  • If an exception did occur during the asynchronous callback:"
    • The button’s text is changed
    • The button is disabled
    • The error is reported as handled, which allows the application to continue

Now that we have this client-side code, we need to get it to the client. We do this by using the Scripts section of the ScriptManager to send this file to the client. The listing below shows the updated layout code for our simple application. I’ve highlighted the change in the listing below:

Listing 4: Revised Default.aspx – Layout for the page of our simple ASP.NET Ajax application.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebApplication1._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Error Handling Demo 1</title>
</head>

<body>
    <form id="form1" runat="server">

        <div>
            <asp:ScriptManager ID="ScriptManager1" runat="server">
                <Scripts>
                    <asp:ScriptReference Path="~/ErrorHandler.js" />
                </Scripts>
            </asp:ScriptManager>
            <asp:UpdatePanel runat="server" ID="UpdatePanel1">
                <ContentTemplate>
                    <asp:Button runat="server" ID="Button1"
                    Text="Click Me" OnClick="Button1_OnClick" />
                </ContentTemplate>
            </asp:UpdatePanel>
        </div>

    </form>
</body>

</html>

The Scripts section of the ScriptManager lets us specify scripts to be sent to the client along with the page, with each script specified in a ScriptReference tag.

When we run the app (remember, without debugging on) with these changes and click the button, here’s what we get:

In a later article, I’ll look at other ways of using client-side error handling in ASP.NET Ajax in .NET 3.5.

The Error in Teach Yourself ASP.NET Ajax in 24 Hours

Here’s the page layout code for the error-handling example in Teach Yourself ASP.NET Ajax in 24 Hours. The code-behind for the page and the client-side JavaScript are fine, it’s this code that has the error. See if you can spot what’s amiss:

Listing 5: Default.aspx — Page layout of client-side error-handling example in Hour 9 of Teach Yourself ASP.NET Ajax in 24 Hours.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebApplication1._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>

<body>
    <form id="form1" runat="server">

        <div>
            <asp:ScriptManager ID="ScriptManager1" runat="server" />
            <asp:UpdatePanel runat="server" ID="UpdatePanel1">
                <ContentTemplate>
                    <asp:Button runat="server" ID="Button1"
                    Text="Click Me" OnClick="Button1_OnClick" />
                </ContentTemplate>
            </asp:UpdatePanel>
        </div>

        <br /><br />

        <div id="Message" style="visibility: hidden;">
            <asp:HyperLink ID="HyperLink1" runat="server"
                           Font-Bold="true"
                           Text="Error Occurred..."
                           Font-Italic="true"
                           ForeColor="red" >
            </asp:HyperLink>
        </div>

    </form>
</body>

</html>

Just for kicks, here’s what happens when you click on the button in the app using the code straight from Teach Yourself ASP.NET Ajax in 24 Hours:

The mistake is simple: although there is some error-handling client-side JavaScript in the app, it’s not referenced in the ScriptManager tag, which means it’s not sent to the client. Without error-handling code on the client side, the exception is thrown, there’s nothing to catch it and the user is presented with the standard error dialog box.

The fix is equally simple: reference the script in the ScriptManager tag’s Scripts section:

<asp:ScriptManager ID="ScriptManager1" runat="server">
    <Scripts>
        <asp:ScriptReference Path="~/ErrorHandlingScript.js" />
    </Scripts>
</asp:ScriptManager>

Once that’s done, the program works as promised.

Hey, it looks like I’ve got some potential reading material for the holidays! O’Reilly’s just released their new book, Learning XNA 3.0, an introduction to Microsoft’s 2-D and 3-D game development framework for the PC, Xbox 360 and Zune. Here’s an excerpt from O’Reilly’s description of the book:

Written by an experienced university-level game development instructor, Learning XNA 3.0 walks you through the framework in a clear and understandable step-by-step format. Each chapter offers a self-contained lesson with lots of illustrations and annotated examples to help you master key concepts. Once you finish the book, you’ll know how to develop sophisticated games from start to finish.

• Learn game development concepts from 2D animation to 3D cameras and effects
• Delve into high-level shader language (HLSL) and introductory artificial intelligence concepts
• Develop three complete and exciting games using 2D,3D and multiplayer concepts
• Develop and deploy games to the Xbox 360 and the Microsoft Zune

While teaching XNA to beginning game developers, author Aaron Reed noticed that several key concepts were difficult for students to grasp. Learning XNA 3.0 was written specifically to address those issues. With this book, you can test your understanding and practice new skills as you go with unique "Test Your Knowledge" exercises and review questions in each chapter.

The book, when purchased from O’Reilly, comes in several formats:

• Dead-tree format (that is, an actual paperback book): US$34.99 (currently CAD$44.06) / £24.99 in the UK
• Ebook (PDF, EPUB and Kindle-compatible “Mobipocket” format): US$27.99 (currently CAD$35.23)
• Dead-tree and ebook: US$45.49 (currently $57.27)

If you’re in Canada, you’ve got a chance to save big. Chapters/Indigo’s online price for the paperback book is CAD$23.09, which makes it cheaper than the electronic version. If you’re an iRewards member, they’ll shave another buck-fifteen off the price to make it CAD$21.94.

Links

• O’Reilly’s page for Learning XNA 3.0
• Learning XNA 3.0 at Chapters/Indigo’s online store (cheap for Canadians!)
• XNA Creators Club Online
• Download page for Microsoft XNA Game Studio 3.0

Maybe we’re seeing the start of a strange new manga trend in books. First came The Adventures of Johnny Bunko: The Last Career Guide You’ll Ever Need, and now there’s The Manga Guide to Databases:

Here’s the publisher’s write-up of the book:

Want to learn about databases without the tedium? With its unique combination of Japanese-style comics and serious educational content, The Manga Guide to Databases is just the book for you.

Princess Ruruna is stressed out. With the king and queen away, she has to manage the Kingdom of Kod’s humongous fruit-selling empire. Overseas departments, scads of inventory, conflicting prices, and so many customers! It’s all such a confusing mess. But a mysterious book and a helpful fairy promise to solve her organizational problems—with the practical magic of databases.

In The Manga Guide to Databases, Tico the fairy teaches the Princess how to simplify her data management. We follow along as they design a relational database, understand the entity-relationship model, perform basic database operations, and delve into more advanced topics. Once the Princess is familiar with transactions and basic SQL statements, she can keep her data timely and accurate for the entire kingdom. Finally, Tico explains ways to make the database more efficient and secure, and they discuss methods for concurrency and replication.

Examples and exercises (with answer keys) help you learn, and an appendix of frequently used SQL statements gives the tools you need to create and maintain full-featured databases.

(Of course, it wouldn’t be a royal kingdom without some drama, so read on to find out who gets the girl—the arrogant prince or the humble servant.)

This EduManga book is a translation of a bestselling series in Japan, co-published with Ohmsha, Ltd., of Tokyo, Japan.

The book will be available on December 1st, just in time to order as a Christmas present for someone who’s into both programming and manga.

I Have an Advance Copy of Neal Stephenson’s “Anathem”! It just arrived at the office, and I’ve written about it here.

I absolutely love old computer books…

Photo courtesy of Miss Fipi Lele.

I got a number of books for free this past week:

• Head First PMP – When my friend Leigh Honeywell heard that I was taking a project management course later this month, she told me that she got this book for free at a conference and had no use for it. So she gave this book to me, and I’ll be reading it so that when the course comes around — it’s May 21st through 23rd — I’ll be at least familiar with the material.

And four books from Apress, courtesy of Julie Miller:

• Pro PHP: Patterns, Frameworks, Testing and More
• PHP Objects, Patterns, and Practice, Second Edition
• Practical Web 2.0 Applications with PHP
• Practical Reporting with Ruby and Rails

I’ll be reading them this month and posting my reviews here in Global Nerdy. Watch this space!