SteveStreeting.com

I love it when shots from Ogre just show up in funny places. This time, it’s from a comic strip called Stolen Pixels on the Escapist, where Ogre-powered games Torchlight and Zombie Driver have been used for comedic purposes:

Thanks to BuschnicK for the heads-up on the Torchlight one, I was surprised to see Zombie Driver just days earlier too!

So, I’ve been a little quieter than usual since the new year, and that’s because I’ve been in  a rather reflective mood as I plan out how I’m going to spend my time in 2010. That’s right – planning! Talk about the final frontier

Basically, as you may have gleaned from my previous post, I’ve been looking to make some significant changes to the way I do things in 2010. I spent 2009 reeling from a back injury and trying to figure out how to deal with that given that I’m self-employed (ie I don’t get paid when I’m not working, regardless of the reason), and a leader of an open source project (with the inherent time requirements that comes with). This meant working out on the fly how to stay afloat financially, and still keeping my own interests and open-source plates spinning, without slipping back into the ‘permanent voluntary crunch mode’ style which triggered my back problems. I can’t stress enough how difficult that transition has been for me – it’s not like anyone was forcing me to work/live that way, I did it because I wanted to, but then it suddenly had to stop. When you invest so much of your time and perceived identity in something, backing away from it is very, very hard.

Of course the economic climate wasn’t great either, meaning I spent a lot of time jumping around between many small projects, leading to more overhead dealing with admin & business relations. I ended up just going almost month-to-month on-demand, not  planning very much and just being grateful to be able to work a decent amount at all – which given how unwell I was at the start of the year was definitely something to be glad about. But, now I’m back on my feet and pretty confident of my future health again (within reason – I’m not going to be bungee jumping any time soon!), I’m ready to start being more pro-active again and to map out some plans.

One thing is for sure, there’s no going back to how I used to do things. My days of saying ‘yes’ to almost everything and being at the keyboard until past midnight most days, and most of the weekend, are gone forever. I don’t regret doing it, despite the pain it ended up causing me, because OGRE wouldn’t be here otherwise and I learned a vast amount and had a ton of fun – but I’ll leave that to the under-35s in future; have fun guys From now on, I’m being ruthless and somewhat selfish about what I work on, and concentrating on things that maximise my personal love-growth-cash triangle. It means I’m passing on a lot more projects, and concentrating far more on things that are strategically significant to me, rather than anyone else.

I’m still planning to lead OGRE, so long as the community is happy for me to do so, but by necessity I’m stepping back a bit to let other people take more responsibility where they want to, and to refocus my time on mentoring and advisory roles rather than trying to be everywhere at once. We have some great people in the team and in the wider community, and I hope our MIT license will foster even more in future. Both I and the community have gotten used to perceiving me as the ‘go to guy’ in the first instance, with responsibility for pretty much everything, but in practice for some time now it’s been very much a team & community effort, just one that I happen to lead (and financially support where needed). In fact one of the things I’m quite proud of is the way so many others have picked up on the way I do things, and taken things forward themselves in a way that I wholly approve of. That’s open source in action, and I’m glad to be part of it, even if I can no longer have my fingers in absolutely every pie with an OGRE symbol on it

Here’s to 2010 anyway. It’s going to be different, but change is good.

Zero Punctuation reviewed Torchlight yesterday!

Of course he was both inaccurate (you don’t have to keep clicking at all, you can hold the button down) and overly harsh, but still very funny. It’s odd to enjoy watching something you had a hand in (albeit in a background technology way in my case) being ripped to shreds, but when it’s done in such an amusing way somehow it’s ok. I guess this is why Yahtzee hasn’t had his teeth kicked in by disgruntled game developers yet

As Runic’s Twitter said: “We’ve arrived!”.

It’s now almost a year since I decided to try using Twitter, specifically to post about Ogre development work I’m doing and other Ogre-related things (well, most of the time anyway). Seeing as I totally deride the concept that it’s a good thing to share the inconsequential, tedious minutae of your life with the internet and view it as the absolute pinnacle of sad, narcissistic behaviour, joining Twitter was a hard sell. After all, at least on a blog you have to write enough in a post to naturally filter out anything that’s not worth saying (in theory), while Twitter seemingly encouraged you to share whatever crossed your mind during the day. In the end my reason for joining was that there tended to be things large and small that happened in and around Ogre that many people might like to know about, and these things didn’t always warrant a blog post,  a news article on ogre3d.org or even a forum post. Provided I stuck to that raison d’etre, perhaps it could have value.

