ChronoPositron.Random()

WindsorBootstrapper for Prism2

Ryan Billington — Wed, 01 Apr 2009 05:30:10 +0000

For a large, enterprise application at work, I have been utilizing the Prism (CompositeWPF) framework. The application is still in progress, so I am unable to discuss it’s nature too much in detail. However, Prism has been a large help in getting the base framework for the application laid out and constructed. After finishing a few other tasks, I decided to check the status of the CompositeWPF project and look for any updates. That day just happened to coincide with Prism2′s latest release. The update sounded appealing, so I started the process of moving everything over to it.

While moving over to the February 2009 release of Prism2, I ran into issues with a few of the pieces I was using from the CompositeWPFContrib project. For example, the Windsor container bootstrapper had not been updated for the new release of Prism, leading to many problems. In order to fully move over to Prism2, I’d need to either give up on using Windsor, or create a new bootstrapper for Prism2 capable of working with Castle Windsor. Choosing option 2, I started with the bootstrapper for Unity and with the base Castle Windsor implementation for ServiceLocator, then modified them quite a bit. The final results that I ended up with will be posted below.

One significant difference between Castle Windsor and Unity came to light while writing and testing these new classes. If a specific instance of a class that hasn’t been registered into the container is requested from Unity, Unity doesn’t complain and just goes ahead and injects what is needed. Castle Windsor, on the other hand, will throw an exception complaining that the component wasn’t registered. Both seem like valid approaches, but I wanted to make the transition as simple as possible. So, to avoid changing too much of the logic found within Prism2 (and the bootstrapper), I added a “ResolveEx” extension function to IWindsorContainer. If a specific class is requested through this function that isn’t in the container, it will register it as transient and return an instance. I also changed the ServiceLocator implementation for Castle Windsor to use “ResolveEx” if a key is not passed in.

And without further ado, here are the files in all their glory (+ zip):

WindsorBootstrapper.cs

Note for WindsorBootstrapper.cs: There are four resource properties that will need to be added to your project. They should just be simple strings that explain the problem that occurred. The four resource properties are: NullLoggerFacadeException, NullWindsorContainerException, NullModuleCatalogException, and TypeMappingAlreadyRegistered.

#region Usings!
 
using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using Core.Properties;
using Castle.MicroKernel;
using Castle.Windsor;
using Microsoft.Practices.Composite;
using Microsoft.Practices.Composite.Events;
using Microsoft.Practices.Composite.Logging;
using Microsoft.Practices.Composite.Modularity;
using Microsoft.Practices.Composite.Presentation.Regions;
using Microsoft.Practices.Composite.Presentation.Regions.Behaviors;
using Microsoft.Practices.Composite.Regions;
using Microsoft.Practices.ServiceLocation;
 
#endregion
 
namespace Core.Windsor
{
    /// 
    /// Base class that provides a basic bootstrapping sequence that
    /// registers most of the Composite Application Library assets
    /// in a  and uses 
    /// for logging.
    /// 
    /// 
    /// This class must be overriden to provide application specific configuration.
    /// 
    public abstract class WindsorBootstrapper
    {
        private readonly ILoggerFacade loggerFacade = new Log4NetLogger();
        private bool useDefaultConfiguration = true;
 
        /// 
        /// Gets the default  for the application.
        /// 
        /// The default  instance.
        public IWindsorContainer Container { get; private set; }
 
        /// 
        /// Gets the default  for the application.
        /// 
        /// A  instance.
        protected virtual ILoggerFacade LoggerFacade
        {
            get { return loggerFacade; }
        }
 
        /// 
        /// Runs the bootstrapper process.
        /// 
        public void Run()
        {
            Run(true);
        }
 
