Scott Hanselman

My two-hundred-and-twenty-fifth podcast is up. Scott chats with Jason Dentler about NHibernate and their new 3.0 release. Jason is the author of the upcoming "NHibernate 3 Cookbook" from Packt Publishing. Is NHibernate hard and scary? Jason gets Scott up to speed and talks open source community.

NOTE: If you want to download our complete archives as a feed - that's all 225 shows,subscribe to the Complete MP3 Feed here.

Subscribe:

Download: MP3 Full Show

Links from the Show

• NH Forge
• Fluent NHibernate
• NHibernate Profiler
• HQL Add In
• ConfORM
• NH Users Group
• Jason's Blog
• LLBL Gen Pro
• NH Contrib Download
• Hibernating Rhinos Support
• Packt Publishing Open Source Books
• Unofficial NHibernate Add Ins
• iMeta Support
• S#arp Architecture
• Slyce Software's Visual NHibernate
• NH Download

Do also remember the complete archives are always up and they have PDF Transcripts, a little known feature that show up a few weeks after each show.

Telerik is our sponsor for this show.

Hanselminutes podcasts listeners can get $50 off any Telerik product this summer. All interested listeners should drop an email to podcast@telerik.com and mention the Hanselminutes promo and their sales team will reply with the special $50-off coupon code.

Building quality software is never easy. It requires skills and imagination. We cannot promise to improve your skills, but when it comes to User Interface and developer tools, we can provide the building blocks to take your application a step closer to your imagination. Explore the leading UI suites for ASP.NET AJAX,MVC,Silverlight,Windows Formsand WPF. Enjoy developer tools like .NET reporting,ORM,Automated Testing Tools, TFS, and Content Management Solution. And now you can increase your productivity with JustCode, Telerik’s new productivity tool for code analysis and refactoring. Visitwww.telerik.com.

As I've said before this show comes to you with the audio expertise and stewardship of Carl Franklin. The name comes from Travis Illig, but the goal of the show is simple. Avoid wasting the listener's time. (and make the commute less boring)

Enjoy. Who knows what'll happen in the next show?

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

If you've got a programming blog, chances are you'll want to post some code snippets. Posting code sounds easy but it's surprisingly tricky if you consider all the ways that people will be reading your blog. There's a number of ways. Here's a few and their pros and cons.

Copy Paste from your IDE (like Visual Studio, for example)

If I copy paste directly from VS into my editor of choice, Windows Live Writer, I'll get a <pre> section.

using System;
 
namespace WindowsGame1
{
#if WINDOWS || XBOX
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            using (Game1 game = new Game1())
            {
                game.Run();
            }
        }
    }
#endif
}

Pros:

• It's just text.
• Looks the same everywhere.
• Code is in a pre and you can apply css rules to pre's if you like.

Cons:

• It's just text.
• Looks the same everywhere.

I can also go to the Visual Studio Gallery and get the Copy As HTML Extension from inside the "Productivity Power Tools." When someone names something "Productivity Power Tools" but doesn't include it out of the box that means they are "things that aren't totally tested and that would blow your mind if we did include them in the box so just get them and be happy but we are sorry we didn't ship them straight away."

Once this extension is plugged in, when I Ctrl-C some text, VS adds not just plain text to the clipboard but also rich HTML and what-not.

using System;
 
namespace WindowsGame1
{
#if WINDOWS || XBOX
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            using (Game1 game = new Game1())
            {
                game.Run();
            }
        }
    }
#endif
}

This looks lovely, but it includes a pile of <spans> and now my code is a bunch of marked up HTML, rather than a block of code.

Pros:

• Looks the same everywhere, RSS or on your site. Consistent.
• Will always look like this, no need to change anything.

Cons:

• Inline styles and colors. Ick.
• Span-itis.
• Stores the formatting in your blog system directly (in the DB, etc)
• Will always look like this, you can't change anything.

Using PreCode and SyntaxHighlighter

