When to fix and when to rewrite

We have all faced the dilemma of whether to fix or rewrite software. Unfortunately it’s never a straight forward decision. Many industry heavyweights say NEVER rewrite, whilst others say it is only OK in specific circumstances.

The reasons for wanting a rewrite are usually based on the following:

The existing code is crap: the code displays all the features of a big ball of mud, and exhibits the usual code smells that indicate the code should be quietly taken outside, lined up against a wall and shot – the code that is, not necessarily the developers, but sometimes…

We now understand what it’s supposed to do: Agile development techniques build of the principles of only delivering what is immediately needed or know. This is then added to and extended continuously as new requirements, features and understandings emerge.  Without rigorous attention to refactoring, the code base quickly descends into a quagmire of modified methods, classes and objects that are now doing things they were never initially intended to do.

We want to use this new funky programming language: With the plethora or new languages, tools and techniques. MVC, JavaScript libraries, document databases, new devices, mobiles, tablets…

We need a bunch of new functionality: we want to add these great new features.

In most cases, don’t do itdo not rewrite from scratch. It is well documented that rewriting and existing application from scratch is almost always a bad thing:

  • It almost always takes much more effort than you expect.
  • What is to say that your New code is that much better than the old. It is well know that developers always want to work on the new, latest, shiniest piece of code. Working on old code is always Hard, especially if you didn’t write it in the first place.
  • It is usually far more complex than you anticipate. The original developers resolved a series of problems to come up with their final solution. You will probably need to resolve those problems again – so why reinvent what has already been done?

When is a rewrite acceptable?

However, there are some cases where a rewrite is the only alternative:

When the cost of inaction far outweighs the cost of action

This means that if you can measure the cost or risk of not rewriting your application, and compare that with the costs and risks of a rewrite then it’s a no-brainer. I have worked on applications that are so completely screwed that even an infinite number of monkeys with typewriters would give up and go to StarBucks. that’s when you know a rewrite is inevitable.

When a major platform change is required

If you find that you need to move say from console/character based to windows/web based, and the existing UI is heavily embedded in the existing code a rewrite may be more cost effective.

When a very significant change or addition of functionality is needed

You need to make the application do something it was never ever designed to do. “That functionality we said We will never ever need… Well things have changed!”

Try not to start from scratch

Given the indicators above, even if a rewrite appears to be the only viable option, if the technology allows you should always try to migrate, refactor, adapt or re-engineer your existing application. You will be starting from a (hopefully) working application and re-using whatever existing code or functionality that is salvageable. There are a number of techniques for doing this from standard refactoring to my favourite the Strangler method .

When all else fails

On those occasions when there really is no choice but to start again, do it properly. Go back to your business owners, customers or designers and start from scratch in understanding exactly what he new application is required to do. Do not copy the old application. Do not look at the source code of the old application. Do not look at the database design of the old application. Start from scratch with a clean and clear set of prioritized must have features and functions.

Of course, review the old application from a functional perspective. What features work, what don’t work, what could be improved.  However, beware of reproducing faithfully all the functionality especially that which is either superfluous or more worrying put into place to work around other issues or other systems.

Javascript Friendly Date and Time

I recently had a requirement in javascript to translate a date and time into something more friendly, so that for example 10th January 2014 10:45 becomes “Yesterday 10:45”, or 12:15 today becomes “2 hours ago”. After scanning the various solutions I could find, I came up with the following:

  • < 5 minutes: now
  • < 1 hour: xx minutes ago
  • today: today hh:mm
  • yesterday: yesterday hh:mm
  • < 7 days: day-of-week hh:mm
  • this year: month day
  • default: month day year
