
‘Why are there bugs in your software?’ is one of my least favourite questions
It’s not really a bad question and as a rather heavy user of software myself, I completely understand it. It’s just a little bit frustrating and tends to nag at me – sort of like when your mother keeps asking when she can expect her first grandchild.
I like to dream that we have faultless software that installs and runs like a finely tuned automobile. This lets me live on a beach and check my email which only contains suggestions for new features and enhancements. My computer never crashes, slows down or beeps at me for no apparent reason and my blender only makes perfect lime margaritas. Ahhhhh!
Back to reality – All software has bugs. Our software has some. Multi billion dollar corporations with hundreds of programmers and quality assurance staff have some. They are as inevitable as ants at a picnic. Even the software we use to write the RoomKey PMS software you use has bugs. We try very hard to create programs that work perfectly but it just doesn’t happen. I think it all boils down to the fact that people (who I think can also have software bugs) design software and people are not perfect.
Most of the random program features in our software are now due to the complexity of the RoomKey program. Some would argue that as a piece of software ages it should have fewer bugs. This is probably true to some extent. Programs written in prior years that have been in use for a while and have had most of their bugs removed, work pretty much as advertised. We run into some speed bumps in this theory when the software changes.
Change is a good thing. It keeps the software current and relevant. Change is necessary. Computer hardware changes constantly and the software must keep up. Business practises change over time and software must change to match. The more knowledge people have available, the more they want their software to keep track of it. Change presents some challenges to the programmers (which is also good).
Let’s look at RoomKey specifically. It was originally written a number of years ago. At first, it made reservations, checked people in and out, posted charges to their accounts and reported on all the above – Simple. Over time, it’s gotten a bit more sophisticated. A reservation alone now takes many factors into account. If you merely examine the rates portion of a reservation we need to look at:
- client type
- number of adults
- number of children
- date
- number of nights
- occupancy
- room charge
- Is it a package?
- minimum nights restrictions on the rate
- maximum nights restriction by date range
- Groups…
The list goes on. As you can see, it is no longer a simple process and this is only one part of a reservation which is also only one part of the program. A calculation error in any one of these parameters, a typing mistake like ( or [ instead of {, an error in compiling thousands and thousands of lines of code or a sneezing fit while typing and bumping your keyboard (true story) leads to…. you guessed it…. a bug!
When you look at how complex the program has become, you can see that there are many ways for bugs to creep in there. The more complex the machine, the more things can go wrong with it. Luckily, there is a very dedicated team of programmers and support people here at RSI whose job it is to try and make sure the bugs go away and your experience is pleasant and productive.
Do we do a good job of debugging? I think so. Is it perfect? No, not yet but we’re working on it. The dream lives on.
Stay tuned for future posts including: Why does it take so long to fix some of these bugs?!