It’s not what you think, exactly, but close. I have been interviewing again, this time for a full time position. During my search, on one of the interviews, I was asked to use the PEX coding for fun website to flex my programming muscles.

If you don’t know about the Microsoft Research project, you can get more info at PEX. Pex finds interesting input-output values of your methods, which you can save as a small test suite with high code coverage.

So Pex basically creates unit tests by sending in arguments to a method and compares the results to the expected output. It’s a neat piece of software. Here was my code challenge:

1
2
3
4
5
6
7
8

using System;
 
public class Program {
  public static int Puzzle(int x) {
    // Can you write code to solve the puzzle? Ask Pex to see how close you are.
    return x;
  }
}

When you run it, Pex tells you the x parameter value and if the return value was correct. My solution was x * ((x * 2) - 1). Not too hard, but my interviewers threw me a curve ball when they also gave me the windows calculator on the scientific settings. I thought it was going to be some MOD square root nonsense.

I was really impressed with this approach to interviewing and the use of PEX. It might have been simpler to code up some unit test to a console program but the geeky-ness of their solution won me over. I was offered the position but did not accept it.

If a bank employee posted this image on their cube for everyone to see, would you be concerned?

He writes software that touches your checking account! Not so funny now is it! The older I get, the less I like surprises. I don’t know if it’s a “Get off my Lawn” thing or if I am getting old and crotchety. Or both. Putting untested code into production is something this developer never wants to do again. Ever. I have better things to do with my life.

For me perfection was debilitating and would keep me from finishing, or worse, starting projects. My bright ideas were perfect until they were brought into the light. That’s usually when my drive to finish a project would wain or completely fail me. So to help me avoid my need for perfection, I made sure that I produce something. Even if it was a total pile.

Produce I did.

Professional Accomplishments

www.PrintToPress.com

Is a vanity book printing website that takes PDF files and produces perfect bound books. These are the books that you find in the bookstore but better quality. Nice million color glossy front covers thanks to my c# skills and a mess of 2D drawing math. This project is not perfect but we have produced over 13K books in just a short 9 months. Profitable it’s not but fills a need in the publishing industry, and it does it well.

www.Foojal.com

Foojal was a food photo journaling application that allowed people with camera phones to take pictures of their food to track how and what they ate. The site is no longer up but the code for the whole site has been open sourced and placed under my Github account for all to see and use. The site was a challenge because I coded it in Python using WSGI stack on Google Appengine. It was a wonderful learning experience and it’s not perfect.

Wells Fargo and NRT

I have a dirty little secret, I love Microsoft WCF. I don’t know what it is but I love connected systems. Most of my employers know this secret and Wells put me to work writing a cross platform web service for their PeoleSoft HR data. The best part was getting an email that the Mainframe can connect and successfully use the service. Yes the Mainframe!

Personal Accomplishments

Motorcycle

For as long as I can remember I have wanted to ride, so this year I did it. I have taken and passed the Riders Edge course put on by my local Harley Davidson motorcycle dealer and I am the proud owner of a new Honda Phantom. I love riding and in Arizona I have plenty of days to ride it. Even in the winter.

Concealed Carry

My uncle used to take me to the range near where we lived. The only problem was I was a better shot than he was. I guess it’s hard on a man when a 13 year old can shoot repeatedly through a bullseye at 30 feet and he can’t. I tell people that duck hunt was my teacher. One of the nice things about living in Arizona is all of the freedoms a citizen in good standing has. One of them being the right to carry and bear arms. So after some lengthy training I now have my concealed carry permit. I love putting little holes through paper at 30 feet. No, I do not carry all the time, especially not at work.

Well that’s enough tootin my own horn. 2011 was a great year and 2012 is shaping up to be very productive albeit not a perfect year.

Warning: Phil, I am going to give you some grief, but you are awesome. How can you not be with Asp.Net MVC.

Phil is a Senior Program Manager at Microsoft and Mr. Asp.Net MVC. A good guy, but I find it funny when you comment on your blog like this:

I run Microsoft OS’s with Microsoft IIS and program websites with Microsoft languages and frameworks but can’t do reoccurring tasks without punting out of the web project and into Windows Services or console programs. Don’t get me wrong Phil, I know you are busy but what the heck! Where is the worker role from Azure?

I suspect that Microsoft can figure out how to give it’s most popular development server (IIS) the ability to do batch processing. How can IIS in its 7th version not have the same features as Azure beta or AppEngine from Google? Can you say Cron.yaml?