And in fact, it’s actually been very useful. I’ve almost stopped blogging about Ogre work unless there’s a significant event or something I feel needs greater analysis, because my Twitter feed is a better way to get the word out about things. It’s also been useful to get feedback on certain technical issues and to keep up to date with what other people are doing. Specifically, I tend to only follow people who post about things I’m interested in, rather than just because I know them.

And this tends to work well – I’ve found that Twitter users, or at least the ones I follow, in general tend to automatically filter their content to things that are actually interesting. This is in contrast to Facebook, which is so chock full of the utterly banal that I lose the will to live every time I try to catch up with the feed – there are usually some things in there I’d genuinely be interested in, but it’s so full of crap I can hardly face spending the time to find it. Much of that is due to its insistence that I’m somehow interested in the events of all the Facebook games people are playing, when in fact I couldn’t give a flying toss what new fish someone has just unlocked in some ridiculous mini-game. I’m close to just deleting my account and forgetting all about it – if you want to be social, grab a coffee / drink with me sometime or something – at least then you’re unlikely to keep interrupting to tell me what your level is in FarmVille.

Computer systems are tools, and can be used for good or ill. I’ve come across lots of people that use Twitter in a genuinely useful and non-intrusive way, and I try to do the same, and as such it’s made a firm place for itself in my day – something I would not have taken for granted when I started using it.

I’ve already posted about my experiences with Git and Mercurial, the end result of which was a vastly increased respect for Git but a basically confirmed preference for Mercurial, based on ease of use, platform consistency and resilience.

Mercurial’s conversion tools are really quite good – the core tools worked fine but I was impressed by hgsubversion‘s speed and that it seemed to just work, in both initial conversion and pulling subsequent updates. It was missing a couple of features that I wanted though – firstly the ability to reflect merge points between branches during the conversion, and secondly to be able to ‘squash’ ancient history down to a simple snapshot to save space.

At OGRE, we’d carried forward all our history from CVS to Subversion and as such have almost 8 years of history, including a couple of file reorganisations. Mercurial’s storage efficiency falls down compared to Git when files are moved around, because a file stored in more than one place in the tree over the history of the project is physically stored multiple times too, whilst Git stores the content only once with pointers from the various locations / history points. Most of this overhead could be removed just by eliminating old history we didn’t need anymore – history that does no harm in Subversion since only the server holds it, but does cause unwanted overheads in a DVCS since every user gets the entire repository. Removal of history is something that Mercurial shuns – rightly so in the case of public repositories but in these rare cases it would be nice if there was a tool for removing old history; again Git allows this but it has to be used with care. In the absence of that, doing it at conversion seemed the best way.

I asked about these things in the hgsubversion community, but the tradition of open source is that if you really want something urgently, you know where the code is Mercurial is really nice when it comes to hacking because it’s all Python; so there’s a nice unified API in one place that you can refer to – that’s one of the reasons I like it over Git which is far more fragmented in technology terms. I’m not a Python guru by any means, but I managed to implement both these features – I did the “mergemap” support a little while ago and added the “skipto” option today – it’s called that because “skipto” was already referred to in the hgsubversion code but it had no implementation.

The result is that the OGRE Mercurial repository with only the last ~3 years of history (back to when the v1.4 branch was created) is now only 74MB, rather than the 206MB of the original, complete conversion (in comparison Git was 116MB for the whole thing). By dropping the history I’ve removed most of the instances of reorganisation which is where most of the space has gone. I  hope eventually that Mercurial adds a utility to deal with stripping ancient history (right now, you can only strip branches) but this solves my primary conversion issue. Since this new repo can be kept in sync in a very lightweight fashion with the existing Subversion repo, I’ll be periodically updating it and doing more tests to reassure myself that the content really is ok.

If you’d like to get my custom version of hgsubversion with these features, it’s here: http://bitbucket.org/sinbad/hgsubversion/. I make no promises that it’s error-free, use at your own risk. It currently assumes that you’re using the standard Subversion layout, are converting from the root of that and have the ‘svn’ command on your path.

