Some of us like to split up software into various little pieces, while others of us like to create larger files and keep it all together in a single file. Two different styles of programming that don’t fit well together. I find other programmers who like big chunks find my code hard to understand, while I find code in larger chunks more difficult to understand.

But everyone does break up their software (of significant size, anyway) into chunks; I’m disregarding those who write an entire piece of software in a single file as that’s more of an edge case. This is the first difference: the size of the chunks. But there’s another difference too.

If we represent our code as a tree of components, you can either have a shallow tree or a deeper tree, as shown in the diagrams below.

Now, this is the part I’m not so sure of. Are programmers who prefer smaller chunks more likely to make deeper trees? Are programmers who prefer larger chunks more likely to create shallow trees or maybe it’s the other way around? Or maybe there’s absolutely no correlation at all. Software has this never-ending problem of managing complexity and the fun part of it is each of us manages it differently by changing these factors.

This post is in progress and is something I’m going to be adding to over time - next time I’ll be exploring how the size of chunks affects complexity. Subscribe to my newsletter at https://world.hey.com/scottdavey to be notified of further updates.