PreCode is Anthony Bouch's Windows Live Writer plugin. SyntaxHighlighter is Alex Gorbatchev's JavaScript (that's client-side) syntax highlighter. SyntaxHighlighter highlights your code locally using <pre> blogs that are marked for specific languages. You include "brushes" for just the langugaes you care about. This is the combination that I currently use.

SyntaxHighlighter is definitely the client-side highlighter of choice, but there are others you might also check out including:

• Chili Highlighter - Hosted on Google Code
• Google Code Prettify - This is the code highlighter that Google themselves use on Google Code. It doesn't require you to specify the language. It works on most C-style languages, works iffy on Ruby, PHP and VB, and needs extensions for LISP and F# and others.

NOTE: Make sure whatever one you pick that you're cool with the OSS license for your library of choice.

From within Live Writer you click "Insert PreCode Snippet" and paste your snippet in. It has a number of nice options. I use HTML encode and "replace line endings with <br/> which is required for use in DasBlog for historical reasons. It also has a number of SyntaxHighlighter specific options for doing line-highlights or turning the toolbar on and off.

This creates output like this. Here's the trick, though. If you are reading this post via RSS, you're seeing just plain text. You need to visit this post on my site directly in order to see pretty fonts and colors because the JavaScript isn't firing in your RSS Reader.

It's created a <pre> that looks like this <pre class="brush: csharp; auto-links: false;"> and the JavaScript comes around later and processes it in the browser.

using System;

namespace WindowsGame1
{
#if WINDOWS || XBOX
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            using (Game1 game = new Game1())
            {
                game.Run();
            }
        }
    }
#endif
}

Pros:

• Having code stored in a pre means there's no formatting stored in your blog system.
• Looks great in any browser with JavaScript
• You can choose themes and change the look and feel of your code whatever
• You also get nice printing support, toolbars, line highlighting, etc.

Cons:

• RSS readers effectively lose out and see just text.
  • NOTE: There really is no "good" solution for RSS viewers unless your blog engine's RSS Feed Generator does the processing on the server-side for code blocks and sends <span>itis when the feed is requested.
• Once you've inserted code in WLW with PreCode, you can't easily edit the code. I usually edit it outside and paste again.

Using Code Formatter Plugin for Windows by Steve Dunn

Another Windows Live Writer plugin is Steve Dunn's Code Formatter. It has a few features that differ from PreCode, and a few quirks (as of the current version). It supports not just Syntax Highlighter style <pre>'s for code but also <span>itis inline styles using ActiPro's SyntaxHighlighter.

 1 using System;
 2 
 3 namespace WindowsGame1
 4 {
 5 #if WINDOWS || XBOX
 6     static class Program
 7     {
 8         /// <summary>
 9         /// The main entry point for the application.
10         /// </summary>
11         static void Main(string[] args)
12         {
13             using (Game1 game = new Game1())
14             {
15                 game.Run();
16             }
17         }
18     }
19 #endif
20 }

You can also insert code as images, which people do, so I mention it here, but I think is rude to blind folks, and not useful as GoogleBing can't see it. Don't do this. You're a bad person.

Pros:

• Supports WLW's "Smart Content Editing" so you can edit your code after you insert it.
• When using ActiPro
  • Looks the same everywhere, RSS or on your site.
  • Will always look like this, no need to change anything.
• When using SyntaxHighlighter
  • Looks great when users visit your site
• Supports images (if you're into that kind of thing and you are Satan)

Cons:

• When using ActiPro
  • Intense Span-itis and embedded colors.
  • Inline styles and colors. Ick.
  • Stores the formatting in your blog system directly (in the DB, etc)
• RSS readers effectively lose out and see just text.
• The plugin inserts unneeded (IMHO) inline styles like width and height.
• Supports images (if you're NOT into that kind of thing or you're blind.)

Hosting your Code elsewhere like GitHub

GitHub is a social code hosting and sharing site, and Gist is a part of their site where you can easily share code without logging in. You can create private or public Gists, or you can create your own GitHub login and keep the source you host on your blog in one place.

You can share your code by using embedded JavaScript like this: <script src="http://gist.github.com/516380.js?file=Hanselman%20Sample%201"></script>. You don't get too much control over the look and feel of it, but it "just works." 

using System;

namespace WindowsGame1
{
#if WINDOWS || XBOX
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            using (Game1 game = new Game1())
            {
                game.Run();
            }
        }
    }
#endif
}

Pros:

• You can store all your code in an external service, just like you might store all your pictures at Flickr.
• All your code is in once place.
• Dead simple.

Cons:

• You're no longer storing your code with your blog posts. You're storing a JavaScript link.
• You need Javascript running within your RSS reader for the code to show up. Most won't do this for security reasons. Otherwise, you'll see nothing.
• You can't control it. It's alive!

Conclusion

As with all religious arguments, I don't care who you choose to go with, just that you pick one and be excited about it, and that you know the pros and cons. You can certainly switch back and forth if you like, but I personally believe there's something to be said for consistency, so pick something you can live with for a few years, or your life on earth. ;)

