NetFXHarmonics (Online Home of David Betz)

Minima 3.0 Released

Fri, 23 May 2008 20:52:16 GMT

Every few months I like to release a new open-source project or at least a new major revision of an existing project. Today I would like to introduce Minima 3.0. This is a completely new Minima Blog Engine that is built on WCF, that is factored into various controls and that introduces a completely new model for ASP.NET development.

As a Training Tool

Normally I leave this for last, but this time I would like to immediately start off by mention how Minima 3.0 may act as a training tool. This will give you a good idea to Minima 3.0's architecture. Here was the common "As a Training Tool" description for Minima 2.0 (a.k.a. Minima .NET 3.5):

Minima 2.0 could be used as a training tool for ASP.NET, CSS theming, proper use of global.asax, integrating with Windows Live Writer, framework design guidelines, HttpModules, HttpHandlers, HttpHandlerFactories, LINQ, type organization, proper-SQL Server table design and naming scheme, XML serialization, and XML-RPC.NET usage.

Here's the new "As a Training Tool" description for Minima 3.0:

Minima 3.0 can be used as a training tool for the same concepts and technologies as Minima 2.0 as well as SOA principles, custom WCF service host factories, custom WCF behaviors, WCF username authentication, custom WCF declarative operation-level security, WCF exception shielding and fault management, custom WCF message header usage, WCF type organization, WCF-LINQ DTO transformation, enhanced WCF clients, using WCF sessions for Captcha verification, SQL Server 2005 schema security, XmlWriter usage, ASP.NET programmatic user control usage, custom configuration sections, WCF JavaScript clients, ASP.NET control JavaScript registration, JavaScript namespaces, WCF JSON services, WCF RSS services, ASP.NET templated databinding, and ASP.NET control componentization.

As you can see, it's an entirely new beast. As you should also be able to guess, I'm not going to use Minima for simply entry level .NET training anymore. With this new feature set, it's going to be my primary tool for intermediate and expert-level .NET training. In the future, I'll post various blog entries giving lessons on various parts of Minima.

New Features

Since it's no where near the purpose of Minima, in no version have I ever claimed to have an extraordinary feature set. In fact, the actual end-user feature set of Minima 3.0 is fundamentally the same as Minima 2.0 except where features are naturally added because of the new architecture. For example, it's now naturally a multi-blog environment with each blog allowed to have it's own blog discovery data, Google sitemap, and other things.

Architecture

There are really three major "pillars" to the architecture of Minima 3.0: WCF, ASP.NET, and Minima's use of NetFXHarmonics Themelia (pronounced THE[as in the name "Thelma"]-MEH-LEE-UH; Koine Greek for "foundations"). It will take more than one blog entry to cover every aspect of Minima's architecture, but for now I'll give a very brief overview. I will explain the ASP.NET and Themelia pillars together.

WCF Architecture

The backend of Minima is WCF and is split up into various services to factor out some of the operations that occur within Minima. Of course, not every single possible operation is included as that would violate the "specificness" of SOA, but the core operations are intact.

The entire Minima security structure is now in WCF using a custom declarative operation-level security implementation. To set security in Minima, all you have to do on the service side is apply the MinimaBlogSecurityBehavior attribute to an operation and you're all set. Here's an example:

[MinimaBlogSecurityBehavior(PermissionRequired = BlogPermission.Retrieve)]
public BlogEntry GetSingleBlogEntry(String blogEntryGuid)
{
    //+ ...
}

This handles all authorization, but authentication would happen long before an operation. For this, the client must send extra information about the blog to the service, which is done via a custom MessageHeader, then on the service-side a custom UserNamePasswordValidator picks that up and does the authentication.

The WCF implementation also includes a fault promotion system based on the one in O'Reilly's Programming WCF by Juval Lowy. Everywhere an exception is thrown that is part of the operation's fault contract, a strongly-typed exception is thrown instead.

ASP.NET Architecture and Themelia Usage

In previous versions, Minima was basically a classic webform with a few MultiView and Repeater controls that you would customize. In Minima 3.0, everything is changed. Now Minima is a set of controls that work almost magically. The controls are either server controls or compiled "FrameworkInitialize" user controls, which allows for control extensibility via inheritance and for packaging in an assembly. Let me show you what I mean when I say these work also magically.

In a classic ASP.NET webform I have a PlaceHolder:

<asp:PlaceHolder ID="phMinimaBlog" runat="server"></asp:PlaceHolder>

...and in the codebehind in the OnInit method I am adding the MinimaBlog control to it:

phMinimaBlog.Controls.Add(new Minima.Web.Control.MinimaBlog());

Done! You now have a fully functional blog. Want a label list, an per-month archived entry list, or a recent entry list? Just add more controls to strategically placed PlaceHolders (don't under estimate the useful of the PlaceHolder; it's a great way of decoupling your ASPX from your codebehind!):

phLabelList.Controls.Add(new Minima.Web.Control.LabelList());
phArchivedEntryList.Controls.Add(new Minima.Web.Control.ArchivedEntryList());
phRecentEntryList.Controls.Add(new Minima.Web.Control.RecentEntryList());

Huh? How in the world did it even remotely know what blog to show? This functionality is something that Themelia provides.

Minima 3.0 is built on another project if mine called Themelia, which includes as part of its functionality extreme HTTP pipeline hijacking. Themelia was built for Minima, but are usable anywhere. In fact, all my applications and web sites are built on it. Just as how the various C# 3.0 features were built for LINQ, you use them outside of LINQ too. Since this is a completely different project (to be released on CodePlex soon), I will only explain how Minima uses Themelia.

Below is part of the web.config file for the sample web site included with Minima. Notice that there's no "minima.web" config section, but, rather, it's all part of the Themelia configuration.

<themelia.web>
    <webSections>
        <section name="second" path="/second/" />
    </webSections>
    <routing>
        <components>
            <add key="Minima" type="Minima.Web.Routing.Component.MinimaComponent, Minima.Web">
                <registration>
                    <add webSection="root">
                        <parameter name="page" value="~/Default.aspx" />
                        <parameter name="blogGuid" value="19277C41-7E4D-4AE0-A196-25F45AC48762" />
                    </add>
                    <add webSection="second">
                        <parameter name="page" value="~/SecondBlogPage.aspx" />
                        <parameter name="blogGuid" value="B23115B1-42E8-46A2-88DE-A56CE505E7D0" />
                    </add>
                </registration>
            </add>
        </components>
        <fallThroughProcessors comment="used when no http handlers match">
            <add type="Minima.Web.Routing.BlogFallThroughProcessor, Minima.Web" priority="1"/>
        </fallThroughProcessors>
    </routing>
</themelia.web>

What you're looking at is a completely new paradigm for ASP.NET development. Instead of working with simple HTTP handlers, you are working with preprocessors, handler injectors, handler mappings, and fall-through processors. You can safely ignore most of those fancy terms for now as they will be explained when the Themelia source is released. However, you should be aware that Themelia also provides a web component system that allows you to turn all the fanciness I just mentioned into a nicely packaged component.

This config file declares a "web section" (a Themelia concept which is like a "Web AppDomain"; the "root" web section always exists), then it registers the MinimaComponent and specifies a fallThroughProcessor. The MinimaComponent registers all the required Minima functionality. The fallThroughProcessor is what handles unhandled HTTP requests. For example, in other web sites that I run, this is the WebFormFallThroughProcessor so that ASP.NET can handle it via the PageHandlerFactory, but in this case I want to catch all URLs in the "root" and "second" web sections so that Minima can route then using it's own magic (i.e. scan for a link, a label, or archive access).

When registering the MinimaComponent, you also set all the parameters required for usage as can be seen in the above sample. Therefore, the controls you place on a page just "know" what web section they are in and use the information for that particular web section (a while back I made an executive decision to only allow one configuration per component per web section; therefore, only one blog per web section).

This is how I was able to get by with the above ASP.NET code where I just added new controls to a PlaceHolder and expected them to magically work. But what if you wanted to show the recent blog entry from another blog in another web section in the "root" web section? (i.e. on your home page)? Simple.

phRecentEntryListSecondary.Controls.Add(new Minima.Web.Control.RecentEntryList
{
    WebSection = "second",
    Heading = "Second Blog",
    HeadingIsLink = true
});

By simply pointing the control to a different web section, you can show that web section's recent entry list in your own web section. As you can see there are no blog IDs, GUIDs, or paths to mess with; everything is done via web sections.

