Simon Says ...

2009-08-31T17:07:00.001-07:00

Track the LSU equipment truck to Seattle -- http://ping.fm/RVla0

2009-08-09T14:18:00.001-07:00

Celebrating 150 years -- http://ping.fm/i14OB

2009-08-06T15:28:00.001-07:00

When I say "interesting...", I actually mean "Please go away"

2009-08-06T15:25:00.001-07:00

We are all technology zombies. Must upgrade now, must have latest, must have coolest, must eat flesh, must have latest, must have coolest.

2009-08-03T12:37:00.001-07:00

Malarky! - "Seven (More) Reasons to Ditch Your iPhone" - http://ping.fm/VrdUH

2009-08-02T20:36:00.001-07:00

Can't wait for this movie, "It Might Get Loud". Jack White, The Edge and Jimmy. http://ping.fm/ZLFVz

2009-08-02T18:43:00.001-07:00

Dress up

2009-08-02T18:26:00.001-07:00

Mobile photo

2009-08-02T18:23:00.001-07:00

#Family night at papa and grammy's

2009-08-02T15:35:00.001-07:00

Impressive win by Tiger at the Buick open. Is he back? http://ping.fm/XeFnf

2009-08-02T08:20:00.001-07:00

Mobile photo

2009-08-02T00:08:00.001-07:00

http://is.gd/1YH50

2009-08-02T00:07:00.001-07:00

Mobile photo

2009-08-01T23:35:00.001-07:00

Nice photo

2009-08-01T23:23:00.001-07:00

Mobile photo

2009-08-01T21:43:00.001-07:00

"The Dead Weather" is blowing my mind. http://ping.fm/Zqisf

2009-08-01T21:00:00.001-07:00

blogged: How to use SPDeploy to compile a WSP via TFS Team Build. http://ping.fm/pGUqH sharepoint wss spdeploy

Data Cache component now available in Rapid Tools

2008-09-15T12:09:00.000-07:00

Rapid Tools for SharePoint now includes the data caching component as described in my previous post. The data cache module is only available in daily builds for now but I am planning to promote a featured build very soon. Any comments/questions/flames are welcome!

SPTechnique: Using the SharePoint content database as a cache

2008-09-12T12:11:00.000-07:00

Data caching is a core concept in the web dominated world that we live in. The premise is that we should not have to go back to retrieve data from a data store for every single web request when the data is unchanged, thereby sharing data across web requests. This offers huge performance advantages because all latency related to data fetching, query processing and transmission is eliminated for requests that use the same data. In the SharePoint world this can be a very valuable technique when querying MOSS page libraries or any data stored in the content database. For high traffic sites, the performance of the SPQuery or SPSiteDataQuery api is not acceptable when executing queries for each request.

The most common data caching implementation is using the HttpContext.Cache collection. This is an ASP.NET facility that allows as an in-memory object cache associated with the ASP.NET application domain (w3wp.exe). For SharePoint applications this cache works great when caching can be scoped to the HttpContext. For applications that need caching that is not scoped based on the HttpContext it is necessary find a different solution. The most common case non-HttpContext caching would be any instance where you are consuming data outside of the ASP.NET context such as SPTimer jobs, stsadm commands, winform applications or console applications. For these cases it is not possible to use the HttpContext cache.

There are a few potential solutions to this problem including using the HttpRuntime static cache, but the best solution (in my opinion) is to use the SPSite instance as a data cache. The idea is that by using the SPSite.RootWeb.AllProperties hashtable, we can store cached data into the content database for later retrieval. This solves the HttpContext problem because for any application to operate it will need to have a SPSite object to provided context for it's operation no matter where it may be running. Because the SPSite object provides context, the data cache is always available.

Here's the class signatures for my implementation of SPSite data caching. By creating a subclass from this base you can implement application independent caching of any data type. The full implement can be found here.

public abstract class RapidCachedDataAdapterBase<TData> where TData : class
{
    protected Guid SiteID;
    protected virtual bool AutoRefreshCache;
    protected virtual string CacheKey;
    protected virtual string CacheExpireKey;
    protected virtual int CacheTimeoutMinutes;

    public virtual TData CachedData;

