Anyhow, I have just read ‘The Art of Agile Development’ by Shire and Warden, which concentrates on the principles, practices and potential benefits of introducing the Extreme Programming methodology into your development teams. If Extreme Programming is a road you feel you may want to go down, or if you require some help with putting the ideas it brings in practice, I can highly recommend this book. For me, XP is currently not an option with the size of the development team I work in, which has been reduced to me, myself and I, together with an, I guess, Product Manager/Customer/Domain Expert, whilst we both double as testers. However, you never know what the future will bring (but you can hope!), so I wanted to give myself some background knowledge on the current popular methodologies.

So, I am going to start by looking at some of the more conventional models for a Software Development Process or Lifecycle, before moving onto the Agile models. The aim of adopting any such model is to achieve improved ‘productivity’ and ‘quality’ (big buzz words) by using a repeatable and predictable structured process. By incorporating such a model within your project management strategy is to ensure that your projects are delivered ‘successfully’, i.e. on budget, on time and with all the features in the agreed specification. All sounds fantastic in an ideal world where requirements do not change over the length of the project, and design specifications have no mistakes. Up until the revolution that is Agile, this is what we were taught. I also want to mention here that Agile type modelling has probably been used way before the term Agile was coined and applied to defined models. There are probably a large number of software teams who work to their own ideals or models using Agile type processes to enhance the holy grail of productivity and quality, and I should now add to that, delivering what the customer needs to improve their business. All models from what I have read use pretty much the same phases described below, just in a different way. I’m going to discuss these phases, how they work and the ideas behind them in another blog.

The Waterfall Model, the daddy. This uses sequential movement from Analysis (requirements), to Design, to Construction, to Integration, to Testing, to Deployment to Maintenance. This is also known as a top down strategy. This is a strict ideal where once each phase is completed, only then can the next be started. Moving onto the next phase may be dependent upon a review, which I guess can allow some flexibility if changes are required, however once a phase has been formally completed, the model discourages revisiting or changes to the previous phase.

The Big Design Upfront (BDUF) model comes from the idea of the Waterfall model, and advocates investing a large amount of time on design (without the need for prototyping or any initial implementation at this stage) as to reduce the chances of bugs being created and found within later phases.

The Spiral model is similar in phases to the Waterfall model, but like the BDUF model in that the design phase is seen as the most important. It comes with the aim of combining both Design and Prototyping, resulting in a top down/bottom up combo strategy. The idea is iterative, however, not in the way Agile defines iterations. After exhaustively defining the requirements through a number of strategies, emphasis is placed on creating a preliminary design in which all possible alternatives are investigated and strategies are used to determine the best way forward. The aim of this phase is also to find and resolve risk in each element of the design. If risks show there is uncertainty within the requirements, prototyping can be used to find a solution and an update to the requirements can be made. A preliminary scaled down version of the system is then build from the resulting design. This model is then evolved via firstly evaluation (strengths, weaknesses and risks), and then following the model in another iteration of refining requirements, then design, construction and so on. This can then be repeated.

So what is iterative development in the way Agile sees it? Well, it is basically splitting a project up into small independent chunks, and then applying to Software Development Lifecycle to each chunk until the project is created. Agile development uses this is its basis, but it places higher value on communication and feedback through Test Driven Development practices (TDD) and release of features at regular intervals, rather than meticulous planning.

Coming back to the traditional goals of increased productivity, increased quality and development success (on time, on budget, and with all features) I should start by saying that XP is no magic bullet. It is described as a “Way of working differently, not faster, although it has been noted that Agile teams usually have above average productivity”.

So maybe it can hit these goals? But then that depends on whether you define success as stated, or whether this definition of success is limited as it does not take into consideration whether the project hits its business targets of generating cash or improving process or whatever it may be.

This is where an Agile model differs vastly from its predecessors. The aim of an Agile approach is to not only bring personal (increased productivity) and technical (quality of work) success, but also “organisational success”, i.e. to deliver value for decreasing costs by changing and adapting to changing business needs and requirements as and when decisions are made and new data is uncovered. This is done through TDD, regular reviews, continual code improvements and therefore enhanced maintainability.

Let’s look at the most complete Agile model, Extreme Programming or XP. XP gears itself towards technical excellence and code longevity using pairs programming where two people review every piece of code. It focuses on operational success by only releasing new features (a feature contains a number of tasks or stories) when they make business sense. This requires code integration from developers so features are ready for release when required. By only working on a single feature at a time and requiring completion before the next is started, this reduces unexpected delays and allows teams the freedom to change direction when business needs dictate them to. A team will commit to a number of tasks/stories for the length of a single iteration, usually a week or two. In a nutshell, XP is about responding to change and technical excellence. The phases of Analysis (requirements gathering), Design, Construction, Integration and Testing are performed simultaneously each day.

