Jez Higgins

Freelance software grandad
software created
extended or repaired


Follow me on Twitter
My code on GitHub

About
Contact

Older posts are available in the archive or through tags.

Feed

Thursday 02 April 2020 Diary Space

Jez Higgins is a freelance software grandad. He mucks in with programming, lends a hand with build & deployment processes, provides a leg up with TDD practices, and keeps an eye on the young 'uns so they don’t get trapped down the old mine shaft.

Like many, many people in the strange and scary world we’ve all gently slid into this year, I have what’s euphemistically known as space in my diary.

A piece of work that I’d been expecting has disappeared, so I’m looking at a significant amount of staring into the middle distance, loud exhaling, and general thumb-twiddling coming up in the pretty immediate future.

If you might be able to help save me from those long hours of nothing by filling some of that space, I’d be delighted to hear from you.

Wednesday 05 February 2020 The Forest Road Reader, No 2.43 : STinC++ - compare

STinC++ rewrites the programs in Software Tools in Pascal using C++

Here we are at the start of Software Tools in Pascal’s third chapter, entitled Files. It’s all very well reading one input and writing one output, but eventually we’re going to want to access “some kind of permanent file system where information can be kept for extended periods on secondary storage”.

In their opening paragraphs Kernighan and Plauger outline the territory - each operating system has its own jargon for describing file system operations, each has its own capabilities and limitations, some operations are easier on this system than that. This is still true, perhaps even more so given that there isn’t a one-to-one mapping of operating systems to filesystems, although happily most of us are able to ignore that in our daily programming lives.

System variations, while a pain, were not Kernighan and Plauger’s biggest obstacle - file system access was just not a thing Pascal concerned itself with. When I was taught Pascal some years after Software Tools in Pascal was written, the language support for file access could best be described as grudging. K&P handle the problem in the same way as they handled console i/o in earlier chapters, presenting a library of file access primitives. The primitives are, unsurprisingly, very similar to those provided in C, and much of the chapter is spent on describing their operation and the operation of file systems in general.

In keeping with their step-by-step approach, Chapter 3’s first program is compare, a file comparison program. Our program needs to read two files, but we can reuse the console output we’re familiar with.

Comparing two files

Because this is Software Tools in Pascal and not, say, The Art of Computer Programming, and the point of the chapter is file handling not algorithm development, the approach to file comparison is not sophisticated.

As long as the two lines are identical, no output will be produced; if [the files] end together, all is well, even if both are empty. If one file is a prefix of the other, then a message to that effect is printed. Finally, if the files differ anywhere in some line, the differing lines will be printed.

compare.cpp
void compare(
    std::string left_file_name,
    std::istream& left,
    std::string right_file_name,
    std::istream& right,
    std::ostream& out
) {
    size_t line_count = 1;
    do {
        auto left_line = getline(left);
        auto right_line = getline(right);

        if (left.eof() && !right.eof()) {
            out << end_of_file << left_file_name << '\n';
            return;
        }
        if (!left.eof() && right.eof()) {
            out << end_of_file << right_file_name << '\n';
            return;
        }

        if (left_line != right_line) {
            out << line_count << ':' << '\n'
                << left_line << '\n'
                << right_line << '\n';
        }

        ++line_count;
    } while (left && right);
} // compare

std::string getline(std::istream& in) {
    std::string line;
    std::getline(in, line);
    return line;
} // getline

It’s not often you get to write a do while loop. Exciting times! You can see this lines up exactly with Kernighan and Plauger’s description:

  • read a line from each input stream

  • check to see if one or other stream is at the end

  • compare the two lines, and output a message if they differ

  • repeat while there is still input to read

You’ll also note, file names aside, there’s no mention of files anywhere in the code. The input stream abstraction, familiar from our earlier endeavours shields us from it. If we really needed to get down into the details of a file - how big it was, or where are we in the file say - then, sure, we’d need to be dealing with a some kind of handle to the file itself, but here we’re not. We just need to be able to read each file until there’s nothing left, and the stream abstraction gives us exactly that.

I used the non-member std::getline in preference to the std::istream::getline member function because it deals in std::string rather than a char* and a count. We’re living in the 21st century and there’s no need to be messing around with raw memory pointers in a program like this. I then threw a little wrapper around std::getline because the out value by reference feels ugly.

To connect the compare function up to a couple of files, we just need a little bit of extra set up.