    public RapidCachedDataAdapterBase(Guid siteID);
    public RapidCachedDataAdapterBase(SPSite site);

    protected abstract TData GetNativeData();
    protected virtual TData GetData();
    protected virtual TData GetCache();

    protected virtual void SetCache(TData data);
    protected virtual string Serialize(TData data);
    protected virtual TData Deserialize(string data);

    protected string SerializeInternal(object data);
    protected T DeserializeInternal<T>(string data);

    public virtual void InvalidateCache();

}

Notes:

GetNativeData() is the only method you must override when creating a subclass. GetNaiveData() provides data from the native datastore to feed the cache, it is called any time that data needs to be retrieved from the native data store.
Serialization to a string is necessary for all cached data types. Since SPSite.RootWeb.AllProperties accepts only limited data types (date, int and string), it is necessary for us to convert our data into a string. My default the base class uses the standard XmlSerializer class. If you are caching a data type that is not xml serializable (such as Hashtable, Dictionary & DataTable) then you need to implement the Serialize() and Deserialize() method within your subclass. You can choose to serialize your data any way you like as long as it can be represented as a string.
The CacheTimeoutMinutes property determines how long the cached data will live. An automatic refresh will be triggered when the timeout period expires. The timeout period is set to 20 minutes by default but you can override this in your subclass.
You need to handle cache invalidation when native data changes. Cache invalidation is supported by the base class, but it is only called automatically if the cache expires due to a cache timeout. You will need to identify the cases where you would like to invalidate the cache and call InvalidateCache() at the appropriated time. Usually you would invalidate the cache when you detect that data has changed, such as when a user changes a list item. In this case you would need to have a feature receiver to detect the change and call InvalidateCache().
The CachedData property used for data access. The CachedData property will either load the cache or retrieve the cache depending on the situation. You can use the CachedData property as the single access for data.
Using SPSite.RootWeb.AllProperties does carry a cost. Because we need to load and manipulate an SPSite object, there is an implied cost associated with this approach. Anytime SPSite is loaded or saved SharePoint needs to communicate with the content database and that takes cycles. This is in sharp contrast to the HttpContext.Cache approach where all data is stored in memory. To mitigate this cost the base class uses the HttpContext.Items collection to cache data for each http request. This means that the SPSite object will only be loaded used once per request.

Here's a sample subclass:

public class FaqDataAdapter : RapidCachedDataAdapterBase<DataTable>
{
    public FaqDataAdapter()    : base(SPContext.Current.Site.ID)
    {
    }

    public FaqDataAdapter(Guid siteID) : base(siteID)
    {
    }

    public FaqDataAdapter(SPSite site) : base(site)
    {
    }

    protected override DataTable GetNativeData()
    {
        DataTable table = null;

        SPSecurity.RunWithElevatedPrivileges(() =>
        {
            using (SPSite esite = new SPSite(SiteID))
            {
                SPList list = esite.RootWeb.GetList("faq");
                table = list.Items.GetDataTable();
            }
        });

        return table;
    }

    protected override string Serialize(DataTable data)
    {
        if (data == null)
            return null;

        var ds = new DataSet();
        ds.Tables.Add(data);
        return SerializeInternal(ds);
    }

    protected override DataTable Deserialize(string data)
    {
        if (string.IsNullOrEmpty(data))
            return null;

        var ds = DeserializeInternal<DataSet>(data);
        return ds.Tables[0];
    }
}

Any question or comments are greatly appreciated!

Anonymous access and item level permissions

2008-04-03T12:13:00.000-07:00

You are probably familiar with the fact that SharePoint now has the capability to host site with anonymous access turned on. I learned the hard way that item level permissions do not participate in the anonymous access behavior the way you might expect. When an item does not inherit permissions, it is not possible to enable anonymous access on that item.

Note the document library permission settings menu:

Here's the same menu for an item which is not inheriting permissions from the parent library:

I found an interesting post that quotes Tom Rizzo on the subject. He explains that this behavior is by design and due to the fact that the product team feels that it is important that anonymous access setting should always cascade and child node should never have a higher degree of anonymous access than it's parent.

SPTechnique: Custom Field control implemented as a User Control

