alan

Alan's musings

This is a multipart article – link to part 1


3. Make it easy to report issues.
Yes, your software is got a bug. Never thought about it, didn't you? And here it is. 

Now, users shouldn't be forced to climb mountains in order to report it. You might not want it to be dealt with just in the discussion area, so a bug tracker is usually a good idea, but just like the discussion group, quick access should be allowed, either via anonymous issue reporting or using a backend supporting a decentralized authentication system. Remember, any bug reporter is doing you a favor! You shouldn't ask too much to them.

Many large open source hosting platforms, like github, launchpad, bitbucket, google code, are great examples of how you can achieve this goal pretty easily.

4. Make it easy to submit bugfix patches.
This is a big one, and I'm sure many people won't agree with me.

Sometimes a patch comes along a bug report, yet many projects have got some coding standards, and they don't accept patches that don't follow such standards. 

Whew. 

Many times, though, either the coding standard isn't really a widely accepted one, like PEP-8 for Python projects, but it's just how the lead developer likes to code, or many old parts of the codebase themselves don't follow such standard.

Hence, after I've discovered a bug in your software, I've debugged it, I've tracked it down and now I'm providing you a patch, you're rejecting it on a mostly cosmetic base because of some principles you alone chose to follow. Thank you very much sir, you're so nice to me. Don't call me by the way, I'll call you if I update my patch to achieve your great coding perfection.

The whole point is, your coding standards are your business. Never forget the Boy Scout rule - you don't have to make every module perfect before you check it in. Removing a bug is enough of an improvement to let a patch be accepted. If you don't want non-complaint code in your codebase just edit the patch – it should be easy for you – don't reject it and don't ask the reporter to edit it.

Of course there are perfectly good reasons to reject a patch. If it's a “worst hack ever” style of patch, or if it adds unnecessary complexity, provokes unintended side effects or changes a behaviour on which existing clients rely, just do whatever you think it's right.

There's another top rejection reason:  missing unit tests or insufficient coverage. Some projects with high coding standards require a unit test for each functionality and maybe 100% test coverage. It's perfectly fine, but there're issues with this choice.

Very often there're some legacy parts of the codebase that have got little test coverage; in order to achieve 100% test coverage the reporter might be forced to create a unit test that does not exist for some code that he has not written. That's a burden and most people will get discouraged.

Other times the overall design in some parts of the code does not allow for easy dependency injection, hence making it hard to create a good unit test which can really test the specific behaviour being patched, and the reporter might be able to reproduce the issue only with an higher-level, more integration-level-like test example.

In both those cases you should remember that the quality of your codebase is your business. You should not reject a patch from being applied because there're no unit tests if creating such a unit test is impractical and the fault is yours. Of course you can create a guideline for patch submission that says that you prefer the issues to be reproduced via a unit test, but don't make it a strict requirement. A patch without a test is better than nothing, you might just pick it up later when you've got some time and write a test for it.

Of course if a patch does not convince you for any reason and you don't get a unit test, just don't apply it – but don't be a template zombie - i.e. don't place policies ahead of people.

If you're unable to reproduce a problem because it happens in scenario you aren't able to test, try checking whether the patch causes any drawback to your supported scenarios. If it doesn't, you might decide to just trust the reporter.

Feature patches are a completely different story IMHO – when you accept something new in your codebase you should  be able to dictate whatever you want.

5. Reply to issues 
Reply to issues. Always. If possible, do it in a reasonable amount of time, which should be, in my opinion, ten days at a maximum. You don't have to take immediate action. Your reply could just be Investigating the issue or something like that. Remember the Inbox Zero approach to GTD: don't let unread, unaccepted bug tickets linger in your bugtracker! A lingering ticket is the first stop on the path to killing community support to your project.

The same approach is valid for issues with an attached patch – say something. Don't let issues linger unanswered.

And never, never wake up after a bug has been lingering for months just to ask the reporter if it “still applies”! This is terrible, I hate it when it happens. “Sorry, being too busy but did 37 releases of my software in the meantime, could you check if this still happens with the latest?”. You're probably in a better position for verifying the issue – assuming that a way to reproduce it is provided – on any release, since you made them.

The next part will deal with APIs and public info for your project – see part 3

#Ollivander #community #OpenSource

There's a lot of buzz about open source software lately. Many projects are supposed to embrace the Bazaar development model, but they really don't, and their leaders just seem to ignore users a lot. This often leads both to wild forking – one new feature, one new fork that's never merged in the original code base – and to multiple incomplete implementations – there're many projects to satisfy a single need, but none of them is complete.

What should you do to make your project successful? Those are my guidelines. I've split the post into pieces since it was growing too large for a single entry.

This is mostly developer-oriented; I think supporting a community of end-users might be slightly different, although concerns might sometimes be similar.


1. Make it easy to discuss about your software.
Something might not be clear about your software, whether it's usage, availability, license, scope, and so on. It must be easy to ask a question, whether it's on a mailing list, on a forum or by any other mean – Launchpad Answers or GetSatifaction are good alternatives – just don't make it too hard to just ask a question!

 If you're using a custom forum or any other portal, make sure it supports a decentralized authentication system, be it OpenID, Google Account, MSN or whatever you like. Very often creating a new username/password couplet, fill in a few forms, clicking to verify an email, etc. etc. may just be too much an hassle for somebody who just wants to ask a small question.

Similarly, if you're using a mailing list, make sure it's not too hard to get subscribed; if possible, just let anyone post a question – then a “reply all” from any list subscriber should reach the poster. Don't moderate subscriptions and posts unless you've got a really good reason to – e.g. too much spam that automatic filters can't handle. Consider using mailing list providers that make it easy to use the ML from the web as well – Yahoo Groups and Google Groups are great examples; they'll give a great overall user experience, and satisfy those who prefer forums and those who prefer mailing lists at the very same time.