function friendlyDate(dateValue) {
    // < 5 mins   : now
    // < 1 hour   : xx minutes ago
    // today      : today hh:mm
    // yesterday  : yesterday hh:mm
    // < 7 days   : day of week hh:mm
    // this year  : month + day
    // default    : month + day + year
    var dateparts = dateValue.toUTCString().split(' '); // Thu May 29 2014 10:09:32 GMT+0000 (GMT)
    var weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
    var now = new Date();

    var diffMsec = now.getTime() - dateValue.getTime();
    var diffMins = Math.round(diffMsec / 60000);

    if (diffMins < 1) {
        return "now";
    } else if (diffMins === 1) {
        return "1 minute ago";
    } else if (diffMins < 60) {
        return diffMins + " minutes ago";
    }

    // ignore time component
    var testDate = new Date(dateValue);
    testDate.setHours(0, 0, 0, 0);
    now.setHours(0, 0, 0, 0);
    var mSecPerDay = 24 * 60 * 60 * 1000; // hours * minutes * seconds * milliseconds
    var diffDays = Math.round(Math.abs((now.getTime() - testDate.getTime()) / (mSecPerDay)));

    if (diffDays === 0) {
        return "today " + dateparts[4].substr(0, 5);
    } else if (diffDays === 1) {
        return "yesterday " + dateparts[4].substr(0, 5);
    } else if (diffDays < 7) {
        return weekdays[dateValue.getDay()] + ' ' + dateparts[4].substr(0, 5);
    }

    if (dateValue.getFullYear() === now.getFullYear()) {
        return dateparts[1] + ' ' + dateparts[2];
    }

    return dateparts[1] + ' ' + dateparts[2] + ', ' + dateparts[3];
}

You can try this out on jsfiddle

C# Interview Questions