So, I’ve just about completed my practical experiments & review of Mercurial and Git.

In the end, I had far too many separate notes and sets of experiences to post, so I boiled the argument down into the 10 most important factors to me, and scored Mercurial and Git on a scale of 1-5 based on what I’d found when using them. Here are the (annoying) results:

I’ll explain the scores, and my conclusion, after the jump.

Read the rest of this entry »

Penny Arcade tends to divide a room much like Marmite, but I like both. I was pleased this morning, therefore, to see Torchlight, a game deep within which little gears of my own construction are happily spinning away, featured as the news and comic of the day, and in a very positive fashion.

(image copyright Mike Krahulik & Jerry Holkins, click for full-size from original source)

Needless to say the Runic guys are rather happy about this too, no doubt not only because it’s very cool, but also in a more sober sense that you can’t buy this kind of publicity. Their tweet summed it up: “/dieshappy”.

Woohoo, Torchlight, the new ARPG by Runic Games and using OGRE for rendering, is launching today! Well, strictly speaking the single player game launches today, with an MMO version planned for 2010. Torchlight has been developed in Seattle by a veteran team composed of the designers and leads of projects like Diablo, Diablo II, Mythos, and Fate, so you knew this was going to be good.

Well, Runic were kind enough to send me an advance copy which I played a little yesterday, and boy, is it polished. You can really tell the heritage of this team, it’s immediately fun to play and has really great production values with tons of neat little touches and is something of a visual treat, which considering it was designed to work on low-end hardware too (it has an explicit ‘netbook mode’ for goodness sakes) is no mean feat. A level editor is coming out very soon too – the very same one that Runic used to create all the levels in the game – so that will be a lot of fun to play with too I’m sure.

Obviously we’re very proud that OGRE has been a part of creating this title. Torchlight is available to purchase in about 10 minutes time according to the countown clock, as a digital download from Perfect World, Steam, Direct2Drive and other partners. It’s staggeringly good value, so go get it!

[edit]In case you need more convincing, here’s a nice video review / overview:

As  you know I’ve been reviewing DVCSs lately. I’m taking my time doing real use cases on them, and deliberately not doing the sort of feet-first leap into whatever looks best / most popular on the surface because I don’t particularly want to discover unexpected problems down the track. It’s consuming a lot more time than I expected – I’m writing up my findings and may publish the entire results later on if I can find the time to clean them up and format them better, but for the moment I thought I’d share some experiences with the conversion process of a relatively large, long-lived, multi-branch repository (OGRE) from Subversion to Git and Mercurial, because that’s what I’ve been wrestling with in the last few days. I discovered a bunch of additional issues during this process that did not occur when starting from scratch or doing conversions from more trivial repositories, so I thought it might help others to talk about it.

Source Subversion repositiory specifications

Revisions: 9215 (as of today)
Branches:  9 permanent, 22 temporary / experimental
Size: 375 MB

Also of note is that the source repository is still at Subversion 1.3 – this is because Sourceforge was stuck on this version for a long time and we haven’t upgraded the repository since they started supporting newer versions. We never bothered because it requires locking out the repository while you download the whole thing to a local machine, upgrade it and re-upload it, which is a hassle, especially when you have things to do. In practice the server-side version hasn’t been a major issue since you can still use newer clients with it and svnmerge operates regardless.

General Approach

I rsync the OGRE repository down to a local Linux server several times a week, so that was the source of all my conversions, eliminating most of the network time. I tried to convert the repositories using Windows clients in the first instance, because that was easier to use the latest versions of the tools (my Linux Server is on Ubuntu 8.04 LTS and even with hardy-backports available it’s not as up to date – and for simplicity because this is an important server I stick to the official versions). There is a 1Gb network connection between the machines so it could be pretty speedy.

The principle is that I want to preserve all history, all branches, and all tags. In practice I may actually prune off some branches later on, so that the clone process is quicker, but the base principle is that it should be a lossless conversion in the first instance. Definitely no top-skimming of the trunk like some conversion articles advocate – we have stable branches that must be maintained and regularly have work that we want to keep in experimental branches. In particular, post conversion it must be possible to continue committing to and merging from stable branches.

Git Conversion Experience