Currently, I'm using PreCode with SyntaxHighlighter until a better solution comes along. Did I miss any good options?

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

My team has to write a lot. We write some blog posts, sure, but we also write a lot of tutorials for various sites. Right now the http://www.asp.net site runs on Umbraco, but MSDN runs on custom internal what-not, and there's other sites as well. The only common thread is HTML.

Sometimes someone will write a tutorial or document in Word, then try to get some HTML out of that, that will only ends in pain and suffering. We could use something like Markdown or Dreamweaver or Expression Web, or write the HTML ourselves, but we keep coming back to Windows Live Writer. No joke, for our workflow, WLW is the best blog editor out there.

It creates nice clean markup, and lets us stick to the basics, which for us are H1, P, PRE, UL, LI, ACRONYM, BLOCKQUOTE, IMG and not much more. It supports plugins for editing and coloring code (I use the PreCode plugin) and has very nice image handling features like Watermarks, resizing and linking to larger versions, etc. We would like to write everything in it.

Problem is, it doesn't include a Save As dialog. We could view|source and copy the HTML directly after we edit, but WLW uses temporary image links of a custom type while editing with names like $whatever.png and hides the images in temp files and opaque blobs.

NOTE: Windows Live Writer does support editing and publishing to the Blogger API, the MetaWeblog API and via AtomPub. AtomPub is the newest and most rigid, but I'm going to start by creating a MetaWeblog Server because I understand it and it's trivially lightweight. I'll try to follow this post up the with the same functionality except with AtomPub soon in order to juxtapose the two. Remember that MetaWeblog extends the Blogger API and is all about blogging and content. AtomPub isn't just about blogging, it's about editing anything. WLW is a blogging client that speaks AtomPub, but it's not a general AtomPub client.

So what I'm going to build is a small local "NotABlog" server that I can point Windows Live Writer to and fool it into thinking it's a blog. Then I'll effectively be able to Create, Read, and Update blog posts (HTML files and their associated images) that are sitting in a local publish folder.

This sample might be interesting to you and your organization (or the not-yet-written AtomPub version) because you could potentially put an endpoint in front of existing systems that you work on and enable business users to edit content with Windows Live Writer. WLW isn't too scary for business folks and it's a nice interface for updating existing custom content management systems that you might have lying around. Creating an editing endpoint for existing clients is a low-effort way to reinvigorate existing content management systems.

Metaweblog

Many years ago (like 12) XML-RPC was created by Dave Winer and some Microsofties. It's not SOAP, it's literally remote procedure calls over HTTP with XML. There are other protocols built on top of XML-RPC, which are just interfaces. Effectively they are agreements that an endpoint will contain certain named methods with certain parameters.

The MetaWeblog API is an XML-RPC interface that Dave made that lets you edit weblog entries. It's older, but it's effectively universal. Here's an example of what an XML-RPC call looks like.

  examples.getSomething
  
    
        70
    
  

Charles Cook created an amazing and elegant library called XML-RPC.NET and has given it to the community. He's kept it working nicely such that I was able to get it working in my .NET 4.0 application without any modification even though I was using an older 1.0.0.8 version for .NET 1.0 in my first version. That's a testament to Charles' work. Later I downloaded the latest 2.4.0 from 2008 and it worked nicely also and fixed some bugs.

In 2008, Keyvan Nayyeri created a nice little MetaWeblog ASP stub in ASP.NET so I started building with that. I just return true in the ValidateUser method, because this is for local editing. I lie (return hard-coded stuff in a few places) to Windows Live Writer.

Here's what the interface looks like:

namespace NotABlog
{
    public interface IMetaWeblog
    {
        #region MetaWeblog API

        [XmlRpcMethod("metaWeblog.newPost")]
        string AddPost(string blogid, string username, string password, Post post, bool publish);

        [XmlRpcMethod("metaWeblog.editPost")]
        bool UpdatePost(string postid, string username, string password, Post post, bool publish);

        [XmlRpcMethod("metaWeblog.getPost")]
        Post GetPost(string postid, string username, string password);

        [XmlRpcMethod("metaWeblog.getCategories")]
        CategoryInfo[] GetCategories(string blogid, string username, string password);

        [XmlRpcMethod("metaWeblog.getRecentPosts")]
        Post[] GetRecentPosts(string blogid, string username, string password, int numberOfPosts);

