Below is the code I am now using to create my RenderPartialToString method:

/// Static Method to render string - put somewhere of your choosing
public static string RenderPartialToString(string controlName, object viewData)
{
     ViewDataDictionary vd = new ViewDataDictionary(viewData);
     ViewPage vp = new ViewPage { ViewData = vd };
     Control control = vp.LoadControl(controlName);

     vp.Controls.Add(control);

     StringBuilder sb = new StringBuilder();
     using (StringWriter sw = new StringWriter(sb))
     {
         using (HtmlTextWriter tw = new HtmlTextWriter(sw))
         {
             vp.RenderControl(tw);
         }
     }

     return sb.ToString();
}

As you can see, this method is much shorter and doesn’t have any sort of additional library contingencies. Pass it a path reference to your partial view and ViewData object (maybe you want that, maybe you don’t) and away you go. The following is an example of how to call the above method from your controller:

// Controller Method
public string Create()
{
     {...}
     var viewData = new SomeViewData { Note = n };

     string s = RenderPartialToString("~/Views/Clients/Notes/ClientNotesRow.ascx", viewData);

     return s;
}

That’s all there is to it!

Be sure to check out the first post in our GridView series, which explains and provides code to render your GridView, including sorting and paging

In my last GridView post, I explained how BrightMix solved the problem of creating sortable, paging GridViews in ASP.NET MVC. In this post, I’ll show you how we took advantage of the urls generated by the grid to maintain the state of the grid across postbacks.

When we set out to write this code, we started with the basics. We knew that we needed to create an html helper that would append the “RedirectUrl” to a url (when a user leaves a grid to view an item’s details, for example), and another helper to read that same url and send the user back to the previous page, with their grid state in tact.

The code for our “AddRedirectHyperLink” is fairly straightforward. As with the paging and sorting, we rely heavily on our custom query string helpers to do the bulk of the work.

public static string GenerateRedirectUrl(RedirectProperties properties)
{
     string redirectUrl = HttpContext.Current.Request.Path;

     string qString = QueryString.SetValues(new NameValueCollection(), HttpContext.Current.Request.RawUrl);

     if (qString.Length > 0)
          redirectUrl += "?" + qString;

     if (!properties.Href.Contains("?"))
          properties.Href += "?";
     else
          properties.Href += "&";

     properties.Href += string.Format("{0}={1}", RedirectKey, HttpUtility.UrlEncode(redirectUrl));

     return properties.Href;
}

The tag on the view is also fairly straightforward. In order to generate the link, we have to populate the RedirectProperties class with the appropriate values for the text and url.

<%=Html.AddRedirectHyperLink(new RedirectProperties { Href=Url.RouteUrl("Default",
     new { action="View", controller="Home", id=c.Id}), Text="View Details" }) %>

Once we had the redirect information added to the url, we needed a way to read it back out of the url, and send the user back to their previous page.

public static string ReadFromRedirectUrl(RedirectProperties properties)
{
    string url = string.Empty;
    string redirectURL = QueryString.GetString(RedirectKey);
    if (!string.IsNullOrEmpty(redirectURL))
    {
        if (redirectURL.Contains("?"))
        {
            int i = redirectURL.IndexOf("?") + 1;
            NameValueCollection collection = QueryString.CreateRedirectNameValueCollection(HttpContext.Current.Request.QueryString[RedirectKey]);
            string qs = QueryString.FormatQueryString(collection);
            redirectURL = redirectURL.Substring(0, i) + qs;
        }

        url = redirectURL;
    }
    if (string.IsNullOrEmpty(url))
    {
        if (!string.IsNullOrEmpty(properties.BackupHref))
            url = properties.BackupHref;
    }

    return url;
}

The last step was to add the “ReadRedirectHyperLink” to our view and edit pages. You’ll notice we added an optional backup url. On the off chance the user landed on a page with out a redirect in their querystring, we don’t want the site to blow up.

<%= Html.ReadRedirectHyperLink(new RedirectProperties
    { Text = "Back", BackupHref = Url.RouteUrl("Root", new { action = "Index", controller = "Home" }) })%>

Click Here To Download The Code

Advantages of EC2

We chose EC2 primarily because it would give us the ability to have automated and cheap server scaling. Specifically, you can create and shut down server instances through the EC2 API. This allows you to programmatically scale your web application from zero to any number of servers based on necessity (if you got techcrunched, for instance, you’d probably need a lot) and you only pay for what you use. If you’re interested in more details about EC2 scaling, check out Dusty’s presentation.