I’d previously converted some other, small and fairly simple Subversion repositories using git-svn (less than 500 revisions, and 2-3 branches) and it worked fine. However, when trying it against the considerably more complex OGRE repository I hit problems very quickly. On Windows, using msysGit 1.6.4 the process failed after 1900 revisions, just after doing the automatic repository tidy (git gc). The error message was simply ‘fatal error running git-svn’, even though it had been running exactly that command for the last 1900 revisions. Thinking there might be an msysGit issue here, I switched to the Linux server (git 1.5.4) and tried the same thing. This time it fell over at revision 176 with absolutely no error message. In both cases the repository left behind was corrupt so I could not resume the process.

The other thing I noticed was how long the process took on Windows. 1900 revisions took 5 hours (!) and thus I wasn’t in a hurry to retry the process there. On Linux the process was much faster, as far as it got. It’s worth noting that this is not caused by running across 2 machines – not only do I have a very adequate 1Gb link, Mercurial managed significantly faster conversions using the same topology. msysGit’s git-svn conversion is simply incredibly slow.

At this point I decided to try upgrading the Subversion repository, just in case git-svn hadn’t been tested with older repository versions. My Linux server had svn 1.5 on it, so I upgraded the OGRE repository to that locally and re-ran the git-svn process on the Linux machine (as I say, I wasn’t keen on repeating the glacially slow msysGit conversion). Sure enough, this time all 9200-odd revisions converted fine, in only about 1 hour 40 minutes, or about 15 times faster than doing it on Windows.

So, I may have had a few problems, and being forced to upgrade the repository before converting was a bit of a pain, but at least it worked and was fast (on Linux anyway). After that, I started cloning the repository both on Linux and Windows and tried performing some standard operations.

The first thing that surprised me was that when cloning the converted repository, I could only see the ‘master’ branch on the remote machine. It’s common practice for Git not to create any local branches other than master on clone, but usually you can do ‘git branch -a’ to see all the remote branches that are available, which show up as something like ‘origin/v1-6′ – you can then check them out to local branches. However, no branches other than ‘origin/master’ showed up, even though I knew they’d been converted. It turns out that git-svn converts all branches except master into remote branches in the converted repository, referencing the original Subversion URL – so very much like having cloned from another Git repository. That sort of makes sense, but in the context of a full conversion to a repository that is destined to become the upstream master, isn’t that useful. In practice what you need to do is after the git-svn conversion is complete, git checkout each of the branches that you care about in your converted repository, thus creating local branches in that repository which subsequent cloners will be able to checkout themselves.

So, once I’d figured this out I started to check out different branches to test if it had worked. At first it seemed to, when checking out the first branch (switching from master to v1-6 in a local clone from the conversion). When I came to try to switch back to master however, Git complained that I had modified files in my working directory. WTF? I’d only just checked out the clean copy of the v1-6 branch. But sure enough, git status told me I had 5 modified files. Diffing them showed no changes, and “git reset –hard” returned with no error, but git status still showed these files as modified. Bizarre. A git checkout -f still let me switch, but again after completion a set of other files showed up as modified. Switching back and forth (with -f) a few times revealed that the list of modified files after checkout was different each time. Again worried that this was a Windows thing, I tried checking out on my Linux machine instead (so at that stage the entire process, conversion to checkout, was done on Linux). But no, the same problem occurred – a random selection of 5-7 modified files on clean checkout.

This has raised some serious concerns about using Git for me. Firstly the flaky conversion which requires a bunch of extra steps just to get it to work at all, then the post-conversion bizarre behaviour of thinking files are modified when they’re not. I had none of these problems with smaller repositories, created from scratch or converted, which up until now I’d been using for testing (and Git had been winning me over in fact since it had been working well). But the bottom line is that this process needs to work reliably for the OGRE repository. If it doesn’t, it’s pretty much untenable.

Mercurial Conversion Experience

I started off with the in-built ‘hg convert’ process. It all went smoothly and took about 8 hours, and the resulting repository was mostly fine. However, the default behaviour is to process the revisions in an order which “produces the fewest jumps between branches in the commit log”. In practice, I found that this meant the revision log when reviewing multiple branches was badly jumbled and difficult to use; the use of the ‘–datesort’ option resolved this but increased the conversion time to just under 10 hours (still faster than msysGit but a lot slower than git on Linux).

