Experiment, Adopt, Achieve

I’ve just finished reading Geoffrey Moore’s Dealing with Darwin and while there is a fair amount of content that, as far as I can see, doesn’t necessarily reflect a lot of what is to be found in the academic literature regarding innovation, there is one very important concept tackled that is at the heart of firms’ ongoing desire to actually benefit from innovation initiatives undertaken. This is the concept of “repurposing context for core”.

Context is that required effort to “keep this thing going”. It’s the overhead involved in keeping already existing services and products getting to market. Most obviously it’s the Operations department in most service organisations and the Marketing and Sales department in product organisations. But it’s also everything that supports those departments: Finance, HR, IT, etc. 

Moore talks about the organisational inertia created when increasingly more resources are invested in context than in core. Although he says inertia is not the enemy of innovation (since the inertia of the previous innovation allowed the firm to stay it’s course), it does resist things at the point of change. It is at this point where executive management needs to pay special attention to be able to deconstruct organisational inertia and repurpose the resources it consumes in favour of more innovative undertakings. To this end, companies create new departments with the aim of completely freeing them up from context. Sometimes they go a step further and create an entirely new spinoff company. Read Meeting the Challenge of Dispruptive Change by Christenson and Overdorf for more.

On the other hand, core “is that which differentiates your company to create sustainable competitive advantage”. Moore indicates that while context might outweigh core by organisational resource allocation, but core outweighs context in strategic importance. Putting resources into context pays off next quarter; putting resources into core pays off next year and hopefully for the next few years.

This whole situation can be applied to a software development team as well. We are constantly looking to “repurpose context for core” (or at least reducing the effort and attention required by context) by automating testing, automating deployments, reducing process friction, refactoring to a more agile codebase and reducing wasted effort like not building the right thing or the thing right. Doing these things successfully buys us the ability to spend more time and attention focusing on things that can increasingly set us apart from the mediocre, like better usability and quicker response time to market of newly developed features and products. Of course it is common to find that driving down the effort required by overhead is often done “to make life easier” or to “cut out mistakes” rather than with the explicit goal of freeing up resources to focus on differentiation.

I think it is a compelling argument to begin using time gained by doing things in better ways, to doing things that differentiate your product or service.

“There is no new technology in the iPod.”

- Geoffrey Moore

With January safely put to bed, and with it the threat of making goals that get taken less seriously and have not much chance of survival, I thought I’d blog five sufficiently woolly (read achievable) goals for myself, with the aim of retrospecting come December 2010.

1. Write more: They say writing is a muscle, and I intend to train that muscle more this year. I intend to blog both here and (more frequently) my work team blog to practice writing coherent, readable and perhaps even interesting content.
2. Read more: I was never really a reader until a few years ago but since moving to London where books are a lot more affordable (vs South Africa), it seems counter-intuitive not to make good use of Amazon. Also very compelling but ‘recent’ is  the utterly trivial effort one has to put in to access the top 1% of any particular topic making it so easy to read only the best rated stuff. I am hoping that my Msc will only keep me down to 1 book every month or so.
3. Pick an interesting dissertation subject and start on the research: At the moment I’m thinking about doing something related to Evidence-based Management. Starting a dissertation in the first year of a two-year Msc is ahead of schedule though so this strikes me as a good goal to have.
4. Health and Fitness: Last summer I was going pretty well with sport and gym until I tore my calf muscle playing a tough game of squash. The 3 month layoff after that made me lazy and the Winter has delayed any real come back. This year I want to regain that fitness and stay injury free.
5. Learn more French: I have done some basic courses but I want to attain the next level in the summer with another course. In a few years when I have more time for different things I plan to become conversational, but I’m happy to limit it to 1 step towards that this year.

Well that wasn’t so hard. I guess the hard part is sticking to them! Let’s return in 11 months time to see how I’ve done.

The following is an academic essay prepared for my Msc in Managment at Birkbeck University.

[Update: This essay received 70%]

The following is an academic essay on Knowledge Management prepared for my Msc in Management at Birkbeck University, London.

[Updated 15 Dec with final version]

Organisational Knowledge as One of the Core Assets of our Time:

Implications for Management

by Mark Gibaud

Knowledge is one of the key assets of the intellectually-powered “new” economy. Organisations can achieve critical competitive differentiation if they learn to leverage the collective and cumulative knowledge of their employees. Starting earnestly in the mid 90’s, Knowledge Management (KM) has emerged as the key discipline to support this endeavour, but many organisations have not yet fully recognised the benefits of managing their knowledge due to a poor understanding of the nature of workplace knowledge itself and how to effectively manage its capture, storage and distribution within the organisation. This essay aims to explore the implications for management by illuminating the nature of knowledge in the workplace, how it is generated and how to further amplify its generation such that an organisation can be in a better position to capture and diffuse it. Also highlighted are the compelling reasons as to why knowledge should be managed. Finally, one leading strategy, of moving from “channels” to “platforms”, is more fully explored through the analysis of a new type of “wiki” software.