Other good things about EC2:

• Ability to build an image (AMI) of an existing instance. Once built, you can create any number of clones of your existing instance in just a few minutes. Since it’s a copy, you don’t have to install OS libraries, packages, patches, or otherwise on the instance. Very groovy.
• Very active developer community around hosting on EC2. There are a lot of people using EC2 and building stuff around it.
• It’s very affordable and competitively priced. One small EC2 instance runs about $100/month if you keep it on all the time.

Drawbacks and Disadvantages of EC2

Here are a few of the disadvatanges we’ve seen and experienced with EC2.

Server Configuration Woes

As it turns out, it can be a real pain in the ass to set up and configure a Rails app in the cloud all by yourself. We leveraged a really sweet Rails plugin called EC2OnRails, which automates the setting up an EC2 instance for Rails hosting. EC2OnRails, doesn’t, however, help you do any sort of automatic dynamic scaling. For that, you’d need to go for something like Scalr or RightScale.

Unrecoverable Instances

If you manage to mess up your instance’s boot sequence, networking or routing configurations, or SSH server, you can easily exile yourself from an instance. More specifically, you won’t be able to log into it and fix whatever you broke. Your only options are to get support from Amazon (generally unreliable and slow from our experience) or build a new instance. Yeah, I had this happen to me a few times – one time in particular it was as a result of installing some innocent Ubuntu OS updates. That was a real bummer.

Random Loss of your Instances!

We’ve never had an instance vanish on us; we’ve actually had a few instances that have been running for upwards of a year now. However, there is always the looming possibility of one just going poof and being gone forever. So, if you want to roll in the EC2 cloud, you need to be able to quickly rebuild a lost instance.

What Caused us to Move Tripleseat

When we launched Tripleseat, we really had no idea how many users we’d have on the site all at once and how much they’d tax the server. After selling the app for several months, it became apparently that Tripleseat’s growth was going to be fairly steady and predictable. No techcrunching or YouTube-esque traffic patterns. As a result, the primary reason we chose EC2–the ability for Tripleseat to scale an infinite number of servers–wasn’t justified. 37Signals basecamp app grew in a similar fashion:

“We ordered a dedicated server from our original web hosts at Tilted and turned it on. Basecamp ran on that single dedicated box for a year. One server, one year.” -Jason Fried

Hosting Your App on One EC2 Instance is Dangerous

Back in December, our Tripleseat EC2 instance disappeared from the Internet for around an hour. There was no reason for it–we just couldn’t access tripleseat.com–and neither could our customers. Our recovery strategy was to launch a new instance from a prebuilt image, deploy the code to it, and populate the new database from backups on Amazon S3. As it turns out, this strategy means you are destined to have downtime for at least a while. We lucked out, though, as our original EC2 instance magically reappeared. But it was certainly a scary situation, and our customers were less than happy.

Overall Lessons Learned

1. If you don’t know how much traffic or bandwidth your app will require, go with a more simple and secure hosting solution. You can always ramp up. (Slicehost, dreamhost, mediatemple are all good.)
2. If you want to roll on the EC2 Cloud, don’t store data on the instance or, if you do, back it up frequently (like every 5 minutes). Additionally, make an AMI of your instance so they can be easily recreated and/or cloned.
3. Unless you can dedicate quite a bit of time to configuring, running, and monitoring EC2 instances, I’d recommend a less risky hosting solution that provides immediate support and full, automated server backups.

Update! RenderPartial to String has become much easier in ASP.NET MVC, see the new post here!

We usually don’t post much about hardcore programming-related things here, but this is an exception to the rule.

We’re primarily a Ruby on Rails shop, but we still do ASP.NET development fairly regularly. Our overall interest in ASP.NET was waning until the new ASP.NET MVC framework was released. ASP.NET MVC brings a number of the concepts we love from Rails into the ASP.NET arena.

However, one limitation we’ve come across with ASP.NET MVC is the lack of ability to render a partial to a string. This is really handy if you’re doing Ajax things; it also happens to be one of the things we really love about Rails. Additionally, it’s a feature others have been wanting, too, see here and here.

Well, the good news is I have a solution for at least some of you out there. I’ve cobbled together a few concepts from various sources and forum posts to make it all happen. Here is how you can render a view into a string.

First, you need to include these files in your project, both are from the MvcContrib project.

Download BlockRender.cs – from MvcContrib

using System;
using System.IO;
using System.Web;
using System.Collections.Generic;