        /// 
        /// Run the bootstrapper process.
        /// 
        /// If , registers default Composite Application Library services in the container. This is the default behavior.
        public void Run(bool runWithDefaultConfiguration)
        {
            useDefaultConfiguration = runWithDefaultConfiguration;
            ILoggerFacade logger = LoggerFacade;
            if (logger == null)
            {
                throw new InvalidOperationException(Resources.NullLoggerFacadeException);
            }
 
            logger.Log("Creating Windsor container", Category.Debug, Priority.Low);
            Container = CreateContainer();
            if (Container == null)
            {
                throw new InvalidOperationException(Resources.NullWindsorContainerException);
            }
 
 
            logger.Log("Configuring container", Category.Debug, Priority.Low);
            ConfigureContainer();
 
            logger.Log("Configuring region adapters", Category.Debug, Priority.Low);
 
            ConfigureRegionAdapterMappings();
            ConfigureDefaultRegionBehaviors();
            RegisterFrameworkExceptionTypes();
 
            logger.Log("Creating shell", Category.Debug, Priority.Low);
            DependencyObject shell = CreateShell();
            if (shell != null)
            {
                RegionManager.SetRegionManager(shell, Container.Resolve<IRegionManager>());
                RegionManager.UpdateRegions();
            }
 
            logger.Log("Initializing modules", Category.Debug, Priority.Low);
            InitializeModules();
 
            logger.Log("Bootstrapper sequence completed", Category.Debug, Priority.Low);
        }
 
        /// 
        /// Registers in the  the  of the Exceptions
        /// that are not considered root exceptions by the .
        /// 
        protected virtual void RegisterFrameworkExceptionTypes()
        {
            ExceptionExtensions.RegisterFrameworkExceptionType(
                typeof (ActivationException));
 
            ExceptionExtensions.RegisterFrameworkExceptionType(
                typeof (ComponentNotFoundException));
 
            ExceptionExtensions.RegisterFrameworkExceptionType(
                typeof (ComponentRegistrationException));
        }
 
        /// 
        /// Configures the . May be overwritten in a derived class to add specific
        /// type mappings required by the application.
        /// 
        protected virtual void ConfigureContainer()
        {
            Container.RegisterInstance(LoggerFacade);
 
            Container.RegisterInstance(Container);
 
            IModuleCatalog catalog = GetModuleCatalog();
            if (catalog != null)
            {
                Container.RegisterInstance(catalog);
            }
 
            if (useDefaultConfiguration)
            {
                RegisterTypeIfMissing<IServiceLocator, WindsorServiceLocator>(true);
                RegisterTypeIfMissing<IModuleInitializer, ModuleInitializer>(true);
                RegisterTypeIfMissing<IModuleManager, ModuleManager>(true);
                RegisterTypeIfMissing<RegionAdapterMappings, RegionAdapterMappings>(true);
                RegisterTypeIfMissing<IRegionManager, RegionManager>(true);
                RegisterTypeIfMissing<IEventAggregator, EventAggregator>(true);
                RegisterTypeIfMissing<IRegionViewRegistry, RegionViewRegistry>(true);
                RegisterTypeIfMissing<IRegionBehaviorFactory, RegionBehaviorFactory>(true);
 
                ServiceLocator.SetLocatorProvider(() => Container.Resolve<IServiceLocator>());
            }
        }
 
        /// 
        /// Configures the default region adapter mappings to use in the application, in order
        /// to adapt UI controls defined in XAML to use a region and register it automatically.
        /// May be overwritten in a derived class to add specific mappings required by the application.
        /// 
        /// The  instance containing all the mappings.
        protected virtual RegionAdapterMappings ConfigureRegionAdapterMappings()
        {
            var regionAdapterMappings = ServiceLocator.Current.GetInstance<RegionAdapterMappings>();
            if (regionAdapterMappings != null)
            {
#if SILVERLIGHT
                regionAdapterMappings.RegisterMapping(typeof(TabControl), 
                                    ServiceLocator.Current.GetInstance<TabControlRegionAdapter>());
#endif
                regionAdapterMappings.RegisterMapping(typeof (Selector), 
                                    ServiceLocator.Current.GetInstance<SelectorRegionAdapter>());
                regionAdapterMappings.RegisterMapping(typeof (ItemsControl),
                                    ServiceLocator.Current.GetInstance<ItemsControlRegionAdapter>());
                regionAdapterMappings.RegisterMapping(typeof (ContentControl),
                                    ServiceLocator.Current.GetInstance<ContentControlRegionAdapter>());
            }
 
            return regionAdapterMappings;
        }
 