According to the book I just read, XP is about:

• Satisfing customers first with continuous delivery of functionality
• Always welcoming changing requirements
• Preference to shorter timescales for delivery, 2 weeks to 2 months
• Working with the business in a joint effort
• Using working software is the best measure of progress
• Attention to technical excellence for best agility and longevity
• Reflecting continuously to improve efficiency

The Analysis phase will consist of the Product Manager, someone who talks with the business and decides what needs to be done will create the requirements for a feature. Estimates by the coders will then allow more details to be added to the requirements before they can be coded.

The Design phase is integrated with coding and testing. As mentioned previously, TDD is used. The requirements are used to create customer tests, preferably with a customer, or someone who knows how the feature needs to work providing the insight and business logic. The tests are passed on to the coders who in pears create work on tasks/stories of the current feature, constantly refactoring and improving the code base. Once coding is complete, unit, integration and end to end testing are done. The code is then passed over for exploratory and performance/stability testing, with root cause analysis applied to any issues found. Regression testing is applied on integration to ensure nothing else has broken.

Deployment first occurs to a demo system. This is timely at the end of the current iteration. The real deployment is dependent on business needs.

After completion of the current iteration a period called retrospectives occurs. Here, the team talk about what went well, what didn’t, how the process can be improved, and anything which is hindering progress. Finally, the next iteration is discussed and planned.

This is a quick and dirty summary of the XP model, which is far more complex then what I have written here. For more information, I would suggest reading ‘The Art of Agile Development’ by Shore and Warden.

Lastly, I want discuss Scrum, another popular Agile model. Scrum is arguably a scaled down version of XP, for smaller development teams. The aim is to produce a feature, or set of features, which are tested and shippable, within a given time-frame (time-boxed), which rather than being pre-defined, is set by the team.
This iteration is called a Sprint. The features going into the Sprint come from what is known as the Product Backlog, a maintained (by the Scrum Master) set of prioritised (by the Product Manager) high level requirements. Any items not complete are removed from the Sprint. Which items go into the next Sprint is determined at a Sprint planning meeting.

As with XP, the aim of Scrum is to be able to adapt to changing business needs and by working in small Sprints, the focus for development can change and when required.

There are a number of further Agile models such as Feature Driven Development (FDD) built around a core set of industry best practice, Agile Unified Process (AUP) and Dynamic System Development Method (DSDM). I hope to look at these in due course.

Related posts:

1. Logically Modelling Requirements for Analytical Systems A brief discussion of relational and dimensional logical modelling techniques, to model requirements for analytical systems. The discussion extends into a comparison of some prominent dimensional modelling techniques such as the Bus Matrix, the Starnet Model, the Sun Model and the Star Schema. Click the title above to read more....

If you want to limit the character pool the password generator selects characters from or change the maximum number of characters selected in your randomly generated passwords, you will need to implement your own Custom Membership Provider to override this behaviour.

1 – Create a new class in your project and name it say ‘MyMembershipProvider’.
2 – Inherit from the default ‘SqlMembershipProvider’.
3 – Override the Initialize method to reset the password length.
4 – Override the GeneratePassword method with your custom method for generating a password.

The VB.Net code listing can be found at the bottom of this blog entry. If you would like this converted to C#, let me know.

For your Web application to make use of your new Custom Membership Provider, you need to make some changes to your web.config file.

In your web.config file, you will see the following -

<membership defaultProvider="DefaultMembershipProvider">
    <providers>
    ...
    </providers>
</membership>

Update this to

<membership defaultProvider="MyMembershipProvider">
    <providers>
        <add name="MyMembershipProvider" type="MembershipProvider" minRequiredPasswordLength="6" .... />
    </providers>
</membership>

Code listing for MyMembershipProvider class:

Public Class MyMembershipProvider
    Inherits SqlMembershipProvider 

    ' private variable declarations
    Private _random As System.Random
    Private _chars() As String
    Private _passwordLength As Integer 

    ' Constructor
    Public Sub New()
        _random = New Random
        _chars = InitialiseCharArray()
        _passwordLength = 6
    End Sub 

    ' Override Initialize method to reset the password length
    Public Overrides Sub Initialize(ByVal name As String, ByVal config As  system.Collections.Specialized.NameValueCollection)
        Dim _l As String = _passwordLength
        Dim _lc As String = config(”resetPasswordLength”)

        If Not IsNothing(_l) Then
           ' Have to remove the config entry as the provider we are inheriting from
           ' doesn’t understand it and will throw an exception.
            config.Remove(”resetPasswordLength”)
            If Not Integer.TryParse(_lc, _l) Then
               _l = _passwordLength
            End If
        End If
        MyBase.Initialize(name, config)
    End Sub

    ' Procedure to override the password generation functionality and return a random password of 6 alphnumberic characters.
    Public Overrides Function GeneratePassword() As String
        Dim _password As String = String.Empty
        For i As Integer = 1 To _passwordLength
            _password &= GenerateRandomCharacter()
        Next
        Return _password
    End Function

    ' Create a character map of characters we want our passwords to be constructed from.
    Private Function InitialiseCharArray() As String()
        Dim _s(34) As String
        ' Add numbers, 1 to 9.
        For i As Integer = 0 To 8
            _s(i) = i + 1
        Next
        ' Add letters, a to z - lowercase only.
        For j As Integer = 97 To 122
            _s(j - 88) = Char.ConvertFromUtf32(j)
        Next
        Return _s
    End Function  

    ' Procedure to return a random character from our character list.
    Private Function GenerateRandomCharacter() As String
        Return _chars(_random.Next(_chars.GetUpperBound(0)))
    End Function
