DAX 2009: SoapServerException when installing Role Center & Enterprise Portal in Dynamics AX 2009

Entering function CurrentUserAlias
    Leaving function CurrentUserAlias
    Creating new Enterprise Portal Site with following the parameters:\n URL: http://Portal/sites/EP\n Title: EP Site\n LCID: 1033\n OwnerLogin: WE\AxAdmin
    Administration Web Service URL: http://machine:90/_layouts/ep/WSSAdmin.asmx
    Information: Debugging mode is off.


    An error occured while Setup was creating a new site.
    Exception of type 'Microsoft.SharePoint.SoapServer.SoapServerException' was thrown.
    The Web site http://portal/sites/CEC was not created correctly.  An error has occurred on the server.
    Exception of type 'Microsoft.SharePoint.SoapServer.SoapServerException' was thrown.

System.Web.Services.Protocols.SoapException
   at System.Web.Services.Protocols.SoapHttpClientProtocol.ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, Boolean asyncCall)
       at System.Web.Services.Protocols.SoapHttpClientProtocol.Invoke(String methodName, Object[] parameters)
       at Microsoft.Dynamics.Framework.Deployment.Portal.WSSAdmin.CreateSite(String Url, String Title, String Description, Int32 Lcid, String WebTemplate, String OwnerLogin, String OwnerName, String OwnerEmail, String PortalUrl, String PortalName)
       at Microsoft.Dynamics.Framework.Deployment.Portal.EPDeployment.CreateDefaultEPSite(String virtualServerUrl)


RESOLUTION:
1. Make sure the Sharepoint Folder - Program Files/ Common Files/Microsoft Shared/Web Server Extensions/12 has required permissions and is not read-only/compressed
2. Make sure the host header for the sharepoint web application into which EP site will be deployed is configured (do not use the host header while installing Role Center/EP - for some reason the installer has conflicts when dealing with host header)

DAX 2009: Temporary Tables in Enterprise Portal

http://msdn.microsoft.com/en-us/library/bb314749(AX.10).aspx

Temporary Tables vs. Containers

Microsoft Dynamics AX supports a special data type called a container. This data type can be used just as you would use a temporary table. For more information, see Containers.

Data in containers are stored and retrieved sequentially, but a temporary table enables you to define indexes to speed up data retrieval. Containers provide slower data access if you are working with many records. However, if you are working with only a few records, use a container.

Another important difference between temporary tables and containers is how they are used in method calls. When you pass a temporary table into a method call, it is passed by reference. Containers are passed by value. When a variable is passed by reference, only a pointer to the object is passed into the method. When a variable is passed by value, a new copy of the variable is passed into the method. If the computer has a limited amount of memory, it might start swapping memory to disk, slowing down application execution. When you pass a variable into a method, a temporary table may provide better performance than a container.

 

1.1       Temporary Tables and context

Using temporary tables as the primary data source in EP page posse a number of technical limitations. The most significant being the lack of context.

1.1.1       Problem Description

Context is not maintained on temporary tables hence the web part that contains it cannot be used as a provider to other webparts like the toolbar webpart which is connected to the current context of the provider view. The flow of activities in the process is hindered since additional processing needs to be done to pass the context explicitly to the caller. Temporary tables cannot be used as the source of a lookup control either.

RELATED POST : Setting Session Timeout for Dynamcis AX EP

http://www.odetocode.com/Articles/450.aspx

http://geekswithblogs.net/vivek/archive/2006/10/04/93094.aspx

http://msdn.microsoft.com/en-us/library/ee330228.aspx

http://msdn.microsoft.com/en-us/library/ee330227.aspx

DAX 2009 Enterprise Portal Development : Using the Ax Session

Accessing the Session object

When adding code to User Controls for Enterprise Portal, many of the methods that you will use in the Enterprise Portal framework require access to the session object, for holding temporary values of the session, passing values between pages in Enterprise Portal.

Steps to access the session object

·         The Session object can be accessed through the AxWebPart hosting the AxUserControl.

·         The following namespaces have to be included in the User control to access the WebPart hosting the control and the Session object used by it.

using Microsoft.Dynamics.Framework.Portal.UI.WebControls.WebParts;

using Microsoft.Dynamics.Framework.BusinessConnector.Session;

·         The following accessor method can be added to the code to fetch the active Session object

AxBaseWebPart webPart;   

    protected AxBaseWebPart WebPart

    {

        get

        {

            if (webPart == null)

                webPart = AxBaseWebPart.GetWebpart(this);

 

            return webPart;

        }

    }

protected ISession AxSession

    {

        get

        {

            AxBaseWebPart webpart = this.WebPart;

            return webpart == null ? null : webpart.Session;

        }

    }

·         The getter method can be used as described in the following examples

1.    AxSession.AxaptaAdapter

2.    e.DataSetRunArgs.parmEnumType = EnumMetadata.EnumNum(this.AxSession, "name");

3.    AxSession.GetItemFromCache("name");

4.    AxSession.SetItemInCache("name", AxGridView1.SelectedDataKey.Value.ToString());

 

 References

·      http://msdn.microsoft.com/en-us/library/cc581944.aspx

 

Using AxPopupParent& AxPopupChild Control

Using AxPopupParent and AxPopupChild controls

Reference: http://msdn.microsoft.com/en-us/library/cc592938.aspx

Configuring the Parent:
  • Add the "AxPopupParentControl"  to the AxUserControl which is supposed to host the Popup.
  • Specify the "Height" & "Width" of the Popup to be created by giving the appropriate values to the control
  • Generally a dialog form returns a value - create a holder for this expected return value by creating a field in the "Fields" property of the "AxPopupParentControl". Assuming one field "Field1" for the current case.
  • Go to the "Events"  of the control and specify the "onpopupclosed" event handler on the control.
  • In the event handler add the code to accept the value from the popup by using the parent popupcontrol
string strReturnValue = AxPopupParentControl1.GetFieldValue("Field1");


Configuring the Child (Dialog/Popup):
  • Create a AxUserControl with the content intended to be displayed in the Popup just as any regulat EP AxWebUserControl would be developed
  • Additionally add the "AxPopupChildControl" and specify the Field that has to be passed from the Child
<dynamics:AxPopupField Name="Field1" TargetControlId="Field1ValueTextBox" />
  • The markup should be similar to the above. The TargetControlID refers the ID of the control that hold the value to be passed from the popup back to the parent. (For other method of passing value check the MSDN link above)
  • Add the user control to the AOT and create a page in EP that uses the web control
  • Create an AX Web Menu Item that refers to this page and deploy the page.
  • Back in the Parent user control's code behind file (ascx.cs file) use the following code to invoke the popup.
 AxUrlMenuItem objMenuItem = new AxUrlMenuItem("WebMenuItemLinkingThePopupPage");
            AxPopupParentControl1.OpenPopup(objMenuItem);

This will have your popup and parameter passing from it configured.
Integrating ASP.NET 2.0 application in Sharepoint
http://www.sharepointblogs.com/jscott/archive/2008/04/15/integrating-asp-net-2-0-web-pages-into-sharepoint-2007.aspx
http://geekswithblogs.net/RogueCoder/archive/2006/12/11/100889.aspx

Coming soon !!

DAX 2009 - Single Server Multiple EPSites (BC.NET - AOS)

Objective: To have two EP Sites that are connected to two different AOS's, configured on a single server machine.

Current Software & Hardware Environment

  • Server runs on a 64Bit Processor
  • Windows 2003 R2 Enterprise 64 bit with SP2
  • SQL Server 2005 SP2
  • Sharepoint Server 2007
  • Dynamics Ax 2009