The MinimaComponent also uses a Themelia's handler injector to handle various HTTP requests differently. The features of these handlers include url processing, blog entry image viewing, file downloading, blog discovery (i.e. rsd.xml creation), Windows Live Writer Manifest creation (i.e. wlwmanifest.xml), feed creation, Google site map creation, and MetaWeblog API support. Each of these are web section-aware and therefore only show data for their own web section. For example, /blogmap.xml would show a Google sitemap for the "root" web section while /second/blogmap.xml would show a Google sitemap for the "second" web section (not that paths and web section named need to match; they don't). So, a lot of stuff happens in a simple component registration.

Now, since everything is componentized, how are things customized? Simple: use CSS. If you are still hacking your HTML to get a certain visual result, then you seriously need to upgrade your skill set and take some notes from www.csszengarden.com. They have literally thousands of insane designs for their website, but every single web site design is based on the exact same XHTML structure. This is how professions do web development. So, if you want to modify the look of your blog, do it in CSS. Tightly-coupling two completely different world (in this case, structure and view) is just about always a bad idea.

However, if you wanted to completely revamp the way the control worked all you have to do is create a new ITemplate and set the CustomPostTemplateType or CustomCommentTemplateType property with that template's type. That template will then be used in control rendering. If you aren't sure how to do this, then Minima is a good example of how you can create powerful controls. Just look at how Minima creates the default ITemplate entities internally. You can also customize little things as well by setting more trivial properties as seen in the above code sample.

Remember that this is just a simple overview of Minima 3.0. In the future I will write slowly introductions to the various portions of Minima and when Themelia is released, I will be writing about that as well. For now, just go get Minima 3.0 and play with it.

Setup

Setup instructions can be seen on CodePlex (see link below), however, I would like to mention that you must have server certificates Setup for any WCF security to work. WCF doesn't allow you to send credentials over the wire unprotected. To setup the certificates, see this blog entry. This guy should get some sort of award for writing such an easy to follow explanation.

Architectural Overview: Using LINQ in WCF

Fri, 11 Apr 2008 08:24:25 GMT

Today I would like to give an architectural overview of my usage of LINQ. This may actually become the first in a series of architectural discussions on various .NET and AJAX technologies. In this discussion, I'm going to be talking about the architecture of the next revision of my training blog engine, Minima. Since the core point of any system is that which goes into and comes out of the system, the goal of this commentary will be to get to the point where LINQ projects data into WCF DTOs. Let me start by explaining how I organize my types. Some of you will find this boring, but it's amazing how many times I get questions on this topic. For good reason too! These questions show that a person's priorities are in the right place as your type, namespace, and file organization is critical to the manageability and architectural clarity of your system.

However, before we get started, let me state briefly that as I've stated in my post entitled SQL Server Database Model Optimization for Developers, when you design your database structure you should design it with your O/R mapper in mind. If you don't, then you will probably fall into all kinds of problems as my post describes. This is incredibly important, however, if you keep to normal everyday normalization procedures, you are probably doing OK for the most part anyway. Since I've written about that before, there's no reason for me to go into detail here. Just know that, if you database design sucks, your application will probably suck too. Don't built your house on the sand.

In terms of LINQ, I actually use the VS2008 "LINQ to SQL Classes" template to create the LINQ information. In most every other area of technology, it's a good practice to avoid wizards and templates like the plague, but when it comes to O/R mapping, you need to be using an automated tool. If your O/R mapper requires you to do any work (...NHibernate...*cough*cough*), then you can't afford to work with it. You need to be focusing on the business logic of your system, not playing around with mechanical nonsense. As I've said in other contexts, stored procedures and ad hoc SQL are forms of unmanaged code. When you are managing the mechanics of a system yourself, it's, by definition, unmanaged. Stored procedures and ad hoc SQL are to LLBLGen/LINQ as ASP/PHP is to ASP.NET as C++ is to .NET languages. If you are managing the mechanical stuff yourself, you are working with unmanaged code. When it comes to using managed code, in the context of database access, this is the point of an O/R mapper. Furthermore, if the O/R mapping software you are using requires you to write up templates or do manual mapping, that's obviously not completely managed code.