You might be asking “What’s wrong with this?” and if you like spaghetti the answer is nothing. Some people say that object orientated code is complicated because of the hiding of implementation in base class’s obscures what the program does, but I can also argue that seeing all of the implementation details in static classes obscures the forest because of the trees. Either way, too far to the left or right and you will have issues. A more moderate approach is swinging between the paradigms and choosing the correct design techniques.

Choosing between static and instance methods is a matter of object-oriented design. If the method you are writing is a behavior of an object, then it should be an instance method. If it doesn’t depend on an instance of an object, it should be static. Remember, testing static methods that have dependencies are notoriously difficult to isolate and Unit test.

You might be asking why where you walking through a mainframe department. Well it’s a funny story. One day an architect on my team came over to my desk and said he needed me to help a team connect to one of our existing web services. That’s right; he walked me right into the mainframe developer’s lair. It was surreal. I am thinking to myself how do I get a dinosaur to drive a Prius? My architect introduced me to a gentleman that could have been old enough to be my grandfather and abruptly left.

After some awkward questions like, do you use SOAP? Can the mainframe understand XML? Do you have a SOAP client or are you going to submit xml blobs with replaced sections? I was amazed when they said “yes we use SOAP and have a client for the mainframe”, I thought of that Prius with a dinosaur driving down the street.

At my grandfather’s age will I still be coding? I hope so and now I have hope because of the mainframe and there developers. Live long enough and the world will surprise you. Here’s to the mainframe, long live the mainframe!

There are two different types of interview questions, the specific and the general. Questions like “What color do you get when you add blue and yellow together” will only tell you they know how to make green. A better question is “How do you use a color wheel.” Can you see the difference?

When I interview a candidate for a position, I use a set of questions that dips or tunnels into the specifics on their knowledge and background. Here is an example:

How many lines in an Asp.Net code behind file is too many?

If they answer with something reasonable like 200 lines, then I would move on. If not, then you might have other questions.

How would you break up a code behind file to be smaller?

Again, hopefully, they say something about user controls and breaking up the functionality on the page and not move the hard coded injection flawed SQL queries from the code behind. Then you can dig a little deeper and ask something harder like:

How do you communicate from one user control to another or to the host page?

If they answer this last question correctly, you know that they know what’s going on in Asp.Net and not that they have memorized the page lifecycle. Did you notice who would have to do most of the talking? That’s right, the candidate. You can pick up a lot from these conversations.

Here are a few more conversation starters

• How can you throttle WCF service calls from a specific client?
• What’s your take on ORM’s good and bad?
• What blogs or books have you read in the last three months?
• What would you like to learn next?
• How can you share data from one website to the other?

• Do you need it to process all the time. Will recycling the app pool cause you pain?
• Is it truly batch processing or processing a lot of items?
• Are you on shared hosting?
• Can you install a service?
• Will your processing demands spike periodically?
• Have more than one node?
• Can you put an executable on the box?
• Can you use the windows Task scheduler?
• Thought of moving to Azure or App engine?

Ok, all kidding aside, some of these questions have real impact on how good your batch processing job will perform and how often you will be babysitting it. For a simple site with a small batch processing need, I would use the old timer trick in a http module right in the web site.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class BatchModule : IHttpModule
{
  protected static Timer _timer = null;
  
  public void Init(HttpApplication application)
  {
      if (_timer == null)
      {
          var timerCallback = new TimerCallback(DoWork);
          _timer = new Timer(timerCallback, null, 10000, 60000);
      }
  }
  
  public void DoWork(object state)
  {
      //do something
  }
}

This technique has many issues and should only be used for the simplest things. Some issues include the app pool recycling and shutting down your batch processor. Others include having to make your processing code reentrant.

If I was asked today to do batch processing for a client, I would use a Windows Service with WCF backed by MSMQ or some other distributed asynchronous message system that would scale when nodes are added to the cluster. Even if this app was run on a single server, I would still use a local MSMQ queue to start. The atomic way that MSMQ distributes messages and the benefits of throttling, discreet work packets, dead lettering and scalability outweigh the initial complexity of the solution.

There are many platforms today that make batch jobs easier like Azure worker roles, AppEngine and Heroku, not to mention, cron on Unix platforms. I know about the Windows Scheduler and the pain of using it in production. I was hoping that Microsoft would add the worker role functionality to IIS and Asp.Net but it does not look like the cool app fabric features will be coming to IIS.

