Design Codes

Tracking Performance Degradation with Visual Studio Load Testing Framework and Cruise Control .NET

2012-01-02T03:58:00.001+02:00

In previous posts we created a Load Test for the book store service and saw how the Load Test can be executed continuously via 'Cruise Control .NET' (CCNet), In this post, we'll take a step forward and add a custom task to CCNet that will query the database and generate a custom xml summary that includes performance comparison with previous runs, performance counters measurements per machine (

Continuous Integration for Visual Studio Load Test via Cruise Control .NET

2011-12-30T23:55:00.001+02:00

In the previous post we created a load test for the book store service. We developed a functional test per user scenario for generating synthetic load and walked through the entire process of creating and running the Load Test. In this post we will see how the Load Test can be executed continuously via 'Cruise Control .NET' (CCNet) and provide immediate feedback via CCNet's portal. here's a

Creating a Load Test using Visual Studio 2010

2011-12-29T17:59:00.001+02:00

Visual Studio Team System Test Edition provides extremely powerful framework for developing load tests for web applications. The framework (Load Testing Framework) introduces a simple process for generating synthetic load, possibly from multiple machines, and provides rich infrastructure for generating reports. The framework can be used to generate load and collect results for different purposes

Component Testability KILLERS (and suggested solutions)

2010-12-03T00:48:00.001+02:00

Since system quality depends on component quality, any defective component causes a ripple effect throughout systems that include that component. Hence, validation and quality control of isolated components is crucial for producing quality systems. In order to validate component quality, we must follow a cost effective test process and implement a rigorous quality process for all generated

Testing with Managed Extensibility Framework (MEF) for Silverlight

2010-11-07T01:36:00.001+02:00

In the previous post, we developed test strategies for a three tiers, MVVM based Silverlight application, which uses the Managed Extensibility Framework (MEF) in order to loosen the coupling between the components and to provide better testability and extensibility. In this post, we’ll see how the Managed Extensibility Framework (MEF) fit in with the overall testing strategy and try to figure out

Testing Silverlight 4.0 App with MVVM, MEF and WCF Data Services

2010-11-01T12:46:00.001+02:00

In the previous post, we reviewed a simple 3 tiers Silverlight application that follows the MVVM design pattern, uses MEF for applying the dependency injection pattern, and uses WCF data service implemented using a custom data provider for CRUDing data in a RESTfull way (via HTTP). In this post, we’ll put together a testing strategy for the application and demonstrate testing in component level

Developing Silverlight 4.0 App with MVVM and MEF

2010-10-24T00:41:00.001+02:00

In the previous post we walked through the process of developing three tiers web app using Silverlight 4.0, MVVM and WCF Data services. In this post, we’ll see how we can take advantage of the new Managed Extensibility Framework (MEF) for Silverlight in order to loosen the coupling between the parts in the application and by that 1) simplify the development process, 2) make our application more

Developing Silverlight 4.0 Three Tiers App with MVVM and WCF Data Services (OData via ATOM)

2010-10-13T00:27:00.001+02:00

In this post we’ll walk through the process of developing a three tiers, rich web application using Silverlight 4.0. As many applications built on top of WPF/Silverlight technologies, we’ll based the design on MVVM design pattern, and we’ll use WCF data services to query/update data exposed by a mid tier application. In the next posts we’ll add the new Managed Extensibility Framework (MEF) to

The Pillars of Concurrency

2010-08-08T05:39:00.001+03:00

In recent years, microprocessors designers are hitting the walls of memory latency, heat dissipation, and number of transistors for single core processors. As a result, the microprocessors industry consistently introducing more cores on the same chip in order to keep on providing stronger processors and maintain Moore's law. Consequentially, applications' parallelism become more fine-grained,

Scaling Up with STM.NET (Software Transactional Memory)

2010-02-23T21:35:00.001+02:00

Content Abstract Locking Hazards STM.NET Overview STM.NET Characteristics STM.NET Implementation Alternative Implementations Hardware Transactional Memory Abstract Every developer that spent enough time with concurrent applications must have learned that producing a reliable, high performance application that scales gracefully to many core hardware