        [XmlRpcMethod("metaWeblog.newMediaObject")]
        MediaObjectInfo NewMediaObject(string blogid, string username, string password, MediaObject mediaObject);

        #endregion

        #region Blogger API

        [XmlRpcMethod("blogger.deletePost")]
        [return: XmlRpcReturnValue(Description = "Returns true.")]
        bool DeletePost(string key, string postid, string username, string password, bool publish);

        [XmlRpcMethod("blogger.getUsersBlogs")]
        BlogInfo[] GetUsersBlogs(string key, string username, string password);

        [XmlRpcMethod("blogger.getUserInfo")]
        UserInfo GetUserInfo(string key, string username, string password);

        #endregion
    }
}

You just need to derive from Charles' XmlRpcService and he'll handle the routing of the HTTP POSTs and the calling of the methods and tearing apart of the parameters. (Actually, as a curiosity back in the ASP.NET MVC 1.0 timeframe both Phil and I write XmlRpcRoutes and supporting samples just to see if it was possible. It is.)

The idea is to catch the calls and just redirect them to the file system. Here's a simple example:

string IMetaWeblog.AddPost(string blogid, string username, string password,
    Post post, bool publish)
{
    if (ValidateUser(username, password))
    {
        string id = string.Empty;
        string postFileName;
        if (String.IsNullOrEmpty(post.title))
            postFileName = Guid.NewGuid() + ".html";
        else
            postFileName = post.title + ".html";

        File.WriteAllText(Path.Combine(LocalPublishPath, postFileName), post.description);
        
        return postFileName;
    }
    throw new XmlRpcFaultException(0, "User is not valid!");
}

Go run it yourself if you like. Here's how.

Setting up your Local Publishing Endpoint

First, edit the web.config and change your local publish directory if you like. Currently it just puts posts in a folder .\LocalPublish in the current directory of your web application. Free free to change it. I put it in my desktop.

Since this is a web application, I need a Web Server to run it under. I didn't want to require Visual Studio or IIS to run it, so I figured I'd use IIS Express from WebMatrix to do it since it's free and you don't need to be Admin to run it (except on Win2k3). Install WebMatrix and you'll get IIS Express.

I created a batch file called StartNotABlog.bat and put this in it:

SET ExecPath=%ProgramFiles(x86)%
IF "%ExecPath%" == "" SET ExecPath = "%ProgramFiles%

"%ExecPath%\Microsoft WebMatrix\iisexpress.exe" /path:"%CD%" /port:12345

It's pretty straightforward and it'll work on both x86 and x64. It starts up a Web Server on port 12345 with the current directory (that the batch file is running in, not the environment's current directory) as the path.

Now, start up Windows Live Writer. Add a blog, select Other...

And select "Metaweblog API" as the type.

Put in http://localhost:12345/MetaWeblogAPI.ashx as the remote posting URL.

There's no username or password so just put in something.

Click Next and Finish and go edit a post! I'm using it now to edit a 3000 word tutorial on ASP.NET.

Not a Blog.zip. Download the Code and have fun playing with it. There's actually not much there but it's already changed how I do my job. Now the trick will be to show the bosses how easy it is to give anything an endpoint that WLW will talk to. Maybe this blog post will help. ;)

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

Creating a Twitter client is a really interesting exercise in application development because, amongst many reasons, it's taking input from effectively an infinite number of people and places. Never trust user input, right? Input to your application comes not only in the form of text, but also images. Writing a Twitter client is effectively writing a web browser that only browses one website. Getting a browser stable is hard.

Long Zheng, Raphael Rivera and the MetroTwit team (MetroTwit is a lovely new Twitter client) have hit an extremely interesting crashing bug. The input comes in the form of a corrupted JPG image from the web.

Here's the bad image. Looks like a picture some folks speaking on a panel. However, even though this image looks fine, this specific binary version of it has a corrupted Color Profile.

Sometimes folks don't realize that image formats contain lots of metadata that you can't see. Your JPGs may show what camera you used, what lens, what settings, possibly even the geo-coordinates of where you took the picture!

You can view all this extended information (EXIF) with a number of tools. A great free one is ExifTool by Phil Harvey at the command line, or a non-command line one like ExifPro. Windows Live Photo Gallery lets you view the data also.

Here's a snippet of some of the info in this pic:

