Posted
by
timothy
on Thursday July 12, 2012 @12:36PM
from the when-bugzilla-is-a-monster dept.

An anonymous reader writes "One of my personal software projects grows bigger than I thought and the bugs becomes too many to just remember. I looked around for an open source bugs tracking system but found no ideal solutions. Ideally I wanted a simple system that does not need server setup and extra database setup, and can run under Mac OS X. Another option is a cloud service if it's affordable enough. Any suggestions from Slashdot?"

Second Mantis. It is a webapp, but it's fairly simple to get up and running. It's PHP+MySQL, which should run fine on a mac (you do have homebrew, right?). I don't think you're going to find any single-user bug tracking programs, but I could be wrong!

I tried out Lighthouse when looking for a new bug tracking system and was pretty underwhelmed... IMO, it was functional, but lacked polish. We also tried using Trajectory for a while, but settled on DoneDone.

I wrote find-issues.sh, a script that extracts comments of a certain type within the code and then groups them by file. Downside: your code files change when you register a bug. Upside: when done right, your bug description is next to the code that needs fixing.

Obviously won't work for distributed development, but for single-coder projects, it's really been useful to me.Note some assumptions and grep magic to exclude third-party files and other non-code files.

I file mine in my todo.txt, which also includes missing features. Since I don't do a release if there are *any* known outstanding bugs, "bugs" and "incomplete features" are essentially the same for me.

I also log every bug fixed into changelog.txt, which gives a nice history.

I file mine in my todo.txt, which also includes missing features. Since I don't do a release if there are *any* known outstanding bugs, "bugs" and "incomplete features" are essentially the same for me.

I file mine in my todo.txt, which also includes missing features. Since I don't do a release if there are *any* known outstanding bugs, "bugs" and "incomplete features" are essentially the same for me.

While it has been nearly a year since I released, that's mostly because I haven't touched the project in over eight months.

Before that, I did actually manage a few releases. The "zero bugs" was never an issue - between the small size of the project, and the smaller size of the testing corps, there just weren't that many known but unresolved bugs.

This is enough for the cathedral, which doesn't even have source control. Anything sold in the bazaar should have source control and some kind of bug tracking. Just pick whatever integrates well with the repository. Free sites will probably have a "most popular" bug tracking or integrated tracking. Just use it. A company will impose something. Use that, duh!

I pretty much do the same thing, but the file is called TODO and does not live in the repository. It gets backed up when my machine gets backed up, which is good enough. I don't want to air my dirty laundry in the source tree. Especially with all the swearing about browser bugs.

Sounds like the Apple school of management. After years of screaming at them, MS just ignores people and release their Tuesday patches occasionally. Google is the search engine, so they can just hide complaints. That leaves Apple, who (and I could be wrong but it) appears to me to be one of the most litigious consumer electronics companies ever... at least in terms of going after their own customers and contributors.

I've got a few hundreds megs of perl code. I've got five text files of bugs / planned features / quirks.Not sure what features of a bug tracking system you seek. I need the file name, the function name, and a description. Text files are great, and far more portable and accessible than a spreadsheet.

But I've never been one to like "proper" bug tracking systems. Of course, I'm not working with dozens of other developers.

For those like me who don't need a feature packed application like org-mode and who prefer Vim to Emacs, there's VimOutliner [vim.org]. It's basic but very usable, and it comes with nice plugins (e.g. checklists) and scripts to export to various formats.

Trouble is that it requires more than an internet connection. It requires an application. Nice part about the text file is that I can keep it next to the code -- main.pl can have main.bugs. I can edit it in my favourite code editor, with all of the same features that I've been using all day to manage code.

Oh I so very much agree. The negative organization effects come in so many ways. Mainly, real bug tracking systems are designed for projects where keeping bugs around is the norm, but tracking those bugs is also necessary. That's just weird for most projects; it's a weight that kills most projects.

You say explicitly this is a personal project. That is why bug trackers aren't going to fit very well. Bug trackers are for teams of people to coordinate their efforts. They are mostly pointless if you're working alone.

Just put your ideas, plans, comments, and bug notes right into the source. Most IDEs will let you easily flag sections so they stand out when desired, for instance Eclipse has the TODO: tag for exactly this purpose.

Now your notes are seen every time you work on that section of code, and they benefit from versioning right along with the rest of the code (assuming you are using some sort of source control).

What happens when you have more bugs than you have time to fix? How do you choose which to work on first? How do you remember which ones lead to data loss, and which ones have a workaround? How do you remember how to reproduce each bug? How do you manage patches? How do you remember which patches are compatible with other patches? How do you track the number of reported occurrences of a bug so you can prioritize your fixes more intelligently?