Knowledge is defined by the Oxford English Dictionary as “expertise and skills acquired by a person through experience or education”. One might think that simply by extending this definition to include the situational context of the workplace, one can then arrive at an accurate assessment of organisational knowledge. However, this is only a part of the story. Organisations amplify knowledge in a number of ways from the cumulative efforts of its staff (Nonaka 1994), potentially creating a knowledge repository contributed to and in turn leveraged by all employees. Michael Polyani popularised the nature of tacit or implicit knowledge which is embodied in an individual and not easily codified or transferred (Polanyi 1966). Later, Ikujiro Nonaka focused on the distinction between tacit knowledge and explicit knowledge, which can be written down and transferred (Ikujiro & Takeuchi 1991). Polyani also argued (1966:55) that all knowledge is either tacit or rooted in tacit knowledge.  Pairing this observation with the fact that the world is full of visible codified knowledge, it follows that tacit knowledge could be further broken down into that which is codifiable, albeit with more intensive effort and management, and that which remains uncodifiable, such as intuition gained from experience, vis-à-vis Polanyi’s “We can know more than we can tell”. Organisations have historically exhibited a high level of explicit knowledge codification such as operational manuals, process documentation and annual financial reports. However, it is the generation, codification and dissemination of knowledge further along the knowledge continuum (Leonard & Sensiper 1999) (that is, increasingly tacit knowledge) that represents the major challenge for contemporary organisations and thus becomes the primary opportunity for knowledge management solutions (Twentyman 2006) (see diagram 1). In turn, the term “Knowledge Management” has many definitions. The common elements of the most-cited definitions centre around defining a strategy for creating, capturing, storing, accessing, and distributing knowledge across individuals, teams and the entire organisation (and sometimes even outside it) in an effort to generate value (increased skill in employees, more innovative products or services, etc) from an organisation’s knowledge-based assets (Stankosky 2005, Davenport et al. 2008, O’dell & Grayson 1998, Rumizen 2001, Brooking 1998).

Nonaka, through the development of his SECI model (Nonaka 1994), argued that organisational knowledge can take on a self-generative nature when knowledge is transferred between tacit and tacit, tacit and explicit, and explicit and explicit states. He argued, after closely studying Japanese firms, that organisational knowledge takes on a “spiral” nature when transferring between these states, inferring that this “knowledge conversion” process serves to continually increase the organisation’s total stock of knowledge as learning becomes embedded in the organisation’s culture. A deeper analysis of Nonaka’s SECI model is beyond the scope of this essay, but the key implication for management is that in order to create a useful knowledge base from which employees may leverage value, an organisation must first take the necessary steps to begin to support and facilitate the generation of that knowledge.

Another useful lens through which to define knowledge is with reference to the Knowledge Hierarchy (Zeleny & von Hayek 1980) or DIKW (Data to Information to Knowledge to Wisdom) taxonomy, if only to assert that while an organisation might record data and make sense of that data turning it to information, gaining knowledge from that information is indeed the next level entirely. Consider when Google asked users in a survey whether they would prefer more search results per page (Millis 2006). Users responded that “more is better”, so Google lengthened the results from 10 to 30 for some users. However, it turned out that the extra half-second that the page took to load drastically decreased user satisfaction such that users conducted fewer searches. Google took the data from the initial survey, turned it to information (a recommendation to provide more search results per page and thereby increase user satisfaction) but then, only after going forward with an experiment, did Google gain the knowledge that users actually far preferred faster load times than more results per page. The lesson here is that the management of knowledge, is very different to the management of mere data and information.

Much reference is also made to the dynamic nature of organisational knowledge (McInerney 2002), in that it is constantly being updated, upgraded and refreshed, and should be regarded and managed as a living entity rather than a static artifact.  Davenport & Prusak argue that knowledge is not only bound to “documents and repositories” but also “routines, processes, practices and norms” (Davenport & Prusak 2000). Knowledge is produced, captured and transferred in many ways, from formal mentoring arrangements, apprenticeships and training programs to informal workplace discussions. Since these workplace practices occur on an ongoing basis, it is imperative that any KM strategy and/or solution needs to facilitate the consistent and continual upgrading and improving of the organisation’s knowledge.

There is broad and growing consensus that the strategic management of knowledge assets contributes directly to an organisation’s competitive advantage (Teece 2000) and is key to providing new products and services (Kessels 2001). On the other hand, neglecting this need leads to organisations suffering redundancy in effort and repeating past mistakes (Garfield 2007). International Data Corporation, a technology research group, reported that a poor capability to manage knowledge cost the Fortune 500 $12 billion per year (Stewart 2001, cited by McInerney 2002). But knowledge cannot be bought in and of itself; rather, it has to be cultivated in-house (Teece 2000) before any opportunity to embed it into new products or services can be fully exploited. The more salient knowledge an organisation has, and the more accessible it is, the more opportunities employees will find to leverage that knowledge in the innovation of new products and services. This will not only  decrease time-to-market and increase quality, but also expand the potential for future improvements to said products and services. It would appear that executives can no longer afford to lack a strategy for managing the collective of their employees’ knowledge.