namespace MvcContrib.UI
{
    /// <summary>Renders an Action delegate and captures all output to a string. </summary>
    public class BlockRenderer
    {
        private readonly HttpContextBase _httpContext;

        public BlockRenderer(HttpContextBase httpContext)
        {
            _httpContext = httpContext;
        }

        public partial class HttpResponse
        {
            public bool UsingHttpWriter { get { return true; } }
        }

        /// <summary>Renders the action and returns a string.</summary>
        /// <param name="viewRenderer">The delegate to render.</param>
        /// <returns>The rendered text.</returns>
        public string Capture(Action viewRenderer)
        {
            HttpResponseBase resp = _httpContext.Response;
            Stream originalFilter = null;
            CapturingResponseFilter innerFilter;
            string capturedHtml = "";

            if (viewRenderer != null)
            {
                try
                {
                    resp.Flush();
                    originalFilter = resp.Filter;
                    innerFilter = new CapturingResponseFilter(resp.Filter);
                    resp.Filter = innerFilter;
                    viewRenderer();

                    resp.Flush();
                    capturedHtml = innerFilter.GetContents(resp.ContentEncoding);
                }
                finally
                {
                    if (originalFilter != null)
                    {
                        resp.Filter = originalFilter;
                    }
                }
            }
            return capturedHtml;
        }
    }
}

Download CapturingResponseFilter.cs – from MvcContrib

using System.IO;
using System.Text;

namespace MvcContrib.UI
{
    public class CapturingResponseFilter : Stream
    {
        private Stream _sink;
        private MemoryStream mem;

        public CapturingResponseFilter(Stream sink)
        {
            _sink = sink;
            mem = new MemoryStream();
        }

        // The following members of Stream must be overriden.
        public override bool CanRead
        {
            get { return true; }
        }

        public override bool CanSeek
        {
            get { return false; }
        }

        public override bool CanWrite
        {
            get { return false; }
        }

        public override long Length
        {
            get { return 0; }
        }

        public override long Position { get; set; }

        public override long Seek(long offset, SeekOrigin direction)
        {
            return 0;
        }

        public override void SetLength(long length)
        {
            _sink.SetLength(length);
        }

        public override void Close()
        {
            _sink.Close();
            mem.Close();
        }

        public override void Flush()
        {
            _sink.Flush();
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            return _sink.Read(buffer, offset, count);
        }

        // Override the Write method to filter Response to a file. 
        public override void Write(byte[] buffer, int offset, int count)
        {
            //Here we will not write to the sink b/c we want to capture

            //Write out the response to the file.
            mem.Write(buffer, 0, count);
        }

        public string GetContents(Encoding enc)
        {
            var buffer = new byte[mem.Length];
            mem.Position = 0;
            mem.Read(buffer, 0, buffer.Length);
            return enc.GetString(buffer, 0, buffer.Length);

        }
    }
}

With the above two files included in your project, you’re almost ready to go. Now you just need to include a method that makes all the magic happen (more easily). As seen in the example below, define the RenderPartialToString() and then call it from your controller:

/// Static Method to render string - put somewhere of your choosing
public static string RenderPartialToString(string userControl, object viewData, ControllerContext controllerContext)
{
    HtmlHelper h = new HtmlHelper(new ViewContext(controllerContext, new WebFormView("omg"), null, null), new ViewPage());
    var blockRenderer = new BlockRenderer(controllerContext.HttpContext);

    string s = blockRenderer.Capture(
        () => RenderPartialExtensions.RenderPartial(h, userControl, viewData)
    );

    return s;
}

/// Your Controller method...  
public ActionResult MakeStringForMe()
{
    var objectViewData = new objectViewData { SomeString = "Dude", SomeNumber = 1 };

    string s = RenderPartialToString("~/Views/Controls/UserControl.ascx", objectViewData, this.ControllerContext);

    View();
}

With a little bit of luck and good fortune, it should work and you’ll be rendering partials to strings like a machine!

How It All Works

Basically, it’s using the Response object to render a usercontrol and capture the output into a string. Then, it filters that rendered content out of the response with some fancy trickery. All in all, it’s definitely a hack, but it gets the job done—at least until the Microsoft team can address this issue at its core (hint hint).

A Few Limitiations and/or Questions

I read somewhere that this might not work if you need to retrieve things out of the session. I have not verified this.

Additionally, I have no idea what effects using this approach will have on the large-scale performance of an app. It hasn’t caused any problems for the application I’m using it on.