2. Answer questions and doubts.
This seems a silly one, but it isn't. Make sure users get a minimum of feedback, be it just a “read the FAQ”, or “it's not implemented yet” or “I don't know”. Any message left lingering is a big thumbs down for your project.


3. Have a FAQ

This was pretty common during the nineties, I can remember being turned down with a “Read the FAQ” many times when I was young and inexperienced, but it's not such frequent thing anymore. There're some questions that get asked again and again. If you don't mantain a FAQ you can't tell people “Read the FAQ!”, and you'll need to answer the same question again, and again, and again. And you won't like it.


Link to part 2 - bug reporting and patch submission.

#Ollivander #community #OpenSource

Apple has announced it will contribute to the OpenJDK project, so there's probably no risk that MacOS-specific pieces of the current JDK will be lost. Probably the next, Oracle-backed JDK will be just fine on Mac and will probably be released on time.

There're two things I don't understand:

  •  why such a bad timing? Apple could have deprecated his Java and announced OpenJDK participation at the same time – and that would have been good news. I don't understand if Apple had already chosen to contribute to OpenJDK or it had been pushed in that direction once it saw what happened in the dev community after their deprecation.
  • It's still not clear why I can't use Java in a software I'd like to distribute within the Mac App Store. If it's Oracle backed it's not a “deprecated technology” anymore, right? The language restriction was lifted even in iOS apps, why should it come back on Mac apps?

#Ollivander #apple #java

I'm not an hardcore Apple user. My first Apple product ever was a Macbook Pro I bought about one year ago.

But I fell in love with the Mac platform, and I think its really strong point is that it's versatile. It's got plenty of useful proprietary apps that sometimes I want to use or I am forced to use, like Microsoft Office or Adobe Photoshop, a pretty decent Adobe Flash implementation, but since it's a BSD derivative it's got a lot of nifty tools I'm used to and that I really like.

Sure, Windows might be faster at many tasks, especially if you're gonna spend as much money as you need to invest in Apple hardware, but my feelings towards Windows are mixed. I liked XP at the beginning, but it grew old and tired; Vista was a mess; Seven seems fine, but Microsoft still needs to conquer back my trust. Also, Windows is fine as a development platform as long as you use Microsoft tools – which are quite good – but it can get squeaky as soon as you adventure into the FLOSS land – I can remember some madness I incurred in while trying to use git under Windows.

What about Linux? I's a great development environment. I simply love my Ubuntu box, it's exactly as I want it. Eclipse, Netbeans, everything is set up as I want, all the key bindings, all the details. But my Ubuntu box is a tower form factor workstation with ethernet connectivity and two monitors – I think Ubuntu fails pretty hard at the common desktop experience, especially on a notebook – wireless connectivity is often an issue, suspend and hibernate are unreliable, the battery doesn't last as long as I'd like, and Flash on full screen is flaky. I don't think it's Canonical's own fault – it's really hard to have an OS work on each and every hardware and giving it away from free – but from the user's point of view this is a failure.  Some key apps are also missing – OpenOffice might not be enough a replacement for Office, and GIMP is not quite as effective as Adobe Photoshop.

But the Mac has it all, and that means it's got a lot of appeal on developers – we usually want the eye candy and the dark console, we like our computer to 'just work' and yet we like to be able to tune every detail. Whenever I go to a conference I can see there're far more Macs, iPads, iPhones than in any other typical business environment. A lot of developers from many communities simply love using Macs for their development work - I simply don't think that developers don't count in Mac market as someone stated. Maybe many of them are not Java developers, but as soon as they're unable to install Eclipse they'll complain as well.

Apple's Java sports its own Cocoa bindings, which are very useful to achieve a native look-and-feel, OS integration and general responsiveness for all java based software. Eclipse is java based and it's a widely used platform, RubyMine is one of the great favourites for Ruby coders, Netbeans is evolving at a great pace and supports Java, Ruby, Python, PHP and many others. Not to mention the fact that while I write those lines it's the only JDK available and working out of the box on Snow Leopard.

Now this is going to change. Java is deprecated on Snow Leopard, won't be included in Lion and can't be used for Mac App Store.

If Mac OS X were to be left with a third-party Java implementation – and let's hope SoyLatte can cope with such burden – we'll probably lose native OS integration, everything that's Swing or SWT based will need X11 to run, Swing will probably use its native Metal widget set while SWT will probably rely on GTK+ bindings; Apple doesn't even seem to be willing to contribute its own patches to the OpenJDK project, even though it would be meaningful if they just didn't want to waste resources on what they think it's a dead technology.

It's not a great scenario, but the real question here is: why?


Why should Apple have done all that? Is it that difficult to update the current JDK to work with  Lion? JDK7 might be a different topic, but hey – they're basically dropping what they've already done! And they're not letting anyone to continue their job easily. I think Apple is perfectly aware that the Mac OS X ecosystem is fairly different from the walled garden of IOS –  Windows is still got a much larger market, and limiting what Mac OS X can do will just feed Microsoft's pockets again.

I don't think there will be an official statement on that, but I bet Oracle has a part on this. Mac JDK seems to have been built by Apple but to have sprung from Sun's own JDK – is Oracle not willing to let this deal to go on? Maybe Apple needed to renegotiate its license and it turned out to be too expensive? Even though Apple may think Java is dead, it has no apparent reason to silently stab it again.

Their decision is causing a lot of noise in the Mac/Java community, let's see if Steve comments on this as well

#Ollivander #apple #java