Now when I create a LINQ classes I will create one for each "architectural domain" of the system that I deem necessary. For example, in a future release of Minima, there will be a LINQ class to handle my HttpHandler and UrlRewriting subsystem and another LINQ class to handle blog interaction. There needs to be this level of flexibility or my WCF services will know too much about my web environment and my web site (a WCF client) will then have direct access to the data which the WCF service is intended to abstract. Therefore, there will be a LINQ class for web site specific mechanics and another LINQ class for service specific mechanics. Also, when I create the class for a particular domain I will give it a simple name with the suffix of LINQ. So, my Minima core LINQ class is CoreLINQ.cs and my Minima service LINQ class is ServiceLINQ.cs. Simple.

Upon load of the LINQ designer and either after or before I drop in the specific tables required in that particular architectural domain. Then I'll set my context namespace to <SimpleName>.Data.Context and my entity namespace to <SimpleName>.Data.Entity. For example, in the Minima example, I'll then have Core.Data.Context and Core.Data.Entity. One may argue that there's nothing really going on in Core.Data.Context to which I much respond: yeah, well there's already a lot going on in Core.Data (other data related non-LINQ logic I would create) and Core.Data.Entity. The reason I say "after or before I drop in the specific tables" is to emphasize the fact that you can change this at a later point. It's important to keep in mind at this point that LINQ doesn't automatically update its schema with the schema from your database. LLBLGen Pro does have this feature built in and it does the refreshing in a masterful way, but currently LINQ doesn't have this ability. Therefore, to do a refresh, you need to do a "CTRL-A, Delete", to delete all the tables, do a refresh in Server Explorer, and then just re-add them. It's not much work.

Now, moving on to using LINQ. When I'm working with both LINQ entities (or LLBLGen entities or whatever) and WCF DTOs in my WCF service, I do not bring in the LINQ entity namespace. The ability to import types in from another namespace is one of the most powerful set under appreciated features in all of .NET (um.. JavaScript needs them!), however, when you have a Person entity in LINQ and a Person DTO, things can get confusing fast. Therefore, to avoid all potential conflicts, my import is left out and I, instead, keep a series of type aliases at the top of my service classes just under the namespace imports. Notice also the visual signal in the BlogEntryXAuthor table name. This tells the developer that this is a many-to-many linking table. In this case it's in the database schema, but if it weren't in there, I could easily alias it as BlogEntryXAuthorLINQ without affecting anyone else.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Minima.Data.Context;
//+
using AuthorLINQ = Minima.Data.Entity.Author;
using CommentLINQ = Minima.Data.Entity.Comment;
using BlogLINQ = Minima.Data.Entity.Blog;
using BlogEntryLINQ = Minima.Data.Entity.BlogEntry;
using BlogEntryUrlMappingLINQ = Minima.Data.Entity.BlogEntryXAuthor;
using BlogEntryXAuthorLINQ = Minima.Data.Entity.BlogEntryXAuthor;
using LabelLINQ = Minima.Data.Entity.Label;
using LabelXBlogEntryLINQ = Minima.Data.Entity.LabelXBlogEntry;
using UserRightLINQ = Minima.Data.Entity.UserRight;
//+