Lastly, you cannot specify the ContentType on the response. If you do, you’ll get an exception:

Server cannot set content type after HTTP headers have been sent

This seems to be a limitation that results from rendering a usercontrol. This will be problematic if you want your controller to return data with a ContenType of, say, “text/javascript.” I ran into this problem while building a Rails-like RJS framework (see below), but managed to deal with it fairly elegantly.

Rails-like RJS for ASP.NET MVC

In line with the ability to RenderPartial to string, I’ve also put together a Rails-like RJS framework for ASP.NET MVC. Simply put, RJS is a framework that renders and builds dynamic javascript on the server. Similar to Rails’ RJS, it’s specific to the Prototype framework – sorry JQuery guys (for what it’s worth, it could probably be easily ported to JQuery!).

Here’s a quick snippet of what this allows you to do from your Controller:

// Example Usage in your Controller:
public ActionResult HideElement(string elementId)
{
    RjsResult r = new RjsResult();
    r.Effect(elementId, RjsResult.EffectTypes.Hide);

    return r;
}

// A more complicated but powerful example of returning the contents of two UserControls and inserting them into two different <div>'s
public ActionResult InsertUserControl()
{
    ObjectViewData viewData = new ObjectViewData { SomeString = "dude", SomeNumber = 1 };

    var r = new RjsResult();
    r.Insert("div_one", RjsResult.Positions.Top, "~/Views/Controls/UserControl1.ascx", ObjectViewData, ControllerContext);
    r.Insert("div_two", RjsResult.Positions.Bottom, "~/Views/Controls/UserControl2.ascx", ObjectViewData, ControllerContext);

    return r;
}

In both of the above examples, I’m calling a few different methods on the RjsResult object. Behind the scenes, the RjsResult object is building up a string of javascript commands that make all the magic happen in the user’s browser. If you’re still confused, I suggest you read this page from the Rails documentation, which might explain the concept better.

With that said, here is the code for my ASP.NET MVC RJS framework!

Download RjsResult.cs

