I Am Old
I like software to be correct. I know. Controversial, right? But as I have gained experience tinkering with various technologies, and building hobby project after hobby project, with some professional projects in-between, I have come to realize that I do not want to just pray and hope. I want to know that my programs work. And I do not want to spend 99 % of my time manually testing them.
When I first encountered Python, coming from a QBasic, C and C++ background, it was a bliss not having to declare types manually. Instead of wasting time writing boilerplate, I could actually make my programs do what I wanted them to do.
But, as my projects grew more ambitious, I had to become stricter and stricter to make sure I found bugs as early as possible. So wrote tests, I set up linters, wrote tests, added back typing through type annotations, and wrote tests.
Type annotations get a bad rap, but they are actually useful, unlike C types.
In C, types are mostly about memory layout, and not so much about correctness. When it comes to semantics, a
char is an
int, a short is an
int, and an
int could be a
long, or a
float. Also, an
int could be a
short1. And of course, you can add strings to arrays, pointers to integers, and floating point values to enumerations. Because, in the end, it’s all the same to C2.
With type annotations, you start to get the point that functional aficionados have been trying to make since forever. “Yeah, that value could be None, so you need to check for that before you use it. By the way, you’re evaluating the addition between a hash table and a list; don’t.” Thanks, compiler3.
And when you start thinking like that, you might want to say: “Okay, this variable holds euros. I really do not want to add it to kilowatts.”. That’s when you know it’s too late. But now you have implemented a full-fledged system for dimensional analysis in your type system. And it is glorious. You have forgotten what it was meant for, though.
What’s this to do with Web Apps? Seriously, not much. But there is a point!
Web Apps have two fully separated software components talking to each other: the frontend, and the backend. And it’s very easy to introduce bugs at the interface between the two. Especially when they use different languages4.
Of course, the solution is XML. As everyone knows, you simply write an XSD or DTD specification for your format. Then, you can easily transform your data for consumption thanks to XSLT and even presentation with XLS. You might even have something working within ten years!
Okay, okay, everyone is doing JSON these days. Thankfully, we do have a way to describe what a JSON document contains:
Fine. So you write this OpenAPI thing. Then what?
Well, that’s where the current picture is still lacking. We now have three components and two interfaces:
- backend code
- OpenAPI specification
- frontend code
How do we get out of manually checking everything and make sure it works?
First, we can generate some frontend code from the OpenAPI specification, which will handle all communications with the backend. For this, I use openapi-typescript-codegen. Okay, that one mostly works fine.
Now, the fun part is to make the backend code and the OpenAPI code work together.
The convention is to generate the OpenAPI specification from the backend code, and not backend code from the OpenAPI specification. In Python, you might be familiar with
Flask-RESTful Flask-RESTplus Flask-RESTX. In Rust, you could be using Utoipa.
In principle, this is great: you add some annotations to your backend code, and you can be sure that your frontend code sees the same types!
However, this is still a very immature space. You can very easily document the wrong type in the annotations, and you won’t get a problem until you try to actually use the generated OpenAPI specification in the front-end.
Things have definitely improved since the days I was writing PNG parsers in QBasic. But we still have ways to go until we really pick all the low-hanging fruit for software correctness. I want the compiler to shout at me more often!
- Yes, I am aware of type ranks. The point is that none of this helps you make your program more correct. ↩︎
- Sure, you cannot add a struct to a bit-field. But guess how you pass a struct around? ↩︎
- Or mypy in this case. ↩︎