Well, I have and this is how I solved it. First, we look for better options like not writing code and use IIS IP Filtering. After that’s rejected by the client, I fire up my IDE; it takes so loooong.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public class IPFilteringAuthorizationManager : ServiceAuthorizationManager
{
  private const string ServiceActionAttempedBy = "{0} Service Action {1} attemped by {2}.";
  private const string NoAuthorizedIPAddress = "{0} is not an authorized IP address for {1}.";
  private const string AuthorizationManagerFailure = "ARTServiceAuthorizationManager failure.";

  protected override bool CheckAccessCore(OperationContext operationContext)
  {
      var callerIsAuthorized = false;

      var callersIP = ((RemoteEndpointMessageProperty)operationContext
          .IncomingMessageProperties[RemoteEndpointMessageProperty.Name]).Address;
      var mesageTo = operationContext.RequestContext.RequestMessage.Headers.To.Segments.Last();
      var messageAction = operationContext.RequestContext.RequestMessage.Headers.Action;

      try
      {
          callerIsAuthorized = GetAuthorizedIPAddresses(mesageTo).Contains(callersIP);

          if (!callerIsAuthorized)
          {
              _log.Info(String.Format(NoAuthorizedIPAddress, callersIP, mesageTo));
          }
      }
      catch (Exception ex)
      {
          _log.Error(ex);
      }
      finally
      {
          _log.Info(String.Format(ServiceActionAttempedBy, mesageTo, messageAction, callersIP));
      }

      return callerIsAuthorized;
  }
}

I am a big fan of how WCF can be composed so I used a ServiceAuthorizationManager and added it to the services behaviors through the config.

1
2
3
4
5
6
7
8
9
10
11
12

<serviceBehaviors>
  <behavior name="IPFilteringBehavior">
      <serviceMetadata httpGetEnabled="true"/>
      <serviceDebug includeExceptionDetailInFaults="false"/>
      <serviceAuthorization
          serviceAuthorizationManagerType="AdamJWolf.IPFilteringAuthorizationManager, 
              AdamJWolf.Core, 
              Version=1.0.0.0, 
              Culture=neutral, 
              PublicKeyToken=null" />
  </behavior>
</serviceBehaviors>

I left out the boring part about which IP addresses are allowed and at what time, but I think you get the point. These dynamic rules for access to a WCF service can get a little sticky but WCF has some great extensibility points that allow you to solve your client’s problems. I have also used the same type of dynamic service authorization for use with Active Directory Groups.

The presentation shows how some language designers understand that the user experience of a language is just as important as run-time performance. Just take a look at how Ruby and CoffeeScript have been designed for developer happiness and not the machine. After programming in Ruby and Python, now I constantly leave off the semicolon in C#. Why can’t the compiler do this for me?

If you disagree with me, then you must be thinking for yourself and that’s good. These pages will not have a feedback mechanism, but if you are so inclined, I would love to discuss your point of view over a diet coke. Please contact me by heavily spam filtered email.

The server is sitting in a colo that deals with only Minis called Macminicolo.net. Not the most original name but the service and the customer support are top notch. After ordering the server, it was up and running in a day. Setting up the Apache web server for OSX is criminally easy. Check one box and Bam! servers ready. Eat your heart out IIS.

I have tried every known .net open source blog and let me tell you, WordPress beats them all, no questions. If you are serious about blogging, WordPress is the easiest and most feature rich blogging platform. Don’t waste your time with the others, just get WordPress up and running; you will never go back. The install of the database was a check box and some configuration. The blog was a directory copy and editing one configuration file. Everything else was just admin stuff like user names and themes.

For all of you .Net Microsoft Kool-Aid drinkers out there, do me a favor and try something different like OSX, Apache, WordPress and MySql. What do you have to lose? Maybe some of that wool from over your eyes.

Single Responsibility Principle (SRP) defined by wikipedia

Martin defines a responsibility as a reason to change, and concludes that a class or module should have one, and only one, reason to change. As an example, consider a module that compiles and prints a report. Such a module can be changed for two reasons. First, the content of the report can change. Second, the format of the report can change. These two things change for very different causes; one substantive, and one cosmetic. The single responsibility principle says that these two aspects of the problem are really two separate responsibilities, and should therefore be in separate classes or modules. It would be a bad design to couple two things that change for different reasons at different times. Agile Software Development, Principles, Patterns, and Practices