There are many opportunities to both capture and diffuse knowledge already present in most organisations. Any design, development or engineering of a product is fundamentally a knowledge creation process, and the lessons of bringing a product to market are invariably valuable to future efforts (M. Poppendieck & T. Poppendieck 2006). Davenport and Prusak, in their book “Working Knowledge: How Organisations Manage What They Know”, highlight the value of interpersonal communication when facilitating knowledge transfer (Davenport & Prusak 2000). Time should be allotted, they argue, to allow staff members to engage in spontaneous conversations, organised group KT (knowledge transfer) sessions, demonstrations, presentations and experience reports, and the idea of “productivity” should be broadened to include these activities. Swap et al. suggest (2001) that storytelling and mentoring are also powerful ways to diffuse knowledge if well managed, and highly recommend the practice of joint-problem solving involving a senior and junior practitioner (Leonard & Swap 2004). A good example of this is in the software development industry where two programmers engage in “pair programming” (Williams & Kessler 2002). Two programmers sit at one computer, taking turns to command the keyboard and mouse while the other reviews the code as it is written. The result is a higher quality piece of work, and a good deal of knowledge transfer between the programmers involved. Peter Senge also advocates creating learning situations (Senge 1993). In his book “The Fifth Discipline”, he champions the creation of a “learning organisation” through five key disciplines including “team learning” through dialogue and group discussion. It is clear that there is already a wealth of key opportunities for the capturing of knowledge in the workplace, but the key is to institutionalise the culture of knowledge capture and sharing. Workers should not feel harried or rushed; rather, they must have the opportunity to constantly reflect and analyse how practices and processes might be improved (Garvin 2003). Projects should end with (or be punctuated by) “retrospectives” or “post-mortems” where questions such as “What did we do right?”, “What did we do wrong?” and “How can we improve?” are asked and provoke discussion in their answers (Derby et al. 2006). Another key aspect to evolving towards a culture that facilitates KM is the breaking down of boundaries and isolated teams and individuals. Along with the aforementioned communities of practice, working groups provide an opportunity for individuals to share and collaborate with employees outside of their day-to-day teams. Management teams that cultivate this kind of culture will, in addition to fostering innovation, prime themselves for return on investment when engaging in KM practices.

But how exactly do we use these opportunities to capture a deeper set of knowledge? Andrew McAfee recommends that organisations move away from communication “channels” where knowledge is one-to-one, formulated haphazardly and expended quickly, to communication “platforms” where knowledge has a bigger audience (and thus often displays more care in its creation) and can be kept relevant, salient and accessible (McAfee 2006). An instruction sent in an email to a new employee detailing the tools, practices and processes of the organisation is redundant effort, likely to be incomplete, and loses accessibility and visibility rapidly after its immediate use has expired. But a web page on the corporate intranet titled “Things you need to know to start” that is both easy to find, and easy to update, is instantly accessible to anyone, likely to be kept relevant and updated, and also likely to be a product of a group of people rather than one individual, greatly increasing the chance that it is of a higher quality (Mader 2007). A “wiki” is a website that allows users to create and edit HTML pages with rich content for immediate consumption by potentially everyone with a web browser. Wikipedia has built its success and huge popularity on this model. Contemporary wiki products include features like configurable access rights, a WYSIWYG (what-you-see-is-what-you-get) text editor, document revision history and several more features that make it an extremely compelling KM tool for the enterprise. A number of organisations have identified wikis as an excellent tool to facilitate communication and collaboration (Grace 2009) and one of the easiest ways to move from the “channel” of communication (often email) to a “platform” of wiki documents, photo galleries and blog entries. Management teams should look keenly to this and other “Web 2.0″ technologies that contribute in bringing people together, as Nonaka’s spiral can be greatly infused when large groups of employees, who are otherwise distributed across the organisation, are brought together in the same virtual space.

However, it is important to note that the role of technology in Knowledge Management has historically been misdiagnosed and overstated. Consequently a number of organisations have missed the mark by focusing too much on the technology (Davenport et al. 2008). According to Teech (2000), IT solutions are only an enabler, and they should be implemented not to enable the storage and retrieval of knowledge, but the connection of people. This should be self-evident in today’s Facebook dominated world, but as Joel Spolsky says, to promote the successful community-driven collaboration tool he helped create, “A successful Exchange [an installation of the product] depends on whether you [the product buyer] can supply the community”, implying that even the best software solution will not create a useful knowledge base without the engagement of a community.