1_compare.cpp
int main(int argc, char const* argv[]) {
    auto arguments = stiX::make_arguments(argc, argv);
    if (arguments.size() != 2) {
        std::cout << argv[0] << " file1 file2" << std::endl;
        return 0;
    }

    auto left = openfile(arguments[0]);
    auto right = openfile(arguments[1]);

    if (!left || !right)
        return 0;

    stiX::compare( (3)
        arguments[0],
        left,
        arguments[1],
        right,
        std::cout
    );
}

std::ifstream openfile(std::string const& filename) {
    std::ifstream f(filename); (1)
    if (!f) (2)
        std::cout << "Could not open '" << filename << "'\n";
    return f;
}
  1. An std::ifstream is an input file stream. Passing a filename to the constructor attempts to open the file, ready for reading.

  2. An istream is good if it is readable and implicitly convertible to true. If our newly created stream is not good, we just give up and display an error message. (Note, however, that an istream that is not good is not necessarily bad.)

  3. With two open files, hand off to our compare function.

It does a job, but it’s no diff

The comparison algorithm used here is rudimentary at best. The program compare is mimicking this time is, of course, diff, which is another of Doug McIlroy’s many contributions to programmers the world over. The algorithm McIlroy and his colleague William Hunt developed, later described in (the short and very readable) An Algorithm for Differential File Comparison, is the basis of pretty much all file differencing and source code control tools, at least as far as I’m aware, as well as finding applications in funky things like analysing DNA sequences.

I once developed a three-way XML document diff and merge tool and it too used the Hunt-McIlroy algorithm, although I went the long way round to get it. I found a diff implementation written in Perl, which itself might have been a port from Smalltalk, and without any real understanding of how it worked translated that into Java. I then jabbed at for several days until it produced reasonable outputs. The end result was, I thought, a pretty decent bit of kit, although it absolutely failed to make my fortune.

Source code

Source code for this program, indeed the whole project, is available in the stiX GitHub repository. compare is first program of Chapter 3.

Library Reference

Endnotes

This whole endeavour relies Software Tools in Pascal and Software Tools, both by Brian W Kernighan and PJ Plauger. I love these books and commend them to you. They’re both still in print, but new copies are, frankly, just ridiculously expensive. Happily, here are plenty of second-hand copies floating round, or you can borrow them from the The Internet Archive using the links above.

For this project I’ve been using JetBrain’s CLion, which I liked enough to buy a license. CLion uses CMake to build projects. My previous flirtations with CMake, admittedly many years ago, weren’t a huge success. Not so this time - it’s easy to use and works a treat.

The test harness I’m using is Catch. I’ve been aware of Catch pretty much since it was first released, but this is my first time really using it. I like it and will use it again.


Tagged code, and software-tools-in-c++

Wednesday 01 January 2020 The Forest Road Reader, No 2.42 : First Foot

At the beginning of last year, my humble missive was Tharg’s Letter of the Week in Prog 2114 of the Galaxy’s Greatest Comic, 2000AD. It was a real thrill, which continues to bring me joy.

Towards the end of the year, I was called "a total moron" by an anonymous Redditor, in what was their first post in five years and only their second ever. I’m delighted my talk at the ACCU Conference moved them so deeply.

I hope you found similar little personal high points in an otherwise globally gloomy year. Hey, let me know if you like.

Eyes on the horizon. Look after yourselves.

Friday 27 December 2019 The Forest Road Reader, No 2.41 : In Clown’s Clothing

Fluffy-haired and youthful at forty-eight, and with a vocabulary peppered with archaic expostulations - Balderdash! Tommy-rot!! Oh my giddy aunt!!! - Peter Judd has long established himself as the unthreatening face of the old-school right, popular enough with the Great British Public, which thought him an amiable idiot, to make a second living outside Parliament as a rent-a-quote-media-whore-cum-quiz-show-panel-favourite, and to get away with minor peccadilloes like dicking his kids' nanny, robbing the taxman blind, and giving his party leader conniptions with off-script flourishes. ('Damn fine city,' he’d remarked on a trip to Paris. 'Probably worth defending next time.') Not everyone who’d worked with him thought him a total buffoon, and some who’d witnessed him lose his temper suspected him of political savvy, but by and large PJ seemed happy with the image he’d either fostered or been born with: a loose cannon with a floppy haircut and bicycle.