End Class

Related posts:

1. Creating a Custom Web Server Control – Alphabet Selector Web Server Control Instructions on how to create a Web Server Control. These instructions will use the example of creating your own Alphabet Selector Control. These principlals can then be applied to creating any control of your choice. Click the title above to read more......
2. Component to Connect to Active Directory with Sharepoint WSS Download a component for your Sharepoint (WSS) Intranet to connect to the Active Directory(AD) via LDAP. This component will allow users to search for colleagues in the AD. It will also allow users to update their own contact details. This component requires Window Authenticated access to your Intranet. Click on the title above to read more......

To download this web server control and with projects (VB.Net and C#), please click HERE.

To use the web server control in your own projects, you will need to reference the dll file. The dll file is available in the ‘Bin’ directory of both sample projects, select either one.

To use the control in a single project, add a reference to the dll file (Visual Studio – Project – Add Reference – Browse to dll file). The reference will appear in your project’s ‘Bin’ directory. Then simply register the control in your webpage (<@Register….>) and add the control <cc1:Alphabet…..>.

To make the control so it is available to all your projects, add it to the Global Assembly Cache by either:

1) Windows Explorer – C:\Windows\Assembly – drop dll file into there.
OR
2) Use the GACUtil tool from Visual Studio Cmd Prompt – GACUtil.exe /if <path to the dll file>.

Then simply register the control in your webpage (<@Register….>) and add the control <cc1:Alphabet…..>.

(You can also add the control to your Visual Studio Toolbox then drag and drop onto your webpage whereby the plumbing code will be automatically created for you).

To learn how to create your own Web Server Control click here.

Related posts:

1. Creating a Custom Web Server Control – Alphabet Selector Web Server Control Instructions on how to create a Web Server Control. These instructions will use the example of creating your own Alphabet Selector Control. These principlals can then be applied to creating any control of your choice. Click the title above to read more......
2. Failure adding assembly to the cache: Unknown Error – GACUtil A solution for: Failure adding assembly to the cache: Unknown Error - when adding an Assembly to the Global Assembley Cache (GAC) Click on the title to read more......
3. Component to Connect to Active Directory with Sharepoint WSS Download a component for your Sharepoint (WSS) Intranet to connect to the Active Directory(AD) via LDAP. This component will allow users to search for colleagues in the AD. It will also allow users to update their own contact details. This component requires Window Authenticated access to your Intranet. Click on the title above to read more......

2) Your new project will consist of a single class file which inherits from WebControl. It contains a single default property ‘text’ which we do not need, and an override of the RenderContents method where you place your code if you want to output to the screen. Since we will be creating a LinkButton control for each letter in the alphabet and adding this to the page controls, we will not need to override the RenderContents method. Instead we will be overriding the OnInit method within which we will create our alphabet.

3) Update the class file as follows:

Imports System
Imports System.Collections.Generic
Imports System.ComponentModel
Imports System.Text
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls

Public Class ServerControl1
    Inherits WebControl

End Class

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public class ServerControl1 : WebControl
{

}

4) The first thing we are going to declare is a public event. On selecting a letter from the Alphabet, an ItemSelected event will be raised. Raising this event allows the page using our control to know what letter has been selected by handling the event. In your class definition, add the following:

Public Class ServerControl1
    Inherits WebControl

    Public Event ItemSelected As System.EventHandler

End Class

public class ServerControl1 : WebControl
{
    public event EventHandler ItemSelected;

}

5) After handling the event declared above, for the page to be able to get to the data about what letter has been selected, we need to make a public property available which holds this information. Add the following property to your code:

Public ReadOnly Property SelectedItem() As String
    Get
        Dim _s As String = CStr(Me.ViewState("selected"))
        If _s Is Nothing Then
            Return String.Empty
        Else
            Return _s
        End If
    End Get
End Property

public string SelectedItem
{
    get
    {
        string _s = (string)(this.ViewState["selected"]);
        if (_s == null)
            return string.Empty;
        else
            return _s;
    }
}