Current Configuration

  • Sharepoint is installed to run on a website “Sharepoint – DEV” (on port 80) and uses an application pool with the same name. The app pool uses a Ax admin account for its identity, the account will be referred to as “AxAdmin” in this blog entry.
  • The Dynamics Ax 2009 Client Configuration is configured to use the “Development” AOS referred to in this blog entry as “DevAOS” and so is the Business Connector.
  • The “AxAdmin” account is configured to be the Proxy account for accessing Dynamics Ax through the Business Connector.

 Configuring two EP Sites linked to different AOS’s coexist on a single server

  1. Run the “Ax 2009” installation.
  2. Select “Add Remove” (or Repair) option from the installer screen.
  3. Select “Role Centers and Enterprise Portal” as the component to be installed.
  4. Enter the password for the “AxAdmin” account which is also the Proxy account
  5. Select  the website “Sharepoint –Dev” , Check “Configure for Windows Sharepoint Services” and check create web site – the site url is “http://myserver/sites/DevSite” – referred to as “DevSite” in this blog entry
  6. Complete the installation. After which the development site is up and running. The “DevSite” connects to “DevAOS” and works fine.
  7. Create a new “Application Pool” using the existing “DevSite” application pool “Sharepoint – Dev” as the template, this application pool will be referred to as “Sharepoint-Test” in this blog entry.
  8. Create a new website “TestSite” and use “Sharepoint – Test” as the application pool. Set the port to “90” (any port that is not is use already)
  9. Open the “Dynamics Ax Client Configuration” and change the AOS referred to by the Local Client and the Business Connector to the “TestAOS”
  10. Open the AOT of “TestAOS” and select Web > Web Files > Static Files > EPSetupParam and edit it – Change the URL to “TestSite”.
  11. Repeat steps 1 to 6 on the new website.
  12. Add the following Web.config entries based on the blog entry from Solutions Monkey

https://blogs.msdn.com/solutions/archive/2006/09/11/ep-configuration-single-web-server-multiple-aos-installations.aspx

On the Web server, make the following edits to the Web.config file in the wwwroot folder (for example, C:\inetpub\wwwroot where the Second Web server is installed in the C: drive):

 1) Add the Microsoft.Dynamics section group under <configSections>. Add the following text:

<sectionGroup name="Microsoft.Dynamics">
<section name="Session" type="System.Configuration.SingleTagSectionHandler, System, Version=1.0.5000.0, Culture=neutral,PublicKeyToken=b77a5c561934e089" />
</sectionGroup>

2. Add the following Microsoft.Dynamics element under </system.web>. Add the following text to the file:

 <Microsoft.Dynamics>
     <Session Timeout="15" Configuration="C:\Inetpub\wwwroot\axapta.axc" />
 </Microsoft.Dynamics>

You can export the AX configuration pointing to the second AOS to a file  and refer it in the second step.

 

 

NOTE: The installation creates a new application pool and a new website virtual directory with the same name but prefixed with a GUID.

NOW how two versions of the product being developed should be deployed on the same sharepoint server is still a QUESTION Hmmm will get back to this blog after I have an answer from the Microsoft guys :)
Workaround: Create a new Layout and ControlTemplate folder and change the web folders in the new website to refer to the new folders and copy the controls to the new folder. This is a clumpsy fix but it works !!

Possible errors

The installation might rollback if there are users connected to the AOS - and the DAX dlls might be locked. There is another error which was encountered saying "Sharepoint port" is already in use dont know the reason for this error but try stopping the other website during the installation

Microsoft Dynamics Ax 2009 Enterprise Portal Development

Coming Soon!

ERR 1: Enterprise Developer Tools - Dynamics Projects not shown in Visual Studio
ERR 2: Unable to connect to Microsoft Dynamics AX. The Dynamics AX Enterprise Portal Tools are not available.

A taste of ERP : Microsoft Dynamics NAV 5.0

Enterprise Resource Planning systems (ERPs) integrate (or attempt to integrate) all data and processes of an organization into a unified system.

Microsoft Dynamics NAV is an enterprise resource planning (ERP) software product from Microsoft.
The product is part of the Microsoft Dynamics family, and intended to assist with finance, manufacturing, customer relationship management, supply chains, analytics and electronic commerce for small and medium-sized enterprises. VARs can have have full access to the business logic source code, and it has a reputation as being easy to customize

Microsoft Dynamics NAV C/SIDE Application Objects
  1. Tables
  2. Forms
  3. Reports
  4. Dataports * (Allows the import or export of table data)
  5. XMLports * (Allows the import or export of XML data)
  6. Codeunits*
  7. MenuSuites*
Programming Language of C/SIDE is object-based - No derived objects (NO-INHERITANCE) and No Polymorphism (Overloading & Overriding). A Pascal like language.

C/SIDE (Client Server Integrated Development Environment) :

Tools for creating Application Objects held in the "Object Designer"
  • Table Designer
  • Form Designer
  • Report Designer
  • Dataport Designer
  • XMLport Designer
  • Navigation Pane Desinger (Menu Designer)
  • C/AL Editor (Code Editor)
All objects in C/SIDE Applications are from the database. The Application ties these objects into a meaningful 'whole'.

Relating Application objects to the general concepts
  • Properties, Fields, Keys, Data Items,
  • C/AL Functions, Triggers, Controls, Request Form,
  • TagNames, TagTypes, XMLport Events,
  • Menu Node, Menu Group, Menu Item
  • Properties:   Properties control the appearance and behavior of application objects
  • C/AL: C/AL is the language used for writing functions in C/SIDE
  • Triggers: When specific things happen to the application objects, the system automatically activates a trigger. Inside a trigger, you can add your own C/AL code if you want to modify the default behavior of the application object or extend its functionality
  • Keys: A key defines the order in which data is stored in your tables and speed up searches on the data
  • Fields: A field is the smallest unit of information in the database
  • Controls: Controls are objects on a form or report that display data, perform actions or decorate the form.
  • Request Form: A request form is a form used in a report. Before a report is run, a request form appears to let the user specify filters and options for the report
  • Data Items: A data item is a building block used for defining a model of data when creating a report.
  • Sections: A section is a substructure of a data item. A section is where controls are placed to display information.
  • TagName: TagNames are used to specify the name of a tag in an XML document.
  • TagTypes: This property is used to specify whether an XML object is an element or an attribute.
  • Menu Node: Either a Menu Group or a Menu Item.
  • Menu Group: A collection of Menu Nodes.
  • Menu Item: The lowest level of the menu tree.
Logical structure of Database
DATABASE ->COMPANIES->TABLES->RECORDS->FIELDS

Fields: A field can be of only one data type out of the 17 types supported
Records: A information holder that group fields that belong to a single entry in the database.
Tables: A logical collection of homogenus Records.
Company: A grouping of Private and Public (Tables shared with other companies) Tables.

Integration tools: ODBC, OCX (ActiveX/OLE Custom control) , OLE Automation and C/Front.NET (API  to access C/SIDE Database a library of functions)


Data Types of Fields used in C/SIDE database system

In the Microsoft Dynamics NAV Server, data is stored with a 4 byte alignment because of performance considerations. The sizes of text, code, and binary fields (that can have variable lengths) are rounded up to the nearest value that is a multiple of four. This means that, for example, a text string of ten characters occupies 12 bytes.

# DATATYPE DESCRIPTION RANGE ---SIZE--- SQL  DATATYPE SIZE
01 Option Equivalent to an Enumeration with a Display item as string and Value item as integer (starts with index 0) -2,147,483,647
to 2,147,483,647
4 Bytes INTEGER (4 Bytes)
02 Integer   -2,147,483,647
to 2,147,483,647
4 Bytes INTEGER (4 Bytes)
03 Decimal   -1063 to +1063 12 Bytes DECIMAL(38,20) (17 Bytes)
04 Text Alphanumeric string (The extra byte holds the length of the string) Maximum 1 - 250 Characters (n+1) Bytes
n = characters
VARCHAR(n)
05 Code Right Justified if all numbers
Left Justified if alphanumeric
Letters get converted to Uppercase
(The extra bytes - 1st stores the length of the string and 2nd stores the alignment)
Maximum 1 - 250 Characters (n+2) n = characters VARCHAR(n)
06 Date Undefined date expressed as 0 1/Jan/0 to 31/Dec/9999 4 Bytes DATETIME (8 Bytes)
07 Time Stored as an integer 00:00:00 to
23:59:59.999
(m+1) m = milliseconds after 0:0:0
4 Bytes
DATETIME (8 Bytes)
08 Boolean Displays YES or NO implicitly equals TRUE or FALSE TRUE/FALSE 4 Bytes TINYINT (1 Byte)
09 Binary Maximum 250 Bytes Max 250 Bytes  n Bytes VARBINARY(n)
10 BLOB Binary Large Object NOT stored with the record but linked to the BLOB Area of the TABLE 8 Bytes for the Link to the BLOB stored in the Record Upto 2GB IMAGE
11 DateFormula Used to validate DATEs entered eg: 30D, CM+1M, D15 4 Bytes 4 Bytes
12 DateTime Coordinated Universal Time Displays based on local settings 4 Bytes 4 Bytes
13 TableFilter Used to apply Filter on other tables      
14 BigInteger   64 Bit Integer 8 Bytes 8 Bytes
15 Duration Difference in milleseconds between 2 points in time - Allows negatives   8 Bytes 8 Bytes
16 GUID Globally Unique Identifier   16 Bytes 16 Bytes
17 RecordID Unique Record Identifier      