2008-03-13T12:24:00.000-07:00

When creating custom controls it is often must easier to create a control using the "User Control" development model instead of the "Server Control" model. Server controls generally have a more "low level" feel and dictate that the developer build the control's rendering from scratch. Either by building a control tree or by constructing the rendered output in code.

Alternatively user controls have nice separation of code and presentation by virtue of having a markup file (.ascx) and a code behind file; much like a standard aspx page. User controls can be created and developed using the same standard approaches and processes that we all know and love from the aspx page model.

When implementing a custom field control for SharePoint, the development experience can be streamlined to a large degree by utilizing a user control. Traditionally field controls are created using the server control model but with a few tricks you can implement a custom field control with a user control.

First, here is the base class used for the field control. It has a virtual property used to set the user control path. A property override for the value of the field which is read from the user control. On initialization it loads the user control and sets the context.

using System;
using System.Web.UI;
using Microsoft.SharePoint.WebControls;

namespace MyProject.Web.UI.FieldControls
{
    public abstract class UserControlFieldBase : BaseFieldControl
    {

        private SPFieldUserControlBase _usercontrol;

        public virtual string UserControlPath { get; set; }

        public override object Value
        {
            get
            {
                return _usercontrol == null ? base.Value : _usercontrol.Value;
            }
            set
            {
                base.ItemFieldValue = value;
            }
        }

        public UserControlFieldBase() : base()
        {
        }

        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            UserControlPath = null;
        }

        protected override void CreateChildControls()
        {
            Controls.Clear();
            base.CreateChildControls();

            if (!string.IsNullOrEmpty(UserControlPath))
            {
                _usercontrol = (SPFieldUserControlBase)Page.LoadControl(UserControlPath);
                _usercontrol.FieldControl = this;

                Controls.Add(_usercontrol);
            }
        }
    }
}

Here's an example field control subclass. This class simply specifies the user control path and let's the base class handle all the details of loading the user control and setting the context. This is the server control that you will embed into you page layouts.

using System.Web.UI;

namespace MyProject.Web.UI.FieldControls
{
    public class MyFieldContol : UserControlFieldBase
    {
        public override string UserControlPath
        {
            get
            {
                return "~/_controltemplates/MyFieldControl.ascx";
            }
        }
    }
}

Next, is the abstract base class for the user control. This class provides a property for a reference to the parent field control and an abstract property for the field value. The field control property is important because our user control will need to know all the information about the field it is attached to. This includes the SPField context and control mode among other things.

using System.Web.UI;

namespace MyProject.Web.UI.FieldControls
{
    public abstract class SPFieldUserControlBase : UserControl
    {
        protected SPFieldUserControlBase();

        public BaseFieldControl FieldControl { get; set; }
        public abstract object Value { get; }
    }
}

Lastly you can create a user control that inherits from the SPFieldUserControlBase class and implement the specific UI that is necessary for you field control to function. See my pervious post on how to create a custom field control for further direction on creating field controls from scratch.

This technique also you to have easiest possible development process while leveraging the SharePoint field control infrastructure. Any questions or comments, please let me know!

HOW TO: Create a Custom SharePoint Field Control and Field Type

2008-01-18T11:15:00.000-08:00

With WSS 3.0 / MOSS 2007 it is now possible to create custom field types and field control. These constructs are exciting in that they can be used to expose complex data types in SharePoint site columns. For example, if you'd like to capture and store structured data such as an address, a social security number or a phone number that is now possible with a few custom code pieces. In fact the default SharePoint fields such as text, lookup and choice all use this same infrastructure to exposes data to SharePoint lists and page layouts.

The field type class is the native field type implementation that is used to create new site columns and list fields.

Read more here:
Custom Field Type Definition
How to: Create a Custom Field Type and Field Control

Here's how I create a custom field type and field control:

Create the Field Control class
This class is a server control that is used by the edit form or placed on a page layout to exposes data in your custom field type. It includes any formatting necessary for "view" mode and any input controls necessary for "edit" mode.

In this example I am creating a simple field control that exposes a text field type with minimal formatting and a text input box for editing. Note the "Value" property override, this property is used by the SharePoint framework to get the value of the field when editing in a page layout or item edit form.