        /// 
        /// Configures the . This will be the list of default
        /// behaviors that will be added to a region. 
        /// 
        protected virtual IRegionBehaviorFactory ConfigureDefaultRegionBehaviors()
        {
            var defaultRegionBehaviorTypesDictionary = Container.TryResolve<IRegionBehaviorFactory>();
 
            if (defaultRegionBehaviorTypesDictionary != null)
            {
                defaultRegionBehaviorTypesDictionary.AddIfMissing(AutoPopulateRegionBehavior.BehaviorKey,
                                                                  typeof (AutoPopulateRegionBehavior));
 
                defaultRegionBehaviorTypesDictionary.AddIfMissing(
                    BindRegionContextToDependencyObjectBehavior.BehaviorKey,
                    typeof (BindRegionContextToDependencyObjectBehavior));
 
                defaultRegionBehaviorTypesDictionary.AddIfMissing(RegionActiveAwareBehavior.BehaviorKey,
                                                                  typeof (RegionActiveAwareBehavior));
 
                defaultRegionBehaviorTypesDictionary.AddIfMissing(SyncRegionContextWithHostBehavior.BehaviorKey,
                                                                  typeof (SyncRegionContextWithHostBehavior));
 
                defaultRegionBehaviorTypesDictionary.AddIfMissing(RegionManagerRegistrationBehavior.BehaviorKey,
                                                                  typeof (RegionManagerRegistrationBehavior));
            }
            return defaultRegionBehaviorTypesDictionary;
        }
 
        /// 
        /// Initializes the modules. May be overwritten in a derived class to use a custom Modules Catalog
        /// 
        protected virtual void InitializeModules()
        {
            IModuleManager manager;
 
            try
            {
                manager = Container.Resolve<IModuleManager>();
            }
            catch (ComponentNotFoundException ex)
            {
                if (ex.Message.Contains("IModuleCatalog"))
                {
                    throw new InvalidOperationException(Resources.NullModuleCatalogException);
                }
 
                throw;
            }
 
            manager.Run();
        }
 
        /// 
        /// Returns the module catalog that will be used to initialize the modules.
        /// 
        /// 
        /// When using the default initialization behavior, this method must be overwritten by a derived class.
        /// 
        /// An instance of  that will be used to initialize the modules.
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
        protected virtual IModuleCatalog GetModuleCatalog()
        {
            return null;
        }
 
        /// 
        /// Creates the  that will be used as the default container.
        /// 
        /// A new instance of .
        protected virtual IWindsorContainer CreateContainer()
        {
            return new WindsorContainer();
        }
 
        /// 
        /// Registers a type in the container only if that type was not already registered.
        /// 
        /// Registers the type as a singleton.
        protected void RegisterTypeIfMissing<TFromType, TToType>(bool registerAsSingleton)
        {
            ILoggerFacade logger = LoggerFacade;
 
            if (Container.IsTypeRegistered<TFromType>())
            {
                logger.Log(
                    String.Format(CultureInfo.CurrentCulture,
                                  Resources.TypeMappingAlreadyRegistered,
                                  typeof (TFromType).Name), Category.Debug, Priority.Low);
            }
            else
            {
                Container.RegisterType<TFromType, TToType>(registerAsSingleton);
            }
        }
 
        /// 
        /// Creates the shell or main window of the application.
        /// 
        /// The shell of the application.
        /// 
        /// If the returned instance is a , the
        ///  will attach the default  of
        /// the application in its  attached property
        /// in order to be able to add regions by using the 
        /// attached property from XAML.
        /// 
        protected abstract DependencyObject CreateShell();
    }
}

WindsorContainerHelper.cs

#region Usings!
 
using System;
using System.Diagnostics.CodeAnalysis;
using Castle.Core;
using Castle.Windsor;
 
#endregion
 
namespace Core.Windsor
{
    /// 
    /// Extensions methods to extend and facilitate the usage of .
    /// 
    public static class WindsorContainerHelper
    {
        /// 
        /// Returns whether a specified type has a type mapping registered in the container.
        /// 
        /// The  to check for the type mapping.
        /// The type to check if there is a type mapping for.
        ///  if there is a type mapping registered for .
        /// In order to use this extension method, you first need to add the
        /// 
        public static bool IsTypeRegistered(this IWindsorContainer container, Type type)
        {
            return container.Kernel.HasComponent(type);
        }
 
        public static bool IsTypeRegistered<TType>(this IWindsorContainer container)
        {
            Type typeToCheck = typeof(TType);
            return IsTypeRegistered(container, typeToCheck);
        }
 