namespace System.Web.Mvc
{
    using System;
    using System.Text;
    using System.Web;
    using System.Collections.Generic;
    using System.Security.Policy;
    using System.Web.Script.Serialization;
    using MvcContrib.UI;
    using System.Web.Mvc.Html;

    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    public class RjsResult : ActionResult
    {
        #region Constructors
        public RjsResult(bool setContentType)
        {
            Actions = new List<IRjsActionBase>();
            this.SetContentType = setContentType;
        }

        public RjsResult() : this(false)
        {
        }
        #endregion

        #region Private Vars
        private bool SetContentType { get; set; }

        private List<IRjsActionBase> Actions
        {
            get;
            set;
        }

        #endregion

        #region Rjs Actions
        public interface IRjsActionBase
        {
            string Render();
        }

        private class RjsUpdateAction : IRjsActionBase
        {
            public RjsUpdateAction(string element, string contents)
            {
                this.element = element;
                this.contents = contents;
            }

            public string element { get; set; }
            public string contents { get; set; }

            #region IRjsActionBase Members

            public string Render()
            {
                if (!contents.StartsWith("\""))
                    contents = "\"" + contents + "\"";

                return string.Format("Element.update(\"{0}\", {1});", element, contents);
            }

            #endregion
        }

        private class RjsInsertAction : IRjsActionBase
        {
            public RjsInsertAction(string element, Positions p, string contents)
            {
                this.element = element;
                this.contents = contents;
                this.position = p;
            }

            public string element { get; set; }
            public string contents { get; set; }
            public Positions position { get; set; }

            #region IRjsActionBase Members

            public string Render()
            {
                if (!contents.StartsWith("\""))
                    contents = "\"" + contents + "\"";

                return string.Format("Element.insert(\"{0}\", {{{1}: {2} }});", element, position, contents);
            }

            #endregion
        }

        private class RjsStringAction : IRjsActionBase
        {
            public string contents { get; set; }

            public RjsStringAction(string contents)
            {
                this.contents = contents;
            }

            #region IRjsActionBase Members

            public string Render()
            {
                return this.contents;
            }

            #endregion
        }

        private class RjsShowAction : IRjsActionBase
        {
            public RjsShowAction(string element)
            {
                this.element = element;
            }
            public string element { get; set; }

            #region IRjsActionBase Members

            public string Render()
            {
                return string.Format("$(\"{0}\").show();", element);
            }

            #endregion
        }

        private class RjsAlertAction : IRjsActionBase
        {
            public RjsAlertAction(string message)
            {
                this.message = message;
            }
            public string message { get; set; }

            #region IRjsActionBase Members

            public string Render()
            {
                return string.Format("alert('{0}');", message);
            }

            #endregion
        }

        private class RjsHideAction : IRjsActionBase
        {
            public RjsHideAction(string element)
            {
                this.element = element;
            }
            public string element { get; set; }

            #region IRjsActionBase Members

            public string Render()
            {
                return string.Format("$(\"{0}\").hide();", element);
            }

            #endregion
        }

        private class RjsRemoveAction : IRjsActionBase
        {
            public RjsRemoveAction(string element)
            {
                this.element = element;
            }
            public string element { get; set; }

            #region IRjsActionBase Members

            public string Render()
            {
                return string.Format("$(\"{0}\").remove();", element);
            }

            #endregion
        }

        private class RjsEffectAction : IRjsActionBase
        {
            public RjsEffectAction(string element, EffectTypes effect, KeyValuePair<string, string>[] options)
            {
                this.options = new Dictionary<string, string>();

                if (options != null)
                {
                    foreach (KeyValuePair<string, string> pair in options)
                        this.options.Add(pair.Key, pair.Value);
                }

                this.element = element;
                this.effect = effect;
            }

            public string element { get; set; }
            public EffectTypes effect { get; set; }
            public Dictionary<string, string> options { get; set; }

            #region IRjsActionBase Members

            public string Render()
            {
                string ret = string.Format("new Effect.{0}(\"{1}\"", effect.ToString(), element);
                ret += ", {";

                foreach (string key in options.Keys)
                {
                    ret += string.Format("{0}: {1}", key, options[key]);
                }
                ret += "});";

                return ret;
            }

            #endregion
        }

        /// <summary>
        /// Call me from your controller and pass me your ControllerContext and I'll render a UserControl for you and return the contents as a string!
        /// </summary>
        /// <param name="userControl"></param>
        /// <param name="viewData"></param>
        /// <param name="controllerContext"></param>
        /// <returns></returns>
        private string RenderPartialToString(string userControl, object viewData, ControllerContext controllerContext)
        {
            HtmlHelper h = new HtmlHelper(new ViewContext(controllerContext, new WebFormView("omg"), null, null), new ViewPage());
            var blockRenderer = new BlockRenderer(controllerContext.HttpContext);

            var r = new RjsResult();
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            string s = blockRenderer.Capture(
                () => RenderPartialExtensions.RenderPartial(h, userControl, viewData)
            );

            return serializer.Serialize(s);
        }
        #endregion

        #region Fun Enums
        public enum Positions
        {
            Before = 1,
            After,
            Top,
            Bottom
        }

        public enum EffectTypes
        {
            Appear = 1,
            Fade,
            SlideDown,
            SlideUp,
            Shake,
            Highlight
        }
        #endregion

        #region Rjs Methods
        /// <summary>
        /// Renders a user control and inserts the contents into specified element
        /// </summary>
        /// <param name="element"></param>
        /// <param name="p"></param>
        /// <param name="userControl"></param>
        /// <param name="viewData"></param>
        /// <param name="controllerContext"></param>
        public void Insert(string element, Positions p, string userControl, object viewData, ControllerContext controllerContext)
        {
            Insert(element, p, RenderPartialToString(userControl, viewData, controllerContext) );
        }

        /// <summary>
        /// Inserts content into specific element
        /// </summary>
        /// <param name="element"></param>
        /// <param name="p"></param>
        /// <param name="contents"></param>
        public void Insert(string element, Positions p, string contents)
        {
            Actions.Add(new RjsInsertAction(element, p, contents));
        }

        /// <summary>
        /// Update a part of the page by rendering a user control
        /// </summary>
        /// <param name="element"></param>
        /// <param name="userControl"></param>
        /// <param name="viewData"></param>
        /// <param name="controllerContext"></param>
        public void Update(string element, string userControl, object viewData, ControllerContext controllerContext)
        {
            Update(element, RenderPartialToString(userControl, viewData, controllerContext));
        }

        public void Update(string element, string contents)
        {
            Actions.Add(new RjsUpdateAction(element, contents));
        }

        /// <summary>
        /// Alert some text
        /// </summary>
        /// <param name="message"></param>
        public void Alert(string message)
        {
            Actions.Add(new RjsAlertAction(message));
        }

        /// <summary>
        /// Render some javascript code.. whatever you want
        /// </summary>
        /// <param name="contents"></param>
        public void RenderString(string contents)
        {
            Actions.Add(new RjsStringAction(contents));
        }

        /// <summary>
        /// Shows an element
        /// </summary>
        /// <param name="element"></param>
        public void Show(string element)
        {
            Actions.Add(new RjsShowAction(element));
        }

        /// <summary>
        /// Hides an element
        /// </summary>
        /// <param name="element"></param>
        public void Hide(string element)
        {
            Actions.Add(new RjsHideAction(element));
        }

        /// <summary>
        /// Delets an element
        /// </summary>
        /// <param name="element"></param>
        public void Remove(string element)
        {
            Actions.Add(new RjsHideAction(element));
        }

        /// <summary>
        /// Calls an effect of type EffectTypes, also takes array of prototype options
        /// </summary>
        /// <param name="element"></param>
        /// <param name="effect"></param>
        /// <param name="options"></param>
        public void Effect(string element, EffectTypes effect, KeyValuePair<string, string>[] options)
        {
            Actions.Add(new RjsEffectAction(element, effect, options));
        }
        public void Effect(string element, EffectTypes effect)
        {
            Actions.Add(new RjsEffectAction(element, effect, null));
        }

        #endregion

        #region ActionResult Override
        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpResponseBase response = context.HttpContext.Response;

            if (this.SetContentType)
                response.ContentType = "application/javascript";

            string result = string.Empty;

            foreach (IRjsActionBase action in Actions)
            {
                result += action.Render();
            }

            response.Write(result);
        }
#endregion
    }
}

