Processing Applications

In Development by PaulLeave a Comment

I really enjoy writing console applications that do some sort of processing. I did that again a few weeks ago. A client needed an application that read a text file, made various modifications to it, and then output the new file. Some of the modifications included:

  • Removing lines that matched particular patterns.
  • Merging lines that matched particular patterns.
  • Identifying lines between certain other lines. Performing some processing only on those lines.
  • Replacing text within certain parts of certain lines. Some of these replacements were non-trivial (e.g., using an algorithm to change a list of values into a range of values).

It’s very easy for bugs to creep into an application like this. So I made any bugs easier to find by doing the following:

  • Runtime verification. The application looked for very specific text patterns and threw an error if the patterns didn’t match. So if the application got “confused”, it threw an error — it didn’t output incorrect information.
  • Log file. Verifying the differences between the input and output files using a “diff” program was time-consuming because of the sheer number of modifications. So the application wrote a list of the unique modifications it made to a log file. That way, I (and my client) could review 30 lines in a log file rather than 1,000 lines in a “diff” program.
  • Unit tests. The client is planning to use the application for a long time. Some changes to the algorithms are inevitable. So I wrote a bunch of unit tests. That way, I can easily make changes in the future and verify that I didn’t break anything else.

Leave a Comment