Background of this analysis: Unlike most people who see life as serious work and games as something for fun, for me, life is a game and how well you perform in life is like the game score. With that, I perform this analysis from this perspective.
The Julia community, while small, is filled with brilliant minds. However, brilliant minds tend to get bored easily. Open-source work is usually either
- A free work
- A work from someone who can find a good salary doing something fun for them
- Both at the same time.
So, what’s the problem?
Let’s list what is possibly subjectively fun and not-so-fun.
- Writing an algorithm and seeing it work.
- Optimizing the hell out of it.
- Fixing my own bugs.
- Fixing other bugs when those bugs are served on a platter.
Not so fun:
- Making an interface that allows the package to work with an interface consistent with other libraries when you already have your functions working the way you intended, especially if those other libraries have a pretty long interface standard or if those libraries have a variety of settings that you need to implement/support or throw an error when your library doesn’t support and so on.
- Just… packing the package in general and ensuring it works on other machines - and that you ain’t missing dependencies or something.
- Ensuring your code can be composed with other packages even in unexpected ways.
- Maintaining a large codebase, probably with 10 other people working on it, with missing documentation/etc on the functions some code calls forcing you to trace down the functions and multiple possible dispatches they take, or other issues. (Abstraction works for users who just want the packages to work, but not those who want to understand how the things are implemented or how bugs occur and want to fix them, for they would need to dig deep through abstraction layers and figure out what went wrong.)
- Writing a diagram or… say… communicating a mental model that other people should understand how your package works, or say… documenting the core part of where the core algorithm gets implemented instead of the interface that formats the problem for the algorithm.
Worse yet, if you don’t document for both the users AND the developers, you risk making it harder for potential package developers who might’ve developed a new algorithm for you to implement their algorithm for your library, and when it’s hard and not fun, well, chances are slim.
So, you get the idea, that writing an algorithm to use yourself is fun, and seeing it work on your computer is fun, but communicating it out might not be. This meant problems, especially since the Julia language tries to shine by being a fun language, but also a language that involves emergent behaviors when several sections of code can be composed and “just works”.
This means making sure the fun can continue is a priority. For those who are used to seeing works as a place where fun makes no place in the analysis, and where you focus on making the most “practical” choice or the most “optimal” business choice without considering this, well, I would say that fun matters.
So, my question is this. Is package development fun for you?