One Major Gotcha

A trick to getting this to work with Prototype’s Ajax.Request is the ContentType of the returned data needs to be of type “text/javascript” in order for it to automatically be evaluated as javascript. However, you can get around this by forcing Prototype to evaluate the response data as javascript via the EvalJS: ‘force’ parameter.

So that’s it. A working way to RenderPartial to a string on the server-side and also the startings of a Rails-like RJS framework for ASP.NET MVC!

Thoughts, comments, patches or otherwise are appreciated!

It’s not about the technology - its about experience.

Funny thing is, here we are two years later, and we’re finally building the product… Interestingly, this is still exactly the vision and direction that we’re taking things. I encourage you to do the same… Though this was initially for our webapp, I truly believe that this stuff transfers. Reader’s Digest version:

Be 100 percent about the user. Provide value. Be awesome.

• Happy users = returning users = more traffic
• Happy users tell their friends
• Happy users don’t get frustrated, and spend more time on site
• How to make happy user?
  • Site easy on the eyes
    • No BLINKING ADS!
  • Don’t FORCE ADS DOWN THEIR THROATS
    • Google taught us that RELEVANT, unobtrusive ads can be VERY PROFITABLE
    • Annoying ads are not good for the advertiser OR the user
  • Actually RELEVANT, USEFUL CONTENT will drive the MOST TRAFFIC
    • Make a site that people actually WANT TO USE
  • Provide them with the information that they WANT
    • Provide value, and the people will come
    • Provide value, and the people will tell other people.
  • Provide them with USEFUL INFORMATION
    • Don’t just put information “just because”
    • Give serious thought to providing VALUE to the user in every area of the site.
      • Why is the user visiting the ??? section? Am I solving his/her needs?
  • Make it EASY
    • On the internet, it’s EASY for a user to go somewhere else.
    • Make the site EASY TO USE, or they will leave, and go to a competitor whose site IS easy to use
      • Don’t assume that they will stay because of your BRAND, or because of your MONOPOLY.

You see, we’re deeply committed to many of the ideas that Joel Spolsky has set forth. I guess you could say we drank the Koolaid – and liked it.

For the last five years I’ve been testing that theory in the real world. The formula for the company I started with Michael Pryor in September, 2000 can be summarized in four steps:

Best Working Conditions

→

Best Programmers

→

Best Software

→

Profit!

It’s a pretty convenient formula, especially since our real goal in starting Fog Creek was to create a software company where we would want to work. I made the claim, in those days, that good working conditions (or, awkwardly, “building the company where the best software developers in the world would want to work”) would lead to profits as naturally as chocolate leads to chubbiness or cartoon sex in video games leads to gangland-style shooting sprees.

It’s one thing to pay lip service to providing this kind of environment, and as such I think lots of companies would say that they are “developer oriented.” I mean, everyone wants to hire the best-of-the-best, but how many companies actually do what it takes? Kevin and I think that in Omaha, this concept is truly unique. We believe that the top developers can choose to work where they want, and we want them to choose to work here.