Next, since we are in the context of WCF, we need to discussion validation of incoming information. The following method is an implementation of a WCF service operation. As you can see, when a user sends in an e-mail address, there is an immediate validation on the e-mail address that retrieves the author's LINQ entity. This is why the validation isn't being done in a WCF behavior (even though there are tricks to get data from a behavior too!) You may also note my camelCasing of instances of LINQ entities. The purpose of this is to provide an incredibly obvious signal to the brain that this is an object, not simply a type (...as is the point of almost all the Framework Design Guidelines-- buy the book!; 2nd edition due Sept 29 '08)

//- @GetBlogListForAuthor -//
public List<Blog> GetBlogListForAuthor(String emailAddress)
{
    using (ServiceLINQDataContext db = new ServiceLINQDataContext(MinimaConfiguration.DatabaseConfiguration))
    {
        //+ check existence of blog
        AuthorLINQ authorLinq;
        Validator.EnsureAuthorExists(emailAddress, out authorLinq, db);
        //+
        return db.Blogs.Where(p => p.BlogId == MinimaConfiguration.BlogId).Select(p => new Blog
        {
            CreateDate = p.BlogCreateDate,
            Description = p.BlogDescription,
            PrimaryUrl = p.BlogPrimaryUrl,
            FeedTitle = p.BlogFeedTitle,
            Guid = p.BlogGuid,
            Title = p.BlogTitle,
            FeedUrl = p.BlogFeedUrl
        }).ToList();
    }
}

It would probably be a good idea at this point to step into the Validator class to see what's really going on here. As you can see in the following class I have two methods (in reality there are dozens!) and most of it should be obvious. The validation is obviously in the second method, however, it's the first one that's being directly called. Notice two things about this: First, notice that I'm passing in my DataContext. This is to completely obliterate any possibilities of overlapping DataContexts and, therefore, any strange locking issues. Second, notice that I'm pre-registering my messages in a strongly typed Message class(notice also that the members of Message are not static-- the magic of const.) This last piece could easily be done in a way that provides for nice localization.

Now moving on to the actual validation. Unless I'm desperately trying to inline some code, I normally declare the LINQ criteria prior to the actual link statement. Of course, this is exactly what the Func<T1, T2> delegate is doing. Notice also that I try to bring the semantics of the criteria into the name of the object. This really helps in in making many of your LINQ statements read more naturally: "db.Person.Where(hasEmployees)".

namespace Minima.Service.Validation
{
    internal static class Validator
    {
        //- ~Message -//
        internal class Message
        {
            public const String InvalidEmail = "Invalid author Email";
        }

        //- ~EnsureAuthorExists -//
        internal static void EnsureAuthorExists(String authorEmail, out AuthorLINQ authorLinq, ServiceLINQDataContext db)
        {
            EnsureAuthorExists(authorEmail, out authorLinq, Message.InvalidEmail, db);
        }

        //- ~EnsureAuthorExists -//
        internal static void EnsureAuthorExists(String authorEmail, out AuthorLINQ authorLinq, String message, ServiceLINQDataContext db)
        {
            Func<AuthorLINQ, Boolean> authorExists = x => x.AuthorEmail == authorEmail;
            authorLinq = db.Authors.SingleOrDefault(authorExists);
            if (authorLinq == null)
            {
                FaultThrower.ThrowArgumentException(message);
            }
        }
    }
}

In the actual query itself, you can see that the semantics of the method is that a maximum of one author should be returned. Therefore, I'm able to use the Single or SingleOrDefault methods. Note that if you use these and you return more than one entity, an exception will be throw as Single and SingleOrDefault only allow what their name implies. In this case here, AuthorEmail is the primary key in the database and, by definition, there can be only one (at this point I'm sure about 30% of you are doing Sean Connery impressions). The difference between Single and SingleOrDefault is simple: when the criteria is not met, Single throws an exception and SingleOrDefault returns the type's default value. The default of a type is that which the C# "default" keyword will return. In other words, a reference type will be null and a struct will be something else (i.e. 0 for Int32). In this case, I'm dealing with my AuthorLINQ class, which is obviously a reference type, and therefore I need to check null on it. If it's null, then that author doesn't exist and I need to throw a fault (which is what my custom FaultThrower class does). What's a fault? That's a topic for a different post.

As you can see from the method signatures, not only is the author e-mail address being validated, the LINQ entity is being returned to the caller via an out parameter. Once I have this authorLinq entity, then I can proceed to use it's primary key (AuthorId) in various other LINQ queries. It's critical to remember that you always want to make sure that you are only using validated information. If you aren't, then you have no idea what will happen to your system. Therefore, you should ignore all IDs that are sent into a WCF service operation and use only the validated ones. A thorough discussion of this topic is left for a future discussion.

Now we are finally at the place where LINQ to WCF projection happens. For clarity, here it is again (no one likes to scroll back and forth):

return db.Blogs.Where(p => p.BlogId == MinimaConfiguration.BlogId).Select(p => new Blog
{
    CreateDate = p.BlogCreateDate,
    Description = p.BlogDescription,
    PrimaryUrl = p.BlogPrimaryUrl,
    FeedTitle = p.BlogFeedTitle,
    Guid = p.BlogGuid,
    Title = p.BlogTitle,
    FeedUrl = p.BlogFeedUrl
}).ToList();