Keys:
A Key is  sequence of one or more field IDs from the table, Upto 40 Keys can be defined on each table and the first key is always the Primary Key for the table. Keys provide a basis for indexing data. Secondary keys are used to view records in an order different from the one in which they are sorted according to
the primary key fields. Each secondary key can contain up to 20 unique fields. However, these 20 unique fields must also include all the fields from the primary key. (i.e., if your primary key has four fields then your secondary key can have these 4 fields and a maximum of 16 other unique fields) An Index is maintained on every "ACTIVE" Secondary Key

Special Table Fields:
SumIndexFields
•FlowFields
•FlowFilter Fields

A SumIndexField is a decimal field that can be attached to a key definition. SumIndexFields permit the fast calculation of sums of numeric columns in tables, even in tables with thousands of records. They form the basis for the FlowFields. SumIndexFields permit the fast calculation of sums of numeric columns in tables, even in tables with thousands of records.

FlowFields is like a virtual field that extends the table data it is not a permanent part of the table . The information in the flowfields exists only at run-time. They are automatically initialized to zero. The C/AL function "<Record>.CALCFIELDS" is the function used to up   
Type DataType Description
Sum Decimal Sum
Average Decimal Average
Exist Boolean Record Exists
Count Integer Record Count
Min Any Minimum value
Max Any Maximum value
Lookup Any Lookup
date a FlowField.












Calculation Formula & CalcFormula Property
A FlowField is always associated with a calculation formula that determines how the value in the FlowField is calculated.

Types of Table
  • Master - Contains information about the primary focus subject of its functional area
  • Supplemental - Stores information about a supplemental subject used in one or more functional areas
  • Setup - Stores one record that holds general information about its functional area.
  • Register - A sort of table of contents for its corresponding Ledger table or tables
  • Subsidiary - Contains information which is subsidiary to either a Master table or a Supplemental table or both.
  • Ledger - Contains the transactional information that is the primary focus of its functional area.
  • Journal - The primary transaction entry table for a functional area.
  • Document - Secondary transactional tables that allow entries in a functional area or into multiple functional areas at once. This is actually implemented as a pair table. (Document Header Table & Document Line Table)
  • Document History - Contains the transaction history for documents that have been posted.
Types of Forms
  • Card Form (associated with Master Table)
  • List Form (associated with Master Table)
  • Statistics Form (associated with Master Table)
  • Tabular/Worksheet Form (associated with Supplemental/Subsidiary Table)
  •  

Visual Studio 2005 All Editions Feature Comparison

Found this comparison chart which might be pretty handy
Product Feature Comparisons

http://msdn2.microsoft.com/en-us/vstudio/aa700921.aspx
http://www.howtoselectguides.com/dotnet/visualstudio2005/

Configuring ASP.NET 2.0 Applications on Windows 2003 (IIS 6.0)

Configuring CruiseControl.NET for IIS 6.0

In your system's IIS Admin tool:


   1. Map a virtual directory to the 'webdashboard' subfolder of your CCNet folder (typically called ccnet)
   2. In the configuration for this virtual directory, click the Configuration button of the Virtual Directory tab
   3. Click Add to add a new Application Mapping
   4. In Executable, enter the location of the aspnet_isapi.dll file you use (look at the .aspx mapping as an example. A typical value would be c:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\aspnet_isapi.dll for CruiseControl.NET release 1.2.1 or earlier, or c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_isapi.dll for later releases)
   5. In Extension, enter .xml
   6. Make sure Script engine is checked and Check that file exists is not checked
   7. Click OK as necessary to save your changes
   8. Under the Virtual Directory's Documents tab make sure that default.aspx is added as a default document


Incase of "Page cannot be found" error

The security settings in Windows 2003, prohibits ASP.NET ISAPI.
Here is how you should solve this
1. Click on "Web Service Extensions" in IIS
2. Select "All unknown ISAPI extensions"
3. Click on "Allow"
4. Select "ASP.NET vx.x"
5. Click on "Allow"

Dynamic Events in Javascript

WITHOUT PARAMETERS
Element.<<EVENT>> = <<FUNCTION-NAME>>
eg: document.onLoad = showShadow;

WITH PARAMETERS
Element.<<EVENT>> = function(){ <<FUNCTIONNAME>>(<<PARAM LIST>>)};
eg:  element.onClick = function(){ showAlert(param1,param2) }; // This is a reference to a function

Drinking & Drowning in TDD

Test Driven Development: Testing methodology associated with Agile Programming in which every chunk of code is covered by unit tests, which must all pass all the time, in an effort to eliminate unit-level and regression bugs during development. Practitioners of TDD write a lot of tests, i.e. an equal number of lines of test code to the size of the production code. (Agile Testing: Testing practice for projects using agile methodologies, treating development as the customer of testing and emphasizing a test-first design paradigm.)


 The first step for you to make the jump to TDD properly is to drop the code gen tools for a while. The whole premise of TDD is to design your code using tests as the design artifact to help drive out the solution incrementally. Most code gen tools do a big bang approach of code gen which you as the developer then need to go in an tweak to make work for your scenario. Utilizing code gen will not help you get into the habit of:
  • Writing a failing test for a requirement.
  • Getting the test to compile
  • Coding up the necessary behavior to make the test pass.
  • Cleaning up
  • Continuing
One of the main reasons people have a hard time getting into TDD is that it is a radical departure from the way most people normally develop. In the beginning you will walk slowly, stumbling and falling often. The tests that you initially write may not be overly good. This is because you are now crafting your skills in a new art. Over time, what initially seemed alien and uncomfortable will seem normal, rapid, and welcoming.

“Wouldn’t it take a very long time to finish the project as you are hand coding each class one by one?”

One of the things that is hard to appreciate from the small video that I showed on DNRTV, is the tools and techniques that come into play when you become a proficient test driven developer. In the class that I just finished teaching in Richmond,VA, we built a full portion of an enterprise e-commerce application with a Rich Domain Model, O/R Mapping Layer etc all over the course of a week using Test Driven Development, Design Patterns etc. One of the comments that someone made was the fact that not once during the course of the week did I use studio to either compile or run the project!
 
Again, that might seem like something out of the blue, but it is the little things that make you much more proficient as you get more accustomed to TDD. Once you are into the swing of it, you can bring your CodeGen tools back into the mix where they make sense. More often than not, most people who get swallowed up by TDD start to seriously question the value of Code Gen tools. It’s not to say that they don’t have their place, their use just becomes considerably diminished to how you may be using it right now.
Test-driven development’s main goal is not testing software, but aiding the programmer and customer during the development process with unambiguous requirements. The requirements are expressed in the form of tests, which are a support mechanism (scaffolding, you might say) that stands firmly under the participants as they undertake the hazards of software development

Abraacadabraa...RED GREEN REFACTOR presto !!...and again
The following sequence is based on the book Test-Driven Development by Example, which many consider to be the original source text on the concept in its modern form.

1. Add a test

In test-driven development each new feature begins with writing a test. This test must fail since it is written before the feature is implemented. In order to write a test, the developer must understand the specification and the requirements of the feature clearly. This may be accomplished through use cases and user stories to cover the requirements and exception conditions. This could also imply an invariant, or modification of an existing test.

2. Run all tests and see the new one fail

This validates that the test harness is working correctly and that the new test does not mistakenly pass without requiring any new code.

The new test should also fail for the expected reason. This step tests the test itself, in the negative.

3. Write some code

The next step is to write some code that will cause the test to pass. The new code written at this stage will not be perfect and may, for example, pass the test in an inelegant way. That is acceptable as later steps will improve and hone it. It is important that the code written is only designed to pass the test; no further (and therefore untested) functionality should be predicted and 'allowed for' at any stage.

4. Run the automated tests and see them succeed

If all test cases now pass, the programmer can be confident that the code meets all the tested requirements. This is a good point from which to begin the final step of the cycle.

5. Refactor code