        /// 
        /// Utility method to try to resolve a service from the container avoiding an exception if the container cannot build the type.
        /// 
        /// The cointainer that will be used to resolve the type.
        /// The type to resolve.
        /// The instance of  built up by the container.
        [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter")]
        public static T TryResolve<T>(this IWindsorContainer container)
        {
            object result = TryResolve(container, typeof(T));
            if (result != null)
            {
                return (T)result;
            }
            return default(T);
        }
 
        /// 
        /// Utility method to try to resolve a service from the container avoiding an exception if the container cannot build the type.
        /// 
        /// The cointainer that will be used to resolve the type.
        /// The type to resolve.
        /// The instance of  built up by the container.
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
        public static object TryResolve(this IWindsorContainer container, Type typeToResolve)
        {
            object resolved;
 
            try
            {
                resolved = Resolve(container, typeToResolve);
            }
            catch
            {
                resolved = null;
            }
 
            return resolved;
        }
 
        /// 
        /// Resolves a service from the container. If the type does not exist on the container, 
        /// first registers it with transient lifestyle.
        /// 
        /// 
        /// 
        /// 
        public static object ResolveEx(this IWindsorContainer container, Type type)
        {
            if (type.IsClass && !container.Kernel.HasComponent(type))
            {
                container.Kernel.AddComponent(type.FullName, type, LifestyleType.Transient);
            }
 
            return container.Resolve(type);
        }
 
        /// 
        /// Resolves a service from the container. If the type does not exist on the container, 
        /// first registers it with transient lifestyle.
        /// 
        /// 
        /// 
        /// 
        private static object Resolve(this IWindsorContainer container, Type type)
        {
            return ResolveEx(container, type);
        }
 
        /// 
        /// Registers the type on the container.
        /// 
        /// The type of the interface.
        /// The type of the service.
        /// The container.
        public static void RegisterType<TServiceType, TClassType>(this IWindsorContainer container)
        {
            RegisterType<TServiceType, TClassType>(container, true);
        }
 
        /// 
        /// Registers the type on the container.
        /// 
        /// The type of interface.
        /// The type of the service.
        /// The container.
        /// if set to true type will be registered as singleton.
        public static void RegisterType<TServiceType, TClassType>(this IWindsorContainer container, bool singleton)
        {
            if (!container.Kernel.HasComponent(typeof(TServiceType)))
            {
                container.Kernel.AddComponent(typeof(TClassType).FullName, typeof(TServiceType), typeof(TClassType),
                                              singleton ? LifestyleType.Singleton : LifestyleType.Transient);
            }
        }
 
        /// 
        /// Registers the instance of a type on the container.
        /// 
        /// The type of interface.
        /// The container.
        /// The instance.
        public static void RegisterInstance<TServiceType>(this IWindsorContainer container, TServiceType instance)
        {
            if (!container.Kernel.HasComponent(typeof(TServiceType)))
            {
                container.Kernel.AddComponentInstance(typeof(TServiceType).FullName, typeof(TServiceType), instance);
            }
        }
    }
}

WindsorServiceLocator.cs

#region Usings!
 
using System;
using System.Collections.Generic;
using Castle.Windsor;
using Microsoft.Practices.ServiceLocation;
 
#endregion
 
namespace Core.Windsor
{
    /// 
    /// Adapts the behavior of the Windsor container to the common
    /// IServiceLocator
    /// 
    public class WindsorServiceLocator : ServiceLocatorImplBase
    {
        private readonly IWindsorContainer container;
 
        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The container.
        public WindsorServiceLocator(IWindsorContainer container)
        {
            this.container = container;
        }
 
        /// 
        ///             When implemented by inheriting classes, this method will do the actual work of resolving
        ///             the requested service instance.
        /// 
        /// Type of instance requested.
        /// Name of registered service you want. May be null.
        /// 
        /// The requested service instance.
        /// 
        protected override object DoGetInstance(Type serviceType, string key)
        {
            if (key != null)
            {
                return container.Resolve(key, serviceType);
            }
            return container.ResolveEx(serviceType);
        }
 