So, What Do Developers Want?

Different folks have different desires, but, as developers and previous employees ourselves, we’re pretty clued in on what it takes to keep developers happy… and how far most companies are willing to go to see that happen. Here are some example developer requests we’ve witnessed or made, followed by a typical response from ol’ Corporation XYZ and then BrightMix’s response.

Developer: I’d like a comfy chair since I’m sitting for numerous hours every day!

Corporation XYZ: No. Then your chair wouldn’t match the rest of the chairs in the office.

BrightMix: Let’s go shopping!

Developer: I’d like dual monitors.

Corporation XYZ: Those are only given to managers and people of higher importance.

BrightMix: Dual 24” LCD’s are standard issue here. Actually, we can probably get you a 3rd.

Developer: Will you buy me this programming book off Amazon?

Corporation XYZ: Maybe, and only if it relates to what you’re currently doing. We can put in an order and have it here in 6 months.

BrightMix: Go for it. Here’s the company card.

Developer: Free Lunch, Soda, and Snacks?

Corporation XYZ: Egregious!

BrightMix: Have all the snacks and soda you want. We’ll even buy you the types that you like. Also, the company will buy you lunch frequently.

See where I’m going here? And really, it’s not just about money or other tangible things, it’s about providing things that the top 1% of developers want and deserve. This will keep them feeling challenged, important, satisfied, and happy. Some examples:

• Want challenging problems to solve? You got it.

• Want to create a whiz-bang ajaxy spell-checking thing-a-ma-jig? Go for it.

• Want to use the latest and greatest technologies? How ‘bout Ruby on Rails, or ASP.NET MVC, or The Next Big Thing?

Office Environment

On top of all of these things, we’re also trying to foster an environment that’s – gasp – FUN. We believe its possible to have fun at work; it shouldn’t be a place you dread going, but, rather, work should be a place that you want to go. Sure we’ll work hard, but we’ll play hard just the same, and nobody’s working 100 hour weeks (40 hour weeks are the norm). Again, Joel says it best:

The office should be a hang out: a pleasant place to spend time. If you’re meeting your friends for dinner after work you should want to meet at the office. As Philip Greenspun bluntly puts it: “Your business success will depend on the extent to which programmers essentially live at your office. For this to be a common choice, your office had better be nicer than the average programmer’s home. There are two ways to achieve this result. One is to hire programmers who live in extremely shabby apartments. The other is to create a nice office.”

In this regard, we’re already well on our way. We’ve acquired an office space that doesn’t look anything like the typical cubicle farm office building. We like to think it has a warm and cozy feel to it, and we want to outfit it with various fun amenities. There’s already a pool table/ping-pong table, and we’ve got plans for a dartboard and a Nintendo Wii. Of course, we’re also open to suggestions

Great place to work = Great developers

Simply put, as we look forward at our company’s future success, we realize that greatly relies on us hiring the right people. Thus, we want to have the very best developers around working for us, and in order to find, hire and retain these developers, we’re creating the type of environment that they’re going to love.

In the coming days, as we prepare to hire our first official employee(s), we’ll be posting quite a bit more on our philosophies regarding hiring, benefits, work environments, and all things related.

More to come…

However, we’re to the point where we need to able to host Ajaxy Ruby on Rails applications. Unfortunately, we discovered that while Dreamhost is sufficient at serving up static files, it’s less than ideal at hosting web applications (especially Rails) where responsiveness and performance are paramount. Arg! a troubling issue.

What’s a software shop to do?

In our search for an alternate hosting service, Slicehost.com was recommended to us. This company specializes in hosting for developers, Ruby on Rails developers in particular. It all sounded good, so we sign up for 1 year of service.

Service that Rocks the Casba

The sign-up process was completely automated and painless. After signing up, I was told that we would have to wait a month for a slice to become available. (They had a shortage of available slices due to demand.) No worries.

A month later, I received an Email indicating that our slice was available and ready for use! At this point, all I had to do was log into their slick dashboard interface, select which linux distro I wanted to use, and click “go.” Minutes later, our slice was up and running with a full Ubuntu install!

Awesome Documentation

Setting up things in linux can be a little tricky since there’s a lot of configuring to be done. Luckily, Slicehost has some really good tutorials and documentation to help you get your web server/applications rockin and/or a rollin’ in no time. I was able to get BrightMix.com moved and running on its new host after only a few hours. It was all pretty seamless.

