Deborah's Developer MindScape






         Tips and Techniques for Web and .NET developers.

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:

image

The html is:

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

<!– Use the Content Delivery Network (CDN) –>
<script
 
src=”http://ajax.googleapis.com/ajax/libs/angularjs/1.2.17/angular.min.js”>
</script>
<link
href=
http://netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css
rel=”stylesheet” />
</head>

<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>

    <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″>{{movie.date}}</div>
        <div class=”col-md-2″>{{movie.mpaa}}</div>

    </div>

    <script>
        <!—The controller code goes here –>
    </script>

</body>
</html>

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) {
        $scope.movie = {
            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) {
        $scope.movie = {
            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”, []);

    app.controller(“SearchByMovieCtrl”,
            function ($scope) {
                $scope.movie = {
                    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) {
    $scope.movie = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′
    }
};

app.controller(“SearchByMovieCtrl”,
        SearchByMovieCtrl);

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) {
    $scope.movie = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′
    }
};

app.controller(“SearchByMovieCtrl”,
        SearchByMovieCtrl);

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) {
    $scope.movie = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′
    }
};

app.controller(“SearchByMovieCtrl”,
        [“$scope”,SearchByMovieCtrl]);

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″>{{vm.movie.title}}</div>
        <div class=”col-md-2″>{{vm.movie.director}}</div>
        <div class=”col-md-2″>{{vm.movie.date}}</div>
        <div class=”col-md-2″>{{vm.movie.mpaa}}</div>
    </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 () {
    this.movie = {
        title: ‘The Fellowship of the Ring’,
        director: ‘Jackson’,
        date: ‘2001-12-19′,
        mpaa: ‘PG-13′
    }
};

app.controller(“SearchByMovieCtrl”,
        SearchByMovieCtrl);

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 () {
        this.movie = {
            title: ‘The Fellowship of the Ring’,
            director: ‘Jackson’,
            date: ‘2001-12-19′,
            mpaa: ‘PG-13′
        }
    };

    app.controller(“SearchByMovieCtrl”,
            SearchByMovieCtrl);
})();

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.

Enjoy!

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 (http://angular-ui.github.io/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:

image

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: http://plnkr.co/edit/hy6Evh?p=preview

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: http://plnkr.co/edit/p4iLdfoYydZ9LKU312zK?p=preview

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:

image

Hope this tip helps others!

Enjoy!

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!

BUMMER!

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.

Enjoy!

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;

}

Calling:

  • 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:

onClick(“OK”);

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;

}

Calling:

  • 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:

buttonClick(“OK”);

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).

Guidance

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.

Enjoy!

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.

Bummer!

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.

Conclusion

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#”.

Enjoy!

PS circleCheck out my Pluralsight courses!

Code Quality and Automated Code Testing

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

I’ve heard it said that the top three techniques for improving code quality are:

  • Unit testing
  • Unit testing
  • Unit testing

There is no better defense for the quality of your code than a set of automated code tests.

Automated code testing involves exercising code and testing its behavior by writing more code. So you have a set of code that tests your original code.

The goal of unit testing is to isolate each unit of code in an application and verify that the unit of code behaves as expected in both valid and invalid conditions.

To achieve this goal, we can:

  • Refactor our code where necessary into individual units (methods) that can be tested.
  • Create a set of tests for each method.
    • Tests with valid inputs.
    • Tests with invalid inputs.
    • Tests that could produce exceptions.
  • Execute those tests using a testing framework, such as MSTest or NUnit, both of which are executable from with Visual Studio (ALL editions, including the free Express edition!)

Don’t have time to test? See this post!

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

This is what one reviewer said about the “Automated Code Testing” module of this course:

This module is an excellent introduction to unit testing with C#!

In fact it should be recommended to C# subscribers as the first place to go to learn about unit testing, before they take any of the .NET unit testing courses in the library. For many this is all they will need,

It takes a viewer on a clear path from zero-knowledge about unit testing to being able to doing useful, real development, unit testing in 45 minutes.

It does a very good job of covering both the mechanics and how to make practical use unit testing.

Enjoy!

PS circleCheck out my Pluralsight courses!
May 16, 2014

What is Defensive Coding?

Filed under: C#,Testing,VB.NET @ 10:40 am

From Wikipedia (as of 4/14/14):

… an approach to improve software and source code, in terms of:

General quality – Reducing the number of software bugs and problems.

• Making the source code comprehensible – the source code should be readable and understandable so it is approved in a code audit.

• Making the software behave in a predictable manner despite unexpected inputs or user actions.

Let’s consider each of these bullet points…

General quality

Coding defensively means to actively code to reduce bugs. One of the key techniques for improving quality is through automated code testing.

Don’t know that you have time in your project schedule for automated code testing? That’s a topic for another blog post. Or check out my “Defensive Coding” course referenced at the bottom of this post for a demonstration of some simple automated code testing techniques and a discussion of the “no time for testing” issue.

Comprehensible

It is not just computers that need to read and understand your code … people need to read and understand it as well.

If another developer doesn’t understand your intent, they may make incorrect assumptions about that code and make inappropriate code changes … causing your code to fail.

Plus if the code is easy to read and understand, it will be easier and less time consuming to modify as the application is maintained or enhanced over time.

The key to making source code more readable and understandable is by building “Clean Code”. The concept of “Clean Code” was first presented by Robert Martin in his book: “Clean Code: A Handbook of Agile Software Craftsmanship”.

The cleaner your code is, the easier it is to understand, maintain, and test.

Predictable

Predictable code should handle unexpected inputs or user actions by anticipating them and responding accordingly.

This includes techniques such as guard clauses, validation, and error handlers.

Putting these three concepts into a picture summarizes the goals of defensive coding:

image

For more information on Defensive Coding, see my Pluralsight course: “Defensive Coding in C#”.

Enjoy!

PS-circle22

 

Check out my Pluralsight courses!

May 9, 2014

Defensive Coding in C# Course Went Live Today!

Filed under: C#,Visual Studio @ 11:45 am

How do you write great, maintainable code when faced with constantly changing requirements, legacy issues, intensive time pressures and a rapidly evolving environment? And how do you keep that code great after maintenance activities, multiple developers, and the ravages of time?

My new Pluralsight course: Defensive Coding in C# shows you how to write great, maintainable code and keep that code great using defensive coding techniques.

image

Enjoy!

PS-circle22

 

Check out my Pluralsight courses!

« Previous PageNext Page »

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