Now the code can be cleaned up as necessary. By re-running the test cases the developer can be confident that refactoring is not damaging any existing functionality. The concept of removing duplication is an important aspect of any software design. In this case, however, it also applies to removing any duplication between the test code and the production code—for example magic numbers or strings that were repeated in both, in order to make the test pass in step 3.

The cycle is then repeated, starting with another new test to push forward the functionality. The size of the steps can be as small as the developer likes, or get larger if s/he feels more confident. If the code written to satisfy a test does not fairly quickly do so, then the step-size may have been too big, and maybe the increment should be split into smaller testable steps. When using external libraries (such as Microsoft ADO.NET) it is important not to make increments that are so small as to be effectively testing the library itself

History
There are various aspects to using test-driven development, for example the principles of "Keep It Simple, Stupid" (KISS) and "You Ain't Gonna Need It" (YAGNI). By focusing on writing only the code necessary to pass tests, designs can be cleaner and clearer than is often achieved by other methods[3].

To achieve some advanced design concept (such as a Design Pattern), tests are written that will generate that design. The code may remain simpler than the target pattern, but still pass all required tests. This can be unsettling at first but it allows the developer to focus only on what is important.

Test-driven development requires the programmer to first fail the test cases. The idea is to ensure that the test really works and can catch an error. Once this is shown, the normal cycle will commence. This has been coined the "Test-Driven Development Mantra", known as red/green/refactor where red means fail and green is pass.

Test-driven development constantly repeats the steps of adding test cases that fail, passing them, and refactoring. Receiving the expected test results at each stage reinforces the programmer's mental model of the code, boosts confidence and increases productivity.

GLOSSARY
Acceptance Testing: Testing conducted to enable a user/customer to determine whether to accept a software product. Normally performed to validate the software meets a set of agreed acceptance criteria.

Automated Testing: Testing employing software tools which execute tests without manual intervention. Can be applied in GUI, performance, API, etc. testing.
The use of software to control the execution of tests, the comparison of actual outcomes to predicted outcomes, the setting up of test preconditions, and other test control and test reporting functions.

Basis Path Testing: A white box test case design technique that uses the algorithmic flow of the program to design tests.Basis Set: The set of tests derived using basis path testing.

Baseline: The point at which some deliverable produced during the software engineering process is put under formal change control.

Benchmark Testing: Tests that use representative sets of programs and data designed to evaluate the performance of computer hardware and software in a given configuration.

Beta Testing: Testing of a prerelease software product conducted by customers.

Black Box Testing: Testing based on an analysis of the specification of a piece of software without reference to its internal workings. The goal is to test how well the component conforms to the published requirements for the component.

Bug: A fault in a program which causes the program to perform in an unintended or unanticipated manner.

CMM: The Capability Maturity Model for Software (CMM or SW-CMM) is a model for judging the maturity of the software processes of an organization and for identifying the key practices that are required to increase the maturity of these processes.

Cause Effect Graph: A graphical representation of inputs and the associated outputs effects which can be used to design test cases.

Code Complete: Phase of development where functionality is implemented in entirety; bug fixes are all that are left. All functions found in the Functional Specifications have been implemented.

Code Coverage: An analysis method that determines which parts of the software have been executed (covered) by the test case suite and which parts have not been executed and therefore may require additional attention.

Code Inspection: A formal testing technique where the programmer reviews source code with a group who ask questions analyzing the program logic, analyzing the code with respect to a checklist of historically common programming errors, and analyzing its compliance with coding standards.

Code Walkthrough: A formal testing technique where source code is traced by a group with a small set of test cases, while the state of program variables is manually monitored, to analyze the programmer's logic and assumptions.

Component: A minimal software item for which a separate specification is available

Context Driven Testing: The context-driven school of software testing is flavor of Agile Testing that advocates continuous and creative evaluation of testing opportunities in light of the potential information revealed and the value of that information to the organization right now.

Cyclomatic Complexity: A measure of the logical complexity of an algorithm, used in white-box testing

Debugging: The process of finding and removing the causes of software failures.

Defect: Nonconformance to requirements or functional / program specification

End-to-End testing: Testing a complete application environment in a situation that mimics real-world use, such as interacting with a database, using network communications, or interacting with other hardware, applications, or systems if appropriate.

Exhaustive Testing: Testing which covers all combinations of input values and preconditions for an element of the software under test.

Functional Testing: Testing the features and operational behavior of a product to ensure they correspond to its specifications.
Testing that ignores the internal mechanism of a system or component and focuses solely on the outputs generated in response to selected inputs and execution conditions.

High Order Tests: Black-box tests conducted once the software has been integrated

Gray Box Testing: A combination of Black Box  and White Box testing methodologies: testing a piece of software against its specification but using some knowledge of its internal workings.

Integration Testing: Testing of combined parts of an application to determine if they function together correctly. Usually performed after unit and functional testing. This type of testing is especially relevant to client/server and distributed systems.

Localization Testing: This term refers to making software specifically designed for a specific locality.

Negative Testing: Testing aimed at showing software does not work. Also known as "test to fail".

Positive Testing: Testing aimed at showing software works. Also known as "test to pass".

Load Testing/Performance Testing: Testing conducted to evaluate the compliance of a system or component with specified performance requirements. Often this is performed using an automated test tool to simulate large number of users. Also know as "Load Testing".

Race Condition: A cause of concurrency problems. Multiple accesses to a shared resource, at least one of which is a write, with no mechanism used by either to moderate simultaneous access.

Ramp Testing: Continuously raising an input signal until the system breaks down.

Regression Testing: Retesting a previously tested program following modification to ensure that faults have not been introduced or uncovered as a result of the changes made.

Sanity Testing: Brief test of major functional elements of a piece of software to determine if its basically operational

Smoke Testing: A quick-and-dirty test that the major functions of a piece of software work. Originated in the hardware testing practice of turning on a new piece of hardware for the first time and considering it a success if it does not catch on fire.

Static Analysis: Analysis of a program carried out without executing the program.

Stress Testing: Testing conducted to evaluate a system or component at or beyond the limits of its specified requirements to determine the load under which it fails and how. Often this is  performance testing using a very high level of simulated load.

System Testing: Testing that attempts to discover defects that are properties of the entire system rather than of its individual components.

Test Bed: An execution environment configured for testing. May consist of specific hardware, OS, network topology, configuration of the product under test, other application or system software, etc. The Test Plan for a project should enumerated the test beds(s) to be used.

Test Case: Test Case is a commonly used term for a specific test. This is usually the smallest unit of testing. A Test Case will consist of information such as requirements testing, test steps, verification steps, prerequisites, outputs, test environment, etc. A set of inputs, execution preconditions, and expected outcomes developed for a particular objective, such as to exercise a particular program path or to verify compliance with a specific requirement.

Test Plan: A document describing the scope, approach, resources, and schedule of intended testing activities. It identifies test items, the features to be tested, the testing tasks, who will do each task, and any risks requiring contingency planning. Ref IEEE Std 829.

Test Scenario: Definition of a set of test cases or test scripts and the sequence in which they are to be executed.

Test Script: Commonly used to refer to the instructions for a particular test that will be carried out by an automated test tool.

Test Specification: A document specifying the test approach for a software feature or combination or features and the inputs, predicted results and execution conditions for the associated tests.

Test Suite: A collection of tests used to validate the behavior of a product. The scope of a Test Suite varies from organization to organization. There may be several Test Suites for a particular product for example. In most cases however a Test Suite is a high level concept, grouping together hundreds or thousands of tests related by what they are intended to test.

User Acceptance Testing: A formal product evaluation performed by a customer as a condition of purchase.

White Box Testing: Testing based on an analysis of internal workings and structure of a piece of software. Includes techniques such as Branch Testing and Path Testing. Also known as Structural Testing and Glass Box Testing. Contrast with Black Box Testing.

Workflow Testing: Scripted end-to-end testing which duplicates specific workflows which are expected to be utilized by the end-user.