Seconded. Though I'd prefer the tag "FIXME" instead of "TODO". TODO is more for things like 'some functionality is still missing here' (button xyz does not do anything yet when pushed) while FIXME indicates 'something is wrong here' (things that might look okay and be overlooked if the tag wasn't there).

Another possibility:On a former personal project of mine, a compiler, I used a small self-written regression test framework. It consisted of a bunch of sourcefiles to be fed to the compiler with comments ins

If they are actual bugs, just fix them as soon as you can... Add some TODO flags where you think they are happening, add more asserts and unit tests.. set breakpoints, recreate, fix, comment and test.. Avoid putting something into another todo list if it can be fixed right away. Most bugs I run into are simple NPE's, copy and paste bugs (where similar code is copied but incorrectly modified).. and logic bugs... Few bugs are so complicated I need to write out a long description of the problem before tacklin

When I need to set up a self-hosted project and bug tracker, I normally use Redmine, which is very easy to use. It's written with Ruby on Rails, and so should be relatively easy to get a local SQLite-backed copy running on Mac OS using Rails' built-in mini web server.

This post is overly complicated but some of its information may be useful:

We use Redmine as well, but it has some fairly severe problems. The biggest is the lack of a search function. There's no way to make a query like "find all open bugs assigned to category 'X' where the description contains 'keyword'".

If you make use of subprojects, then the fact that categories aren't shared can be a huge PITA.

I use the free FogBugz plan along with Tickets [manicwave.com], which is a native Mac client for accessing FogBugz. It has a nice Mail.app-like interface with smart folders, easy sorting, attachment handling, multiple accounts, etc. It has a few bugs, but overall it works very well for me.

I don't have any mod points, but just want to second the parent. Fogbugz works great for one or two people and it's free until you get bigger than that. It's nice having something hosted and free without being forced to open-source your project.

Okay, first I'm not given a lot of info about what you are trying to do, so I am forced to make assumptions. First, you are doing this part-time. Second, you have a small amount of users. Third, I assume these users either email you or tell you about problems in person. Fourth, you don't have any need to formally update people on statuses.

I have a great solution for you. It is called a spreadsheet. The positive is that is it free, easy to use and modify to suit your needs. No, it isn't flashy, but I find that folks tend to use software as a replacement for their own brain and creativity. I've used spreadsheets for a lot of different utilities from project management, to bug tracking to help desk support in small environments. Once the user base sees limitations, they can begin to see what they truly need and it helps immensely in determinng what the desired solution really is versus what the Microsoft shill^h^h^h^h^h consultant tells them they need.

So, yes, use a spreadsheet. Heck, in your case it really sounds like a text editor would meet your needs.

For what it's worth, there are issue trackers offered alongside even the free levels of both github and bitbucket.org (which lets you use both git and hg). Bitbucket's free tier even lets you have a private repo if your source needs to be private (issue tracking and wiki instantiation are configurable via admin there, and should be offered as part of project repo creation). This way you get source control for your personal work as well as an issue tracker.;)

I vaguely recall that Sourceforge also has some sort of bug tracker as well, if you'd rather use cvs/svn. (It's been a long time since I looked in that level of detail at SF though, so ymmv.)

All of these are "cloud" (blech) solutions that don't require any server setup on your part. If you aren't familiar with source control, that's kind of another matter, but there are quality GUI clients for OSX for most of the common protocols and cvs, svn, git, and hg all have reasonably good documentation publicly available in various forms.

There are no bugs in personal software projects. If something doesn't work, it gets fixed. you don't need anything to remind you that something you want to work doesn't. It's only the other people who try to use my software that find bugs, if you are making software for other people, it isn't really a personal project anymore, it's a product.

As some of my personal projects have gotten bigger, the standard TODO file became cumbersome to manage. I've recently been working with Taskwarrior [taskwarrior.org] an open source command line task management tool that can act as a simple todo manager, but also includes advanced features like projects, tags, filter-able queries -- all from the command line.

http://www.turnkeylinux.org/redmine [turnkeylinux.org]
Seriously. I had an issue tracker running in 5 minutes. By 15 minutes I had the settings the way I wanted it.
They ship you a virtual machine image. You load it into VirtualBox and click start. The VM loads to a little screen that tells you what IP address the redmine is running at. It also has git i installed, and it was super quick to migrate my git repo into it. Since I use redmine with git, it's really handy because they are already integrated - when I put "refs #32" in my git commit message, it appears on ticket #32.

Host your project on github or BitBucket, whatever. They all offer a bug tracker. Using an SCM allows to know when a bug has been introduced after writing the proper test.