Microsoft chairman Bill Gates framed the challenge precisely in an interview for a Newsweek magazine article in 2006: “While information wants to be free, knowledge is much ‘stickier’ – harder to communicate, more subjective, less easy to define.” He continued that an employee’s value to their firm is wrapped up in their tacit knowledge. “Your ability to combine it with the knowledge of co-workers, partners and customers can make the difference between success and failure – for you and your employer.” (Twentyman 2006) The message to management is clear: the cultivation and generation of strategic knowledge, followed by the effective capture, diffusion and consequent amplification will define competitiveness in tomorrow’s businesses. Organisations are highly advised to adopt strategies for the effective management of their employees’ collective knowledge, as it is critical to survival in a knowledge-driven economy of the 21st century.

References:

Brooking, A., 1998. Corporate Memory: Strategies For Knowledge Management 1st ed., Cengage Learning Business Press.

Davenport, S.T., Prusak, L. & Strong, B., 2008. Putting Ideas to Work. Wall Street Journal.

Davenport, T.H. & Prusak, L., 1998. Working knowledge: How organizations manage what they know, Harvard Business School Pr.

Derby, E., Larsen, D. & Schwaber, K., 2006. Agile Retrospectives: Making Good Teams Great illustrated edition., Pragmatic Bookshelf.

Elinor Millis, 2006. Google says speed is king – CNET News. CNet News. Available at: http://news.cnet.com/2100-1032_3-6134247.html [Accessed November 16, 2009].

Garfield, S., 2007. Knowledge Management in the Real World. Lecture at Lawrence Technological University. Available online at

http://www.slideshare.net/SGarfield/knowledge-management-in-the-real-world [Accessed November 16, 2009].

Grace, T.P.L., 2009. Wikis as a knowledge management tool. Journal of Knowledge Management, 13(4), 64 – 74.

Kessels, J.W., 2001. Learning in organisations: a corporate curriculum for the knowledge economy. Futures, 33(6), 497–506.

Lave, J. & Wenger, E., 1991. Situated learning: Legitimate peripheral participation, Cambridge Univ Pr.

Leonard, D. & Sensiper, S., 1999. The role of tacit knowledge in group innovation. Knowledge and Strategy, 281.

Leonard, D. & Swap, W., 2004. Deep smarts. IEEE Engineering Management Review, 32(4), 3–10.

Mader, S., 2007. WikiPatterns, John Wiley & Sons.

McAfee, A.P., 2006. Enterprise 2.0: The dawn of emergent collaboration. MIT Sloan Management Review, 47(3), 21.

McElroy, M.W., 2003. The new knowledge management: Complexity, learning, and sustainable innovation, Butterworth-Heinemann.

McInerney, &., 2002. Knowledge Management and the Dynamic Nature of Knowledge. Journal of the American Society for Information Science and Technology, 53(12), 1009–1018.

Nonaka, I., 1994. A Dynamic Theory of Organizational Knowledge Creation. Organization Science, 5(1), 14-37.

O’dell, C. & Grayson, C.J., 1998. If Only We Knew What We Know: The Transfer of Internal Knowledge and Best Practice 1st ed., Free Press.

Polanyi, M., 1966. The tacit dimension. New York.

Poppendieck, M. & Poppendieck, T., 2006. Implementing Lean Software Development: From Concept to Cash (The Addison-Wesley Signature Series), Addison-Wesley Professional.

Rumizen, M.C., 2001. The Complete Idiot’s Guide to Knowledge Management 1st ed., Alpha.

Senge, P.M., 1993. The Fifth Discipline: Art and Practice of the Learning Organization New edition., Random House Business Books.

Senge, P.M., 1990. The Leader’s New Work: Building Learning Organizations. Sloan Management Review, 32(1), 7-23.

Spolsky, J., 2009. StackOverflow Podcast 70, IT Conversations. Transcript available at: http://blog.stackoverflow.com/2009/10/podcast-70/ [Accessed November 16, 2009].

Stankosky, M., 2005. Creating the Discipline of Knowledge Management: The Latest in University Research, Butterworth-Heinemann.

Swap, W. et al., 2001. Using Mentoring and Storytelling to Transfer Knowledge in the Workplace. Journal of Management Information Systems, 18(1), 95-114.

Teece, D.J., 2000. Strategies for managing knowledge assets: the role of firm structure and industrial context. Long Range Planning, 33(1), 35–54.

Twentyman, J., 2006. Capturing knowledge Knowledge capture is an area that has traditionally been poorly served by supporting software tools. INSIDE KNOWLEDGE, 9(6), 42.

Wenger, E., 1999. Communities of practice: Learning, meaning, and identity, Cambridge Univ Pr.

Williams, L. & Kessler, R., 2002. Pair Programming Illuminated, Addison Wesley.

Zeleny, M. & von Hayek, F.A., 1980. Management support systems: Towards integrated knowledge management. Management, 1(1), 7.

