Deborah's Developer MindScape

         Tips and Techniques for Web and .NET developers.

September 5, 2014

Abstract Class vs Interface

Filed under: C#,OOP @ 5:10 pm

Since publishing my course on Object-Oriented Programming Fundamentals in C# for Pluralsight, I often receive questions from viewers. One of the common questions is on the difference between an Abstract Class and an Interface.

Abstract Class

An abstract class is a class that cannot be instantiated, meaning you can’t use the new keyword to create one. Some key qualities of an abstract class:

  • It is intended to be used as a base class for other classes that inherit from it.
  • It can provide implementation, meaning that it can contain the code for an operation.

For example, you could define an abstract product base class:

public abstract class ProductBase


   public bool Save {

       // Code here to save the product



The Save method here would contain the code to save a product.

You could then create specialized product classes: BookProduct, GroceryProduct, and OfficeProduct. Each of these specialized classes inherit from the ProductBase class. The specialized product classes then don’t need to contain the logic for the save, because it is provided in the base class.

Say you then define another abstract class for logging.

public abstract class Logging


   public void Log{

       // Code here to log information



You need the logging functionality in the BookProduct class. Since C# does not allow multiple inheritance, the BookProduct class cannot inherit from *both* the ProductBase class and the Logging class. You instead have to create a hierarchy:

BookProduct class inherits from ProductBase class which inherits from the Logging class.

GroceryProduct class also inherits from ProductBase class which now inherits from the Logging class. So even if the GroceryProduct class does not want or need logging, it still has all of the logging features because Logging is part of its class hierarchy.

This can lead to deep inheritance chains that make the code more complex and difficult to maintain/extend.


An interface is a set of properties and methods. You can think of an interface as a contract whereby if a class implements the interface, it promises to implement *all* of the properties and methods in the interface. Some key qualities of an interface:

  • It is intended to be implemented by other classes. Each class that implements the interface promises to provide code for each property and method in the interface.
  • An interface cannot contain any implementation, meaning that it does not contain any code, just declarations.

Using the same example as above, you could define IProduct:

   public interface IProduct{

       bool Save();


This interface cannot contain any code for the save. So each product class (BookProduct, GroceryProduct, and OfficeProduct) would need to implement this interface and provide its own code for the save feature.

Say you then define an interface for logging.

   public interface ILoggable{

       void Log();


Any of the product classes that need logging can implement this interface. You can think of an interface as defining a role that a class can take on. For example, the BookProduct class could take on a logging role, email role, and printing role by implementing a logging interface, email interface, and printing interface.

By using an interface:

  • Only the specialized product classes that need logging can implement the ILoggable interface.
  • Each product class that does implement the ILoggable interface needs to provide its own implementation.
  • Other classes (completely unrelated to products) can use the ILoggable interface. The class does not need to be defined within the same hierarchy.


You can think of an abstract class as a bucket of functionality shared by all of your relatives. And an interface as a role that anyone in the community can take on.

Use an abstract class if:

  • You are building a base class.
  • You want to provide code that the specialized child classes could use (or override)
  • You don’t need the functionality in the abstract class for any classes other than those within the class hierarchy.

Use an interface if:

  • You are defining a “role” that a class could take on.
  • You may want to use the interface on unrelated classes.
  • Each class implementing the interface will provide an implementation.

Thoughts? Questions? Please use the space below to submit your comments.


PS circle

Check out my Pluralsight courses!

August 1, 2014

Boldly Code With Us: Preview of Visual Studio Live! Washington, D.C.

Filed under: AngularJS,General,Visual Studio @ 4:09 pm

Earlier this week I presented a preview of my two sessions for the Visual Studio Live! conference coming up in Washington DC on October 6-9, 2014. My two sessions at the conference are:

  • New IDE and Editor Features in Visual Studio 2013
  • Build an Angular and Bootstrap Web Application in Visual Studio from the Ground Up

In the preview, I outlined some of the new IDE and Editor features and then selected one to demonstrate.

I then provided an introduction to AngularJS, specifically what it is and why you may want to use it for development of client-side Web applications.

If you are interested, the recording of this preview presentation is posted here.


PS circleCheck out my Pluralsight courses!

July 30, 2014

Learn AngularJS at VSLive in Washington DC

Filed under: AngularJS,General @ 5:24 pm

If you’ve ever been to Washington DC you know that it is filled with pomp and circumstance. It seems every activity is wrapped in ceremony.

That may be fun when touring history … but no so much when you are writing a Web application. When building an application you want to get work done, not spend lots of time on ritual and setup and ceremony.

AngularJS is all about simplification … getting rid of ritual and ceremony. With AngularJS …

  • You don’t have to write code to navigate the document object model (DOM) as you do with JQuery. No need to id everything and find the Ids on the page.
  • You don’t have to write any code that maps properties from your model to the UI and back again … AngularJS provides automatic two-way data binding.
  • You can easily call a Web service such as Web API.
  • You can write clean Web code!

Join me in Washington DC October 6-9 and learn how to use Angular to build your next Web application.

Use this promo code: DCSPK13 or click on the image below for more information or to register. You’ll save $400!



July 23, 2014

AngularJS: 101* Ways to Create a Controller (* actually 8)

Filed under: AngularJS @ 6:53 pm

OK, there aren’t really 101 ways to create an AngularJS controller. But when you are first learning and looking at examples, it may seem that there are 101 ways!

This post walks through the most common ways to create an Angular controller. The goal here is to put the different techniques in one place for you to compare and contrast.

NOTE: In all of these examples, the JavaScript code for the controller is added directly to the HTML file so it is easy for you to try it out. In a “real” application, you would add the code for the controller to a separate .js file (as covered in a future post). You can use the techniques presented below regardless of where the controller code resides.

The UI used in all of these examples is a movie hunter application that displays a list of movies. In all cases, the result appears like this:


The html is:

<!DOCTYPE html>
<head lang=”en”>
<meta charset=”UTF-8″>
<title>InStep Movie Hunter</title>

<!– Use the Content Delivery Network (CDN) –>
rel=”stylesheet” />

<body ng-app>

    <div class=”row  bg-primary”>
        <div class=”col-md-6″>Title</div>
        <div class=”col-md-2″>Director</div>
        <div class=”col-md-2″>Release Date</div>
        <div class=”col-md-2″>Rating</div>

    <div class=”row” ng-controller=”SearchByMovieCtrl>
        <div class=”col-md-6″>{{movie.title}}</div>
        <div class=”col-md-2″>{{movie.director}}</div>
        <div class=”col-md-2″>{{}}</div>
        <div class=”col-md-2″>{{movie.mpaa}}</div>


        <!—The controller code goes here –>


Notice two things:

  1. The ng-app attribute on the body tag in the HTML.
    • This attribute is required to identify the page as an Angular application.
    • This attribute currently has no value assigned to it.
    • This attribute is normally defined on the html or body tag.
  2. The ng-controller attribute on the div tag in the HTML.
    • This attribute defines the name of the controller function associated with a piece of the html.
    • This attribute is set to “SearchByMovieCtrl”, which is the name of the controller function.
    • The html tags that are child tags of this div tag (highlighted in green) have access to any of the controller function’s objects and methods. In this example, the controller provides a movie object.

NOTE: The elements and attributes in the html that begin with “ng-” are called Angular directives.

The code for any of the following controllers can be inserted within the script tag as per the highlighted comment above.

#1: Controller with a Function Declaration

A controller is simply a function. In this example, a function is declared within the script tags shown in the html above:

function SearchByMovieCtrl($scope) {
        $ = {
            title: ‘The Fellowship of the Ring’,
            director: ‘Jackson’,
            date: ‘2001-12-19′,
            mpaa: ‘PG-13′

The browser determines which controller function to call based on the ng-controller attribute defined within the html. So the name defined in the ng-controller attribute must match the name of the function. The name is “SearchByMovieCtrl” in this case.

When this function is called, Angular passes in a parameter called $scope. Anything that the controller function adds to the $scope is accessible to all of the html elements that are within the element containing the ng-controller attribute. (These are highlighted in green above.)

This controller function simply adds a movie object to the $scope. That movie object is then available to the html elements within the div tag containing the ng-controller attribute. The movie object properties can be displayed in the html using the Angular expression syntax {{}} as shown in the html.

To see the effect of the ng-controller attribute, try moving the {{movie.mpaa}} line outside of the outer div element and see what happens.

(The html will then display {{movie.mpaa}} instead of PG-13.)

This style of controller is quick to create, but is problematic in that it adds the function to the global namespace. This means it is available to any other code executing within the browser window. As the page becomes more complex, you could have problems with name collisions. (One function x overrides another function x because they have the same name.)

#2: Controller with a Function Expression

This technique is similar to the prior example, but defines the controller in a function expression instead of a function declaration. (If you are not sure of the difference between a function declaration and function expression, check out this post.)

    var SearchByMovieCtrl = function ($scope) {
        $ = {
            title: ‘The Fellowship of the Ring’,
            director: ‘Jackson’,
            date: ‘2001-12-19′,
            mpaa: ‘PG-13′

Notice that this code assigns the function to a variable called “SearchByMovieCtrl”. In this case, the function itself has no name, so it’s referred to as an anonymous function. But it could have a name without impacting how this controller works.

This technique has the same pros and cons as the prior technique. But now instead of putting a function on the global namespace, it is defining a variable on the global namespace.

#3: Controller with a Module

If you have been learning Angular, you know that Angular prefers that you define a module for your Angular application. The module is the component that ties all of the other Angular application components together.

After defining a module, you define a controller and register it with the module. That way the html can find the controller without needing to put the controller function in the global namespace of the application.

    var app = angular.module(“movieHunter”, []);

            function ($scope) {
                $ = {
                    title: ‘The Fellowship of the Ring’,
                    director: ‘Jackson’,
                    date: ‘2001-12-19′,
                    mpaa: ‘PG-13′

The first line of this example defines an Angular module named “movieHunter”. The module setter has two parameters:

  • The first parameter is the name of the module.
  • The second parameter is an array of dependencies to other modules/components. For a demo application as simple as this one, there are not dependencies so the array is empty.

The second line then registers the controller with that module. The registration method takes two parameters:

  • The string name of the controller (SearchByMoveCtrl)
  • The function that is the controller. In this case, it is an anonymous function.

This example (and all of the examples that follow) requires one additional change to the original HTML. The body tag needs to be changed as follows:

<body ng-app=”movieHunter>

When the ng-app directive is not associated with a module, Angular looks for the controller in the global namespace for the page.

When the ng-app directive is assigned to a module name, Angular will then look for the controller registered with the module when it sees the ng-controller tag.

This technique is a much better than the prior two in that it uses the module. Angular much prefers to use a module to manage the components of the application. Plus it keeps the function out of the global namespace.

#4 Controller with a Module and Function Declaration

Some developers don’t like to put an entire function inside of a parameter of a method call. So you can instead define a function and pass a reference to it to the registration function as shown below.

var app = angular.module(“movieHunter”, []);

function SearchByMovieCtrl($scope) {
    $ = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′


The first line of this example defines the Angular module called “movieHunter” as in the prior example. The second line defines the controller function. The last line registers the controller with the module by referencing the function in the second parameter.

The problem with this approach is that we again have the SearchByMovieCtrl in the global namespace.

#5 Controller with a Module and Function Expression

This technique is similar to #4 above, but with a function expression. (If you are not sure of the difference between a function declaration and function expression, check out this post.)

var app = angular.module(“movieHunter”, []);

var SearchByMovieCtrl = function ($scope) {
    $ = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′


The first line of this example defines the Angular module called “movieHunter” as in the prior two examples. The second line defines the controller function and assigns it to a variable. The last line registers the controller with the module by referencing the function in the second parameter.

This approach puts the SearchByMovieCtrl variable in the global namespace.

#6 Controller with a Module and Minification-Safe Array

To improve performance when an application first starts up, many developers minify their files. This minification process removes excess spaces and changes function parameter names to a single character. This makes the files smaller so they download more quickly from the Web server to the client browser.

The problem with minifying an Angular application is that Angular expects the parameter names to be a specific name, not a minified name. For example, if you replaced the $scope variable in any of these examples with another variable name the code would not work.

To prevent the minification process from shortening the parameter names, you can provide the list of parameter names as strings as the second parameter to the controller registration function as shown below.

When you change the second parameter to a list (or technically speaking an array), you still need to pass the name of the controller (or the entire controller  function) as the last entry in the array. This is shown below.

var app = angular.module(“movieHunter”, []);

function SearchByMovieCtrl($scope) {
    $ = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′


The second parameter of the controller registration is now an array containing:

  • The string name of each controller function parameter.
  • The reference to the function (or the function itself) as the last entry in the array.

This approach works the same as the prior approaches. The only difference is that the code will continue to work correctly after it has been minified. If you never plan to minify the files (and expect no one else on the team or in operations to minify the files) then this array is not needed.

#7 “Controller as” Syntax

This option is new in version 1.2 of Angular, so you won’t see it in any older posts.

The “Controller as” syntax requires several changes both to the original html and to the controller function itself:

  • First, the ng-controller attribute value in the html is changed to include the “as” keyword:

<div class=”row” ng-controller=”SearchByMovieCtrl as vm>

  • Second, the references to the controller objects in the html need to be changed to use the “controller as” alias.

    <div class=”row” ng-controller=”SearchByMovieCtrl as vm“>
        <div class=”col-md-6″>{{}}</div>
        <div class=”col-md-2″>{{}}</div>
        <div class=”col-md-2″>{{}}</div>
        <div class=”col-md-2″>{{}}</div>

NOTE: vm in this example stands for “view/model”. This is commonly what is used here because the controller is thought of as the connection between the view and the model or “view/model”.

  • Lastly, the $scope is no longer required as a parameter to the controller function. It is still available to the function, but implied. Instead of using “$scope”, the code instead adds objects and methods to “this”.

var app = angular.module(“movieHunter”, []);

var SearchByMovieCtrl = function () { = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′


The “controller as” syntax is clean and easy. But the explicit $scope syntax may be easier to understand when first learning.

#8 Controller with IIFE

A key issue with several of the above techniques was concern about the global namespace. Any variable or function declared external to a function becomes part of the global namespace of the application. This can be a problem, especially as the application gets larger.

One way to mitigate this problem is to use an Immediately Invoked Function Expression or IIFE (pronounced “iffy”). The idea of an IIFE is that if variables and functions are declared within a function, then the variables and functions are local to that function and not part of the global namespace.

You can wrap *any* of the above examples in an IIFE. Below is the code for example #7 wrapped in an IIFE:

(function () {
    var app = angular.module(“movieHunter”, []);

    var SearchByMovieCtrl = function () { = {
            title: ‘The Fellowship of the Ring’,
            director: ‘Jackson’,
            date: ‘2001-12-19′,
            mpaa: ‘PG-13′


For more information on IIFE by the person that coined the term, see this post.

You can use an IIFE with any of the above techniques to minimize pollution of your global namespace.

There you have it … 101 …  ok … 8 … ways to create a controller.


PS circleCheck out my Pluralsight courses!

P.S. I am currently working on an Angular course for Pluralsight entitled “AngularJS Line of Business Applications”. Please comment below if you have suggestions for content that is not covered well elsewhere. Thanks!

New Blog Host

Filed under: General @ 6:35 pm

My blog has just been migrated from Community Server to WordPress.

That means:

  • It has a nice new look!
  • As of right now, the image files are not linked.
  • Many of the links to my other blog posts are broken.

Let me know what you think of the new layout!

July 10, 2014

Angular ng-grid Quick Tip

Filed under: AngularJS @ 12:47 pm

I added a grid page to one of my applications using ng-grid ( to provide a quick way to update sets of prices.

But it wasn’t working correctly. If I edited one price and clicked to the next row, the edit box on the prior row did not close. After editing three prices the grid looked like this:


And looking at the output, I found this:

Exception was thrown at line 3494, column 17 in http://localhost:3950/js/ng-grid-2.0.11.debug.js
0x800a01b6 – JavaScript runtime error: Object doesn’t support property or method ‘focus’

After spending the better part of yesterday afternoon trying to figure out what was wrong, I gave up and decided to start fresh again this morning. (Always a good option when you are stuck.)

As part of my debugging, I had found a working example here:

So I downloaded that example and started to modify it to match my existing code. Was it the routing? No. Was it the other loaded controls like the date picker or masked edit? No.

It turned out to be the ORDER of the script files in my index.html.

To see the problem in action, try this:

This is the *same* as the prior Plunk except for the order of the script files.

For the ng-grid to work correctly, the jquery library must be listed BEFORE Angular.

<script src=”js/jquery.js”></script>
<script src=”js/angular.js”></script>

Now it looks much better:


Hope this tip helps others!


PS circleCheck out my Pluralsight courses!

July 1, 2014

TFS Ate My Homework

Filed under: Visual Studio @ 2:50 pm

Just a really big warning out there so you don’t share the same fate that I did!

I had been checking some of my Pluralsight course source files (code, PowerPoints, recordings, etc) into TFS. I was not checking in *all* of the files because some of them were quite large and it was taking 15-20 minutes to check in those files.

When working on code, it was difficult to see added files because under “Excluded Changes” I had “Detected: 782 add(s)”. With so many detected files, I often did not notice that my newest code files were excluded. The problem was that TFS was finding not only my project files but ALL of the Pluralsight course files (including the huge .wmv recordings) that were never checked in.

Now that I am starting my next course, I wanted to ensure that I could easily see what files should be checked in and which should not. So I looked up how to disconnect the older projects from a path so TFS would not longer report all of these additional adds.

It’s easy. Just right-click on the directory in Source Control Explorer and select Advanced | Remove Mapping. No warning message. Seemed easy enough until I looked at the output window:

Deleting C:\Users\Deb\Speaking\PluralSight\Defensive Coding in C#\DefensiveCodingAbstract.docx
Deleting C:\Users\Deb\Speaking\PluralSight\Defensive Coding in C#\DefensiveCodingNotes.docx
Deleting C:\Users\Deb\Speaking\PluralSight\Defensive Coding in C#\AcmeCustomerManagement\AcmeCustomerManagement.sln

<Continuing on for several pages>

Deleting C:\Users\Deb\Speaking\PluralSight\Defensive Coding in C#\module7-exceptions\module7-clip1.camproj
Deleting C:\Users\Deb\Speaking\PluralSight\Defensive Coding in C#\module7-exceptions\module7-clip2.camproj
Deleting C:\Users\Deb\Speaking\PluralSight\Defensive Coding in C#\module7-exceptions\module7-clip3.camproj

Yep. It deleted ALL of my files, including those I had never checked in. GONE!


Hope I never have to update any of my past courses because all of the source files (recordings, etc) are just gone.

Thought I would share this experience with the hope that you won’t share the same fate.

P.S. Now for the rest of the story…

My friend Klaus came by the office today and told me about shadow copy.  Something I must have enabled early on because he found a copy of all of my files from Friday (before they were deleted by TFS on Monday). Hope to have all of the files back in place by the end of day. THANKS KLAUS!!

June 20, 2014

ACM Seminar: Getting Started with AngularJS

Filed under: AngularJS @ 8:57 pm


My business partner, Jerry, and I are presenting a full day session on AngularJS to the Association for Computing Machinery (ACM) on Saturday, June 21st 2014. Should be fun!

Check out this link for more information.

The code for this seminar is here.

NOTE: To make this code easy to execute and try out, the calls to a Web Service are commented out and the data is instead hard-coded into the controllers.

  • The movies controller has a hard-coded list of movies.
  • The movie detail controller has ONE hard-coded movie. So no matter which movie you select to detail, only the ONE hard-coded movie is displayed.
  • Same for the actors controller and actor details controller.


June 18, 2014

JavaScript Function Terminology

Filed under: JavaScript @ 12:43 pm

I have been working on and off with JavaScript since 2001. But its one thing to use JavaScript functions and another thing entirely to know the vocabulary of JavaScript functions.

So here are some common JavaScript function terms:

Function Declaration

Defines a named function.

function onClick(buttonName) {

    return “Clicked: ” + buttonName;



  • onClick() – executes the function and returns the value.
  • onClick – references the function.

In JavaScript, function declarations are always moved (“hoisted“) to the top of their scope at runtime. This means that the function does not need to be declared before it is used.

So something like this is valid:


function onClick(buttonName) {

    return “Clicked: ” + buttonName;


Function Expression

Defines a function as part of a larger expression such as a variable assignment.

The function can be named, as with the onClick function below:

var buttonClick = function onClick(buttonName) {

    return “Clicked: ” + buttonName;


Or anonymous as with this function:

var buttonClick = function(buttonName) {

    return “Clicked: ” + buttonName;



  • buttonClick() – executes the function and returns the value.
  • buttonClick – references the function.
  • onClick() – generates an undefined error.

Function expressions are not “hoisted”. So attempting to use them before they are defined generates a type error:


var buttonClick = function(buttonName) {

    return “Clicked: ” + buttonName;


NOTE: The variable declaration (buttonClick) does get hoisted, but only the definition, not the assignment. So at runtime, var buttonClick = undefined is hoisted. But the assignment does not occur until the un-hoisted assignment statement is executed.

Function Statement

Basically a function declaration. (See above).


In general, guidance says to favor function expressions over function declarations (or function statements) for the following reasons:

  • The hoisting of function declarations can cause confusion or hard to find bugs.
  • Function expressions more clearly imply that the function itself is an object.

See this link for more examples and an enhanced discussion of function declarations vs function expressions.


June 4, 2014

"I Don’t Have Time for Unit Testing!"

Filed under: C#,Testing,VB.NET @ 12:50 pm

So, be honest, when you hear someone talk about unit testing … what is your first thought?

  • Is it: “I just don’t have the time to do unit testing”!
  • Or “Our management will never approve the time for unit testing”?
  • Or something similar?

Let’s look at what unit testing can do for you:

Save you Time

Yes, that’s right!

Throughout my career as a software developer, I have seen how much time unit tests can save.

Let’s think about this …

  • Any developer that has written more than a few lines of code knows that it needs to be run to verify that it operates as expected. Right?
  • You need to execute the feature to confirm that it takes appropriate inputs and produces appropriate outputs. You may need to go through this process several times.
  • And as you build more features, it requires more effort to manually test it.
  • For example, say you write a pedometer application that takes in a step count goal and an actual step count and then calculates the percent of goal you have reached.
    • To test the pedometer feature you need to execute the application, navigate to the appropriate feature, enter all of the required data, and then validate the results.
    • And if you find a bug you may have to repeat this process again, and again, and again.
    • For the feature you are working on now, how many times have you run the application to try it out? 10? 20? more?
  • The idea of an automated code test is that you can write code to perform that testing.
  • So if you want to test that the pedometer calculation is correct, you write an automated code test that defines appropriate inputs, calls the function under test, and verifies the results.
  • Then when the users want a change to that code (and you know that they will), you can make the change and just re-run the tests.
  • No need to slog through the UI again for each possible set of inputs.

This can save you LOTS of time.

Help you Find Bugs Faster

You just received a bug report. Something in the code does not work.

Instead of trying to reproduce the problem by wading through a bunch of UI, you can instead use your unit tests to quickly reproduce, find, and fix the error.

Allow you to Refactor Safely

So you are working on some code that is just too painful to deal with.

You’d like to apply some refactoring techniques to make the code cleaner and easier to use.

With no tests, you are running a risk of introducing bugs if you rework the code.

If you have unit tests in place, you can safely perform a refactoring because when you are done with the refactoring, you can rerun the tests to confirm that all is well.

Readily Add Features

You can add new features and rerun all of the existing tests to ensure that the new feature does not adversely impact any existing features.

No more worry that adding feature b will adversely affect feature a.

Minimize Those Annoying Interruptions

So you are in the middle of coding the next feature and you have to drop everything because someone entered something bad somewhere in your application and now it is crashing.


Having a good set of unit tests can minimize those annoying interruptions.

Enhance your Value

Don’t you just hate it when the “QA” person emails you to let you know your code doesn’t work?

This is especially difficult if that “QA” person if your boss or your client.

Having a good set of unit tests can make you look like a coding master!

Or what if the person after you changes something and now it looks like your code doesn’t work.

Unit tests help the developers that come after you to better understand and modify your code. They can re-run the tests to ensure the code still works after their changes.

Having a good set of unit tests verifies that your code works over the lifetime of the application.


Writing unit tests isn’t hard or time consuming once you get into the habit. And these benefits look pretty good!

For a gentle introduction to automated code testing, see my Pluralsight course: “Defensive Coding in C#”.


PS circleCheck out my Pluralsight courses!

« Previous PageNext Page »

© 2015 Deborah's Developer MindScape   Provided by WPMU DEV -The WordPress Experts   Hosted by Microsoft MVPs