That’s from Mick Herron’s Slow Horses, a thriller about washed-up spies. Peter Judd, clearly a Boris Johnson analogue, plays a small but key role, as a go-between able to tip off an extreme nationalist cell that they’ve been infiltrated by the security services.

'Because we both know the tide’s turning. The decent people of this country are sick to death of being held hostage by mad liberals in Brussels, and the sooner we take control over our own future, our own borders …​'

'Are you seriously lecturing me?'

'It’ll happen, and within the lifetime of your government. We both know that. Not this Parliament, but probably the next. By which time we both know where you expect to be living, and it won’t be Islington, will it? …​ It’ll be Downing Street.'

'Yes. Well.' The effing and blinding PJ of ten minutes ago …​ left the room; in his place was the bumbly figure familiar from countless broadcasts and not a few YouTube moments. 'Obviously, if called upon to serve, I’ll leave my plough.'

'And you’ll want to take your party further to the right …​'

Despite being too toxic to even stand as leader of the Conservative Party just three years ago, Boris Johnson, of course, become Prime Minister earlier this year and he and his party have just won the General Election by a first-past-the-post distorted distance. The current Conservative Party seems be as predicted by Herron, with a number of new MPs following Johnson’s what-the-papers-call-controversial lead, and far-right nutjobs queuing up to try and get a party card.

Slow Horses was written in 2010, so full marks to Herron for his grim prognostication. Look, I’m not saying it’s his fault the country’s being driving towards the cesspit by a bunch of deeply unpleasant shitsacks or anything, but fingers-bloody-crossed PJ gets his comeuppance in one of Herron’s subsequent books.

Hold on tight.

Thursday 28 November 2019 The Forest Road Reader, No 2.40 : STinC++ - Chapter Two Wrap Up

STinC++ rewrites the programs in Software Tools in Pascal using C++

  • entab - replacing spaces with tabs

  • overstrike - crazy old school print preprocessing

  • compress - simple run length encoding

  • expand - and simple run length decoding

  • echo - command line argument handling

  • translit - a positive hydra of character substitution and deletion

Each program in chapter one was progressively a little more complex than the one before. This is not the case in Chapter Two, where the various programs form more of a loose map of the territory. Here we have a program that replaces many characters with a single character, while over there we have a program that might produce many lines of output for a single line of input, and so on.

This chapter is, without directly saying so, pretty explicitly about the Unix philosophy. While Unix systems (or at least Unix-ish systems) are basically the substrate of most modern computing (yes, even if you’re a Windows, Android, or iOS user) in 1981, when Software Tools in Pascal was published, there were “800 systems …​ in use outside [Bell Labs]”. Kernighan and Pike have to take time to describe what’s now commonplace - combining small programs with pipelines, text as common currency, indeed the whole idea of software tools and of the programmer as tool user.

When I first read Software Tools in Pascal, I’d just started my first substantial job on a Unix system (in fact four Unix systems, all slightly different) and I was only passingly familiar with a handleful of command line tools. The idea that these small programs not only did simple things, but could be combined like some kind of giant tokusatsu robot to do very powerful things was really quite startling. It certainly changed, and continues to influence, how I think about programming and I have no doubt I’m a better programmer for that. I’m not sure I’ll ever touch the heights achieved by my friend Thomas in his masterful He Sells Shell Scripts To Intersect Sets, in which he combines standard Unix tools to do full on computer science, but I’m nearer than I otherwise would be.

Next up, files!

Endnotes

This whole endeavour relies Software Tools in Pascal and Software Tools, both by Brian W Kernighan and PJ Plauger. I love these books and commend them to you. They’re both still in print but are ruinously expense. Happily, there are plenty of second-hand editions floating round.

For this project I’ve been using JetBrain’s CLion, which I liked enough to buy a license. CLion uses CMake to build projects. My previous flirtations with CMake, admittedly many years ago, weren’t a huge success. Not so this time - it’s easy to use and works a treat.

The test harness I’m using is Catch. I’ve been aware of Catch pretty much since it was first released, but this is my first time really using it. I like it and will use it again.


Tagged code, and software-tools-in-c++
Older posts are available in the archive or through tags.


Jez Higgins

Freelance software grandad
software created
extended or repaired

Follow me on Twitter
My code on GitHub

About
Contact

Older posts are available in the archive or through tags.

Feed