Better software through software architecture and devops

@jamessnape

Posts

  • For some reason when I’m developing something new I always end up changing my design twice. Note, I’m not talking about architecture here. Architecture is a higher level concept and as such isn’t killed by implementation detail the way a design is. I think there is a reason for this multi-version development though.

    The first design is basically a prototype exploring possibilities. At this point I’m not sure what the best solution is or even what techniques might be best to use. It only just does the job and is probably not very elegant or efficient. Not something to be proud of.

    The second is usually a great design but, more often than not, flawed with a super hero style weakness. It will be elegant, efficient and cover every requirement imagined. The only problem – it will never be finished. This second iteration is usually complex, over designed and would take an eternity to implement.

    After a good dose of reality, the third version takes shape. It’s much more practical, easier to maintain and solves only the requirements that are actually needed. These three designs are usually quite different. Not what the XP crowd would call iterative implementations but the end result is similar.

    I think it’s important not to get too attached to any one way of doing things. I see some who start coding and stick with their first design to the bitter end no matter what. People often complain that a v1 product is OK for early adopters but not general consumption. Iterative design like this enables that sought after v3 product in your first release. Just don’t take three times as long to implement it…

    This entry was posted in agile  and tagged #iteration #personal-development  on .
    Discuss this on Twitter or LinkedIn
  • OK, I’m a little embarrassed to admit but I’ve suffered from coder’s block this week. It’s a state similar to writer’s block which is “a usually temporary psychological inability to begin or continue work on a piece of writing”.

    I think probably everyone suffers it from time to time and, although I haven’t had a case for a several years, this has come at a most inopportune moment because we are on a very tight schedule with our current release.

    I guess it’s a little like depression in that you can’t just mentally “fix it”, you need to work through the cause. In this case I don’t think it’s an inability to write code, it’s more a case of too many possible solutions to the problem in question. They are all good but none are perfect. In particular one of the requirements is to allow additional code generation (note – not just an add-in, this is adding to the system) post release by our professional services engineers. This is hard for me because my brain prefers to work spatially – I need to see the design animated in my head before I code it up; not something that’s possible if an unknown chunk of code if going to be added by someone at a later date. Talking with other developers didn’t help because all that did is give me more good solutions to consider.

    The other problem is that a number of very intricate details have to be thought about or the implementation won’t meet the requirements. Completely overwhelming if you look at them together so on Friday I decided to take a leaf out of the extreme programming book – baby steps. I started by ignoring the mass of requirements and implementing a really small section. By lunchtime I was back in the flow, I managed to check-in something yesterday evening and things are looking to be back on track.

    So if you are suffering similar then I can offer the following advice:

    • Take a break and do something completely different like go for a walk, however doing this too often is just procrastination
    • Try and work out what is causing the block and fix those issues one at a time
    • Take small steps to get something (anything) working
    • If all else fails, see if you can swap your feature with another developer
    This entry was posted in agile  and tagged #personal-development  on .
    Discuss this on Twitter or LinkedIn
  • Just a quick reminder that there is no point manually checking database constraints before modifying your data. Take this code:

    create table Users (
        UserID uniqueidentifier primary key not null default newid(),
        LoginName nvarchar(50) not null unique
    )
    
    if not exists (
        select * from Users where LoginName = 'JohnSmith'
    )
    begin
        insert into Users (LoginName) values ('JohnSmith')
    end

    There is a race condition between the if not exists check and the insertion of data. Another connection could insert the same data before this insert gets a chance to complete. We could wrap the check and insert in a transaction to make sure consistency as follows (note the isolation level because we need to place a range lock on data that could be there):

    begin tran
        set transaction isolation level repeatable read
        if not exists ( select * from Users where LoginName = 'JohnSmith' )
        begin
            insert into Users (LoginName) values ('JohnSmith')
        end
    commit

    This works but we’ve got the added cost of a transaction. There is no point in doing this though as there is already a unique constraint on the column and databases are very good at checking constraints. With this in mind, the new and improved version looks like:

    insert into Users (LoginName) values ('JohnSmith')

    Much simpler. There is only one minor problem, for which I don’t have an answer, and that is if you have multiple constraints on a table then it’s very difficult to find which one failed. The @@error variable will be set to 547 (constraint violation) and a suitable raiserror is generated which could be parsed by the caller but not easily.

    This entry was posted in data-warehousing  and tagged #database-constraints #sql #transactions  on .
    Discuss this on Twitter or LinkedIn
  • Sometimes, when you have to get a lot done in a ridiculously short time, you need a different approach. As a case in point, we need to replace all the remaining ASP code in our product with ASP.NET before we add some essential new functionality. If we don’t we will be stuck with the old code forever. This new functionality has to be delivered in a matter of weeks. It could be implemented in classic ASP but it will be much easier and faster using .NET.

    What is called for is a few days of pure implementation. No “discussion”, no “difference of opinion”, just code. It’s risky - probably only a 50% chance of success but if it works then we could save days in the immediate future and extra weeks down the line.

    There is a way this could work; by modelling the team on an operating theatre. In this setup, there is one person who does the bulk of the work backed by a second to give help and support. These two make the core pair - everything goes through them on the way into the product. The rest of the team are assigned packets of work by the core pair on an as needed basis. When the packets are complete they are given back to the core pair to stitch into the product. Effectively, one feature at a time is worked on by the entire team.

    The main benefit to this style of team is the minimal communication needed, resulting in a higher code to comms ratio. The packets of work are usually so small that they can be described in a couple of sentences. If the result is not quite right then the core pair make whatever changes are required saving the time usually spent explaining extra work to the developer.

    There are two key points to note before you embark on a development style such as this. Firstly, the core pair has to have a very strong shared vision of what the result should be. If not then you won’t be on a straight line to goal and too much rework will kill the efficiency of the method. Secondly, it can be a bit ego bruising to the non-core developers. They are told exactly what to produce, they have no real opportunity for free thought and the code they return may be modified or even not used. Nearly everyone can put their needs and feelings on hold for a week (even developers) but I wouldn’t push it beyond that. This is only for tiger-team style development.

    This entry was posted in agile  and tagged #surgical-teams  on .
    Discuss this on Twitter or LinkedIn
  • They only seem to care because we, as software developers, make them play the requirements game. In reality, the only thing that matters is how the product matches up to their expectations. The big problem is that you can’t capture them in a document to use as the blueprint for development. There are some things you can to make sure your customer is happy with the result:

    1. Write a short “Vision” document describing the key features to get everyone on the same page early on
    2. Program by feature to produce functionality early, don’t spend too much time on infrastructure
    3. When you’ve completed a feature, show it to the customer and get feedback
    4. Allow the customer to change their minds

    These points will only work when both you and the customer share the project risk; either with fixed rates/variable time or fixed time/variable functionality.

    If it’s a fixed price/fixed functionality contract then you’d better start writing those requirements…

    This entry was posted in agile  and tagged #requirements  on .
    Discuss this on Twitter or LinkedIn