Server Control Class:

public class MyCustomFieldControl : BaseFieldControl {

    private DropDownList _editor;
    private Literal _litvalue;

    public override object Value {
        get {
            return (ControlMode == SPControlMode.New 
                        || ControlMode == SPControlMode.Edit)
                    ? _editor.Text : ListItemFieldValue;
        }
        set {
            base.ItemFieldValue = value;
        }
    }

    protected override void OnInit(EventArgs e) {
        base.OnInit(e);
        EnsureChildControls();
    }

    protected override void CreateChildControls() {
        Controls.Clear();
        base.CreateChildControls();

        if (ControlMode == SPControlMode.New 
                || ControlMode == SPControlMode.Edit) {
            _editor = new DropDownList();
            Controls.Add(_editor);
        } else {
            _litvalue = new Literal();
            _litvalue.Text = Convert.ToString(ListItemFieldValue);
            Controls.Add(_litvalue);
        }
    }
}

Page Layout Declaration:

<controls:MyCustomFieldControl 
    id="MyCustomFieldControl1" 
    Runat="server" 
    FieldName="Field1" />

Create the field type class
The field type class in the native implementation of the field behavior including the base type and the field rendering control. Here's an example:

public class MyCustomField : SPFieldText {
    
    public MyCustomField(SPFieldCollection fields, string fieldName) 
        : base(fields, fieldName) {
    }

    public MyCustomField(SPFieldCollection fields, string fieldName, string displayName) 
        : base(fields, fieldName, displayName) {
    }

    public override BaseFieldControl FieldRenderingControl {
        get {
            BaseFieldControl fldControl = new MyCustomFieldControl();
            fldControl.FieldName = InternalName;
            return fldControl;
        }
    }
}

Register the field type class
Once the field type class is implemented and the assembly is deployed to your web frontend, you will need to register this new field type with the SharePoint runtime. To do this you need to add an xml configuration file to the 12/Template/XML directory named fldtypes_<custom name>.xml where <custom name> is a unique name associated with your customization. You can also view the default SharePoint field types registration XML configuration files in this directory.
```
<FieldType>
    <Field Name="TypeName">My Custom Field</Field>
    <Field Name="ParentType">Text</Field>
    <Field Name="TypeDisplayName">My Custom Field</Field>
    <Field Name="TypeShortDescription">My Custom Field</Field>
    <Field Name="FieldTypeClass">MyCustomField, MyCustomFieldAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a1df43608d339111</Field>
    <Field Name="UserCreatable">TRUE</Field>
</FieldType>
```

Now that the field type is registered with SharePoint, you should now be able to create a new site column or list field based on this new custom field type.

HOW TO: Customize the web.config with a SharePoint XML customization

2008-01-16T11:19:00.000-08:00

It is possible to manipulate the web.config file globally by using a little known feature in SharePoint that allows developers to describe a set of changes by using an XML customization file. In fact, both SharePoint and MOSS use this mechanism to publish web.config changes when a web application is created.

Create the customization file
The customization file is used by SharePoint to apply changes to the web.config file when a web application is created. Any changes that are inside the customization file will be applied to all web applications globally. This method of customization does not work for cases where you would like to apply web.config changes to only a specific web application.

In this case I am adding a custom HttpModule to the web.config file. The web.config node will be appended as a child to the configuration/system.web/httpModules node. The id attribute needs to be unique. Everything inside the add node will be appened as a child to the node specified in the path attribute.
```
<?xml version="1.0" encoding="utf-8" ?>
<actions>

    <add 
        path="configuration/system.web/httpModules" 
        id="{8DD2A7B1-0223-4be8-B1B5-339B642EFB21}">
        <add name="MyHttpModule" 
            type="MyHttpModule, MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a1df43608d33992f" />
    </add>

</actions>
```

Copy the customization file to the web front-end
The xml customization file needs to be placed the <sharepoint install root>\12\Config directory and it needs to be named webconfig.<custom name>.xml where <custom name> is a name specified to your customization.

You can take a look at the 12\Config directory to see examples of web.config customizations that are applied by SharePoint and MOSS. You will see that you can not only add nodes to the web.config but also remove or update nodes that exist in the web.config file.