A series of typical C# based interview questions that I have been asked, and also occasionally ask during interviews. These have been built up over a period of years and are regularly updated with newer technologies and techniques.

  1. What is C#?
    C# is an object oriented type safe and managed language that is compiled by .Net framework to generate Microsoft Intermediate Language.
  2. What are the types of comment in C#?
    Single line, Multi Line and XML Comments.

    
                // This is a single line comment - it starts with a double slash
    
                /* This is a multiple line comment
                it begins with a slash-star
                and ends with a star-slash */
    
                /// This is an XML comment
                /// it can be used to document code
                /// and provide intellisense help
    
                

  3. Can multiple catch blocks be executed?
    No, Multiple catch blocks cannot be executed. Once an individual catch section is executed, control is transferred to the finally block and then the code that follows the finally block gets executed.
  4. What is the difference between public, static and void?
    • Public declared variables or methods are accessible anywhere in the application.
    • Static declared variables or methods are globally accessible without creating an instance of the class. The compiler stores the address of the method as the entry point and uses this information to begin execution before any objects are created.
    • Void is a type modifier that states that the method or variable does not return any value.
  5. What is an Object?
    An object is an instance of a class through which we access the methods of that class. “New” keyword is used to create an object. A class that creates an object in memory will contain the information about the methods, variables and behaviour of that class.
  6. Define Constructors
    And the answer goes hereA constructor is a member function in a class that has the same name as its class. The constructor is automatically invoked whenever an object class is created. It constructs the values of data members while initializing the class.
  7. What are Jagged Arrays?
    An array which has elements of type array is called jagged array. The elements can be of different dimensions and sizes. We can also call a jagged array an Array of arrays.
  8. What is the difference between ref & out parameters?
    A ref parameter is two-ways, out is out only. For ref parameters, its necessary to initialize them before passing(compile time error, if not done). But out parameters need not to be initialized
  9. What is the purpose of a using statement in C#?
    The using block is used to obtain a resource and use it and then automatically dispose of when the execution of block completes. Note: Using objects must implement IDisposable. Good for types that access unmanaged resourced such as File and Font. This is the preferred method of using anything that implements IDisposable.
  10. What is serialization?

    When we want to transport an object through network then we have to convert the object into a stream of bytes. The process of converting an object into a stream of bytes is called Serialization. For an object to be serializable, it should inherit ISerializable Interface.

    De-serialization is the reverse process of creating an object from a stream of bytes.

  11. Can “this” be used within a static method?
    We can’t use ‘This’ in a static method because we can only use static variables/methods in a static method.
  12. What is difference between constants and read-only?
    Constant variables are declared and initialized at compile time. The value can’t be changed after wards. Read-only variables will be initialized only from the Static constructor of the class. Read only is used only when we want to assign the value at run time.
  13. What is an interface class?
    An Interface is a class which has only public methods and the methods only have the declaration and not the definition. These methods must be implemented in the inherited classes.
  14. What are value types and reference types?
    Value types are stored in the Stack whereas reference types are
    stored on heap. Value types are therefore quicker.

    Value types: int, enum, byte, decimal, double, float, long

    Reference Types: string, class, interface, object

  15. What are sealed classes?
    We create sealed classes when we want to restrict the class to be inherited. Sealed modifier used to prevent derivation from a class. If we forcefully specify a sealed class as base class then a compile-time error occurs.
  16. What is method overloading?
    Method overloading is creating multiple methods with the same name with unique signatures in the same class. When we compile, the compiler uses overload resolution to determine the specific method to be invoke.
  17. What is the difference between Array and Arraylist?
    In an array, we can have items of the same type only. The size of the array is fixed. An arraylist is similar to an array but it doesn’t have a fixed size.
  18. Can a private virtual method be overridden?
    No, because they are not accessible outside the class.
  19. Describe the accessibility modifier “protected internal”
    Protected Internal variables/methods are accessible within the same assembly and also from the classes that are derived from this parent class.
  20. What are the differences between System.String and System.Text.StringBuilder classes?
    System.String is immutable. When we modify the value of a string variable then a new memory is allocated to the new value and the previous memory allocation released. System.StringBuilder was designed to have concept of a mutable string where a variety of operations can be performed without allocation separate memory location for the modified string.
  21. What’s the difference between the System.Array.CopyTo() and System.Array.Clone()?
    Using the Clone() method, we create a new array object containing all the elements in the original array and using CopyTo() method, copies of all the elements of existing array are copied into another existing array. Both the methods perform a shallow copy.
  22. How can we sort the elements of the array in descending order?
    Using Sort() methods followed by Reverse() method, alternatively we can use Linq with an OrderByDescending() clause
  23. What’s the difference between an interface and abstract class?
    Interfaces have all the methods having only declaration but no definition. In an abstract class, we can have some concrete methods. In an interface class, all the methods are public. An abstract class may have private methods.
  24. What is the difference between Finalize() and Dispose() methods?
    Dispose() is called when we want for an object to release any unmanaged resources with them. On the other hand Finalize() is used for the same purpose but it doesn’t assure the garbage collection of an object.
  25. What are circular references?
    Circular reference is situation in which two or more resources are interdependent on each other causes a lock condition and making the resources unusable.
  26. What are generics
    Generics are used to make reusable code classes, to decrease code duplication, reduce redundancy, increase type safety and performance. Generics use parameterized types, rather than fixed types.
  27. What are the commonly used types of exceptions in .Net?
    ArgumentException, ArgumentNullException, ArgumentOutOfRangeException, ArithmeticException, DivideByZeroException, OverflowException, IndexOutOfRangeException, InvalidCastException, InvalidOperationException, IOEndOfStreamException, NullReferenceException, OutOfMemoryException, StackOverflowException etc.
  28. What are Custom Exceptions?
    Sometimes there are some errors that need to be handled as per specific requirements. Custom exceptions are used for them and are used defined exceptions.
  29. What are delegates?
    Delegates are same are function pointers in C++ but the only difference is that they are type safe unlike function pointers. Delegates are required because they can be used to write much more generic type safe functions.
  30. How do you inherit a class into other class in C#?
    Colon is used as inheritance operator in C#. Just place a colon and then the class name.
  31. What is the base class in .net from which all the classes are derived from?
    System.Object
  32. What is the difference between method overriding and method overloading?
    In method overriding, we change the method definition in the derived class that changes the method behaviour. Method overloading is creating a method with the same name within the same class having different signatures.
  33. What are the different ways a method can be overloaded?
    Methods can be overloaded using different data types for parameter, different order of parameters, and different number of parameters.
  34. Why can’t you specify the accessibility modifier for methods inside the interface
    In an interface, we have virtual methods that do not have method definition. All the methods are there to be overridden in the derived class. That’s why they all are public.
  35. How can we set class to be inherited, but prevent the method from being over-ridden
    Declare the class as public and make the method sealed to prevent it from being overridden.
  36. What happens if the inherited interfaces have conflicting method names?
    Implement is up to you as the method is inside your own
    class. There might be problem when the methods from different interfaces expect
    different data, but as far as compiler cares you’re okay.
  37. What is the difference between a Struct and a Class
    Structs are value-type variables and classes are reference
    types. Structs stored on the stack, causes additional overhead but faster
    retrieval. Structs cannot be inherited
  38. How do you use nullable types in .Net
    Value types can take either their normal values or a null value. Such types are called nullable types and are represented with a question mark after the type e.g. int? or bool?.
  39. How we can create an array with non-default values?
    We can create an array with non-default values using Enumerable.Repeat, or we can populate it with an initializer.
  40. What is difference between is and as operators in c#
    “is” operator is used to check the compatibility of an object with a given type and it returns the result as Boolean.
    “as” operator is used for casting of object to a type or a class.
  41. What are C# attributes and their use
    C# provides developers a way to define declarative tags on certain entities eg. Class, method etc. are called attributes. The attribute’s information can be retrieved at runtime using Reflection
  42. Is C# code is managed or unmanaged code
    C# is managed code because the Common language runtime (CLR) compiles C# code to Intermediate language
  43. What are namespaces, and how they are used?
    Namespaces are used to organize classes within the .NET Framework. They dictate the logical structure of the code. The .NET Framework has namespaces defined for its many classes, such as System.Xml–these are utilized via the using statement. Namespaces are assigned to classes via the namespace keyword.
  44. What is a constructor?
    A constructor is a class member executed when an instance of the class is created. The constructor has the same name as the class, and it can be overloaded via different signatures. Constructors are used for initialization tasks.
  45. Why are strings in C# immutable?
    Immutable means string values cannot be changed once they have been created. Any modification to a string value results in a completely new string instance, thus an inefficient use of memory and extraneous garbage collection. The mutable System.Text.StringBuilder class should be used when string values will change. Immutable types are inherently thread-safe, since no thread can modify it, the risk of a thread modifying it in a way that interferes with another is removed.
  46. What is the execution entry point for a C# console application
    The Main method.
  47. How do you initialise a string without escaping each backslash
    You put an @ sign in front of the double-quoted string
  48. What is boxing
    Boxing is the process of explicitly converting a value type into a corresponding reference type. Basically,this involves creating a new object on the heap and placing the value there. Reversing the process is just as easy with unboxing, which converts the value in an object reference on the heap into a corresponding value type on the stack. The unboxing process begins by verifying that the recipient value type is equivalent to the boxed type. If the operation is permitted, the value is copied to the stack.
  49. What is the .NET datatype that allows the retrieval of data by a unique key
    HashTable
  50. Explain ACID rule of thumb for transactions.
    The transaction must be:

    Atomic (it is one unit of work and does not
    depend on previous and following transactions),

    Consistent (the data is either committed or roll
    back, no “in-between” case where something has been updated and something
    hasn’t),

    Isolated (no transaction sees the intermediate
    results of the current transaction),

    Durable (the values persist if the data had been
    committed even if the system crashes right after).

  51. When would you use a StringBuilder as opposed to concatenating separate strings
    When the concatenation occurs in a loop and you don’t know in advance how many times the loop will execute. Or when you know the concatenation will occur more than 5 or 6 times. Below this, the additional overhead of creating a StringBuilder class outweight the gains used through using immutable strings.