The guys from BitBucket, who I’d talked to to see if they would offer free unlimited hosting for OGRE since we wouldn’t fit in the default 150MB limit (result was that they were super-friendly and offered not only that but lots of advice), suggested that I try hgsubversion instead. I was initially put off by their website suggesting it wasn’t fit for production use (they’ve removed this statement now), but BitBucket told me that was a little out of date, and in fact the Python project is using it for their conversion, which is obviously of major size. So, I gave it a shot and got some good help from the hgsubversion guys, and the results were great – 1hour 40 minutes from the Windows end (coincidentally the same speed Git managed on the local Linux machine), and the log view was properly ordered right off the bat.

The one remaining issue I had (and this is true of git-svn too) is that all of the branches are open-ended on conversion – that is, no record is made of merges that have been done between branches. That means you would have problems continuing a branch and then merging it, because Mercurial would think it has to merge everything from the point the branch was taken. Neither svnmerge or svn:merge properties are taken into account.

One way to resolve this is to manually create a merge point to close off the branches. The easiest way to do this is:

• Grab the default tip
• Open a command line and define a temporary environment variable “HGMERGE=internal:local”. This means that you want to keep the local files and throw away the other source when doing a merge, which is important for our dummy merge
• hg merge <source_branch> -y
  
• commit – only the .hgtags file should be modified, the rest of the commit is merely metadata alteration to close off the source_branch

Once you’ve done that, your branch is joined back to the trunk and you can carry on as before, any new commits to that branch will merge across cleanly. The only downside of this is that the merge is strictly at the wrong point – if you view the history in the trunk it won’t be technically accurate and you’ll need to use your commit messages as the real guide to the actual merges before the conversion.

A better way to do this would be to record the merges during the conversion, that is for merge commits in Subversion to have 2 parents. So far, none of the conversion tools read svnmerge or svn:merge metadata to implement this, but the standard ‘hg convert’ has an option called ‘–splicemap’ where you can specify merge points to be applied during the conversion. Unfortunately I’ve tried to use this twice so far, and both times it hasn’t worked (just silently done nothing). The documentation for –splicemap is not great so it could be I got the URLs wrong. But anyhow, following 2 failed attempts (20 hours! because this was the standard hg convert with –datesort) I decided I’d try to get a similar bit of functionality working in hgsubversion instead, since that’s much faster (1hr 40m a pop). Right now I’m hacking away on it to try to make this work, so far it’s not but I’ll let you know if I eventually succeed. One of the benefits of Mercurial is that it’s all in Python so it’s very easy to modify, compared to Git which runs all kinds of random scripts and executables, including sh and perl so it’s much more tangled to dig into.

Conclusions, so far

I started my DVCS evaluation very pro-Mercurial and very anti-Git. While working through my detailed use cases, a process which I’ve not quite completed yet, Git has grown on me a great deal, and I discovered a few things about Mercurial which I found a bit limiting at first, but which are mitigated via extensions – Rebase, Queues and Transplant particularly. My recent experience with more complicated, full-scale and imported repositories has once again gone in Mercurial’s favour though, and I saw a nastier side of Git – when it goes wrong, it’s a lot more difficult to figure out why. In contrast when I’ve had my Mercurial conversion crash – and I stress this only happened due to my own screw up, once because it ran overnight when my rsync kicked in and changed the repository under its feet, and a few times when I’ve been experimenting with hacking the Python to get the merges done – the reason has always been clear; a nice Python trace, and the repository was always intact anyhow – in the case of the core hg convert the conversion even restarted from where it left off once I’d fixed it.

If I were to graph my relative opinion of the two over the period I’ve been doing this so far, it would look something like this:

Git totally came up from behind and I was really starting to dig it, until it started freaking out on me with the conversion and I started to try to diagnose why and found it mostly unhelpful. Again I stress I’m not done with my tests yet, but I’m perhaps 75% of the way through now and the conversion problems I’ve had with Git in the last few days don’t look good. Bazaar, I’m afraid, is no longer likely to be part of the evaluation – it takes a long time to do these evaluations properly rather than just trivially, and our survey has indicated that it is the least commonly used among our community by a very large margin, so I’m focussing on the ones more users are likely to already be comfortable with.

The evaluation process continues…

Before 2009, I’d never set foot in Germany before; not for any particular reason, I just hadn’t gotten around to it yet. However, thanks to gracious invitations to conferences I’ve now been twice. In May I went to Stuttgart for FMX, and last week I went to Munich for Qt Developer Days.