SharePoint Custom Application Development Methodologies

2008-01-07T11:20:00.000-08:00

As SharePoint becomes more prevalent in the custom application development realm, there has been some friction and malcontent expressed in relation to deployment processes, team development methods and application upgrade paths. I believe that Microsoft has fallen short on providing the tools necessary to promote and support custom application development on the SharePoint platform.

In my opinion, the SharePoint platform should not limit nor impede my ability as a custom application developer to deliver solutions that follow the same deployment principals as any other custom asp.net application. As some readers may be aware, at present the standard Microsoft guidance is flawed because it does not fully support repeatable build processes. This is a huge barrier for custom application developers who are accustom to building applications using source control for all assets, build automation and continuous integration. SharePoint as a lot to offer but taking advantage of the platform as a vehicle for custom applications should be more congruent with standard software development practices.

The Microsoft approach

The Microsoft approach dictates that for team development environments, artifacts such as aspx, html, css files or any other file that lives in the content database should be created, stored and version controlled in a SharePoint authoring environment. These artifacts are created and maintained by "content developers". These content developers use SharePoint designer to create and propagate changes to production.

In parallel, custom application developers are to use standard team development principals (source control, etc) to create assemblies that are then promoted to the authoring environment where they are tested and eventually deployed to the production environment.

Read more:
http://msdn2.microsoft.com/en-us/library/bb428899.aspx

Where the Microsoft approach falters

The primary problem with the Microsoft approach is that in many cases there is a hard dependency between artifacts and assemblies. You need to have the same version of artifacts and assemblies to be able to test in any environment and it is not possible get a synchronized version of both sets of assets from a single source. This relegates developers to constantly migrating and updating both content and assemblies to get a consistent version to test. The problem is only compounded because content authors may not be technically able to update assemblies in the authoring environment.

For a custom application of any complexity you need to be able to build and deploy a set of files that work as a unit. For a standard data-driven (SQL Server) asp.net application that means you would have your database creation scripts in source control and when deploying to a new environment (or upgrading an environment), you would run your scripts to create a new copy of the database for that environment. This way, deploying to a test environment becomes easy because you have a repeatable process. Why treat a SharePoint site any differently? You will of course need to use the SharePoint API instead of a SQL database creation script, but the basic function is the same.

A Solution

After working with SharePoint for 6+ years I have found that it is possible to treat a SharePoint custom application as you would any other asp.net custom application. The Microsoft tools (and therefore the approach) fall short on these topics but with some motivation and know-how you can achieve substantial benefits by following these steps:

Use SPDeploy
Ok, this is shamefully self promotional. What I really mean is that you should be using a deployment tool that can support creating customizations inside Visual Studio and deploying those customization via a SharePoint Solution Package (.wsp) to a remote server. There are a few tools that compile a wsp from Visual Studio such as WSPBuilder or Andrew Connell's custom approach. In my opinion SPDeploy is the most complete and easily repeatable solution to solve this problem, but I am biased :)
Create all your SharePoint customizations inside Visual Studio
We are custom application developers and we use Visual Studio solutions. This should not change when you are working on a SharePoint project.
Use source control
Because we now have all of our SharePoint customizations inside Visual Studio, the next logical step is to commit that solution to source control. Read more about the benefits of source control:
http://msdn2.microsoft.com/en-us/library/ms173539.aspx
Design your solution to provision all site collection assets from source control
Provisioning all site collection assets enables you to create your projects site collection from source control at will. This means that when a new developer steps onto your project, he or she can pull a copy of the files from source control and create a site collection that is identical to your site collection. Furthermore because you now have a repeatable site collection provisioning process, when deploying to test you can hand-off your wsp and have a tester create a site instance in no time at all.

