I put out genius 1.0.7 yesterday. I’m feeling under the weather a bit, so essentially that’s the only productive thing I’ve accomplished.
July 30, 2009
July 27, 2009
So 1057 downloads of my diffy qs notes from distinct IP addresses. I guess that also counts the crawlers, but last I checked they are only a very small subset, so definately over 1000 human downloads anyway. That’s not bad I guess. Not one person yet got the bound version from lulu, so I am most definitely not getting rich off of this book. I am actually very surprised that it got to 1000 so quickly. I was really expecting far less by now. I figured I’d have hard time figuring out which downloads were from the students in the class, but obviously it is now such a small percentage (between the time I made the final version available on zinc (jirka.org) and the time of the final there were about 40 downloads and there were like 65 students in the class, I guess many of them had older version of the notes already and did not bother to download the newest one).
I assume that most of the downloads are students looking for an extra source of information. If this is true, there should be a spike in downloads come September. I think this is a reasonable theory since my page comes up pretty high when searching for “edwards and penney differential equations free download” (I’ve seen searches exactly like this in the logs:) I guess my notes are not exactly what these people are looking for but I guess it helps.
July 24, 2009
So I spent some time I could have spent hacking on genius by reading about git. I think I somewhat understand the way the thing works. What exactly the commands do still remains an enigma and it seems very hard to figure out how to do simple things. Problem is that there is too many states that your changes are in. They are in a dirty tree, then they are in the index (staged?) then you commit them to your local repository then they are published to the main repository.
The bottom up article is pretty good for understanding what’s going on, though many times I’m asking myself “why? why would I ever care?” Git is written by a control freak obsessed with metadata of the changes to the code rather than the changes themselves. For example, it is now easier (though not by much) to split a set of changes into two commits. I think that is not something I have ever ever done, so I can’t mentally justify the added complexity. Git seems like a project that should have been done by somebody doing his phd thesis.
In my view, the fewer branches your project has the more chance you have of understanding what state your code is in. The problem is that changes to code are NEVER local, no matter how good of a programmer you are. Just like every chess book tells you to watch the entire board when making a move, so should every programming book. That’s why you don’t want too many branches and essentially often apply changes that were done to the tree in when it was in a different state. Such patches should be hand checked and hand applied! Git does too much magic like this, plus it by default starts branching the tree whenever you sneeze. Making a new branch should be the last resort unless you have a lot of free time.
My other issue is that it is pretty difficult to get started with git properly, especially on a large project where there is little opportunity for error. That means the startup time for a newcomer is far higher. If this was implemented to make sure more new people join gnome, I think it is seriously misguided. People who are already familiar with git are probably sufficiently at easy with the free software community that they will easily get started. People who just want to fix a few problems in the code and send back patches are going to be overwhelmed by new complexity.
July 23, 2009
I’ve been attempting to read some git docs. But it’s not going well. Unfortunately the online documentation and tutorials read just like if you took a math book, stripped out all the definitions and just included the theorems. Since I am not familiar with what the words mean I can’t understand what it’s doing. There seems to be no “starting point” for git. Every place in the docs seems to assume you know the other parts of the docs and most of all that you know the terminology. I don’t know what refs is, I have no clue what’s the difference between merge and rebase, and in no place does it tell you what those things are working on. I have not yet figured out if I am supposed to commit first before rebasing (or merging or whatever I am supposed to do) or if I should first pull, rebase (or in some other order) then commit then … Oh I forgot add … then push. Something that was possible to do with two commands in cvs or svn.
The only thing I find out by reading docs or online posts about git is that distributed vcs is great, centralized is bad, cvs sucks and I should change my “workflow”. Besides the fact that after this adventure I hate the word “workflow”. Why should I change the way I work just to make a piece of software I want to stay out of my way to stay out of my way and not mess up my code. I’ve seen many posts to criticisms of git basically say that I will at some point really like git. That is not coming. I’ve never felt this resentful against cvs. There were a few times I felt cvs could have done something better, but I understood how cvs works from the absolute beginning without needing to really read anything about it. I have read quite a bit about git, but I still have only a vague idea of how it works and that kind of scares me, since it is supposed to take care of my code. At this point I’m being calmed only by the fact that there are tarballs of my code somewhere safe and I could always take a tarball and start from scratch.
Simplicity is a virtue! Not something to avoid at all costs. Perfect solutions do not exist. Plus I am sure that at some point something else will become the in-vogue religious thing of how to handle code. Then everyone will say “this git thing sucks, we all now use frmgtnfut now, get out of the dark ages” and “frmgtnfut” will be even worse documented but will probably add another buzzy adjective in front of (or instead of) the “distributed”. I should stop being logical, maybe I should just get with the times and start singing the git hare hare git git hare hare songs … Do I need to send some money somewhere to join this cult?
July 22, 2009
I’ve been recently hacking on fixing up the genius scoping rules. In particular, I solved a design issue by adding local variables. That is variables that are only visible in the current context. That way, functions passed as arguments need not see the internals the functions that call them. I was originally going to change the way lookup worked. I think the most natural rule would be to see variables that you could see when you were defined. So each function would save the context in which it was defined and then somehow “jump back to it” for the purposes of lookup. The problem is that I can’t figure out an efficient implementation of this idea. Especially with deep recursion this turns out to be deadly. So I implemented the local variables which are rather easy. That is if you have
function f(g,x) = (
function h(x) = x+a;
a = 2;
will return 12 and not 11. That is the function h will overlook the a and only see the a that was defined globally. An advantage of this approach is that it’s completely compatible. The only places where I’ve made incompatible changes were places where the current engine was buggy (for example it would keep substituting variables if a function was passed up again, though that is unlikely to happen much).
Also I have to rant about git. I tried reading up on it, since it seems that it is rather easy to screw things up with git. I consider myself not an extremely stupid person, but I still do not have a complete understanding of git. Mostly it seems like git does one million things that I will never ever use, nor would I ever dream of wanting to do, but it is very easy to do those things by mistake. It seems that what was previously simple (like merging changes) is now very complicated with lots of commands needing to be issued at the right order etc… Just the whole idea that there are now two types of commits (local and remote) seems absurdly idiotic to me. The fewer versions of the code there are the less chance for stupidities.
I said before git seemed like vcs masturbation. I have to revise this statement. Masturbation, while serving no purpose, is supposed to be fun. Using git instead of cvs or svn is not fun, it is painful (that could be fun for some people).
Maybe I’m just bitter today since I spent about half an hour trying to find a mistake caused by = instead of == in an if statement. Oh well, I think at least I’m pretty much done. The beast passes all current tests. It remains to document the new stuff and write more tests for the local stuff and then release. … Enough hacking … time to go do some math instead.
July 21, 2009
Made the gob 2.0.16 release today, see http://www.jirka.org/gob.html.
I was thinking a bit why things I did were not popular when I did them, yet then later I see the same idea done in a different way and people suddenly think it’s cool, even though their previous arguments could have been easily recycled. I think it’s because I did not manage to put enough buzzwords into my projects. I unfortunately called gob a preprocessor. Had I called it a new technology leveraging the gobject programming paradigm within existing project environment allowing refactoring and whatever other in-vogue nonsense is currently a popular word.
So along comes Vala which is a cool project and it does precisely everything that everyone told me gob should not do. Yet, somehow … hmmm … I think Vala is cool. I wish them luck in “marketing” it.
Another thing I screwed up marketing was pong. I unfortunately mentioned “auto-generated” somewhere and suddenly nobody even looked t what the thing did. Everybody was fine with glade automatically connecting your signals, but pong connecting widgets to gconf was evil for some reason. I bet the reduction in memory footprint which could have bee achieved by letting pong do what every app does miserably with its own code would be easily measurable.
Enough ranting … I just feel sort of sad if I see nonsense being solved (the desktop being turned into an inconsistent flash app for example) while actual problems aren’t being solved for decades. This is not a new disease. I mean we had gtk themes long before we had any sort of printing support. I guess this is part of the problem why I got bored working on software, the priorities are all screwed up.
July 19, 2009
After being pissed off one last time by thunderbird I switched to gmail. Importing mail was not as easy as it could have been, but once it’s all set up it’s not bad. Plus no more having to set up thunderbird everywhere (especially sending mail was always problematic). It almost feels like gmail UI is more responsive, plus it has vi like keys for moving around so I feel like almost back home in mutt. The only trouble is the overzeleaous spam filtering. But for the account where that matters (uiuc) there is already good spam filtering done.
I guess that’s one more thing I do to get on RMSes bad side.
July 6, 2009
I read so much complaining by republicans on how terrible it is that Franken got elected because he’s “too left wing” or “too liberal.” Bar one socialist senator, it is hard to find actual left wingers in congress. There’s just center-right (democrats) and far-right (that other party).
July 5, 2009
So 675 unique IPs have downloaded my Diffy Qs notes pdf. Not too shabby for 8 weeks I guess. Considering these are differential equations, so not the typical idle time browsing. On the other hand, not one person paid the $15 for the bound copy 😦 But now I have my NSF grant (thanks to Obama’s bailout I suppose) so it all works out.