Netflix are one of the tech companies that ground through some sizable losses during the dotcom burst and the following stagnation, and have emerged, on the back of the popularity of the DVD player in US households, to be the biggest online DVD/Blue-Ray rental service in the world. The company has been managed well, and their stock price seems to show it.

Some insight as to how they achieved that can be found in a slide deck detailing their “culture”.

There is a lot of good stuff here, but here are my favourites:

• Company culture and set of values manifests itself in who gets rewarded, promoted, and let go; Big emphasis on “talent density” – I like that.
• Leffort’s Law: If you manage, it’s your fault.
• Effectiveness is far more important than Effort.
• “Rapid Recovery” is the right model, rather than wasting too much time on preventative measures (exceptions exist).
• Vacation policy: There is none – employees take what they need and are encouraged do take “what is good for Netflix” (Professionalism and self-discipline over process adherence).
• Expense policy: “Act in Netflix’’s Best Interest”.
• Annual salary review is also market-based, and not just hiring.

Not only do they have an inspirational vision, but they seemed to have worked out most of the details of how to make it a reality.

Netflix might have its detractors, but the important thing that these slides demonstrate is that management is recognizing what it takes to have a happy, productive, talented tech workforce producing value for business.

Enjoy.

[via Scott Berkun]

I’ve recently completed a fair bit of research and consequent development at work that goes quite far to improve the performance of our web application’s front-end. I thought I’d share the basic solution here.

The first obvious thing to do is benchmark your site using Yahoo’s YSlow and Google’s PageSpeed. These will highlight the "low-hanging fruit" performance improvements to make. Unless you’ve already done so, the resulting suggestions will almost certainly include combining, minifying and gzipping your static content.

The steps we’re going to perform are:

1. Write a custom HTTPHandler to combine and minify CSS.
2. Write a custom HTTPHandler to combine and minify JS.
3. Include a mechanism to ensure that the above only do their magic when the application is not in debug mode.
4. Write a custom server-side web control to easily maintain css/js file inclusion.
5. Enable GZIP of certain content types on IIS 6.

Right, let’s start with CSSHandler.asax that implements the .NET IHttpHandler interface:

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

namespace WebApplication1
{
    public class CssHandler : IHttpHandler
    {
        public bool IsReusable { get { return true; } }

        public void ProcessRequest(HttpContext context)
        {
            string[] cssFiles = context.Request.QueryString["cssfiles"].Split(',');

            List<string> files = new List<string>();
            StringBuilder response = new StringBuilder();
            foreach (string cssFile in cssFiles)
            {
                if (!cssFile.EndsWith(".css", StringComparison.OrdinalIgnoreCase))
                {
                    //log custom exception
                    context.Response.StatusCode = 403;
                    return;
                }

                try
                {
                    string filePath = context.Server.MapPath(cssFile);
                    string css = File.ReadAllText(filePath);
                    string compressedCss = Yahoo.Yui.Compressor.CssCompressor.Compress(css);
                    response.Append(compressedCss);
                }
                catch (Exception ex)
                {
                    //log exception
                    context.Response.StatusCode = 500;
                    return;
                }
            }

            context.Response.Write(response.ToString());

            string version = "1.0"; //your dynamic version number 

            context.Response.ContentType = "text/css";
            context.Response.AddFileDependencies(files.ToArray());
            HttpCachePolicy cache = context.Response.Cache;
            cache.SetCacheability(HttpCacheability.Public);
            cache.VaryByParams["cssfiles"] = true;
            cache.SetETag(version);
            cache.SetLastModifiedFromFileDependencies();
            cache.SetMaxAge(TimeSpan.FromDays(14));
            cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
        }
    }
}

Ok, now some explanation:

IsReUsable property:

We aren’t dealing with anything instance-specific, which means we can safely reuse the same instance of the handler to deal with multiple requests, because our ProcessRequest is threadsafe. More info.

ProcessRequest method:

Nothing too hectic going on here. We’re looping through the CSS files given to us (see the CSSControl below for how they’re coming in) and compressing each one, using a .NET port of Yahoo’s YUICompressor, before adding the contents to the outgoing response stream.

The remainder of the method deals with setting up some HTTP caching properties to further optimise the way the browser client downloads (or not, as the case may be) content.

• We set Etags in code so that they may be the same across all machines in our server farm.
• We set Response and Cache dependencies on our actual files so, should they be replaced, cache will be invalidated.
• We set Cacheability such that proxies can cache.
• We VaryByParams using our cssfiles attribute, so that we can cache per CSS file group submitted through the handler.

And here is the CSSControl, a custom server-side control inheriting the .NET LiteralControl.

Front:

<customcontrols:csscontrol id="cssControl" runat="server">
          <CustomControls:Stylesheet File="main.css" />
          <CustomControls:Stylesheet File="layout.css" />
          <CustomControls:Stylesheet File="formatting.css" />
</customcontrols:csscontrol>