Please note, this entry will be regularly updated and added so pleale chack back for latest changes.

Another book: ASP.NET jQuery Cookbook

ASP.NET jQuery Cookbook
I’ve been editing another book!

This one covers many aspects of using jQuery within ASP.NET in a WebForms based environment. If you are new to the combination of jQuery and WebForms (aspx) then I thoroughly recommend this as a great introduction.

It includes the following:

  • Tips and tricks for interfacing the jQuery library with ASP.NET controls
  • Boost ASP.NET applications with the power of jQuery
  • Use a problem-solution based approach with hands-on examples for ASP.NET developers
  • Step-by-step guide with plenty of code snippets and screen images
  • Simple, effective, and easy-to-follow recipes
  • eBook available as PDF and ePub downloads

For more details, see the publisher’s page here.

ASP.NET MVC 2 Cookbook

ASP.NET MVC 2 Cookbook

Over the past year or so, I have had the pleasure to technically review this book, chapter by chapter and revision by revision.  The final result is an extremely useful collection of ‘recipes’ that will add extra functionality in most MVC applications and help you to understand some of the key concepts.

For more details, see the Packt website here

Principles of Agile Development

Since taking down the old Clicktricity website, I have had a number of requests to re-publish the agile principles.

Agile Development Core Values

The two most important core values of Agile Development are Communication and Simplicity.