Device Mfg Desc                 : IEC http://www.iec.ch
Device Model Desc               : IEC 61966-2.1 Default RGB colour space - sRGB
Viewing Cond Desc               : Reference Viewing Condition in IEC61966-2.1
Viewing Cond Illuminant         : 19.6445 20.3718 16.8089
Viewing Cond Surround           : 3.92889 4.07439 3.36179
Viewing Cond Illuminant Type    : D50
Make                            : Leica Camera AG
Camera Model Name               : M8 Digital Camera
Software                        : Aperture 3.0.2
Shutter Speed Value             : 1/256
Exposure Compensation           : 0
Max Aperture Value              : 1.0
Metering Mode                   : Center-weighted average
Light Source                    : Flash
Focal Length                    : 0.0 mm

You can extract the image profile (ICC Profile) from an image like this with exiftool:

exiftool -icc_profile -b foo.jpg > profile.icc

If you're hardcore, you can get the Windows Imaging Component (WIC) Tools and run WICExplorer. WPF uses WIC to decode images. WICExplorer will report the error with this image as you load it.

Loading Images in WPF

When you're using WPF (Windows Presentation Foundation) to display an image on Windows, you might do something like this:

<Image Width="300" Height="300" ImageFailed="Image_ImageFailed">
    <Image.Source>
        <BitmapImage UriSource="http://hanselman.com/blog/images/JPGwithBadColorProfile.jpg"/>
    </Image.Source>
</Image>

Except with this particular image, I'll get an exception the Color Profile (the image metadata) is corrupted. "ArgumentException: Value does not fall within the expected range." This is a corrupted file.

at System.Windows.Media.ColorContext.GetColorContextsHelper(GetColorContextsDelegate getColorContexts)
at System.Windows.Media.Imaging.BitmapFrameDecode.get_ColorContexts()
at System.Windows.Media.Imaging.BitmapImage.FinalizeCreation()
at System.Windows.Media.Imaging.BitmapImage.OnDownloadCompleted(Object sender, EventArgs e)
at System.Windows.Media.UniqueEventHelper.InvokeEvents(Object sender, EventArgs args)
at System.Windows.Media.Imaging.LateBoundBitmapDecoder.DownloadCallback(Object arg)
at System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
at MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)

If I get this exception, I can try to load the image again and ignore its color profile. Here's how I'd do that in XAML:

<Image Width="300" Height="300" ImageFailed="Image_ImageFailed"  >
    <Image.Source>
        <BitmapImage CreateOptions="IgnoreColorProfile" UriSource="http://hanselman.com/blog/images/JPGwithBadColorProfile.jpg"/>
    </Image.Source>
</Image>

If you're loading from code, you can ignore color profile information by adding the BitmapCreateOptions.IgnoreColorProfile flag to CreateOptions.

As an aside, Andrew Eichacker has a nice post on how to read all the BitmapMetadata in WPF. There's lots in there!

Here's loading the Bitmap into an image Control called "Foo."

var bi = new BitmapImage();
bi.BeginInit();
    bi.CreateOptions = BitmapCreateOptions.IgnoreColorProfile;
    bi.UriSource = new Uri("http://hanselman.com/blog/images/JPGwithBadColorProfile.jpg");
bi.EndInit();

foo.Source = bi;

Knowing about possible corruption is important to be aware of, especially if you're loading arbitrary images from all over the place. If you don't care about color profiles, I'd just ignore them by default in your image loading code. If you are writing an image editor or you care about profiles, I'd catch the exception, let the user know, then load the image again without the profile.

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

Are you in King County/Seattle/Redmond/Bellevue Washington and surrounding areas? Are you a huge nerd? Perhaps a geek? No? Maybe a dork, dweeb or wonk. Maybe you're in town for an SDR (Software Design Review) or VSLive! Quite possibly you're just a normal person and a member of the general public.

We're holding a Nerd Dinner (it's like dinner, except with nerds) next week on Weds, Aug 4th at Crossroads Bellevue Mall Food Court at 6pm.

This one will be different from usual. Why?

It's a Daily Build Nerd Dinner!

We'll have Program Managers and Developers directly from Microsoft who'll bring their laptops with "Daily Builds" of stuff they are working on. Daily Builds mean literally stuff they've built that day that's cool. You'll give them feedback and they'll show you cool new stuff like the Razor View Engine and Visual Studio Tooling.

If you are a member of the public, be here!

Nerd Dinners are for us. All are welcome. Just come on by. We'll be near the Chess Board in the Food Court. Bring your co-workers and your social media friend!

Please spread the word! RSVP and tweet about this dinner at http://nrddnr.com/2770

Add to your calendar now...here's an iCal link for your Outlook or other calendar.

See you soon!

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By