        /// 
        ///             When implemented by inheriting classes, this method will do the actual work of
        ///             resolving all the requested service instances.
        /// 
        /// Type of service requested.
        /// 
        /// Sequence of service instance objects.
        /// 
        protected override IEnumerable<object> DoGetAllInstances(Type serviceType)
        {
            return (object[]) container.ResolveAll(serviceType);
        }
    }
}

Log4NetLogger.cs

#region Usings!
 
using System.Reflection;
using log4net;
using Microsoft.Practices.Composite.Logging;
 
#endregion
 
namespace Core.Windsor
{
    public class Log4NetLogger : ILoggerFacade
    {
        private static readonly ILog logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
        #region ILoggerFacade Members
 
        public void Log(string message, Category category, Priority priority)
        {
            switch (category)
            {
                case Category.Debug:
                    logger.Debug(message);
                    break;
 
                case Category.Exception:
                    logger.Error(message);
                    break;
 
                case Category.Warn:
                    logger.Warn(message);
                    break;
 
                default:
                    logger.Info(message);
                    break;
            }
        }
 
        #endregion
    }
}

Get Shareaholic

Castle ActiveRecord and Fluent Create/Update/Save

Ryan Billington — Wed, 18 Feb 2009 06:38:35 +0000

I came up with an interesting idea the other day at work involving some work I had been doing with Castle ActiveRecord. I am using (a modified) GeneratorStudio to produce ActiveRecord partial classes based on a database schema that I have. All of my code additions go into another set of partial class files so that I can regenerate the base classes whenever I need to.

However, there are many times when I need to find a specific item, and if it isn’t found, I need to create a new one. After this, it is used for yet another item. So essentially, the item has to exist before the code can continue. This is where my slightly clever (if I can call it that) idea comes into play.

I will be using part of the example Post class from http://www.castleproject.org/ActiveRecord/gettingstarted/classes.html as a basis for the new idea:

[ActiveRecord]
public class Post : ActiveRecordBase<Post>
{
    private int id;
    private String title;
 
    public Post()
    {
        created = DateTime.Now;
    }
 
    [PrimaryKey]
    public int Id
    {
        get { return id; }
        set { id = value; }
    }
 