The basics flow of this are as follows: In DataContext db, in the Blogs table, pull sub-set where PersonId == AuthorId, then select transform that data into a new type. The DTO projection is obviously happening in the Select method. This method is akin to a SELECT in SQL. My point in saying that is to make sure that you are aware that SELECT is not a filter; that's what Where does. After execution of the Where method as well as after execution of the Select method, you have an IQueryable<Blog> object, which contains information about the query, but no actual data yet. LINQ defers execution of SQL statements until they are actually used. In this case, the data is actually being used when the ToList method is called. This of course returns a list of List<Blog>, which is exactly what this service operation should do. What's really nice about this is that WCF loves List<T>. It's not a big fan of Collection<T>, but List<T> is it's friend. Over the wire it's an Array and when it's being used by a WCF client, it's also a List<T> object.

That LINQ statement was done using what's called the extension method syntax, but it could have also been written using query expression syntax:

return (from p in db.Blogs
        where p.BlogId == MinimaConfiguration.BlogId
        select new Blog
        {
            CreateDate = p.BlogCreateDate,
            Description = p.BlogDescription,
            PrimaryUrl = p.BlogPrimaryUrl,
            FeedTitle = p.BlogFeedTitle,
            Guid = p.BlogGuid,
            Title = p.BlogTitle,
            FeedUrl = p.BlogFeedUrl
        }).ToList();

This yields the same result, but I opt for the expression method syntax for more native .NET readability and for method chaining. I do, however, use query expression syntax when I'm doing SQL joins. In that situation, the query expression syntax would seem more readable to SQL developers (which is, hopefully, all of us).

In closing I should mention something that I know people are going to ask me about: To project from WCF DTO to LINQ you do the exact same thing. LINQ isn't a database-specific technology. You can LINQ between all kinds of things. Though I use LINQ for my data access in many projects, most of my LINQ usage is actually for searching lists, combining to lists together, or modifying the data that gets bounds to the interface. It's incredibly powerful.

Moving into a non-Minima example, if, for example, you needed to have a person's full name in a WPF ListBox and the name-specific LINQ properties you have are FirstName and LastName property, instead of doing tricks in your ItemTemplate, you can just have your ItemsSource use LINQ to sew the FirstName and LastName together.

lstPerson.ItemsSource = personList.Select(p => new
{
    FullName = p.FirstName + " " + p.LastName,
    p.PostalCode,
    Country = p.Country ?? String.Empty
});

The really sweet part about this is the fact that LINQ entities implement the INotifyPropertyChanged interface, so when doing WPF data binding, WPF will automatically update the ListBox when the data changes! Of course, this doesn't help you if you are doing a seriously SOA system. Therefore, my DTOs normally implement INotifyPropertyChanged as well. This is not a WPF-specific interface (it lives in System.ComponentModel) and therefore does not tie the business object to any presentation.

That should show you a bit more of how LINQ can work with all kinds of stuff. Therefore, it shouldn't be hard to figure out how to project from a WCF DTO to LINQ. You could literally copy/paste the LINQ -> DTO code and just switch around a few names.

If you are new to LINQ, then I recommend the book Pro LINQ by Joseph C. Rattz Jr. However, if you are already using LINQ or want a view into its internal mechanics, then I must recommend LINQ in Action by Fabrice Marguerie, Steve Eichert, and Jim Wooley.

Notice: As of May 23, 2008 I will be available for AJAX, WCF, WPF, LINQ, ASP.NET *work from home* consulting on a part-time basis. Please drop me an e-mail for more information.

Spring 2008 Sabbatical

Wed, 09 Apr 2008 22:31:18 GMT

Starting May 23rd, I'm starting another sabbatical to work on my company projects, to continue my seminary work, and to work on my book (to be clear: sabbatical != vacation). During this time I will be accepting part-time AJAX, WCF, ASP.NET (no graphics work!-- hire a professional graphic designer, they are worth the money!), or general C# 3.0 and .NET 3.5 telecommuting consulting. I'll assist in projects, but I'm not going to be able to work as senior architect on any projects. Also remember, as a web developer, it's my duty to make sure my projects work in Mozilla, Opera, Safari, and IE, and is in no way IE-specific. IE-only environments are the absolute most difficult to work with.

Also keep in mind that this is 2008, not 1988 and the primary purpose of modern technology is to allow us to have simpler lives and just about every single aspect of our technology has it's root in the Internet allowing us to communication from anywhere. What's the point in having web casting and online meeting abilities or in having online white boarding or web-based project management software, or even Google Office if you aren't going to use them in a meaningful way? Why have e-mail at all if you are going to absolutely rely on the ability to go to the person's office? The addiction to physical contact is something that needs to be broken in the 21st century. Stop managing with your physical "field of view" and start managing by results.