Implementing this can be a bit tricky. For a brute force approach you can create a feature that lives at the site level that will provision all sub sites, files, etc. Or if you are adventurous you can create an XML configurable feature that will provision all assets according to a configurable XML file.
Use developer isolated environments
Because we have the infrastructure in place to provision all site collection assets, it is possible to create isolated developer environments. This is the standard development method for any asp.net application and it should not change when developing a custom application on top of SharePoint.
Use continuous integration
This one is somewhat optional but I would strongly recommend using continuous integration on any project. Because of the previous points, continuous integration for a SharePoint project becomes possible. Read more about continuous integration:
http://en.wikipedia.org/wiki/Continuous_integration
Use SharePoint Designer only as a "Immediate Feedback" tool
SharePoint designer should not be used as a primary development tool (as MS suggests) but rather as a tool to quickly and conveniently see changes inside your site instance. Once you are happy with a change, then it should be placed in your Visual Studio solution so that it can participate in source control.

This is usually helpful with rendering assets such as page layouts, XML files, XSLT transforms and stylesheets. It sure is nice to be able to see changes immediately, but be sure to commit your changes to your Visual Studio project (and hence source control) so that they are visible to other developers on the project.

How To: Use SharePoint Explorer View in an ASP.NET page

2007-12-28T11:22:00.000-08:00

For any SharePoint document library there is a default view called "Explorer View". This view displays the the contents of the document library as Windows explorer window that can be used to drag/drop or copy/paste files. This is very handy when transferring large sets of files/folders to a SharePoint document library.

Recently I implemented this view in a custom aspx page. Here's how I did it:

Add the explorer view container to your page. The explorer view uses an iframe as the container for the windows explorer window. Here is what the markup should look like.
```
<iframe id="frmFolder" 
    name="frmFolder" 
    width="600" height="400" 
    src="/_layouts/blank.htm" class="ms-httpFolder">
</iframe>
```

Initialized the explorer view container. Add the following code to your OnLoad page handler to initialize the iframe. In this example I am loading the root folder of the site collection. You can load any SharePoint folder you like.

string js = string.Format(@"
        function navtoframe() {{ NavigateHttpFolderIfSupported('{0}{1}', 'frmFolder'); }} 
        _spBodyOnLoadFunctionNames.push('navtoframe');"
    , SPContext.Current.Site.Url
    , SPContext.Current.Site.RootWeb.RootFolder.ServerRelativeUrl);

Page.ClientScript.RegisterStartupScript(GetType(), "frmFolder", js, true);

The NavigateHttpFolderIfSupported method is defined in the core.js file, which is a part of the SharePoint infrastructure and is associated with all SharePoint pages.

Using .NET Reflector as SharePoint documentation

2007-12-28T11:21:00.000-08:00

Here is something that has proven invaluable to me when trying to get a leg up as a consultant with the SharePoint platform. Use .NET Reflector to deduce how the SharePoint API is implemented.

For the uninitiated, .NET Reflector is a free (and most excellent) tool written by Lutz Roeder that uses the reflection features built into the .NET framework to allow you to browse and even decompile any assembly. Yes! It's true you can open any assembly in reflector and see the source code. With only minimal trade-offs this allows you to see the author's implementation. In terms of SharePoint this means that you have a ton of examples at your fingertips. All you have to do is open the SharePoint assemblies and/or executables in Reflector to see how they are implemented.

There is one situation where this approach isn't viable. Assemblies can be "obfuscated" which means that all private methods/properties/fields are scrambled such that they are not readable by humans. In general this is a tactic used by commercial software companies to protect trade secrets. Thankfully (and I mean thank god!) the SharePoint team decided not to obfuscate their assemblies. There are minor exceptions, some security related code is obfuscated, but 99.9% of all SharePoint assemblies and executables can be decompiled.

Let's face it, the SharePoint documentation is not that great. Yes, there are some decent examples, but there are also lots of things like "SPWeb.Update() : Updates the web." This is not going to be helpful for people like us who are spelunking into the bowels of the SharePoint beast.

Here's an example. I recently had the need to update the farm credentials via the API (don't ask why, just go with me here.) Guess what, stsadm does this function from the command line and stsadm.exe can be decompiled.

Open up Reflector. Drag in stsadm.exe, then navigate to the SPUpdateFarmCredentials operation. Bingo, here's how you update the farm credentials.

Heeeeerrrrrree's Sadie

2007-09-27T15:33:00.001-07:00

