While the Software Inventory post by Joel Spolsky is a thinly-veiled advertisement for Fog Creek’s new (at the time) ‘project management’ tool Trello; the points Joel makes are nevertheless deeply meaningful to me. Points like this:
“The trouble is that 90% of the things in the feature backlog will never get implemented, ever. So every minute you spent writing down, designing, thinking about, or discussing features that are never going to get implemented is just time wasted.”
“… the desire never to miss any bug report leads to bug bankrupcy, where you wake up one day and discover that there are 3000 open bugs in the database, some of which are so old they may not apply any more, some of which can never be reproduced, and most of which are not even worth fixing because they’re so tiny.”
…though you probably won’t need any more than 20 bug reports to find outdated or incorrect tickets!
I’ve just had another reason to hunt-out and refer to this blog post professionally, in an effort to encourage a client that having a bunch of years-old tickets assigned to someone but ‘on-hold’ when the original ticket requester has left the business is a sure-sign that really those projects are never going to happen and are probably not a good idea anyway!
We made a mistake recently, breaking one of our own rules; Be Consistent. Now, of course it is not always possible to ‘be consistent’, sometimes because you are doing something truly new; but often because one incorrectly sees differences – when you may be better off seeing patterns and similarities (and thus implementing something to fit an existing pattern)!
What is Premature Simplification – other than ‘Allowing UI Display Formats to Drive Data Storage Formats’? It will be easiest to start with an example: A company receives records from many devices, and decides that the end-user of the system web site will never want to view detail at finer grain than 1 second… so they decide that all time formats should be stored without milliseconds (or ticks) – that is to say, timing data is rounded or truncated to seconds. Continue reading
In the previous post, we hinted at a couple of examples of developer-managed-caches that may not have optimised a system very wisely. Today we will look at an example of a development team that intentionally wanted to optimise some process-or-other, and made mistakes in doing so. Continue reading
This post by Martin Fowler quotes Phil Karlton:
There are only two hard things in Computer Science: cache invalidation and naming things
(and Martin adds the derivative quote: ‘there are two hard things in computer science: cache invalidation, naming things, and off-by-one errors’) which is quite nice. Today’s post was originally about naming things being hard… but I think I can extend it to something close to the two topics in the quote. Continue reading
The client had a stalled project with many changes to an existing system; there were several areas of new functionality, but they were not completely trusted. There was considerable concern regarding the reliability and performance of the database, and in some senses the database was seen as the whole problem. Not only had this set of changes stalled, but minor fixes had also stacked up waiting to be released and all were dependent upon the main project.
Many modern development tools are providing ways to create databases and populate them with test data; often with the idea that unit tests can then be run against them. But there is an alternative approach available to some people; which is to use live data as a source for our test environments. Now, there may be reasons why this is not possible (not the least of which is ‘compliance’), and there are certainly issues of practicality that will need to be considered, but if you are allowed to do this there can be huge benefits.
We have found that communicating our system designs with clients is most usefully done with diagrams rather than large chunks of text. Some years ago, we looked at using UML Use Case Diagrams for this communication – but see what Martin Fowler has to say about them in ‘UML Distilled':
“But almost all the value of use cases lies in the content, [of the textual cases] and the diagram is of limited value.’
In other words, in his opinion, you should use the textual Use Cases, not the diagrams (which just map those texts visually).
‘Pure’ UML also seems to disappoint in terms of producing very dry monochrome diagrams with stick figures, and simple primitives such as boxes and ovals. Is this really the best we can do to convey the use of a system?
Last time we discussed some general ways to write SQL that made it easier to use it interactively. Today I want to talk about an error I often see with general SQL, especially the use of commenting the
NOT EXISTS clause.
This post is about some top tips and tricks to use when writing and modifying SQL. At first sight they may seem a little bit strange, but hopefully after explanation they will make sense. Let’s take a look at the first bit of SQL:
, TeamName -- (2)
--, BigXmlCol -- (3)
FROM dbo.SomeTable -- (4)
WHERE 1 = 1 -- (5)
AND TeamName LIKE 'Blah%'
--AND EmployeeName LIKE 'Nigel%' -- (6)
ORDER BY TeamName
--ORDER BY EmployeeName