Speaking of which, and even more importantly: WRITE THOSE F*CKING UNIT TESTS!

I cannot stress the last point enough. If you're introducing bugs in your releases, either you're not writing unit tests, or not writing the ones that count (aka the higher level ones), and not using every tool at your disposal to avoid bugs in the first place (test coverage, static analyzer, etc.). You should always strive for 100% test coverage and zero trivial bugs when releasing.

Here we design for testability but only test critical stuff and wrote test case when something break down as our metrics told us that our unit test were worthless as they did not exercise code that broke or when the broken code was executed, the test was as broken as the code. Not that the code or the test were generally bad it's just that our bugs are usually at the multisystems interaction level, especially so when the mainframe is involved... Mocking up everything is not an option as experience thought m

Emac's org-mode [orgmode.org] system is fantastic for things like this. It has TODO tracking with scheduling, etc, and you can put one file in each project or one global file for just you, or... Your choice!

I have used, in the past, Teamatic (http://www.teamatic.com) and http://www.elementool.com/ [elementool.com] - their offering may have changed in the last few years so check exactly what you can do for "free".

Depending on which IDE you're using, you may already have that functionality. Netbeans, for example, has a "Tasks" tab which will show you all your commented notes that start with "TODO:" or "FIXME:" within your code. It obviates the need for a formal bug tracking system if your objective is to make simple notes about what doesn't work, and to keep those notes attached to the broken code.

But in my case "bugs" usually are just desired features. The couple users I have internally at work just will say "yeah but I really think it should be this way". Basically it goes into the email cloud. If it is easy and gets done before it gets buried by other email than it gets done. If not unless I hear about it again or have nothing better to do I assume it isn't important and don't bother with it. Basically it is prioritization by liberal use of the squeaky wheel method.

For plain bugs such as "seg fault when doing x" I just write a test exposing the bug. This way, I won't forget about a bug even if I don't touch the program in six months. It will appear again as soon as I run the full test suite.

For more complex bugs such as design flaws, bugs from user interaction etc I keep them in my to do list in a TiddlyWiki.

TiddlyWiki is the perfect documentation/note taking tool for projects with a single developer since the entire wiki is in a single self

That works great - when you only have a few hundred lines of simple code. However, when you have 200k lines, a couple hundred different files, and some very complex functionality, you need a more complex system.

In addition, how do you manage multiple contributors? How do you deal with letting your users know when bugs are fixed? How do you deal with issues that only occur in a very small amount of edge cases?

It's one thing to fix some code you fat fingered or to clean up some API calls. It's an entirely different thing to fix bugs in 200k lines of non-deterministic code that runs on 3+ platforms.

Knowing how code is structured doesn't automatically mean you know where bugs are. In addition, non-deterministic code occurs on a regular basis in several fields (bioinformatics, MLAs, NLP, so on).

Having a personal project doesn't mean you don't have contributors - It means that you are the only main contributor. You may still receive translations or patches from users or enthusiasts occasionally. In addition, having a public bug tracker helps your users know what to expect when they use your product.

Knowing how code is structured doesn't automatically mean you know where bugs are.

Didn't say it did. Nothing is automatic. But it does mean you should know the coding style and how the program is organized. You should know the data flow and the processing steps. If you see something wrong, you should have a better idea of where to look than anyone else does.

Having a personal project doesn't mean you don't have contributors - It means that you are the only main contributor.

Oh, sorry. That's a different meaning for the word "personal" than we use on planet Earth.

In addition, having a public bug tracker helps your users know what to expect when they use your product.

Which means it isn't a personal project anymore. Perhaps you're thinking of "hobby"? You can program a publicly usable project as a hobby in

For my projects, I will typically fix things I find as I find them. Where I use a bug/issue tracker is for bigger things like tracking planned features for a roadmap -- things that will take longer to develop.

You could also have a problem near a release that is not critical, but you need to remember to fix it later on, or a defect that can only be fixed with an architectural change.

A bug tracking system is also useful for other people to report issues or feature requests they find to you/the developers -- t

This is fine for small, truly personal projects, but once you have a product with other users (as I do), you end up having to prioritize bug fixes. You simply can't fix every single bug right when it's reported. Bug trackers are also good for keeping track of new features to be added in the future, refactoring you'd like to do, etc.

Err, that is very random - we are talking about the same company here, right? Lol.

Atlasssian have been *incredibly* professional in all my emails to them - I use them for Confluence. I honestly can't imagine that happening in an email chain with them. Can you paste any context to this email?

Also, I have a few friends there (Sydney office), and they're all pretty happy with the company - apparently they treat them very well, and staff morale/loyalty seems to be up there with Google so it does seem strange