Communication

It is recognised that poor communication in software teams is one of the root causes of failures within projects – whether it be schedule slips, botched requirements, misunderstandings, faulty development assumptions, and the like. Extreme Programming mitigates this by stressing good communication between all project stakeholders – customers, team members, and project managers (or “coaches”) – on a consistent basis. A representative from the customer should be available as much as possible to answer questions and clarify project requirements. Programmers often work simultaneously in pairs, with each programmer reviewing the other’s work.

Simplicity

One of the most common XP slogans is “YAGNI” or ‘You Aren’t Going to Need It’

The principal of YAGNI is that you shouldn’t develop any code that will only be used by a feature that is needed tomorrow. This does not exclude development of flexibility, but it should be kept in check and only functionality that is required now is actually developed.

Agile Development Principles

User Stories

User stories are short, simple descriptions of required functionality that are written by the customer, rather than our interpretation of what the customer wants. The descriptions should only contain sufficient detail to allow development of an accurate estimate for planning purposes, development of unit tests, and are used instead of large unwieldy requirements documents. When we develop and implement the user stories, the developers will work face-to-face with the customer to determine the specific detailed requirements.

Planning

The Planning phase of development is performed in two parts – firstly the “user stories” described above are elicited from the customer. Secondly, the development team estimates development effort for each story. The customer then decides on priorities and agrees what user stories will be implemented in the next release. This defines the project schedule.

Small Releases

The planning phase determines small units of functionality that make good business sense and can be released into the customer’s environment early in the project. This is critical to getting valuable feedback in time to have an impact on the system’s development.

Design Simplicity

The overwhelming aim is to make things as simple as possible. The only code being worked on should be the code that is absolutely necessary to implement the latest user stories, and no more (see YAGNI, as described previously). The drive for simplicity leads to continual refactoring of code, as described below.

Testing

Testing, and in particular writing test specifications from the user stories before coding is another essential component of this technique. Traditional development techniques that follow a “code first, test later” technique are prone to only testing a limited part of the development. In addition it is common that as schedules become tight – thorough testing is often dropped in the interest of expediency, leading to low quality, error prone code. Our technique is to define and develop automated tests before coding ensuring that untested code cannot be released.

Pair Programming

In pair programming, one member of the pair will write code while at the same time another programmer is critiquing the work at hand, and at the same time offering insight as to the next step as well as exposing trivial defects with the code. In tests, pair programming has been shown to be 30% more productive when quality is taken into account, than the combined productivity of two developers working separately.

Refactoring

Once it becomes apparent to the development team that the system design, a module or piece of individual code is becoming too complex, the code is refactored. The refactoring process is one by which the system functionality remains stationary – all tests that pass prior to refactoring should pass after refactoring is completed – but the code base becomes greatly simplified. This may involve eliminating shared code, redesigning model hierarchies and relationships, or simply renaming variables to fit a particular metaphor.

No Overtime

A standard working week with no overtime is strictly adhered to, based on the assertion that development teams are able to produce high-quality product when they are comfortable and not overly-exerted. This principle serves to complement the idea of both pair programming and communication amongst the development team and their customer.

Customer Availability

It is not enough to have only occasional access to a customer and a customer representative should be continuously available to the development team. This ensures that all unanticipated questions or requirements can be immediately resolved and eliminates the need to produce exhaustive and definitive (and probably still incomplete and non-definitive) specifications at the beginning of the project. This also allows the customer to interact with the development and help in the evolution of the product. Maximizing customer availability makes it possible to minimize the time spent on preliminary planning and focus on development, and maximize feedback, thereby increasing the value delivered to the customer.

Coding Standards

The entire development team agrees to maintain a common set of rules concerning the maintenance and creation of new code. These standards greatly simplify communication through common naming conventions and generate shared ownership and responsibility among all developers.

For more information on the principles of Extreme Programming, please see