On September 19th at 8:05AM we welcomed our second daughter, Sadie Lorraine Simon. She weighed in at 7lb 14oz and 19 inches long. Mother and Baby are doing great. Jennifer and I feel so blessed to have a healthy and happy baby girl. Sadie and Ivy are fast friends and we can't wait to see them grow up together.

Ivy's 1st Birthday Party

2007-07-04T08:51:00.001-07:00

Last Saturday we celebrated Ivy's first birthday and Dad's 33rd birthday. After being sick all week Ivy got well just in time to partake in some cake and charm the pants off everyone in the room :) Thanks to everyone who made it out to our home in Snoqualmie for the festivities.

Tanner Jeans Bike Rodeo 2007

2007-06-23T14:24:00.003-07:00

The Tanner Jeans Bike Rodeo was held today. Kids from Snoqualmie came out to get training from police officers on bike safety. The turn out was great and by all accounts everyone had a great time. Here are the photos...

Long Time Gone

2007-06-16T15:48:00.001-07:00

I have been away from this blog for a long time but I am back and I plan to make updates much more frequently. Here's the highlights since the last time that I posted:

Ivy Arrives! On June 25th 2006 at 11:15 AM we welcomed Ivy Haliday Simon to our family. Jennifer and I feel so blessed to have such a beautiful little girl. For me, It has been fantastic to experience being a father to such wonderful child. She is growing fast! She will be turning 1 year old in just a 2 weeks. More Ivy Pictures.
New House on Snoqualmie Ridge. In December 2005 we moved from our home in Kirkland, WA to Snoqualmie, WA. We were lucky enough to find a home prior to construction, so we were able to participate in the process of picking materials, etc. The house has been a great change considering that Jennifer's parents and her brother's family are also in the neighborhood (Built in babysitters!).
Crystal gets hitched. Yes, it's true my little baby sister is married. The ceremony was held in Punta Cana, Dominican Republic on May 12, 2007. We had lots of fun at the resort, most people arrived at least a few days early for some fun in the sun. About 25 friends and family attended the wedding. The reception was on a catamaran while we were serenaded by a local band. I am so happy to have a new brother-in-law but most of all it's great to see Crystal so happy. Welcome to the family JB! More Wedding Pictures
Baby No. 2 on the way. 3 Months ago we found out that baby No. 2 is on the way! Jennifer and I are so happy that Ivy will be a big sister. With the 2 kids only 15 months apart, they will have a close relationship. We can't wait!

Journeymen 2005 : The Wonderland Trail Conquest

2005-07-28T13:25:00.000-07:00

Our annual Jouneymen trip is complete! This year we took on the Wonderland Trail in Mt Rainier National Park. It is rated #1 by serveral pubications for it's natural rugged beauty. The trail is a loop that measures 92.2 miles with an elevation gain/loss of 28,800 feet. After completing the trail a person has done the equivalent of climbing Mt Rainier 2.5 times. Beleive me, this is one tough trail but we have conquered it in just 8 days! Mike, Keith, Jeff and I started out at Longmire on July 18th on a (rare) sunny day in the seattle area. To our amazement the sunny skies continues through most of the trip. We only got rained on for a single morning. The mountain was magnificent against the flowered meadows and blue-bird skies. See the pictures here.

Snow in Seattle!

2005-01-09T11:56:00.000-08:00

Today Jennifer and I woke up to 3 inches of snow this morning! Kaisa loved the snow down at the park. Here are the pictures.

Wedding Pictures

2005-01-06T19:40:00.000-08:00

Well, our joyous event happened on November 26, 2004. Yep, day after thanksgiving, that oughta help me remember the date. Wait, Thanksgiving is a different day every year. Scratch that. Here's the wedding photos.

Over all we had a great day. The wedding was at the Desert Springs Marriot in Palm Springs California. The ceremony was held at what is called “The Point”. At sunset the ceremony started and of couse the setting was amazing. Jennifer was truly stunning and we were blessed to have all of our friends and family in attendance.

My First Post

2005-01-06T17:18:00.000-08:00

Here’s my first post to my blog. I plan to write about myself and my life here. I know, exciting stuff! But generally it’s nice to have a place where I can tell my family (Hi Mom!) and long forgotten friends to visit.