    [Property]
    public String Title
    {
        get { return title; }
        set { title = value; }
    }
}

For all of my unique indexes, I create additional static helper methods that allow retrieval by those constraints. Let us assume that Title is a unique index; that is, there can only be a single post with a specific title. Then the following function becomes valid (in the Post class):

public static Post GetByTitle(string title)
{
    return FindOne(Restrictions.Eq("Title",title));
}

And here is my little idea for making a small fluent addition (to the Post class):

public Post CreateFluent()
{
    Create();
    return this;
}

A function similar to this would hopefully work for CreateAndFlush, Update, UpdateAndFlush, Save, and SaveAndFlush as well. Once all of this is in place, I now have many new options for dealing with items that need to exist or be updated before they can be used. I find the fluent-like style of this to be easy to read while working through code:

var post = Post.GetByTitle("42") ?? new Post { Title = "42" }.CreateFluent();
 
// do something important with post

Since Post.GetByTitle(string title) will return null if the post cannot be found, the null coalescing operator (??) takes care of automatically running the second half and creating the new Post if a Post with the specified title couldn’t be found. I’m still testing this fully to see how well it works, but I’ll update here once I get concrete evidence of its functionality.

EDIT: I’ve been using this for the last few weeks and I have not run into any issues with it. It looks pretty slick in the code, too.

Get Shareaholic

New Theme, Updated Code

Ryan Billington — Wed, 11 Feb 2009 08:13:37 +0000

I’ve decided on a theme for my blog that I feel comfortable using without tweaking the design too much more. I’ll still be making minor tweaks and enhancements, but at least I won’t be devoting all my blogging time to making a design. Since I’m mostly content with it, I’ll be able to devote a larger portion of my time to actually writing new content.

The theme I chose, though, was only written and available for WordPress 2.5. I know how to work with PHP and HTML/CSS, so I jumped right in to make the modifications necessary to support the new WordPress 2.6 and 2.7 features. WordPress 2.7 added an entirely new comment loop and threaded comments, therefore most of the comment code had to be rewritten to support it. In addition to that, a new function was added to get the classes used for styling each entry:

The post_class() outputs the class=”whatever” piece for that div. This includes several different classes of value: post, hentry (for hAtom microformat pages), category-X (where X is the slug of every category the post is in), and tag-X (similar, but with tags). It also adds “sticky” for posts marked as sticky posts. These make it easy to style different parts of the theme in different ways.
[http://codex.wordpress.org/Migrating_Plugins_and_Themes_to_2.7]

Besides the required changes to make the theme work fully with WordPress 2.7, I also added in a few personal features. First, I made the H1 on the pages dynamic. It was originally constructed so that the title of the blog appeared in the H1 for every single page. I have seen it written multiple times that the title of the blog should only be in an H1 on the main page of the blog. On the individual content pages, the title of the content (post or page) should be contained within an H1. This is supposed to help with SEO. Second, I added my Twitter loading javascripts to the footer. With the load script in the footer instead of in a widget, only a very minimal portion of my site doesn’t load if Twitter goes down. Third, I added my Google Analytics code to the footer as well.

Here's a screenshot of the new threaded comments. Notice the 'Reply' link on the left side if a comment can be replied to.

I would like to make a settings panel for administering options for the theme, such as my new Google Analytics and Twitter support. I feel that this would be useful for myself, but possibly more beneficial to others. If there is sufficient demand (or any ), then I may try to contact the authors of the dark theme for WordPress to see if I can release my own version. If I do that and get permission, I will definitely be adding a settings panel with a multitude of options.

Get Shareaholic

Politics: The Foundation of the U.S. Government

Ryan Billington — Tue, 10 Jul 2007 20:21:00 +0000

I just found a really interesting and enlightening article that was written by a 17 year old law student. The title of the article is “The Great Pillars of Our Government”. The entry talks about some of the things that the founding fathers of this nation were saying and has several excellent quotes on it. One of my favorite quotes from the page is the one below by Robert Winthrop (I retrieved the full paragraph of the quote from Google):

All societies of men must be governed in some way or other. The less they have of stringent State Government, the more they must have of individual self-government. The less they rely on public law or physical force, the more they must rely on private moral restraint. Men, in a word, must necessarily be controlled either by a power within them, or a power without them; either by the word of God, or by the strong arm of man; either by the Bible or by the bayonet. It may do for other countries and other governments to talk about the State supporting religion. Here, under our own institutions, it is Religion which must support the State. (from: Addresses and Speeches on Various Occasions, By Robert C. Winthrop, p. 172)

This varies from what I would normally talk about, but I tend to be a conservative, and I like to at least stay informed about the government. This is from a long time ago, but I think it gives perspective to things that are happening in the current world. As a side note, I think that the next presidential election will be very interesting to watch, as I believe that the running of the candidates will get very heated.

Get Shareaholic

Google Apps

Ryan Billington — Thu, 14 Jun 2007 03:27:00 +0000

I just found that you can get Google Apps for free (standard edition) for any domain that you may own. I just set it up for my domain and I think it’s pretty cool looking. You can get Gmail on your domain, some simple webpages, a google ig start page (partner page or something like that), calendar, and docs for your own domain. For the standard edition (free one) you can have like up to 100 users and each user gets 2gb of mail storage.

The really cool thing is that Google has the MX entries to set the mail up and a place to redirect all the other domain settings to. All i had to do was set up the Google Apps thing, then log into my domain administration page and enter the entries that the step by step instructions say to.

The only downside that I see at the moment is the simplicity of the webpages that you can make. I didn’t really look that far into it, but as far as I saw, they are pretty basic pages. If you have a domain that isn’t being really used or pointed to anything, or you just want a cheap way to get something up and have a nice mail system, Google Apps is definitely something to check into.

Get Shareaholic

Safari. On Windows?

Ryan Billington — Tue, 12 Jun 2007 10:30:00 +0000

For anyone who has yet to make the full switch to Mac (myself included), it looks like Apple is releasing Safari for Windows. It’s still in beta, but from the Apple site, it looks like it’s supposed to be much faster than Internet Explorer 7 and Firefox. I own a Mac (Powerbook G4 laptop) and when I’m using it, Safari is my browser of choice. Now I may have a new browser to use while I’m working on my desktop (I currently use Firefox 2). Once I give it a few days testing, I’ll have to report back how it goes. Anyways, here the link to the page about Safari 3 and the download page.

Get Shareaholic

First post. Woo!

Ryan Billington — Tue, 12 Jun 2007 10:17:00 +0000

Well, now that I have something presentable up for my template, it’s time for the standard first post. My first posts are generally very short and tend to end up looking something exactly like this. Rather than drag it on too long, I’ll just end it here and let everyone look at my new template

Get Shareaholic