There’s a project at work that’s got all the traits to serve as a great vehicle for dabbling some more with open source:
- Not too specific (e.g. to our domain);
- Keeping the IP safe isn’t a concern since it’s just a small tool unrelated to the core business (i.e. we’ve got “the okay” to make it open source);
- It might be of some use to someone else, and failing that it’s still fun to open source it;
While trying to start with the process of extraction and open sourcing, there seem to come up a million things to think about when going through this process. I want to gather my thoughts (by writing this post) and untangle that mental mess, so that I can get to a clear plan of attack. Perhaps this post will even be of use to someone else, somewhere.
Currently, the bits I want to make open source are only slightly coupled to the bits I want to keep closed. That is: currently everything is in one solution, but the split in projects already clearly demarcates what would be open and what would remain closed. To put this in a tabular overview (where “Foo” is the closed bit, and “Bar” is the open bit):
There are some question marks in that overview. Elaborating on them a bit:
- I’m not sure if the distinction between “Core” and “App” should remain a dll/project splitup as opposed to possibly a namespace split.
- I’m not sure how the Open Source solution will be included in the closed source app (via NuGet, or as external source or binaries, or…?).
- I’m not sure if I can easily distribute a generic windows service wrapper, or if I need to create it in the closed source solution after all.
In addition to these source-related questions, there are other things to think about as well. So next up:
What things to think about beforehand?
Let’s summarize all the things I can currently come up with that might be important in this process, in no particular order, merely numbered to be able to reference them easily:
- Project, Namespace, and DLL structure: what’s wise, what’s neat, what’s useful?
- Folder structure: how will the repository be structured? What’s future proof here?
- Initializing git: currently, the project history is in our corporate TFS. So not even sure if/how to keep the history intact, or if that’s even feasible.
- License: okay, that’s not too difficult, but have to choose one nonetheless.
- GitHub setup. What’s a good setup? Should I make the organization main owner of the repo, with a personal fork from which I do pull requests?
- NuGet packaging: how does this even work? As an application developer I had never had the need to learn how any of this works.
- Re-including the open sourced bits in my closed source solution: via NuGet, as external source, or as external binaries?
- Choosing a name. One which is not already in use for some software, where a domain with “normal” extension is still avaible, where the name is not taken on GitHub yet, etc.
- .NET Core. From my rss feeds I gather that it can be a quite fuss to make open source projects .NET Core “proof”, but it would be yet another thing to tackle while starting this whole thing off. Perhaps something for later? Or is that a grave mistake?
- What am I forgetting? I’ve been looking at some of the “top” C# GitHub projects (Restsharp, NodaTime, dapper-dot-net, AutoMapper) and their git history to see how they have evolved, to find out if I’m forgetting anything.
- Decent starting point, code-wise: I might be setting unreasonably (and unnecessarily) high standards for the initial commit, but still something to consider. What is the minimum quality I’m requiring before opening the source?
- Early feedback: it might be useful to get friends and colleagues to review the setup and get the first version(s) of the repository just right.
- Logo: yeah, this project needs the best. logo. ever!
In addition, there’s a practical point: once I split off bits to an open source project, I’ll effectively have two (source-control-wise unrelated) forks of the same code-base, until I’m ready to make my closed source solution depend on the open source bits again.
After writing the above: wew! No wonder I was not getting anywhere: my mind was just wandering in circles through all of the above points. And I guess “Perfect is the enemy of Good”, or some such. Time to tick off some of the above items.