Concurrency Levels Tuning with Task Parallel Library (How Many Threads to Use?)

2009-10-18T03:14:00.001+02:00

In the post ‘Scaling Up with Task Parallel Library’ we reviewed the way in which the TPL (Task Parallel Library) library facilitates the process of adding concurrency to applications. One of TPL’s features that I thought worth a separate discussion is that it enables developers to manually tune the amount of threads (concurrency level) that will be used to serve a given set of tasks. Manual

UML Use Case Diagrams – Modeling the System Functionality

2009-10-03T17:44:00.001+02:00

UML Use case diagrams are used to illustrate the behavior of the system during requirements analysis, they show system wide use cases and point out which use case is performed for which actor. A use case describes a sequence of actions that make up one or more business process and provide something of measurable value to an actor, an actor is a person, organization, or external system that

UML Deployment Diagrams – Modeling the System Physical Architecture

2009-09-04T09:52:00.001+03:00

In the previous post we saw how component diagrams can be used to model the logical architecture of a system. In this post we’ll see how deployment diagrams are used to model the physical architecture of a system; we’ll start from the most simple use of the deployment diagram in which we only present the nodes and their inter-relationships, and complete the picture by including the components and

UML 2.0 Component Diagrams – Modeling the System Logical Architecture

2009-08-22T20:00:00.001+03:00

In UML 2.0 Component diagrams are used to model the logical architecture of a system by showing the system high level components and their inter-relationships. In the next post I will show how components are used in deployment diagrams to model the physical architecture of a system. A component is an encapsulated unit within a system which provide one or more interfaces. When using

MVVM for .NET Winforms – MPV-VP (Model View Presenter - View Model) Introduction

2009-08-02T02:51:00.001+03:00

This post introduces a variation of MVP design pattern called MVP-VM, which is the windows forms (winforms) equivalent of WPF MVVM. The MVP-VM (Model View Presenter – Model View) pattern is a tailor made solution for winforms applications that require full testing coverage and extensively use data binding for syncing the presentation with the domain model. MVVM (Model View View Model) introduces

Multicast Application with Multihomed Support (C# .NET Sample)

2009-07-10T07:05:00.001+03:00

In the previous post we’ve reviewed the multicast addressing technology and examined some of its pitfalls. In this post we’ll dive through the implementation of a simple application that allows sending and receiving multicast data over the LAN, while enabling the selection of the network interfaces (IPEndPoint) through which the multicast traffic will be sent and received. As illustrated in

Multicast Addressing Pitfalls

2009-07-07T17:39:00.001+03:00

The IP multicast model has been described as follows: “You put packets in at one end, and the network conspires to deliver them to anyone who asks”. That sounds pretty simple indeed, but as you spend more time with applications that deliver multicast services you find that in many cases you will ‘put packets in at one end, look at the network protocol analyzer, and see nothing that you expect’.

.NET CLR Thread Pool Internals

2009-06-11T20:16:00.001+03:00

In the previous post we saw how applications that need to scale up can utilize the Task Parallel Library and the improved CLR 4.0 thread pool in order to optimize the scheduling of their massive amount of fine grained, short living tasks. In this post we’ll dive through the implementation of the CLR thread pool in an attempt to understand the way in which it optimizes the creation and

UML Activity Diagram – Modeling Parallel Applications

2009-06-02T19:17:00.001+03:00

Activity diagrams are used to model the behaviors of a system, and the way in which these behaviors are related in an overall flow of the system. In simple terms, they show system-wide and component-wide workflows. This post introduces an approach for modeling parallel applications by utilizing activity diagrams to show parallel workflows and point out the places at which they get synchronized,

UML Sequence Diagram: Interaction Fragment (Alt, Opt, Par, Loop, Region)

2009-06-02T08:50:00.001+03:00

A common issue with sequence diagrams is how to show conditions and iterations. Indeed, the activity diagram is more appropriate to model control logic that involves conditions, loop etc, but in practice, most developers prefer to stick with the sequence diagram to show how objects interact together with the control logic involved.