https://msdn.microsoft.com/en-us/magazine/ee819140.aspx

1. case insensitive (clear the Case - sensitive check box), 

2. accent sensitive,

3. and not binary.

To avoid problems with double-width or hiragana/katakana-equivalent characters, you should select the check boxes to enable Kana and width sensitivity when you install SQL Server.

https://research.microsoft.com/en-us/projects/pex/pexsharepoint.pdf

• Static methods, methods in sealed types, constructors

See here for an example on how to use Moles: https://research.microsoft.com/en-us/projects/stubs/moles.aspx

A parameterized unit test (PUT) is simply a method that takes parameters, calls the code under test, and states assertions.

Parameterized unit tests separate two concerns:

1) They specify the external behavior of the involved methods for all test arguments.

2) Test cases can be re-obtained as traditional closed unit tests by instantiating the parameterized unit tests.

https://research.microsoft.com/en-us/projects/pex/downloads.aspx

Pex finds interesting input-output values of your methods, which you can save as a small test suite with high code coverage. Pex performs a systematic analysis, hunting for boundary conditions, exceptions and assertion failures, which you can debug right away. Pex enables Parameterized Unit Testing, an extension of Unit Testing that reduces test maintenance costs.

HOW IS PEX DIFFERENT?

With VS 2008 Unit Tests Framework and other unit test tools such as NUnit, the user has to provide all test inputs: individual values, ranges, a spreadsheet, or a database of some sort. Improper choice of inputs would lead to missed corner cases or a hugely redundant test suite, or both. With Pex, things change for the better, the user does not have to provide any input to the parameterized unit tests. By analyzing the program behavior at runtime Pex can generate inputs that matter, i.e. inputs that will increase the coverage of the test suite and expose bugs.

WHAT DOES PEX HAS IN IT FOR DEVELOPERS?

Some of the "must have - must follow" design principles

1. Encapsulate what varies = Strategy pattern.
2. Favor Composition over inheritance = Strategy pattern.
3. Program to interfaces not implementations = Strategy pattern.
4. Strive for loosely coupled designs between objects that interact = Observer Pattern.
5. The Open Closed Principle: Classes should be open for extension and closed for modification = Decorator pattern.
6. Depend on abstracts, do not depend on concrete classes = Factory Pattern.
7. Only talk to your friends = The Facade Pattern
8. Always let the higher layers call the lower layer and not vice versa = Template Pattern
9. The Single responsibility principle – A class should have only one reason to change.

*Inspired from the Head First Design Patterns book

At the minimum a good architecture should:

1. Determine the type of application to be built.
2. The architecture styles to be used and
3. how the cross cutting concerns will be handled

A typical approach to defining your architecture should be:

Understand the Business Goals and objectives – why are we building the application.

Understand the Organizational constraints: These might range from budget, hardware resources, human resources etc.

Decide on the Application Type: Understand the client requirements carefully to decide on what type of application will be the best fit for the end-user. The Application types might range from Rich client application to Mobile applications (see App Types in the figure above). The key here again is to think from a Business prospective and then from an organizational constraint prospective. 

Some of the guidelines to follow while deciding and recommending an application to be client might be (these are just the bare minimum a lot of other quality attributes need to be taken into account before recommending an application type):

1. Rich Client: Suggest this when you want to leverage client resources and support disconnected scenarios. Microsoft Word is an example.
2. RIA (Rich Internet Application): Support for advanced graphics and streaming media in a web deployment scenario.
3. Web Application: Application UI over the web for various geographical clients. Minimum or no traces on the client machine.
4. Service: You want to expose a loosely coupled interface to remove clients without a UI. You want to provide autonomous plug and play components that can be leveraged by a variety of clients. E.G.. . a Credit Card Verification service.
5. Mobile: Support for mobile devices over the web / on the mobile device.

More on these in later posts …

Choose an Architectural Style: It is a set of principles. Each style defines a set of rules that specify:

• the kind of components you can use to assemble the system.
• the kinds of relationships used in their assembly
• the constraints on the way they are assembled and
• any assumptions about how you put them together.

Architectural style range from Client / Server, to Layered architecture to MVC, SOA depending on the kind of the application you are building.

Loads on these in later posts :)

Choose the right technology: Once you have decided on the Application Type and the architecture style to use, choosing the right technology can become simpler. Make sure the technology adheres to any organizational constraints and is stable to be delivered in a production environment.

Quality Attributes: These include – security, performance, maintainability etc.

Deciding on what quality attributes to apply for the system depends on the kind of application, priorities  of the quality attribute will differ from application to application or maybe component to component so it is necessary to evaluate the need to each quality attribute before recommending it. E.G.. if security is not a big concern for the organization then it can take a back seat and we can focus on other aspects such as performance etc. Having said that some of these attributes might be globally applicable to all or any kind of application.

This is a very interesting area since these attributes might not be visible functionally to the end-user but can still be essential for the system now or in the long run, making the business user understand the importance of Quality attributed is very essential.

Cross Cutting Concerns

These are the salt and pepper of the software, they represent key areas of your software design that might not be related to a specific layer. Some of these include:

• Authentication
• Authorization
• Caching
• Communication
• Exception Management
• Instrumentation and Logging