Code Refactoring is any change to a computer program which improves its readability or simplifies its structure without changing its results.(When refactoring, best practice is to have test fixtures in place: They can validate that your refactorings don't change the behavior of your software.)

Test-Driven Development (TDD) is a software development technique that involves repeatedly first writing a test case and then implementing only the code necessary to pass the test. Test-driven development gives rapid feedback. The technique began to receive publicity in the early 2000s as an aspect of Extreme Programming and agile programming, but more recently is creating more general interest in its own right

References
http://en.wikipedia.org/wiki/Test-driven_development
http://www.agileprogrammer.com/dotnetguy/archive/2006/08/01/17795.aspx

Tools.NET: Development Tools for Microsoft.NET Developers

Directory of opensource .NET development Tools My collection of development tools is never ending I will never be able to document their applicability - I am lost in utility jungle - but I am loving it

http://www.chiramattel.com/george/blog/
http://opensource.thoughtworks.com/projects/dotnet.html
http://code.google.com/p/ntrac/
http://www.codeplex.com/
http://code.google.com/hosting/
http://sf.net/
http://www.ibiblio.org/fosphost/exhost.htm
http://opensource.thoughtworks.com/projects/dotnet.html
http://csharp-source.net/
http://www.java-source.net/
http://www.opensourcetesting.org/
Selecting the best tool for your job made easy :
http://www.howtoselectguides.com/dotnet/
http://guipro.sourceforge.net/
http://www.group-office.com/
Book Windows Developer Power Tools: Turbocharge Windows Development with More Than 140 Free and Open Source Tools
http://www.amazon.com/gp/product/0596527543/sr=8-1/qid=1155941398/ref=pd_bbs_1/104-1108965-0733512?ie=UTF8
http://msdn.microsoft.com/msdnmag/issues/05/12/VisualStudioAddins/default.aspx
http://msdn2.microsoft.com/en-us/teamsystem/aa718949.aspx
http://www.guidanceautomation.net/cs/library/?tab=3

http://www.microsoft.com/downloads/details.aspx?familyid=89e6b1e5-f66c-4a4d-933b-46222bb01eb0&displaylang=en
http://www.springframework.net/
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cptools/html/cpconxmlschemadefinitiontoolxsdexe.asp

Recommendations by others
http://codebetter.com/blogs/jeremy.miller/archive/2007/03/05/Do-you-use-OSS-tools-for-.Net-development_3F00_.aspx
http://www.jameskovacs.com/blog/CategoryView.aspx?category=.NET+Tools
http://msdn.microsoft.com/msdnmag/issues/04/07/MustHaveTools/default.aspx
http://www.theserverside.net/news/thread.tss?thread_id=33285
http://www.jpboodhoo.com/blog/WhatOSSSoftwareDoYouUse.aspx
http://frazzleddad.blogspot.com/2006/08/book-update-100-final-draft.html

http://www.opensourcetesting.org/functional.php
http://www.developers.net/external/1291

The exhaustive list
Project Management & Issue Tracking WiKi (not in .NET - python & clearsilver)
http://trac.edgewall.org/about

TreeSurgeon.NET (Project Development Tree for .NET)
http://confluence.public.thoughtworks.org/display/TREE/Tree+Surgeon
C#<=>VB Translator
http://www.carlosag.net/Tools/CodeTranslator/Default.aspx
CCNetConfig (When I wanted to create one I already find it is here !! )
http://ccnetconfig.org/
NPlot
http://www.nplot.com/
NVelocity
http://sourceforge.net/project/showfiles.php?group_id=58632
NDEPEND:
http://smacchia.chez.tiscali.fr/NDepend.html
http://www.kiwidude.com/blog/2006/01/ncoverexplorer-debut.html
http://www.sliver.com/dotnet/NCoverBrowser
http://weblogs.asp.net/nunitaddin
http://draconet.sourceforge.net/
http://confluence.public.thoughtworks.org/display/CCNET/Resources
http://nant.sourceforge.net/
http://www.nunit.org/
http://nunit2report.sourceforge.net/
http://ncover.org/site/
http://www.red-gate.com/products/ants_profiler/index.htm
http://www.gotdotnet.com/team/fxcop/
http://www.genetibase.com/nugenunify.php
http://www.swoogan.com/nantgui.html
http://www.nantpad.com/
http://subversion.tigris.org/
Hippo.NET
http://hipponet.sourceforge.net/
DragNET
http://www.sourcegear.com/dragnet/downloads.html
MSBUILD: http://www.microsoft.com/downloads/details.aspx?FamilyID=b6d3a791-c3be-4d53-b20d-dfbe4b1269ce&displaylang=en
NMAKE : http://support.microsoft.com/default.aspx?scid=kb;en-us;Q132084
http://www.redhillconsulting.com.au/products/simian/
http://www.1bot.com/
http://attrice.info/msbuild/?gclid=CPLG5qOo4ooCFQmZbgodGBSz2w
http://zutubi.com/?gclid=CNifqcSt4ooCFQ-WbgodlDbK2Q
http://www.jetbrains.com/profiler/
http://www.microsoft.com/downloads/details.aspx?familyid=A362781C-3870-43BE-8926-862B40AA0CD0&displaylang=en
http://www.object-relational-mapping.net/en/product-information/stop_hibernating?gclid=CL3T3sat4ooCFQmZbgodGBSz2w
NHIBERNATE:
http://www.hibernate.org/343.html
http://www.codeplex.com/SHFB/Release/ProjectReleases.aspx
LIBCHECK:
http://www.microsoft.com/downloads/details.aspx?FamilyID=4B5B7F29-1939-4E5B-A780-70E887964165&displaylang=en
SANDCASTLE HELP
http://www.codeplex.com/SHFB/Release/ProjectReleases.aspx
NPROF:
http://www.mertner.com/confluence/display/NProf/Home
Web Automation Testing Tools
SAHI:
http://sahi.co.in/
http://sourceforge.net/projects/sahi/
SELENIUM:
http://www.openqa.org/selenium-core/download.action
WATIR
http://code.google.com/p/firewatir/downloads/list
http://watin.sourceforge.net/

http://browserunit.sourceforge.net/

http://www.codeplex.com/reflectoraddins
MBUnit
http://mb-unit.googlecode.com/files/MbUnit-2.3.105.exe

http://www.codeproject.com/csharp/nliterate.asp
http://www.codeproject.com/csharp/cssorters.asp

http://www.jetbrains.com/teamcity/
http://www.sparxsystems.com.au/products/ea_downloads.html
http://www.xtreme-simplicity.net/Download.htm
http://www.jetbrains.com/resharper
http://www.jetbrains.com/profiler/
http://blog.dotnetwiki.org/NCoverTutorial.aspx
XSD Class Gen (wish he could share the source its a brilliant idea - no reinventing the wheel)
http://devauthority.com/blogs/ram_marappan/archive/2006/10/03/4755.aspx
ADCG - Automatic Data Class Gen from XSD + XML => C# CS
http://www.codetools.it/index.aspx?summary

WEB IDE for Javascript etc - Aptana
http://www.aptana.com/download_all.php

Favorite tools.

Other open source projects of interest on CodePlex
Litware HR
http://msdn2.microsoft.com/en-us/architecture/bb229292.aspx
(SaaS S+S
http://msdn2.microsoft.com/en-us/architecture/aa699384.aspx )
TRAC
http://trac.edgewall.org/
http://trac-hacks.org
http://trac.php-tools.net/patTemplate/wiki/TracGuide
TACKLE SCRUM
http://www.codeplex.com/Tackle
MSBUILD TASKS
http://www.codeplex.com/sdctasks
Facebook
http://www.codeplex.com/FacebookToolkit/Thread/List.aspx

http://www.codeplex.com/RDdotNet

Issuetracking
http://www.codeplex.com/kobianKare
http://www.codeplex.com/webolize
http://www.codeplex.com/projectstudio
http://www.codeplex.com/webbugs
http://www.codeplex.com/gbugtracker
http://www.codeplex.com/chase

http://www.codeplex.com/eventtrack

http://www.codeplex.com/worktracker

http://www.codeplex.com/scrumptious

http://www.codeplex.com/roobooks

http://www.codeplex.com/ServicesERP
http://www.codeplex.com/bdtte
http://www.codeplex.com/assetman
http://ns.hr-xml.org/2_5/HR-XML-2_5/SEP/Resume.html
http://www.codeplex.com/sharpresume
http://www.codeplex.com/LitwareHR
http://www.codeplex.com/erm
http://www.orangeHRM.com
http://www.heeree.com/samnet
www.visualwebgui.com/
http://www.devdefined.com/Home/Technologies.rails

Interesting projects & tools at TIGRIS

abc Application Builder for C#
activitysensor Capturing developer's activities during development process
ado-mock An ADO.Net provider for mocking databases for unit testing
ankhsvn VS.NET addin for the Subversion version control system.
antelope A graphical user interface for Ant.
argosoffice Star/OpenOffice plugin for ArgoUML
argospe A Software Performance Engineering Tool
argouml A UML design tool with cognitive support
aut Advanced Unit Testing
babylon Develops AJAX based components
bamboo A set of reusable .NET components for building developer tools. (KEEP TRACK)
bugfree a lightweight and simple web-based bug tracking system
busl Beautifier for bsh/C/C++/C#/D/groovy/java/javascript/nice/os/php
cabie Continuous Automated Build and Integration Environment
cairo Cairo is an XP/agile project management system
calendardrawer A .Net library for drawing a calendar
ccmarauder CruiseControl.Net Plugin
cervantes Generic shopping cart - ecommerce application written in PHP
cfnunitbridge NUnit test runner for the compact framework
chmsubscc Lightweight Subversion SCC provider
claw Rapid development framework for PHP5
biscuitproject Ruby on Rails-based framework for PHP
binarycloud php web development platform
eden-php-editor A PHP editor with some unique, useful functions
flarframework A project developing an extensible framework written in
peach PHP5 Content Management Framework
phing PHP project build system based on Apache Ant
php-svn-client PHP extension for access to Subversion client functionality
php-xcore Enterprise php framework / sybase powerdesigner code generation
phpcreate A MySQL centric PHP script generator + simple appl. framework
phrac PHP5 written wiki and bug tracking system for software projects
servmon A php script for monitoring server status.
phruise A continuous building system for PHP5
phpprime A LGPL and complete intranet framework.
phpportalen A new, different, flexible CMS. A framework for webapplications.
phpmakeupdate Web-based intranet tool for export only modified files from SVN
phpobjects Component architecture for PHP
pinetd Simple API used to make socket based applications in PHP.
pivip Forum/Bulletin Board software, written in PHP 5 and valid XHTML
simplemyadmin This is an another php mysql adminstrator.
simplicity An MVC based PHP5 framework for rapid application development.
g1 MVC 2 framework for PHP5
spe SVN Client Library Extension for PHP
limb Limb PHP Framework
spyder A PHP Library specializing in security functions and flexibility
siusx Installation Manager for automatical Installation of PHP scripts
pub PHP Workflow system for small to medium web development teams
yawp Yawp is a single-file foundation for PHP applications.
wasp Web Application Structure for PHP
websvn PHP based web interface of Subversion repositories
wikidotphp Another PHP Wiki
publicera php5 framework for rapid development of php5 applications.
propel Object persistence and query service for PHP5
garden Dependency Injection for PHP5
geese Mini framework for PHP5
combine Combine is a Model-View-Controller for PHP5
interphace PHP Object Model and Framework for User Interface Components.
lawngnome PHP OO DB Model inspired by Django
codeblocks Open-source cross-platform IDE
commitmessage Modular, OO-based Python framework for SVN and CVS commit script
cudgets Javascript library with easy to integrate and extendable widgets
current Current is an open-source package management and deployment tool
cvs2svn CVS to Subversion Repository Converter.
cvsanaly CVS/Subversion repository analyzer
cvslib A .Net library for interacting with a CVS command line client
daffodilcrm Open Source CRM solution - Daffodil CRM
daversy An scm tool for databases
dbhelper ADO.NET access helpers
doodads The dOOdads .NET Architecture
dotcat Computer Assisted Timetabling software
dotnetopenid C# .NET implementation of Janrain's OpenID library.
emow emow - the easy manager of websites
erdms ER-DMS is a E-R model (Entity-Relationship) toolkit
ereport Create database reports in spreadsheets.
ermodeller Database designer built in Java
essence Frontend to MySQL
expergent An rete-based rules engine for the .net platform.
firebreak Continuous Intagration for simultaneous multiplatform builds
force A full featured programming environment for FORTRAN 77.
fsvs Backup/restore for subversion backends
fxcopaddin Open Source FxCop Integration for Visual Studio 2005
gef-dotnet Port of GEF library to .NET
gefnet A C# port of the GEF project
giant Graph Interface to ANT
gridshoresample A Blogging application using the springframework
historian A .Net program for displaying revision history in a project.
imagediff Visually compare (diff) 2 images through TortoiseSVN
inana C# Data Access Layer
insurrection A set of XSLT and CGIs to provide web access to Subversion
javelina an advanced code coverage tool
jcrispy Java style checker / fixer
jreq flexible project management system
jtlscriptingengine An embeddable scripting language written entirely in C#.
juxy Juxy - XSLT unit testing from Java
kamikaze-qscm An SCM query tool similar to Mozilla's tool, Bonsai.
log4javascript Javascript logging framework based on log4j
mantisbt Mantis Bug Tracker
mead A feature-rich mono-c# development environment (IDE)
miscutil A .Net library containing some helpful utility classes
mod CMU West - Managing Outsourced Development
msbuildtasks Open source tasks for MSBuild
myxaml Xml defined user interface generator
ncodestatsreport Produces Pretty Print reports for Codestats task of NAnt
netspell NetSpell is a free spell checking engine for the .net framework.
nlog NLog - A .NET Logging Library
nspec A Behaviour Specification Framework for .Net
nullbugs A bugtracking system for all types of projects.
officesvn Integration of Subversion into (MS) Office
oooooooo A simple instant messenger for lan.
openlicense A complete .NET License Manager.
openteamsystem Open Source System much like MS Team System for VS2005
osgerms Open Source Generic Entity Relationship Management System
ourbts Web based Bug Tracking System
p2pnet A p2p SDK for .net
p2psdk A p2p SDK for .net to build simple p2p Applications.
pageunit Simple web page testing facility
patcher A .Net application for interactive code reviews
plastic UML Modeling Tool
platypus page layout and typesetting system
pncseitbhu SoftwareTool for documenting design patterns
proxy-svnserver Creating a SVN proxy server for SVN
puppy Puppy is a XP team project management platform.
pylibparted Python bindings for parted's library (libparted).
pympeg-7 Python MPEG-7 library
pystructures Python implementation of tree, graph, FSM, etc.
pysvn Python SVN Extension and WorkBench GUI
qforms A JavaScript API for creating interactive HTML forms.
rainbow Opensource ASP.NET CMS, Portal Engine
raindance Raindance is an open-source tool for UML design.
rant4ant Rant is Relational ANT - is is used to build DDL and DML in data
rapidsvn Multi-platform GUI front-end for the Subversion revision system.
rave Requirements Automation and Validation Engine
realmforge Cross-platform 3D game framework and toolset for .NET in C#
rico JavaScript library - now maintained at openrico.org
scarab Artifact tracking system
scatter A distributed human-network-oriented corporate PIM
scplugin SCPlugin allows access to Subversion commands from the Finder
scriptables Javascript Form helper scripts
shock A 3D graphics engine built in C#/.NET 2.0 and Managed DirectX.
sin Continuous Integration for Subversion
soya Information and Knowledge sharing platform
spark Spark is a multi-user, multi-group calendaring environment
spinvoke SQL Server stored procedures wrapper generator for .Net
sqlserverwebconsole Web manager administration console for SQLServer
srp software for selection and recruting of corporate personel.
srtk software requirements toolkit
stencil Template Engine for C#
storyteller Automated acceptance testing for .Net
style CSS for web applications
subcommander qt based multiplatform subversion client, diff & merge tool
subissue Track issues directly in your Subversion repository.
subportal Web portal for Subversion repositories in an Apache HTTP server
subtest Framework for rapid automated testing of Command Line Interface
subtrain Open Source - Subversion Training Materials
subversion A compelling replacement for CVS
subview C#/IIS based web interface of Subversion repositories
subvstats Creates a statistics summary report of subversion repositories.
subwiki Wiki using a Subversion data repository
svn1clicksetup Set up svn with a single installer.
svn2cvs save subversion commits to cvs repository
svn4db organize svn for database development and easy deployment.
svn4office Integration of Subversion into (MS) Office
svnadmin WebApp to manage svn repositories
svnauthzdb Apache authorization database module for subversion repositories
svnbrowser web interface to Subversion repositories
svncontrol A remote administration tool for subversion servers
svnmapper SvnMapper gives you a map to navigate your subversion branches.
svnnotifier Notifies you about other people's commits to subversion
svnpkg Scripts to create packages from a subversion repository
svnscc An SCC Provider for Subversion
svnservice Runs svnserve as a Windows service (requires .NET Framework 1.1)
svnutils Utilities for Subversion
svnvb6 Subversion integration for Visual Basic 6
svnwcrev Incorporate Subversion repository information into your source
svnwebcontrol Control a Web-Project versioned with SVN via Browser.
svtmerge SVN Merge Interface with FileBrowser and contextual menu
tedia2sql Dia UML Diagram --> SQL Converter
testgen Web service test data generator
texteditor This is a open source text editor written purely in C# 2.0.
timelog A .Net application for tracking one's time
tksvn Cross-platform Subversion and CVS GUI
todo-task An ant task to help developers keep track of todo's
tortoisesvn Windows Shell Extension for Subversion
tortoisesvnscc Subversion SCC Plugin for TortoiseSVN
twysiwyg A Twiki wysiwyg editor
ubik .NET Object-Relational Persistence Framework
usvn USVN is a web interface which permit to administrate SVN servers
viewsvnserve Web frontend to the Subversion svnserve daemon.
viewvc Web-based version control repository browser
vss-subverter Convert a VSS Repository to Subversion
vss2svn Visual SourceSafe to Subversion Converter
vss2svn2 VisualSourceSafe to Subversion migration
vss2svnmigrate Migrate VSS repository to Subversion
wirexn AJAX-based application framework and development tools
wxrestedit a wxPython based ReStructuredText GUI editor
wxsvnadmin A GUI frontend for svnadmin based on wxPython
xanta Xanta .NET Language, Compiler & Tools
xap4net XmlHttp Application Plattform for the .NET Framework
xgridcsharp XGrid C# Library
xsltfilter performs Xsl transformations on the ASP.NET output stream
xstream Design and test XML and XSLT structure and process flow
yoxel Agile Product Management

TRAC - Project Management

TRAC - Integrated SCM & Project Management

"Trac is an enhanced wiki and issue tracking system for software development projects. Trac uses a minimalistic approach to web-based software project management. Our mission is to help developers write great software while staying out of the way. Trac should impose as little as possible on a team's established development process and policies. It provides an interface to Subversion, an integrated Wiki and convenient reporting facilities. Trac allows wiki markup in issue descriptions and commit messages, creating links and seamless references between bugs, tasks, changesets, files and wiki pages. A timeline shows all project events in order, making the acquisition of an overview of the project and tracking progress very easy."

Trac gives you a wiki, ticket system, milestones and source viewer that integrates quite nicely with Subversion.
Trac brings as quoted above an
  • Enhanced WIKI (a database of pages that can be collaboratively edited using a web browser)
  • Issue Tracking and problem solving system
  • Advanced & Flexible Reporting
  • Project Management Activities - Time Lines, Progress indicators, Peer Reviews and Deadlines
  • Works on Python, ClearSilver and SQLite(or PostgreSQL, MySQL) SubVersion & GIT (Other plugins available)

Objectives:
1: Install Trac on a Windows Box

2: Configure Trac environment
3: Customize Trac for your organization

I - Installing TRAC on Windows

I am installing Trac on a box running on Windows 2000 Professional.

Pre-requisites

Other Pre-requisites for the Installation are as follows
  1. Web Server : I am using the Apache Web Server 2.0.59 and configuring it to use the port 80. (NB: In case the machine has other web servers configured eg:IIS make sure you have the port 80 dedicated for the Apache Web Server that has to be installed)
  2. Source Control : I am using the same computer to act as my source control server. Will be using Subversion 1.4.4 for handling the source control.
  3. Script Engine: Trac is written in Python, so you will need to install Python. The recommended version of Python at this time is 2.4.4
  4. Other Bindings: There are few python binding packages/libraries that need to be installed for smooth sailing. Those will be covered as we go on further with the installation.

Directory Structure

Create a folder/directory "C:\TRAC" Primary folder for all the installations related to TRAC will be targeted to this folder.

Apache Web Server 2.0.59

  • InstallingApache Web Server 2.0.59 Get the windows installer from http://httpd.apache.org/  For further details on the installation and configuration of Apache Web Server refer this blog entry.  The "Apache Service Monitor” should glow green after the installation.
  • Make sure you opt for the "Custom" installation and select C:\TRAC and install the Apache Web Server related files to a folder "C:\TRAC\Apache2"

Python

  • Installing Python 2.4.4. Get the windows installer from http://www.python.org/download The automated windows installer (msi) works fine. Again make sure you have the installation targetted to  the  folder of your choice say "C:\TRAC\Python24". If you run into problems the python documentation http://www.python.org/doc should help
  • Make sure the installation has appended the installation directory to the PATH environment variable or/and created a "PYTHONPATH" environment variable with the same information (in this case"C:\TRAC\Python24").

Subversion

SQLite 

  • Installing SQLite 3  Get the zip archive containing the Sqlite3.exe unzip it to "C:\TRAC\SQLite3" and add this path to the environment variable PATH. The TCL library or the standalone dll can be downloaded from http://www.sqlite.org. Details on installation can be found at this blog.
  • NOTE: This step is subject to change, since it is not used (Benefit of doubt :p )

Bindings

Optional Bindings

Configuration & Customization to follow ...stay tuned :)
NOTE: Appending
?hdfdump=1 to the Tracs url gives a dump of all server variables and configuration that can be used.

Trac Implementations

Continous Integration : Express Delivery using Cruise Control.NET & NAnt

Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly. This article is a quick overview of Continuous Integration summarizing the technique and its current usage.
~ Martin Fowler ~

"A software engineering term describing a process that completely rebuilds and tests an application frequently"

in transition and getting agile

Advantages
  • Integration problems are detected and fixed continuously - no last minute hiatus before release dates
  • Early warning of broken/incompatible code;
  • Immediate unit testing of all changes;
  • Constant availability of a "current" build for testing, demo, or release purposes;
  • The immediate impact of checking-in incomplete or broken code acts as an incentive to developers to learn to work more incrementally with shorter feedback cycles.
  • You catch build breaks early on.
  • In a distributed development environment where developers do not always communicate with one another, continuous integration is a great way to assure the developer that the build he or she is building is the latest one.
  • Continuous integration also causes less regression
  • The feedback loop is smaller.
  • A developer does not have to wait for the end of the day or week to find out how the check-in affected the build.
  • Integration testing moves up in the chain.
  • Every check-in goes through the integration testing where problems are caught early.
  • Continuous integration enforces better development processes.
  • Each developer is held accountable.
  • You always have a latest-and-greatest build to use in demos, showcases, etc.
Continuous Integration (CI) is a well-established practice which allows us as developers to experience fewer development conflicts and achieve rapid feedback on progress.

Disadvantages:
  • Maintenance overhead often increases.
  • Some teams find that the level of discipline required for continuous integration causes bottlenecks.
  • The immediate impact of a check-in often causes a backup because programmers cannot check in partially completed code.

Continuous integration has both advantages and disadvantages. The primary disadvantage is that it can disrupt the development process. A cost is always incurred when you are developing a component and are suddenly forced to deal with integration issues. The advantages, however, outweigh the disadvantages in this case because you can deal with integration issues while the consequences of integration decisions are still fresh in your mind. Continuous integration can also reduce schedule risk resulting from failures to identify integration issues that may cause significant rework to one or more components.

In my previous organization I remember my teams Associate Project Lead sitting late night to build the project integrating all the modules, I then didnt realize that the manual rigmarole that he was battling had a name. He would daily appear at our workplace at mid-day often half-dead due to the ordeal.

Now that ordeal has a name "Continuous integration", a software engineering term describing the process that completely rebuilds and tests an application frequently.continuous integration is accomplished via a serialized build process . At the completion of a task, the developer (or development pair) takes a build token and runs the build process, including tests. If the tests pass, the task can be committed to the source code repository and release the token. More recently a server process or daemon that monitors a version control system for changes is live and automatically runs the build process (e.g. a make script or Ant-style build script) and then runs test scripts (e.g. JUnit or NUnit). In many cases the build script not only compiles binaries but also generates documentation, website pages, statistics and distribution media.

Continuous integration is the process of generating a build whenever a programmer checks code into the source control server. When you use this process, it is a good idea to have a dedicated build server where you can synchronize and compile the sources, and run unit tests. Software development life cycle processes evolved over time. Development teams realized the importance of having periodic builds. It started with a weekly build. Then it grew tighter when "nightlies" began, and tighter still with "hourlies." As the benefits of frequent builds became more obvious, organizations wanted more builds. And now we have continuous integration. But nightlies still exist. Many organizations still count on them to get a formal, reliable build.

CruiseControl as a tool for Continous Integration is especially valuable when the team is transitioning to agile development and has a large legacy process or source code burden. In those cases, the build fails a lot, and CruiseControl is a valuable cleanup tool and also in certain kinds of heavy-duty testing. Monte-carlo simulations, some kinds of performance testing, memory leak testing, some kinds of automated regression testing. These are all legit, and can be very slow. On the down-side the full test suite is not run before developer checks in his code, so the build will break more often. Since the repository is not locked it is more likely that the team will get code that doesn't work. The test suite is likely to be slower, too, because you won't have to personally wait for the whole test suite to pass.

Commerically available options for CI
  • AnthillPro - a commercial tool from Urbancode. Along with CruiseControl, Anthill is one of the original tools in this category; it remains a market and technology leader constantly adding new features such as dependency mangement, workflow automation, etc.
  • Bamboo - Commercial continuous integration server from Atlassian
  • BuildBot - a Python/Twisted-based continuous build system
  • Build Forge - IBM Rational's adaptive framework to standardize and automate build and release processes.
  • CABIE - Continuous Automated Build and Integration Environment. Open source, written in Perl, works with CVS, Subversion and Perforce.
  • Apache Continuum - a continuous integration server supporting Apache Maven and Apache Ant.
  • CruiseControl - Java-based framework for a continuous build process.
  • CruiseControl.NET - .NET-based framework for a continuous build process.
  • CruiseControl.rb - Ruby-based framework for a continuous build process.
  • DamageControl - a continuous integration server for Ruby.
  • Electric Commander - a continuous integration server by Electric Cloud, John Ousterhout of Tcl fame's company.
  • Apache Gump - Apache's continuous integration tool.
  • Hudson - MIT licensed, written in Java, runs in servlet container, supports CVS, Subversion, Ant, Maven, and shell scripts.
  • LuntBuild - a powerful open source build automation and management tool
  • Tinderbox - a Mozilla based product
  • TeamCity - a commercial tool by JetBrains. Web-based with IDE (IntelliJ IDEA, Eclipse, Microsoft Visual Studio) support. Includes many innovative features.
Build Responsibilities

There is one responsibility that I think is worth noting above all others: it must be self sufficient. This is an absolute must, with out it chances are the practice will fail. The responsibilities listed below aren’t necessarily in order, in some situation they may not be needed. View these as a list of possible responsibilities the build server will fulfill.

  • Monitor for trigger (There are many reasons to trigger and these will depend on your objectives for you build server. The most common trigger is changes to source control.)
  • Cleanup and verify build enviroment
  • Control version of product and artifacts
  • Compile Debug configruation of product and test code
  • Run tests
  • Compile Release configuration of product code
  • Compile installer
  • Publish results and artifacts
  • Trigger dependant builds
  • Complete in about ten minutes

Developer Responsibilities

The developer responsibilities listed below are in sequence of execution, order is important. This list starts off in the greater sequence of events where the developer has just completed the task at hand and is ready to be the build submission process.

  1. Synchronize with the SC repo
  2. Compile
  3. Execute unit tests
  4. Make fixes if needed
  5. Claim the build (don’t forget to communicate if it’s a significant change)
  6. Submit changes to the SC repo
  7. Wait for the build result (do not start coding on somthing)
  8. If the build result is success congratulations, if not fix it

Work in progress !! Please come back after I finish reading all this stuff ;-) Tools for your greater CI !!
References:

http://en.wikipedia.org/wiki/Continuous_Integration
http://www.martinfowler.com/articles/continuousIntegration.html
http://www.martinfowler.com/articles/originalContinuousIntegration.html

http://www.jamesshore.com/Blog/Continuous-Integration-on-a-Dollar-a-Day.html
http://www.methodsandtools.com/archive/archive.php?id=42
http://www.c2.com/cgi/wiki?ContinuousIntegration
http://jayflowers.com/doku/doku.php?id=a_recipe_for_build_maintainability_and_reusability
http://jayflowers.com/joomla/index.php?option=com_content&task=view&id=26
http://www.jamesshore.com/Blog/Red-Green-Refactor.html
http://www.jamesshore.com/Blog/Continuous-Integration-is-an-Attitude.html
http://www.jamesshore.com/Blog/Why I Dont Like CruiseControl.html
http://msdn.microsoft.com/msdnmag/issues/06/03/TeamSystem/default.aspx
http://blogs.msdn.com/buckh/archive/2006/08/09/more_continuous_integration.aspx

Developer Resources & Tools :

TreeSurgeon.NET
http://confluence.public.thoughtworks.org/display/TREE/Tree+Surgeon CCNETConfig http://www.codeplex.com/ccnetconfig/Project/ NCoverExplorer http://www.kiwidude.com/dotnet/NCoverExplorer.zip NAntGUI http://www.swoogan.com/downloads/nant-gui/NAnt-Gui-1.4.0.exe CIFactory (SVN) http://www.mertner.com/confluence/display/CIF/CI+Factory+Home
https://sourceforge.net/projects/jcruisemonitor
http://www.codeplex.com/automation
Source Control Management
Source Control HOWTO- by Eric  http://www.ericsink.com/scm/source_control.html
SubVersion Manual  - http://svnbook.red-bean.com/nightly/en/svn.basic.html
Branching & Merging Primer  - http://blogs.msdn.com/chrisbirmele/archive/2006/05/31/611179.aspx