I'm a web developer/architect, not a piano mover; I don't need to be in a physical office. If you are into technology at all, you are into moving your physical resources into a logical cloud. If I've said it once, I've said it a million times: your associates are your greatest resource and should, therefore, be even more in a logical cloud (as they are humans and would appreciate it more!) It is inconsistent to pursue logical management of resources and require physical management of personnel. Not only that, but it costs a lot less (no office space required!) If your employees don't have enough discipline to work from home, what makes you think they are working in their cube? Unless you are working off the failed notion of "hourly management" instead of being a results-oriented manager, you won't have a problem with 100% telecommuting. Results matter, not "time". Also, if you don't trust your employees, well... maybe you hired the wrong people (or maybe have trust issues in general?) Trust is the foundation of all life. I could speak volumes on this topic, but I'll leave that to the expert: Timothy Ferris. See his blog or get his book for more information. I'm only an anonymous disciple of his, he is the master and authority on this topic. Therefore, send your flames (read: insecurities) his way (after you read his book!-- audio also available; they are both worth 100x their weight in gold!) See also, Scott Hanselman's interview with Timothy Ferris. His YouTube page is also available.

With regards to the book, let me simply say that it's generically about AJAX communication and I'm not going to give out too many specific details on the project at this point, but I will say this: AJAX + SOA - CSS + Prototype + (ASP.NET Controls) - (ASP.NET AJAX) + WCF + (.NET 2.0 Service Interop) + Silverlight + Development Tools. Also, I reserve the right to turn it into a video series (likely), make it a completely learning set of reading + video series (even more likely!), or to completely chuck the project. I don't like to do things the classical way, so whatever I do, you can bet on the fact that I won't do the traditional "book". As I've always said, the blog is the new book, but for this I think I may use a different paradigm. I've turned down two book offers so far because I absolutely refuse to throw more paper on a bookshelf or do something that's been done a million times before.

If you are moving from ASP to ASP.NET, from PHP to ASP.NET, from ASMX to WCF 3.5 or want to add AJAX to your solutions drop me an e-mail and let's talk.

NetFXHarmonics on CodePlex

Tue, 08 Apr 2008 21:59:23 GMT

Well, I finally broke down. My public projects are now freely available for download on CodePlex. Below is a list of the current projects on CodePlex

Here are the current projects on CodePlex:

NetFXHarmonics DevServer
Squid RSS Services (Both the February 2007 and March 2008 Edition)
Minima Blog Engine (Both the February 2007 and August 2007 Edition)
ESV Bible Web Service 2.0 Framework
Dojr.NET

As far as creating "releases", these are shared-source/open-source projects and in the model I'm following "releases" are always going to be obsolete. Therefore, I will provide ZIP versions of the archived major revisions of a project and the current revision will always be available as source code. The only exception to this may be DevServer, which I may do monthly releases or releases based upon major upgrades. I'm currently working on new major revisions for a few other projects and when they are completed, I will then post them on to CodePlex as well.

As a reminder, my projects are always architected to follow the current best-practices and idiots for a particular technology and are therefore often fully re-architected based on the current technology. The reason I do this is for the simple reason that my core specialty is training (technology or not) and that's the driving principle in my projects. Therefore, on each of my projects there is a "As a Training Tool" section that will explain that projects technology and architecture as well as what else you might be able to learn from it.

As a final note, SVNBridge is working OK for me and has really helped me get over the CodePlex hurdle. Scott Hanselman was kind enough to encourage me to try SVNBridge again. I'm honesty glad I did. The Team System 2008 Team Explorer client which integrated into Visual Studio works every now and again, but I got absolutely sick of everything locking up every time I would save a file. Not even a check it! A simple local save! How people put up with "connected" version control systems is beyond me. Do people not realize that Subversion does locking too? Anyways, SVNBridge works great for both check outs and commits (we don't "check in" in the Subversion world-- we use transactional terminology). If you want Visual Studio 2008 integration AND speed and power and flexibility with CodePlex, get VisualSVN. It's an add-on for VS2008 that uses Tortoise behind the scenes. With that, depending on my mood I can commit in both VS2008 (what I would do when working on refactoring or something) and in the Windows shell (what I would do when working with JavaScript files in the world's best JavaScript IDE: Notepad2).