in

 

AgileJoe

Answering all world issues with, "...it depends..."

December 2007 - Posts

  • What I do

    In response to being tagged by Jason!:

    These are one of the few questions I hate to answer because I don't like talking about myself.  In fact if I met you on the street and it was a casual gathering, I would just tell you I work on computers and lead the conversation else where.

    On well here it goes, I am the Assistant Vice President of the Internet Loan Origination Systems here at where Jason mentioned.  Big title, looks nice on resume (more on that later).

    I am responsible for the development effort and over all system integrity for several web based applications that are utilized by our back office and field personnel.  I am equally responsible for insuring that our Agile methodology adheres to corporate, government regulatory and compliance oversight.  This is a full time job in an of itself as the corporate organisms bureaucratic blinders tend to want to stifle productivity and innovation as a result of trying to control risk and the illusion of predictive planning.

    I am very proud of our team as I have seen our solution grow over the past 3 years into the massive conglomeration it is today.  With over 6,000 unit test and growing the integrity of system is unmatched by other systems of similar size.

    I can honestly say that the only reason we are so good at what we do is because we have made tons of mistakes to get to where we are at.  And I do mean tons!  We have taken Agile apart and put it together again several times before we arrived at the right mixture of practices that compliment our arena of development.

    We bare the luxury of interfacing not only with our customers but also a systems analyst group that function as QA.  My responsibilities is insuring the development group and the QA group play nice with one another and get the projects done on time and on budget.

    Since I am in a management  and due to company regulations that have a clear delineation of separation of roles, I can not touch production code (I know, I tear up every time I say that). BUT!!!  What I can do is create all sort of neat little tools that support the overall development effort.  This also allow me to explore new ways of approaching software development such as BDD and other pragmatic practices.  As I learn these new concepts I introduce them to the development group and together we figure out how to implement these practices into our day to day activities.

    When I am not focusing on work, I am also the president of the AlamoCoders.Net association.  It is my responsibility to my community to try to work with the other directors of the association to come up with new and innovative ways on how to bring .Net to the masses.  Not only that but how to enrich the San Antonio programming community on all aspects of software development. 

    In addition to the tools already outlined in Jason's post we (I) also utilize:

    • Urban codes AntHillPro (think CI and Automated deployment bundled as one)
    • Mercury Load Runner
    • Mercury Quality Center
    • Mercury Quick Test Professional
    • FitNesse
    • XPlanner
    • Microsoft Project
    • A kitchen sink
    • And a whole lot of note cards!

    Well that is about it in a nutshell.  As I mentioned before that while I am appreciative of my title I do not use it as badge giving me authority to enact and do anything I want.  All the title gives me is responsibility, not power.  My power comes from my team and my team is my reason for being, I am nothing without my team.  I will do anything and everything to enable and help them to deliver better software. That is my promise and that is my mission.  From that flows prosperity for everyone else involved.

    Now I shall tag:

    Chris Patterson

    Evan Hoff

    Colin Ramsay

    Chad Myers

  • Say goodbye to 411 charges

    And say hello Goog 411

    My brother made me aware of a new free business information service provide by Google. 

    I actually used this over that last couple of days shopping for my kids and having to hunt down the elusive Pink Nintendo DS.  Pretty convenient especially if you are driving.

    One humorous tid bit is the polling sound seems to be someone muttering (boodoop, boodoop, boodoop, boodoop, boodoop, boodoop, boodoop)  Pretty hilarious when you first hear it, then it starts to get annoying.

    Posted Dec 20 2007, 11:00 AM by Joe Ocampo with 3 comment(s)
    Filed under:
  • BDD Surprise: R# Usage Scenarios

    I had to blog about this because it brought a smile to my face when I saw it.

    After some discussion yesterday over the benefits of implementing a REST model in ASP.Net MVC.  I was up late last night looking over the MVCContrib project.  I came across Adam Tybor's SimplyRestful contribution.

    When I look at most OSS project I usually look at the objects implementation first and then I look for the test coverage.

    I found a class named "RestfulActionResolver", the name alone peek my curiosity.  I noticed this class had a ResolveActionMethod that would seem to, resolve the action. :-)  I used ReSharper to find the usages of this method to see just how it was being acted upon by other objects(ctrl-alt-F7). 

    What appeared next shocked me:

    image

     

    The top of the report read like a normal test suite no surprise there but then I quickly noticed the bottom two entries!

    image

    Two things shocked me!

    1. Usage of BDD context/action/behavior (sweet!)
    2. How well it read from a usage report perspective (double sweet!)

    Most of you that read my blog love OSS.  I sometimes hate to go into a project and figure out how some OSS project actually works.  Lets face it documentation is very pore on OSS projects.  But by utilizing a BDD approach the test fixtures and test become self describing meta data for comprehending the intentions and actions of the code. 

    I know there has been some debate on should the specification files contain multiple class entries defining context.

    Ex:

    • File Name: SimplyRestfulSpecs.cs
      • [TestFixture]
        [Category("SimplyRestfulSpecs")]
        public class When_The_Form_Is_Posted_With_A_Form_Field_Named_Method_And_A_Value_Of_PUT

        [TestFixture]
        [Category("SimplyRestfulSpecs")]
        public class When_The_Form_Is_Posted_With_A_Form_Field_Named_Method_And_A_Value_Of_DELETE

    Well chalk this one up in the "Favor" column for "multiple class entries defining context".  With out this I don't know if the report would have read as well.

    Happy coding!

     

    • Customer Perception Model: Know thy customer

      It's important to know how your "working" software is being received out in the field.  Immediate customer feedback is one thing during a release but what about after the code actually gets out into the field.  How are those users feeling!

      Enter the Customer(field) Perception Model:

      image

      As you can see this is a very complex model that involves several frequencies and an algorithm that will make your head explode. 

      No, seriously this model if you will, is intended to be utilized by the product owner or anyone who is the advocate for the field.  We try to update this as much as possible to determine if our users are really happy with the software we produce.

      Do not base the model on defects found in production or any other metric!  There might not be any defects but your users may not like how the system works!  They will use it but they don't like it.

      It is those users that we mentioned above that we are targeting with this model.  This is their voice and as your customers you should do something about it.

      If we start to drop down into the more unpleasant side of the scale we quickly call a retrospective to determine where the team missed the mark and how can we adjust the current release to bring the "happiness coefficient" (ha you like?) up again.

      This model is completely subjective and based on the product owners ability to gauge the field.  If that communication isn't there (first that is a process smell) second you have bigger issues that need to be dealt with.

      Put this up on a wall where everyone can see.  Don't hide from your system or your users.  Make it to where the CIO passes by and notices that the scale is on the ugly side.  Trust me things will get done!

      Enjoy!

    • Now MVC has rescues: Kind Of

      I really missed using the [Rescue] attribute from MonoRail in the ASP MVC framework.  I missed it so much that I decided to create my own.  With the help of Phil Haack's ConventionController and Frederick Norman's post on ErrorHandlerAttribute it wasn't that hard at all.  In fact in the end I have something that almost looks like the MonoRail controller syntax.  Mind you it is not using any Filters but I really see how easy it would be implement them given the time.

      Anyway, the code!

      So the first thing I did was create the actual Rescue attribute:

      public class RescueAttribute : Attribute
      {
          private readonly IList<Type> exceptionTypes = new List<Type>();
          private readonly string rescueView;
          private readonly Action<Type> preRescueAction;
      
      
          public RescueAttribute(string rescueView) : this(rescueView, new Exception().GetType())
          {
          }
      
      
          public RescueAttribute(string rescueView, Type exceptionType)
          {
              this.rescueView = rescueView;
      
              if (exceptionType != null)
                  exceptionTypes.Add(exceptionType);
          }
      
          public RescueAttribute(string rescueView, Type exceptionType, Action<Type> preRescueAction)
          {
              this.rescueView = rescueView;
              this.preRescueAction = preRescueAction;
      
              if (exceptionType != null)
                  exceptionTypes.Add(exceptionType);
          }
      
          public RescueAttribute(string rescueView, params Type[] exceptionType)
          {
              this.rescueView = rescueView;
      
              if (exceptionType != null)
              {
                  foreach (Type type in exceptionType)
                  {
                      exceptionTypes.Add(type);
                  }
              }
          }
      
          public IEnumerable ExceptionTypes
          {
              get { return exceptionTypes; }
          }
      
          public string View
          {
              get { return rescueView; }
          }
      
      
          public Action<Type> PreRescueAction
          {
              get { return preRescueAction; }
          }
      }

      Now I had to add a couple of methods to Phil's ConventionController:

      protected override bool OnError(string actionName, MethodInfo methodInfo, Exception exception)
      {
          ArrayList attributes = GetRescueHandlerAttribute(methodInfo);
      
          foreach (RescueAttribute rescueAttribute in attributes)
          {
              foreach (Type exceptionType in rescueAttribute.ExceptionTypes)
              {
                  if (exceptionType.IsAssignableFrom(exception.InnerException.GetType()))
                  {
                      if(rescueAttribute.PreRescueAction != null)
                      {
                          rescueAttribute.PreRescueAction.Invoke(exceptionType);
                      }
      
                      if (!string.IsNullOrEmpty(rescueAttribute.View))
                          RenderView("~/Views/Rescue/" + rescueAttribute.View + ".aspx", exception);
      
                      return true;
                  }
              }
          }
      
          return false;
      }
      
      private ArrayList GetRescueHandlerAttribute(ICustomAttributeProvider methodInfo)
      {
          ArrayList attributes = new ArrayList();
      
          attributes.AddRange(
              methodInfo.GetCustomAttributes(
                  typeof (RescueAttribute),
                  false));
      
          attributes.AddRange(
              GetType().GetCustomAttributes(
                  typeof (RescueAttribute),
                  true));
      
          return attributes;
      }

      The OnError is called when ever there is an Exception within an Action.  All I did was simply find all the Rescue Attributes on the controller class and iterate through all the registered exception types.  If it finds a registered exception type it looks for a PreAction delegate or lambda and invokes it (still working on this but I thought it was overkill).

      Finally it Renders the rescue view in the Rescue folder.

      image

      That's it!

      Now my controller looks like this (check out the new hip name for the convention controller:

      [Rescue("HelpMe")]
      public class HomeController : SuperConventionController
      {
          public void Index()
          {
              RenderView("Index");
          }
      
          public void About()
          {
              RenderView("About");
          }
      
          public void Error()
          {
              throw new NotImplementedException("Did you get this?");
          }
      }

      When I type in the following url: http://localhost:52634/Home/Error

      It immediately redirects me to the Rescue page HelpMe.aspx

      image

      I don't think this code is near production ready but it serves as a quick representation on how quickly and easily you can extend the MVC framework.

      Happy coding!

    • ASP MVC Forum Link

      This is more for my personal reference than anything else.  But I thought I would share this with everyone in case they  were wondering where we can share information with MS and one another on the ASP MVC framework.

      ASP MVC Extensions Forum

      Happy coding!

      Posted Dec 10 2007, 02:43 AM by Joe Ocampo with no comments
      Filed under:
    • Where the magic happens: Our Dev Lab

      Some if you wanted to see what our lab looks like so I found some pics and thought I would share them with you.  I took these pics late in the day and most of developers had left at this point.  They are camera shy.  :-)

      Lab008

      Lab 009

      Lab011

      And for those who want the layout.

      image

      We are very proud of our lab and have received several compliments. We are constantly looking for new an innovative ways on how to improve it. 

      What do your work environments look like?

    • User Story Templates

      A couple of people emailed me and asked me what the story cards looked like on our information radiator.

      It is important to note that these story cards are only drafted after extensive modeling and feedback sessions during our modeling week.  We don't use them in the traditional XP fashion and caution should be taken when implementing as this may deter from fluid communication if used improperly.

      These templates are word documents that have been formatted to fit on a 4x6 index card.

      StoryCard

      As you can see the story card has several sections:

      • Story Name:  This is the story name but it also contains the [Story Points] estimate in brackets.
      • Business Analyst: This is the business analyst that has been assigned to the story.
      • Systems Analyst: This is the systems analyst that has been assigned to the story.
      • Developer:  This is the developer who has elected to make themselves responsible for the teams delivery of this story.
      • Architect: This is the Architect who is responsible for insuring that the story stays within the Architectural Guidelines of the framework.
      • Estimate SIT:  This is the date that team estimates when the story should be completed by.

      If you notice the only stake holders that are listed are Pigs!  If you have other Pig roles you may want to include them as well.  Don't include the chickens!

      The templates can be downloaded from here.

      Enjoy!

      Note: Some of you may be wondering where the Acceptance Test are.  Well the stories are sent to Mercury Quality Center and the acceptance test plans are written against the stories there.

    • Convention over Configuration: The Haack Response

      Yesterday Sean and I talked briefly about Convention over Configuration and how disappointed we both were on MS direction requiring the [ControllerAction] attribute for each action in the controller.  Similar sentiments seen in Ayende's post as well. 

      Less than a day later Phil Haack responds with a "ConventionController".  This controller gives the convention approach to the ASPMVC framework similar to MR.  I figured it shouldn't be that difficult for MS to implement this approach and Phil expeditiously verified that. 

      Hat's off to Phil for getting this turned around so quickly and listening to the community.

    • Information Radiators: Make life visible

      A couple of people have asked me how we track our work for our iterations. We basically use a somewhat simple information radiator.

      Information radiators serve to quickly give everyone on the project team a quick indication on what needs to be done, what is being worked on, and what has been done.

      Information radiators can be as a simple as a few cards on a cork board to huge 54” plasma displays. It’s up your team to determine what works best.

      Here is a pic of our radiator:

      Cheerleading 006

      As you can see the board is broken up into several columns:

      • Back Log: Contains the prioritized backlog from top to bottom.
      • Working: Contains the stories that are being worked on along with their associated task (the blue cards)
        • When a task is completed it moves t the Completed Tasks column
        • The little colored magnets are the developer’s initials. I can come into the lab at anytime and quickly see who is working on what. When the developers complete a task they place their initials on the board and go on to the next task or story.
        • By utilizing a white board with index cards allows the team to quickly annotate important information and reestablish task priority quickly.
      • Completed Task: Well, it lists all the completed task
      • Analyst Review: Once all task have been completed for a Story the task bundled with the Story are moved over to the Analyst Review column to await smoke testing sign off with the developers.
      • Ready For SIT: Once a story is moved here indicates that this story is ready to be included in the next build to the SIT environment.
      • Deployed to SIT: The build coordinator will move the story to “Deployed to SIT” once the build is complete.

      If you wanted to do this with your team here is a supply list:

      • 3x5 Assorted Color Index Cards (Task Cards): The more the better
      • 3x5 Hot Pink Index Cards: Hopefully you only need one pack of 100 since these cards are used only for high priority issues or risks!
      • 4x6 Index Cards (Story Cards)
      • Magnetic Clips: I recommend around 72
      • 1/8” Chart Tape
      • ¼” Chart Tape
      • Dry Erase Markers
      • 8' x 4', Magnetic White Board
    Copyright Los Techies 2007. All rights reserved.
    Powered by Community Server (Commercial Edition), by Telligent Systems