Long Story Short

We’re extremely satisfied with Slicehost’s pricing and service. BrightMix.com is now approximately 2 gabillion times faster than it was on Dreamhost. If you’re a developer looking for a high-quality, yet affordable, linux-based host, we highly recommend Slicehost.com. It’s simply gravy!

Boo, cubicles!

Simply put, we hate cubicles.

Cubicles suck for jobs that require personal concentration (engineering, accounting, most computer-based jobs, etc.).

As previous software programmers for both large and small companies, we’ve spent plenty of time in the proverbial dilbert‘esque office environment. They exist everywhere, and it gets old… really, really fast. Of course, the reasons why cubicles suck have been repeated and enumerated many times over.

No door leads to mass interruptions and noise pollution

Many experienced cubicle inhabitants will tell you they get the most stuff done in the hours outside of 8-5–when no one else is at the office. It’s really terrible in some office layouts where the programmers are right next to a whole raft of customer service reps whom are on the phone all day.

The private office as a badge

Typically, private offices are relegated to employees of importance or seniority. This is just bogus and unfortunate. Not only does this stink for the lowly employees, but it also reinforces the fact that your organization is built around rank and status. Boo and hiss!

Who likes dull colors and fluorescent lighting, anyway?

There are only so many cubes that can border a window (these cubes are also usually treated as badges). The rest of the cubes are stuck in the middle of the office space, sans sunlight. Couple this with the drab, unexciting color of the cube walls, and you have more of a dungeon than a work space. Nothing says workplace efficiency like a dungeon!

Alternatives to cubicles?

If you’re not in a position to alter your current work environment, there is likely little you can do, aside from bitching and wearing headphones. Joel has some suggestions:

“Look for ways to get out of this environment. Take a laptop to the company cafeteria, where there are lots of tables that are empty most of the day (and nobody can find you). Book a conference room for the whole day… The next time there’s a crunch on and your manager asks you what you need to Get This Done By Tomorrow, you know what to say. They’ll find you an office for the day. And pretty soon they’ll start wondering what they can do to keep that productive thing going year round.

Come into work late and leave late. Those hours after the rest of the company goes home can be the most productive.”

However, if you are in a position of power, we suggest you create as many offices with doors as possible and steal some of the solutions that other successful companies have come up with.

Pixar, for instance, has replaced the lowly cubicle with small sheds/huts, which have a door, are insulated from outside noise, and have a high customization factor. How rad is that?!

What’s the best set up?

There’s no one best set up for all businesses. If you want boring, dull, and lifeless employees, put them in a boring, dull, and lifeless environment (not recommended). However, if you want creative, kick-ass employees, then put them in a creative, kick-ass environment.

Project manager Timmy receives another email from his boss. “We’ve got the go-ahead for software project ‘apples.’ It’s a big project that will take months to complete with a handful of developers. We need to fatten up the programming staff or we’ll never finish in time and we’ll get fired! omg!”

Timmy, having worked on numerous software projects, knows that getting more bodies probably won’t help the project get completed faster. In fact, it will probably make things happen far, far slower.

Aye, but where’s the rub?

The more people involved in a project, the more communication is required to keep everyone up to snuff on things. Communication has to happen between more programmers, project managers, designers, etc. In the end, more time is spent on talking and going to meetings than coding and getting things done… productivity drag, anyone? As Steve McConnell, the author of Code Complete, points out:

Communication flows more easily on small teams than large teams. If you’re the only person on a project, communication is simple. The only communication path is between you and the customer. As the number of people on a project increases, however, so does the number of communication paths. It doesn’t increase additively, as the number of people increases, it increases multiplicatively, proportional to the square of the number of people.

What’s the solution for our friend, Timmy?

We suggest keeping the team for project ‘apples’ lean and focused. Cut out as much fat as possible. Protect the team from looming productivity killers like staff meetings, status report filings, and support tickets. Oh, and load up the team with a free supply of Mountain Dew! A small team of developers, run correctly, will out-perform a large, cumbersome team… hands down.

What if his higher-ups aren’t down with the small team philosophy? That’s rough! Timmy could try pointing them at the plethora of pro-small-team evidence already out there.

BrightMix = Lean!

Dusty and myself have both worked in large development teams and… well, we don’t like it. We like the flexibility and low overhead that our lean-ness gives us in the software development process. Honestly, though, this is the subject for another whole blog post!