Is package development fun?

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

  1. A free work
  2. A work from someone who can find a good salary doing something fun for them
  3. Both at the same time.

So, what’s the problem?
Let’s list what is possibly subjectively fun and not-so-fun.
Fun stuffs:

  • Writing an algorithm and seeing it work.
  • Optimizing the hell out of it.

Somewhat mixed:

  • 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?

Is package development fun for you?

Yes. And I assume that’s true for a lot of people, otherwise, why do it?


Good point!


It depends of course a bit whether it is fun for you – but for me, thinking about an API that is easy to use for others and works well with other packages is fun. Documenting everything and testing everything is fun, because that makes the package usable! Both for me (I do not remember all my kwargs) and for others.
Also composability – I think it is super cool to see where your package can (and hopefully is) used.

If you like a topic (use more manifolds!) it is also a great way to communicate your enthusiasm and find other that have the same or similar interest.
First example – I started with Manopt.jl – and that directly brought others into the game to start the (today even larger) Manifolds.jl package. Super nice!
Or for example super happy that recently the JuMP people wrote an interface to Manopt.jl. Something I am really super happy about!

And sure there is days were you might be annoyed on your past self to not have done something better / easier to use, or you are a bit annoyed that there is another bug popping up, but that is like everywhere else in life (or in your game), sometimes it is reset – and start the level anew.

Finally, I feel, that the Julia community is great and helps a lot in really many aspects, my most recent favourite: DocumenterCitations.jl. I can finally reference papers properly in my docs!

1 Like

I’m quite surprised to hear that. Getting to meet other people with similar interests is certainly great!

However, for some people, what I can imagine is that they implement some algorithm. They find it working out for them, so they publish some half-finished package and move onto the next shiny thing. Sometimes they’re brilliant minds as well, just that they weren’t expecting people to use their packages, and some people just want to use it anyway, forcing some tough work to make the package usable.

Well, a package also develops over time, usually not only because the initial developer sees improvements, but usually also due to other peoples hints, reported issues and bugs, but also other peoples PRs.

Publishing a package is to some extend a duty you set yourself to maintain that at least for a while (unless you directly do it within an org to not be the only one there).

But if, for the extreme case, you do not expect other people to use a package – then there is no reason to develop and/or register it. The same holds for the case, then you do not like other people to comment on your code or ask questions.