I really like to read code written by different people.
I've always been the type of learner that can cover a lot of ground by looking
at examples. A few of the programming tricks I acquired over time have definitely
been learnt by reading programs written by other people. There are of course
cases of disagrement with coding style (lets put that very mildly), so not every
project is fun to read. But I tend to find projects I like enough to actually
look at their source code.
Now, if you get into this habit, there is also the occasional spotting of a bug.
Many are really cosmetic, like typos in comments or documentation.
Others are maybe more serious, who knows what can happen if you read a few
lines of code written by someone you have never met in person.
This is one of the original arguments of open source and free software.
It basically goes like: "People will read your code and report problems."
I know that happens, but I also know that there are cases of people finding
relatively minor things during a small code review, which they don't
report, or which get lost in some developers INBOX.
I remember waiting months to see memory corruption fixes for a particular
project I submitted by email to actually appear in the development repository.
In some cases you really need to track your patches and prod someone to
remind them about your contribution if need be.
True, some of these issues are probably minor enough to not really
hurt if they get lost, but I have a feel that a lot of minor things also
sort of add up.
This is where GitHub comes into play. We have had project hosting services since
at least a decade now, but none of them (to my experience) have ever made it so
easy for all involved parties to submit and merge changes into projects.
Pull requests are just amazing. Well, at least for me, they are
since a few months. I have a sort of mixed hate-love relationship
with GitHub when it comes to a topic that is very important to me,
The last project hosting site I really liked for their simple web interface
(read, still usable with Lynx) was Google Code. That was in the days when
Google still seemed to care about such things. These days, their newer services
are next to unusable to me (with the tools I prefer). SourceForge
was always a catastrophy. Many things were cumbersome to do, because
the site is so loaded with links to all sorts of things I never need.
However, at the time I was using it, all the things I really needed did work.
GitHub is a different beast, in a different era of the internet.
While I can read project pages and a few basic things perfectly fine,
some parts of the GitHub site are simply unusable for no particular reason.
For instance, I can edit (some of my) preferences and even save them.
But I can not star a project, nor can I follow other developers.
Invoking these links gives me a 404, which seems to indicate that
browser does not perform. However, I really wonder why. Because something like
"I want to star this project" will eventually have to end up as a
request on the server anyway, so it seems technically unnecessary to
Luckily, these days, hip projects do have an API. An GitHub is no exception.
I want to emphasis that an API alone is not an accessibility fix,
since you rarely have the time to implement a clinet for a random API, just to
get access to a service you want to use. Sometimes you do, and
an API is a great enabler in such situations, but a reference client
with a rich feature-set is much better. I have to admit that I haven't
evaluated any of the possible alternatives, but one client
I found for GitHub's API did really boost my productivity in the last year.
I am talking about Hub. It is a simple wrapper around Git that adds
a few and enhances some other git commands.
Most importantly, hub fork will fork the current checkout on GitHub,
and hub pull-request allows you to quickly (and I really mean quickly!)
open a pull request for some commits you've just done to your fork of some project.
This is very helpful, and very accessible. While it does not
solve all my accessibility problems with GitHub, it at least
enables me to take part in the GitHub workflow. I can easily
fork projects and submit pull reuqests for changes I did.
And that is what I did, at least a bit, in roughly the past year.
I am not sure exactly, but I think it was spring when someone made me
aware of Hub. One approach would be to check my GitHub
activity graph, but I probably don't have to mention that it is not
Here is a list of some of my contributions to open source projects
on GitHub since I discovered a good client for the GitHub API:
- pelican is the Python based static site generator which runs this blog.
- spirit_x3 is the experimental C++11 implementation of Boost.Spirit.
- music21 is a music notation processing framework for Python from the MIT.
They have just recently moved to GitHub. Some of my (small) contributions to the
braille music module of music21 predate the move to GitHub.
- teq (and teqqer) aim to provide an API for tracker-style sequencing and a
coresponding terminal based client. To me a very exciting project. Clear
separation between the Engine and the GUI is rare in the Linux Audio Landscape.
Notable good exceptions are SuperCollider. But many end-user oriented
tools tend to blend the functionality provided and the user interface into a
single program, which makes it very hard to use if there are any accessibility
issues. This is not true for teq/teqqer. teq is a tracker engine, and
teqqer the coresponding reference user interface.
Lets see what comes of it, the project is rather new.
To summarize: I love GitHub for what it does to the free software community.
I think the simplicity (and transparency) of contributions is to the benefit
of free and open source software.
However, I also hate GitHub sometimes when I need to ask a friend
to do relatively trivial changes for me. What I actually
want, is a command-line client like Hub that makes most or
even all functionality provided on the website available.
True, some things like graphs are not immediately easy to
adapt. But I really shouldn't need to use a modern full-fledged
web browser to tell GitHub that I am interested in the
activities of a certain user. Or delete a fork. Yes, thats
right. I can use Hub to fork a project, but there is no way
to delete it again. Sort of strange for casual small-scale contributions.
I guess the workflow there is: fork, commit, pull-request, wait
for merge, delete. I don't want to have all sorts
of forks on GitHub that I actually don't actively use/maintain.
So once a pull request was merged, and I don't have any other
things I am working on right now, I actually want to get rid
of the fork again. It is easy enough to do a fork should I ever need it again.