It was an enjoyable conference, as always the best part is just meeting other delegates, the sessions themselves are merely the icing on the cake. I shared my presenting slot (in which I showed a couple of applications that use Qt and Ogre together) with two other open source veterans from projects which I have a huge amount of respect for: Bill Hoffman, CTO at Kitware and the founder of CMake (which of course we use in Ogre now, so it was great that I had chance to have quite a few discussions with Bill), and Jean-Baptiste Kempf, Chairman of VideoLAN which is of course in charge of the excellent VLC.

It was also nice (not to mention flattering and somewhat humbling) to have random people I’ve never met before spontaneously say nice things about Ogre. One of the major curiosities of open source is that you never really know quite how many people have encountered & used your software; you get a sampling of that through your community forums etc, but it’s also clear that that only represents a portion of your user base. On the day I was wearing my Ogre T-shirt I had a number of people who were more peripherally involved in the community but who had had a good experience with Ogre, and were more than happy to tell me about it. Definitely a good feeling.

Perhaps most surprising of all though was getting a sizable donation to Ogre in person from a community member while I was there (I won’t mention who just in case he’d rather not be identified, he can post in the comments if he’s happy to). We had what I thought was a theoretical discussion at one of the dinners about how much we get charged by PayPal for donations, and I’d said that although it’s undesirable, any kind of electronic payment mechanism has a cost (merchant accounts, bank transfers all come with some kind of charge). I jokingly said that the way you’d avoid the most charges would be mailing cash in an envelope, although that had it’s own risks. I thought nothing more of it, until I saw him the next day when he presented me with an envelope with a donation in it! Way more than I expected too, enough to push him straight to a Platinum sponsor. Turns out he’d just got his deposit back on a flat he had been renting, and decided to donate that to us in the absence of any code contributions, since Ogre had helped him at university and subsequently in getting a job. I have to admit, I was a little lost for words at that! His donation will definitely help cover the server running costs in the coming few months.

Back to the conference subject, Qt, the conference reinforced my opinion that it’s the best cross-platform UI system out there for C++ developers. It was great to see the range of applications that were being developed on it these days, including a coffee machine which was serving custom beverages in the dining area via a Qt interface. Obviously the Nokia acquisition has meant that they’re keen to move into more dynamic, touch-based interfaces too now, which will obviously power new phones in more interesting ways, but it was clear that they remained committed to a huge range of application targets. Well, except iPhone anyway, that was definitely the elephant in the room – occasionally mentioned but mostly avoided

Obviously Qt’s switch to LGPL this year will have a huge impact on adoption rates. One of the things that had concerned me though is that there’s a clause in the commercial license for Qt that requires you to decide between using the commercial license and the LGPL before you start developing. The reason given for this is that Qt is licensed on a per-developer basis, so if you could wait until deployment to choose the commercial license, you could scale back your team and pay less than you really should have done, which is why you have to decide up-front. I could understand this argument, but in my experience, perfect foresight is impractical and conditions can often change, so making a once-and-for-all choice before a line of code is written did not seem realistic in some cases. Also since the principle was that the entire team must use the same license, I was wondering about the practical implications of say, a commercial outfit leveraging some pre-written code by people using the LGPL version (such as QtOgre). Qt want to encourage greater community involvement (which was the reason for me being invited to the conference after all), so not allowing this seemed to go against the kind of broader adoption they were chasing.

To try to answer these questions, I went to the legal presentation and put this question to the speaker afterwards. Luckily, she mostly allayed my fears on these two issues. On the ‘circumstances change’ issue, the principle must remain that, because of the per-developer licensing, you should make your decision up-front, but if for whatever reason, and in good faith, conditions change (such as suddenly having to target a platform where LGPL is not practical), then some kind of agreement can be reached, such as by paying commercial fees for all developers historically on that project so it comes out the same as if you had opted for the commercial license originally. In addition, she didn’t think there would be a problem with community code re-use for commercial licensees provided this was mentioned during the commercial licensing process; she accepted that greater adoption is what they want, and community development inherently complicates the previous assumption that one team will be responsible for absolutely every aspect end-to-end.

So, a good conference overall. Now, I’m back to continue work on Ogre 1.7.