6) Add the code to create the alphabet in the overrideable OnInit function. Look out for how we define the handler method for the LinkButton click events, i.e.

...
AddHandler _lbAll.Click, AddressOf LinkButton_Click
...

...
_lb.Click += new EventHandler(LinkButton_Click);
...

in

...
Protected Overrides Sub OnInit(ByVal e As System.EventArgs)
    ' Add the A to Z hyperlinks as individual LinkButtons.
    For i As Integer = 65 To 90 ' Ascii representations.
        Dim _lb As LinkButton = CreateLinkButton(Chr(i), Chr(i), Chr(i))
        If Not IsNothing(_lb) Then
            AddHandler _lb.Click, AddressOf LinkButton_Click
            Me.Controls.Add(_lb)
            Me.Controls.Add(New LiteralControl(" "))
        End If
    Next
    ' Optional - add an 'All' button.
    Dim _lbAll As LinkButton = CreateLinkButton("All", "All", "All")
    AddHandler _lbAll.Click, AddressOf LinkButton_Click
    _lbAll.CausesValidation = False
    Me.Controls.Add(_lbAll)
    MyBase.OnInit(e)
End Sub

Private Function CreateLinkButton(ByVal text As String, ByVal cArg As String, ByVal id As String) As LinkButton
    Dim _lb As New LinkButton
    _lb.Text = text
    _lb.CommandArgument = cArg
    _lb.ID = id
    Return _lb
End Function
...

...
protected override void OnInit(EventArgs e)
{
    for (int i = 65; i <= 90; i++)
    {
        LinkButton _lb = CreateLinkButton(Convert.ToChar(i).ToString(), Convert.ToChar(i).ToString(), Convert.ToChar(i).ToString());
        _lb.Click += new EventHandler(LinkButton_Click);
        this.Controls.Add(_lb);
        this.Controls.Add(new LiteralControl(" "));
    }
    // Optional - add an 'All' button.
    LinkButton _lbAll = CreateLinkButton("All", "All", "All");
    _lbAll.Click += new EventHandler(LinkButton_Click);
    _lbAll.CausesValidation = false;
    this.Controls.Add(_lbAll);
    base.OnInit(e);
}

private LinkButton CreateLinkButton(string text, string cArg, string id)
{
    LinkButton _lb = new LinkButton();
    _lb.Text = text;
    _lb.CommandArgument = cArg;
    _lb.ID = id;
    return _lb;
}
...

7 ) Finally, add the click handler function which will store the selected letter and raise the ItemSelected event to be handled by the page using the control.

...
Private Sub LinkButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
    If Not IsNothing(Me.SelectedItem) AndAlso Trim(Me.SelectedItem.ToString) <> "" Then
        Dim _lb As LinkButton = CType(Me.FindControl(Me.SelectedItem), LinkButton)
        _lb.Enabled = True
    End If
    Me.ViewState("selected") = CType(sender, LinkButton).CommandArgument
    ' Disable the selected button (to stop it being clicked multiple times and raising the event more than once at a time.)
    CType(sender, LinkButton).Enabled = False
    ' Throw the ItemSelected event.
    RaiseEvent ItemSelected(Me, New EventArgs())
End Sub
...

...
private void LinkButton_Click(Object sender, System.EventArgs e)
{
    if (this.SelectedItem != null && this.SelectedItem.ToString() != "")
    {
        LinkButton _lb = (LinkButton)this.FindControl(this.SelectedItem);
       _lb.Enabled = true;
    }
    this.ViewState["selected"] = ((LinkButton)sender).CommandArgument;
    // Disable the selected button (to stop it being clicked multiple times and raising the event more than once at a time.)
    ((LinkButton)sender).Enabled = false;
    // Throw the ItemSelected event.
    ItemSelected(this, new EventArgs());
}
...

See this page for information on how to add your shiny new control to a web page.

To download an Alphabet Selector Web Control with example projects for both VB.Net and C#, click here

Related posts:

1. Alphabet Selector Web Server Control A free control will display the alphabet, A to Z, where each letter is clickable. On clicking a letter, an event is raised detailing the letter which was clicked. This letter can then be captured and used as needed, for example to display a set of results beginning with the specific letter. Click the title above to read more......
2. Default .Net Membership Provider – Override Password Generator via Implementing a Custom Membership Provider Implement a Custom Membership Provider and use it to override the .Net Password Generator. Click the title above to read more......
3. Component to Connect to Active Directory with Sharepoint WSS Download a component for your Sharepoint (WSS) Intranet to connect to the Active Directory(AD) via LDAP. This component will allow users to search for colleagues in the AD. It will also allow users to update their own contact details. This component requires Window Authenticated access to your Intranet. Click on the title above to read more......