The single responsibility of a WCF service is to facilitate communication to the underlying business logic. A WCF service should take in messages, coordinate with delegates and return the results. That’s it, very simple, one responsibility. When applying SRP to a WCF service, we find the axis of possible change is when the service interface changes.

1
2
3
4
5
6
7
8
9
10
11
12
13

public Foo DoSomething(Bar a) {

    // Validate

    // Transform

    // Act

    // Transform

    // Return

}

1
2
3
4
5
6
7
8
9
10
11

public Contact[] GetContacts(ContactCriteria criteria) {

    if (!criteria.isValid()) throw new InvalidCriteriaException();

    var blackbook = new AddressBook();
    var entries =  blackbook.GetEntriesByCriteria(criteria);

    var contacts = Converter.ToContacts(entries);

    return contacts;
}

This GetContacts method of the Contact service does not actually do anything except coordinate and delegate responsibilities to other objects. This service will be unaffected by changes in Contract, ContactCriteria, AddressBook, Converter and data access technique, allowing us to change them and not effect the service.

Things that do not belong in a WCF service are

• Business Logic
• Validation Logic
• Data Access Logic
• Transformation Logic
• Logging

Adding any of the above items will greatly increase the chance of change and violate SRP.

Things that do belong in a WCF service are

• Service coordination Logic
• SOAP fault Logic

SRP will help you build systems that are more tolerant to change. That does not mean your service will be impervious to change just a little more nimble. We all know that 1.0 is just the first version of our system that will eventually change.

I remember when I started out developing some years ago and we did not have version control systems (VCS). I used to make backups on to floppy disks. Do I sound old? Today, we have so many good choices for VCS like Team Foundation Server, SVN, Git and Mercurial, just to name a few. I envy the new people coming to this profession; no floppy disks required.

Now that we know we need a VCS, how should you go about picking one? Your choice is going to be dictated by what camp you belong to. If you’re in a Microsoft shop, then TFS might be a good choice due to the integration with Visual Studio. If you are in the Ruby / Rails camp, then you will probably use Git and Pythonist will choose Mercurial. These are not hard and fast rules, just an observation from this floppy shuffler.

I use TFS at work and Git for everything else including this blog post. You know that version control is for more than code, right? I prefer Git, but for some using the command line, it’s not visual enough. I also use Project Locker, a hosting service for SVN and Git repositories. Project locker gives me peace of mind knowing that my version control is under control and backed up regularly. You can also get remote Git repositories from Github.

So, what are you waiting for? Get your out of control assets into a version control system.

Yes, extension methods are the devil, and one day, will come and eat your babies!

Extension Method Example ####

    //Extension methods for logging
 
"This is a message to log.".LogMessage();
 
new InvalidOperationException("You did a bad thing").LogException();
  

Yes, extension methods can get sticky when upgrading your app from one version of the .Net Framework to the next. How many times in your career have you upgraded a production app to a new framework version? I have, twice! You will be able to figure out if your extension methods conflict with a framework version in 30 min, tops.

You know my friend Action and his big brother Action<T> right? How about his cousin Func? If you said no, please stop reading and follow the links for an education. Delegates are powerful but for some reason they freak-out C# 2.0 developers.

Anonymous Methods, Extensions and Lambdas, Oh My! ####

    // Boolean extension methods
var HasMoney = true;
var WillGetPaid = true;
 
HasMoney.IsTrueThen(()=> Debug.WriteLine("Spend Spend Spend."));
 
HasMoney.IsFalseThen(() => {
    Debug.WriteLine("Save your money.");
    Debug.WriteLine("Then spend your money.");
});
 
(HasMoney || WillGetPaid).IsTrueThen(() => Debug.WriteLine("Spend Spend
Spend."));
  

Combining all of these techniques can be a little overwhelming at first but chill out and read the code. Does it sound better? Is it more English like? Does it just roll of your tongue? Ok, so the ()=> is weirding you out. Well get used to the Lambda; it is here to stay. The ability to attach code blocks to event handlers and delegates is neat and all the cool kids are doing it. Come on, you know you want to try it. What’s it going to hurt, just one lambda?

Do you need to know these techniques to build software that your clients are going to love? No, you do not, but ignoring and avoiding them is like sticking your head in the sand. Part of being a craftsman is keeping your tools sharp and learning the features of your current language is part of sharpening the saw. So get back to work and learn the new and old features of C#.