Back:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Web;
using System.Web.UI;
using System.Linq;
using TTC.iTropics.Utilities;

namespace WebApplication1
{
    [DefaultProperty("Stylesheets")]
    [ParseChildren(true, "Stylesheets")]
    public class CssControl : LiteralControl
    {
        [PersistenceMode(PersistenceMode.InnerDefaultProperty)]
        public List<Stylesheet> Stylesheets { get; set; }

        public CssControl()
        {
            Stylesheets = new List<Stylesheet>();
        }

        protected override void Render(HtmlTextWriter output)
        {
            if (HttpContext.Current.IsDebuggingEnabled)
            {
                const string format = "<link rel=\"Stylesheet\" href=\"stylesheets/{0}\"></link>";

                foreach (Stylesheet sheet in Stylesheets)
                    output.Write(format, sheet.File);
            }
            else
            {
                const string format = "<link type=\"text/css\" rel=\"Stylesheet\" href=\"stylesheets/CssHandler.ashx?cssfiles={0}&version={1}\"/>";
                IEnumerable<string> stylesheetsArray = Stylesheets.Select(s => s.File);
                string stylesheets = String.Join(",", stylesheetsArray.ToArray());
                string version = "1.00" //your version number

                output.Write(format, stylesheets, version);
            }

        }
    }

    public class Stylesheet
    {
        public string File { get; set; }
    }
}

HttpContext.Current.IsDebuggingEnabled is hooked up to the following setting in your web.config:

<system.web>
    <compilation debug="false">
</system.web>

So, basically, if your site is in debug mode you get HTML markup like this:

<link rel="Stylesheet" href="stylesheets/formatting.css"></link>
<link rel="Stylesheet" href="stylesheets/layout.css"></link
<link rel="Stylesheet" href="stylesheets/main.css"></link>

But if you’re in production mode (debug=false), you’ll get markup like this:

<link type="text/css" rel="Stylesheet" href="CssHandler.ashx?cssfiles=main.css,layout.css,formatting.css&version=1.0"/>

The latter will then obviously invoke the CSSHandler, which will take care of combining, minifying and cache-readying your static CSS content.

All of the above can then also be duplicated for your static JavaScript content:

`JSHandler.ashx:

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

namespace WebApplication1
{
    public class JSHandler : IHttpHandler
    {
        public bool IsReusable { get { return true; } }

        public void ProcessRequest(HttpContext context)
        {
            string[] jsFiles = context.Request.QueryString["jsfiles"].Split(',');

            List<string> files = new List<string>();
            StringBuilder response = new StringBuilder();

            foreach (string jsFile in jsFiles)
            {
                if (!jsFile.EndsWith(".js", StringComparison.OrdinalIgnoreCase))
                {
                    //log custom exception
                    context.Response.StatusCode = 403;
                    return;
                }

                try
                {
                    string filePath = context.Server.MapPath(jsFile);
                    string js = File.ReadAllText(filePath);
                    string compressedJS = Yahoo.Yui.Compressor.JavaScriptCompressor.Compress(js);
                    response.Append(compressedJS);
                }
                catch (Exception ex)
                {
                    //log exception
                    context.Response.StatusCode = 500;
                    return;
                }
            }

            context.Response.Write(response.ToString());

            string version = "1.0"; //your dynamic version number here

            context.Response.ContentType = "application/javascript";
            context.Response.AddFileDependencies(files.ToArray());
            HttpCachePolicy cache = context.Response.Cache;
            cache.SetCacheability(HttpCacheability.Public);
            cache.VaryByParams["jsfiles"] = true;
            cache.VaryByParams["version"] = true;
            cache.SetETag(version);
            cache.SetLastModifiedFromFileDependencies();
            cache.SetMaxAge(TimeSpan.FromDays(14));
            cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
        }
    }
}

And its accompanying JSControl:

Front:

<customcontrols:JSControl ID="jsControl" runat="server">
    <customcontrols:Script File="jquery/jquery-1.3.2.js" />
    <customcontrols:Script File="main.js" />
    <customcontrols:Script File="creditcardpayments.js" />
</customcontrols:JSControl>

Back:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Web;
using System.Web.UI;
using System.Linq;

namespace WebApplication1
{
    [DefaultProperty("Scripts")]
    [ParseChildren(true, "Scripts")]
    public class JSControl : LiteralControl
    {
        [PersistenceMode(PersistenceMode.InnerDefaultProperty)]
        public List<Script> Scripts { get; set; }

        public JSControl()
        {
            Scripts = new List<Script>();
        }

        protected override void Render(HtmlTextWriter writer)
        {
            if (HttpContext.Current.IsDebuggingEnabled)
            {
                const string format = "<script src=\"scripts\\{0}\"></script>";

                foreach (Script script in Scripts)
                    writer.Write(format, script.File);
            }
            else
            {
                IEnumerable<string> scriptsArray = Scripts.Select(s => s.File);
                string scripts = String.Join(",", scriptsArray.ToArray());
                string version = "1.0" //your dynamic version number
                const string format = "<script src=\"scripts/JsHandler.ashx?jsfiles={0}&version={1}\"></script>";

                writer.Write(format, scripts, version);
            }
        }
    }

    public class Script
    {
        public string File { get; set; }
    }
}

Enabling GZIP:

As Jeff Atwood says, enabling Gzip on your web site server is a no-brainer. After some tracing, I decided to enable Gzip on the following file types:

• .css
• .js
• .axd (Microsoft Javascript files)
• .aspx (Usual ASP.NET Web Forms content)
• .ashx (Our handlers)

To enable HTTP Compression on your IIS 6.0 web server:

1. Open IIS, Right click Web Sites, Services tab, enable Compress Application Files and Compress Static Files
2. Stop IIS
3. Open up IIS Metabase in Notepad (C:\WINDOWS\system32\inetsrv\MetaBase.xml) – and make a back up if you’re nervous about these things
4. Locate and overwrite the two IIsCompressionScheme and one IIsCompressionSchemes elements with the following:

<IIsCompressionScheme    Location ="/LM/W3SVC/Filters/Compression/deflate"
        HcCompressionDll="%windir%\system32\inetsrv\gzip.dll"
        HcCreateFlags="0"
        HcDoDynamicCompression="TRUE"
        HcDoOnDemandCompression="TRUE"
        HcDoStaticCompression="TRUE"
        HcDynamicCompressionLevel="9"
        HcFileExtensions="htm
            html
            txt
            css"
        HcOnDemandCompLevel="9"
        HcPriority="1"
        HcScriptFileExtensions="asp
            dll
            exe
            aspx
            js
            ashx
            axd"
    >
</IIsCompressionScheme>
<IIsCompressionScheme    Location ="/LM/W3SVC/Filters/Compression/gzip"
        HcCompressionDll="%windir%\system32\inetsrv\gzip.dll"
        HcCreateFlags="1"
        HcDoDynamicCompression="TRUE"
        HcDoOnDemandCompression="TRUE"
        HcDoStaticCompression="TRUE"
        HcDynamicCompressionLevel="9"
        HcFileExtensions="htm
            html
            txt
            css"
        HcOnDemandCompLevel="9"
        HcPriority="1"
        HcScriptFileExtensions="asp
            dll
            exe
            aspx
            js
            ashx
            axd"
    >
</IIsCompressionScheme>
<IIsCompressionSchemes    Location ="/LM/W3SVC/Filters/Compression/Parameters"
        HcCacheControlHeader="max-age=86400"
        HcCompressionBufferSize="8192"
        HcCompressionDirectory="%windir%\IIS Temporary Compressed Files"
        HcDoDiskSpaceLimiting="FALSE"
        HcDoDynamicCompression="TRUE"
        HcDoOnDemandCompression="TRUE"
        HcDoStaticCompression="TRUE"
        HcExpiresHeader="Wed, 01 Jan 1997 12:00:00 GMT"
        HcFilesDeletedPerDiskFree="256"
        HcIoBufferSize="8192"
        HcMaxDiskSpaceUsage="99614720"
        HcMaxQueueLength="1000"
        HcMinFileSizeForComp="1"
        HcNoCompressionForHttp10="FALSE"
        HcNoCompressionForProxies="FALSE"
        HcNoCompressionForRange="FALSE"
        HcSendCacheHeaders="FALSE"
    >

And that’s it! This saved us heaps of bandwidth and resulted in a more responsive web application throughout.

Enjoy!

I’ve long been searching for a succinct noun phrase for that certain annoying thing that seemingly requires you to do something in a less-than-perfect way. Something that you know can and should be done better. You curse having that ‘requirement’, you loathe having to create a ‘workaround’, and you dream of a better world. Whether it’s the tardiness of the web standards world requiring CSS browser hacks, or the less-than-stellar API of an enterprise system with which you have to integrate, or perhaps being forced to browse in IE because of corporate bureaucracy, you’ve probably become annoyed at having to contend with this thing that, if the world was a better place, would not otherwise be detrimental to your work or productivity.

Having failed at finding the correct phrase for such a thing, I’ve done what I usually do and made one up. I now consider something like the above to be an illegitimate affecter. Having this succinct term is useful when identifying individual constituent parts of the system that can then be factored out by function and treated to an increase in quality (refactoring/rewriting) on a part by part basis.

For example, I sometimes stumble on poorly named properties only to trace their source back to the (poorly named) property of an outside API. The developer that first created the property in our application used the property name of the API object as an affecter but failed to recognize it as illegitimate, unnecessarily causing that little bit of extra confusion to all developers consequently working with that property.

I’ve also been in design discussions when reasons are brought up against making some architectural/design change to the system, only to be carefully exposed as illegitimate affecters, often temporary in nature, and sometimes actually even lending more weight to the argument to undertake the change proposed.

When they are outside of your control, illegitimate affecters should be kept at bay by abstraction layers. When inside your control, they themselves should form part of the redesign and refactoring discussions.

What illegitimate affecters can you think of?

A couple of weeks ago I presented at an internal company conference on Lean Software Development and what we can learn from Lean Manufacturing. As I am still a neophyte at presenting, the PowerPoint notes are prosaic and should be a coherent read.

I also included a slide discussing the Estimation Fallacy and Optimism Bias in an attempt to provide some insight into why software estimation is so often inaccurate.

The last thing I wanted to slip in was a slide on The Alignment Trap as presented in a Bain Consulting industry research publication released back in 2007. Briefly, the conclusions of this study put companies in four distinct quadrants: Well-aligned/Effective; Less-Aligned/Effective; Well-aligned/Ineffective and Less-aligned/Ineffective. The sales figures of the companies in the less-aligned/effective quadrant were better than the sales figures of the well-aligned/ineffective companies. The lesson there being that companies should avoid the alignment trap by letting their IT departments become effective at what they’re doing, before aligning IT operations more accurately with the business strategy.

It’s all in the presentation in better detail here!

When trying to get developers of a project invested in what they are doing on a day to day basis, few practices go so far as the establishment of an informal meritocracy in the team.

Traditionally in software, meritocracy is talked about with relation to initially giving a developer a small amount of time and trust to contribute something outside of his or her traditional area. The product of that time is then evaluated by the team leader or project manager, and if that mini-project was deemed to be valuable, the developer is given additional time and trust the next time he has an idea (when time permits so as not to negatively affect the main development project). This process works successfully in open source projects.

Now, I think it would be good to extend this phenomenon, contrary to the usual rules of social correctness in the workplace, to informal benefits in and around the workplace itself. Senior developers should get to work from home more, more relaxed internet surfing rules and even free coffee (if not already standard) so as to get juniors to aspire to be just like them. We are not all rewarded in equal financial terms for the value we contribute towards the project, so why should we all be subject to the same office environment rules? People should associate responsibility, accountability, and good performance with benefits beyond just their salary.

Conversely, employees who abuse the trust given to them to perform their job can have their perks reduced or taken away entirely. Is Gerald Facebooking too much? Fine, restrict him and only him to free surfing in lunch hours and after 5pm. If he’s gives a damn, he’ll soon get the message and shape up. If he doesn’t, well, taking away his perks will hopefully be the first few steps to warnings and then a dismissal, because you don’t want anyone like that on your software team.

I am aware that this kind of thing could get messy with the wrong people around, but then again, software development in general gets messy with the wrong people around! I would concede that an informal meritocracy would work best in a mature workplace where the hierarchy is accurately based on experience, qualifications and merit to the project, however rare that may be!

So let’s drop the egalitarian charade and tell it like it is. All software developers are not created equal, and differing perks for juniors and seniors would be a good thing!

In the ongoing quest to helpfully frame the dos, don’ts and whys of software engineering to management, every so often we come up with illuminating analogies that do wonders to illustrate why a software team should or should not follow a particular strategy. One very successful one is technical debt (coined by Cunningham and later helpfully expanded on by Steve McConnell). Although they can be misused, analogies generally help us to communicate to non-techies with more clarity. Having pondered on the life of my current 2yr+ project, I’ve come up with another (albeit flippant and high-level) analogy: Software is like Tetris.

A software project, with specific focus on providing ongoing value to the business as the product evolves towards feature plateau, is like a game of tetris but with one alteration: The blocks fall quicker as they stacker higher. What I mean is that the closer you are to conducting zero-overhead iteration after zero-overhead iteration, the more time (read: less pressure) you have to solve problems: engage in root cause analysis, attack process bottlenecks, conduct code reviews, lower technical debt, and several other things that don’t directly add business value but that are obviously invaluable. The converse to all this is what I experienced on the project I’m on now, but with previous management: As deadlines tighten on features having been promised to the business by overexhuberant non-techie managers, those same managers demand that nothing else be done except the implementation of the feature, the quick-and-dirty hacking in of which slows down implementation of future features. Developers are forced into increasing their estimates because implementing features into a messy codebase takes more time and carries higher risk, and managers think the wool is being pulled over their eyes. Trust ebbs away, entropy sets into the codebase, the business get unstable software, morale is sinking and your tetris blocks are piling up fast and falling quicker.

So it seems like the focus should not be on delivering a piece of software. The focus should be building a team of engineers supported by managers, testers, business domain specialists as well as the right tools and a comfortable working environment to create an entity that can sustain the delivery of features with quality and predictability. Peaks and troughs of feature quantity and quality should be rare and small tweaks and improvements should be made to aid the gradual increase of quality and quantity. Effort should be on keeping overhead low and your features should tick away like lines of blocks in a well-running Tetris game.