Developer Discipline

The objective of coding rules is to reduce confusion among the readers. The key to that is consistency: consistency throughout a project, between projects and between authors.

    * Be consistent ? look at the existing code and make yours fit it.
    * Make the code so simple that its boring to read.
    * Follow .NET naming conventions (see SDK docs) http://home.comcast.net/~lancehunt/CSharp_Coding_Standards.pdf
http://www.idesign.net/idesign/download/IDesign%20CSharp%20Coding%20Standard.zip
    * Prefix private fields with a _ character to look like: int _value;
    * Omit private scope declaration unless it makes the code clearer.
    * Use 4 space indents instead of tabs.
    * One class one file.
    * Class files stored in directories to match namespace.
    * Squiggly on same line as construct in all cases including classes and methods.
    * Always use { } even if statement is a single line.

      // good
      if (foobar) {
      	DoSomething();
      } else {
      	DoSomethingElse();
      }

      // bad - ommits { } - error prone
      if (foobar)
      	DoSomething();

      // bad - same reason as above but requires more work to edit
      if (foobar) DoSomething();

      // bad - does not represent logical structure of code
      // read McConnell, Code Complete
      if (foobar)
      {
      	DoSomething();
      }

      // bad - same reason as above
      if (foobar) {
      	DoSomething();
      }
      else {
      	DoSomethingElse();
      }
      			

    * GPL header on every source file.
    * Namespace starts with SourceForge.NAnt
    * Avoid ? : operations in all but the most trivial cases.
    * Avoid assignment in conditionals.
    * Avoid magic numbers, use a nested enum instead.
The above mentioned Coding Conventions are as mentioned at SourceForge [ http://sourceforge.net/docman/display_doc.php?docid=6080&group_id=31650 ]

Structuring Large Solutions
Developer Discipline: Stucturing your solutions
http://www.javaranch.com/build_standards.jsp
http://www.mikebroberts.com/blog/archive/Tech/ArticlesandPapers/Howtosetupa.NETDevelopmentTree.html
http://www.developer.com/tech/article.php/994991
http://www.ssw.com.au/ssw/Standards/Rules/RulesToBetterLargedotNETProjects.aspx
http://msdn2.microsoft.com/en-us/library/ms998208.aspx
http://msdn2.microsoft.com/en-us/library/ms998215.aspx
http://searchwebservices.techtarget.com/tip/0,289483,sid26_gci1011711,00.html
http://www.code-magazine.com/article.aspx?quickid=0405071&page=7
101 Samples for VS2005
http://msdn2.microsoft.com/en-us/windowsmedia/aa718334.aspx
http://www.code-magazine.com/article.aspx?quickid=0405071&page=1
«November»
SunMonTueWedThuFriSat
25262728293031
1234567
891011121314
15161718192021
22232425262728
293012345