Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 9 years ago.
Improve this question
I have been using the Open Dynamics Engine (ODE) for the last few weeks with great success. It has a very simple API and its simulations at least look realistic. (I sometimes wonder about my collision joint parameters, but whatever.)
My only complaint is that it is sometimes a dog. If I naively simulate 1000s of interacting bodies, then my performance starts to dive.
I know I can spend time with their spatial grids to reduce the load of the collision system, but before I go through the effort of tuning my code to work with ODE, I wonder if there are any other Open Source/Free physics engines worth looking at. This will be for a commercial app, so I am looking for something more solid and more battle tested than some college student's weekend project.
Building a fast, accurate, and stable solver is extremely tricky, and people like Havok are understandably protective of the technology. That said, the free systems I'm aware of are:
Newton Game Dynamics -- This one made its reputation on having a very accurate and stable solver, at the cost of performance. It's spent the last few years trying to gain performance without sacrificing the other two. It is a well designed engine and it works well, but it's still one of the slower ones out there. Not open source.
Tokamak -- Exactly the opposite. This one is awful; even their demos don't run stably. Just pull up their box stacking and you can see massive jitter. I've never been impressed. It is open source and wildly fast, though.
Bullet -- This one's lead by a former Havok employee, who is now employed by Sony (although I can't remember if that's SOE or SCEA). This is the newbie of the scene, and it is actually open source. It's got heavy Sony backing, it's nicely cross platform, and it's developed by people who know what they're doing.
TrueAxis -- A recent appearance on the scene. I don't know much about it, and it hasn't really gained a substantial community. I tend to be a bit skeptical here; it may be well written, but with a small community help can be hard to come by, and it's probably not a well tested and stable engine, compared to the others.
I'm a huge fan of Bullet myself, but I've heard some misc complaints about it. Most of them seem to center around poor documentation, or occasional problems on some of the secondary platforms like Mac. It'd still be my pick after the "Big 2", Havok and PhysX.
Bullet is awesome, and had been used commercially (eg: in the production of Bolt, and several PS3/Wii games) has support for many platforma and even nVidia's CUDA.
Bullet is free for commercial use and sources are available.
The documentation could be much better but there's a forum and a number of examples that can help when getting started.
With today's hardware, if you naively simulate 1000 interacting rigid bodies on a x86 CPU, the performance starts to dive without exception. If you want more performance right now then it'd be better to seek for physics engines that shift their workload to GPU.
CPUs have great integer math and logic processing capabilities, but GPUs have far much greater raw floating point computing capabilities.
If you still want more performance by just using CPUs then you will need to change your requirements.
Farseer is very nice.
http://www.codeplex.com/FarseerPhysics
Nvidias PhysX is not open source, but freely available for Windows, Linux and PS3.
Quote from http://en.wikipedia.org/wiki/PhysX:
Nvidia provides both the engine and SDK for free to Windows and Linux users and developers[6]. The PlayStation 3 SDK is also freely available due to Sony's blanket purchase agreement.
Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 5 years ago.
Improve this question
What are common empirical formulas that can produce a rough estimate of project duration for waterfall methodology ( up to 20% fluctuation is acceptable). If it helps in narrowing down the answer, you can assume that following is more or less known :
Number of devs is known and fixed, most devs are above average in terms of know-how, however some learning about domain-specific issues might be required.
Known and fixed max. number of app users.
Technology stack to be used is reasonably diverse (up to 4 different languages and up to 6 various platforms).
Interfacing to up to three legacy systems is expected.
Please feel free to provide estimate methods which cover a broader scope than the above points, they are just provided for basic guidance.
Do yourself a favor and pick up Steve McConnell's Software Estimation: Demystifying the Black Art. If you have access to past estimates and actuals this can greatly aid in producing a useful estimate. Otherwise I recommend this book and identifying a strategy from it most applicable to your situation.
Only expect to utilize 70% of your developers time. The other 30% will be spent in meetings, answering email, taking the elevator, etc. For example if they work 8hrs a day, they will only be able to code for 5.6 to 6.5 hours a day. Reduce this number if they work in a noisy environment where people are using the telephone.
Add 20% to any estimate a developer gives the project manager.
Lines of code is useless as a metric in estimating a project.
Success or failure depends on concise requirements from the customer. If the requirements aren't complete, count on the customer being not happy with the finished product.
Count on the fact that not all of the requirements will be dictated by the customer. There will be revisions to the requirements throughout the project.
Step 1. Create a schedule that is as granulated as is reasonably possible.
Step 2. Ask the people involved how long their features will take.
Step 3. Create an Excel spreadsheet which maps predictions to actual times.
Step 4. Repeat steps 1-3 for all new projects. Make use of an aggregated mapping from previous instances of step 3 to translate developer estimates to actual estimates.
Note that there are tools which can do this for you.
See also
Evidence-based-scheduling.
This project is not going to be cheap...
Number of devs is known and fixed,
most devs are above average in terms
of know-how, however some learning
about domain-specific issues might be
required.
This is a good thing. You don't want to flood the number of developers into the project. Though if you go above around 10 people, do count every 2 as only 1, as the rest will go up in overhead. Unless you can split the task into something that can be handled by two totally separate teams. Then you could have a chance of getting some traction.
Known and fixed max. number of app
users.
This means that you can with more certainty land your architecture early on, as you can estimate how much effort you must put into scaling your solution. This is a good thing. Make sure that you work within these limits and never ever fool yourself into thinking "it's fast enough". It almost never is if you doubt that it could be too slow...
Technology stack to be used is
reasonably diverse (up to 4 different
languages and up to 6 various
platforms).
This isn't as important as to do your people know this stack/set of languages? If there are any learning involved, raise the estimate x2 or x3 if you don't perform a proof of concept up front to learn the technology. Or even better, take the pain and get some coursing. If the language for implementation or technology to be used is unknown, then it is quite likely that you will misuse the technology and do things that will screw stuff up.
Make sure that the technology is proven or you'll end up getting bitten by it.
Are the source available for the tools/technology?
Do you get support?
Do you understand the product and or used it before?
Have the customer used it before?
If too many of these questions get a no, add some (or a lot of) additional time to the sum.
Interfacing to up to three legacy
systems is expected.
This is really a kicker. For legacy integration ask yourself:
Has anyone else integrated with them?
Do you have access to people with knowledge of these systems?
Do they intend to share this knowledge with you?
Do you have to wait for changes being created in these systems?
Are there test systems available for you to use?
Are there development systems available for you to use?
Again, if too many of these questions has a "no" on them, then be afraid. You should also know that actual integration takes about 3-5 times longer than you actually think.
This isn't a project that I would have given a table grabbing estimate for. Do yourself and your customer a favor and do this by the hour. If not, you will as times go by start cutting corners to cover up your lack of progress/underestimation... And both you and your customer will suffer.
There are many cost estimation software tools that can greatly ease the pain of cost estimation, we use ProjectCodeMeter. I know these tools are not perfect, but they do save time getting started by pointing towards the right direction.
Try this list of estimation tools on Wikipedia.
Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 10 years ago.
Improve this question
I just played a game of RBI Baseball in a browser window.
That in and of itself strikes me as simply amazing. When I was young, the NES was a magical box, capable of providing hours of enjoyment to young kids throughout the world.
Now, decades later, I'm a programmer. And I can appreciate the programming that went into games that were developed with more primitive hardware just a couple of decades ago. In fact someday, I fully expect that code from some of these games will be enshrined in the Smithsonian.
My Programming Question:
Have any classic NES games (like RBI
Baseball) been open-sourced, and if so, where can I find code to study?
Failing that, are there any NES games for which source code is available to study?
I think it would be worthwhile to learn from their example.
For instance:
Did they use object-oriented programming?
Did they use design-patterns to keep the code maintainable?
No. At least none that I know of (and I've been searching).
NES appeared right after the 1983 video-game crash, the main reason why the market crashed was the flood of bad games, triggering the customers to not buy a single game, because there was no way to know what game was good.
So Nintendo when introducing NES (and all other consoles from the time, like Master System from SEGA), decided that only approved games would ever get released, AND making anything open source ever being a breach of contract with heavy fines, the reason for that is that by not releasing a public API, it would make "homebrews" harder to flood the market.
Today Nintendo is much more easy on the part of allowing the games, see the flood of crappy games on the Wii, but still no console allow you to use their "true" API, to avoid the flooding, there are even a issue when someone used a GPL engine (ScummVM) on Wii, causing trouble, because releasing the source of a game for a Nintendo system is a breach of contract, and GPL demands the source to be released, in that particular case the games were pulled of the shelves.
And no, XNA and PS3 Linux are not really console APIs, both impose severe limitations on what you can do with the console.
Maybe you can find homebrew, or reverse engineered games. But I guess that this is not what you asked.
Also the source of remakes and ports sometimes can be found, but these don't use the console API.
Maybe you have since found this, but Metroid (the original, for NES/Famicom) has been disassembled and the code (in beautiful ASM) posted on Romhacking.net.
Direct link.
If you're interested in NES programming you should check out Episode 91 - Tengen Reunion Roundtable of Retronauts. (Note this is episode 91 of the original run of the podcast, newer episodes can be found # http://www.retronauts.com/)
It's basically a bunch of former NES programmers reminiscing about game development on the system (and other retro systems). They occasionally dip into the technical stuff, which is all really fascinating.
I've never worked in the videogames industry, but I've read quite a bit about it and I talk from time to time with friends that do, so I'll try to explain a more or less what's the difference between a game and other application, regarding programming methodologies.
The first thing to understand is that a game is a one-off product. It's not like a spreadsheet or a word processor, where you can release new versions improving and extending the previous codebase.
The second thing, is that you need to release the game as soon as possible. Usually, the more time you spend in a game, the worse will it be in comparison with the other games of the time. This is mostly true for PC games, where hardware evolves much faster than in the console world, but still applies to a large extent (games continue to get better even with the same hardware as better tools and algorithms are developed).
The third thing is that usually games need to push the hardware to the limit. So screw all the elegant patterns that would make your code more beautiful and maintainable if they make it to run slower.
So what I would expect after dissecting an old NES game source code is just spaghetti code, most of it written in assembly with plenty of low level hacks tightly tied to the architecture of the machine.
I hope my answer is useful for you.
I would recommend looking at nesdev.com if you are interested in NES game development. They have detailed documentation.
You won't likely find source for the original games, but there is plenty of homebrew out there and a relatively mature toolchain. As is the favorite answer, google is your friend. But to get you started, here is relatively decent tutorial:
http://www.bestdamnpodcastever.com/millerblog/?p=72 via "The Wayback Machine"
NES Games were developed only (as far as I know) in assembler, and I guess the source code is long lost, after those many years.
Anyway, having assembler source code is not so far from machine code, so it may not be too much revealing as it would C or Java code.
About object orientation and desgin patterns, again, it was assembler and the 80's, don't expect any of that.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 9 years ago.
Improve this question
Is there a reason not to use wordpress and develop your own blogging system?
Same goes with Durpal and our own CMS.
I am wondering since my marketing women disagrees with me that we should develop our own in house solutions because there are better solutions. She also says that we might even loose time and money on it since it is our responsibility to maintain it and solve bugs and we can't throw it on wordpress' dev team for example.
I don't want to invest time in something that might not worth it but I would really like to make more money.
Does it depend on the site's scale and visitors?
What are the factors of choosing one over anohter?
There's rarely a right answer to this fight. It's a question that has raged on since software was sold "off the shelf". Many pros are also cons.
Pro 3rd-party:
They cover a vast number of features
They (hopefully) look after security
Open source means other people can fix your platform.
You get improvements without having to work on your own platform
They have existed a lot longer than your newly conceived project. A lot bugs have been driven out.
Anti 3rd-party:
They don't have all the answers for every project
By extension, it may take you longer to hack in what you need than it would take to just start afresh
Unless you're using it exactly as intended, performance isn't going to be as good as it could be with a custom-built
Larger target for hackers and script kiddies
As they're older, they can be locked (via legacy support) into some bad habits (Drupal and Wordpress certainly have enough)
So if you're doing a blog, unless there are features or platform issues, I'd seriously consider WordPress. If you only needed a very simple blog attached to a much larger system that was completely non-blog, I'd probably write my own as part of that system.
Just to blur the lines, the modern frameworks (Cake, Symphony, Django, Ruby, etc) handle lots of the security, database, usability and let you develop the application without having to worry too much about anything. You get exactly what you want and you get it fast but it probably won't be as polished (eg for blogging) as WordPress.
Good question, +1 :)
My Opinion:
Whatever the scenario, if there is a solution out there that meets your needs, it's open source and your team as the knowledge to make any specific change it might need to meet your purpose, it is probably a good choice to use it. It will save you time(time is money) that you could use to other tasks.
From a developer perspective, it is way more appealing to create something from scratch.
You just have to keep in mind that this is not something you are doing as hobbie, you need to have a product out there as fast as possible, with as few errors as possible, with all the features that the users would expect.
Really it comes down to this:
How much time/money would it require to roll your own?
Does the open source solution you're considering have the features you need (and do they work*)?
How would maintenance of the two solutions compare?
Some "common" answers:
A lot, particularly if you need (or want) a lot of features.
Most of the mature systems have some kind of plugin system and heaps of functionality. Generally if you want it they got it, perhaps some minor tweaks would be necessary.
In-house code may need some time to mature, after this they will probably be about the same. If in-house code is low on features then it may be easier to maintain.
She also says that we might even loose time and money on it since it is our responsibility to maintain it and solve bugs
How is that worse than an in-house solution exactly?
This really depends on your business model.
If you are selling services using an existing open source product can make a lot of sense. (And by the way, you probably can get the wordpress people to work for you - you'll have to pay of course, but you also have to pay your in-house team)
If this blogging system is only for your own usage it makes even more sense to use an existing solution, and the open source solutions stand out in that area because there are a lot of people available that could code some custom solutions for you.
Only if you are actually selling the software the situation with open source becomes a bit harder to get a grip on money-wise.
Our host Joel Spolsky has written an interesting article on this subject.
Yes, there are a lot of reasons. Being open-source doesn't mean it'll automatically be well written.
However, sometimes it really fits your business model because you need to ship something fast, usable, not too specific in requirements and already tested by millions of people. In this case, doesn't make sense to produce something in house.
If you want to convince her of using Wordpress instead of building one, show the arguments on time and money that would be spent in trying to write from scratch instead of using an open source solution. Don't forget to show some live examples from big companies that are using Wordpress (check the official website).
For most companies, developing your own blogging solution is the equivalent of developing your own version of the machine that mixes the tarmac to make the road that leads to your office.
The only exception is if you want to get into the road-building business. But that's a hard and competitive business, an established stable market with a lot of capital requirements, not something to wander into.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
For an university project on usability I'm looking for an open source project that is useful but hardly usable. My group would do a complete usability review and give recommendations over a period of approximately 3 months.
Of course this is no purely altruistic idea and the best-case-scenario would be:
Our recommendations get implemented thus we can include an review of the improved version in our paper.
Are such one-shot usability reviews useful for (and wanted by) the average developer or are they just "better than nothing".
Do you know (actively developed) projects with poor usability that we could contribute to?
Besides sourceforge's "Help Wanted" and openusability.org do you know where to turn to?
Regards,
FGK
Update:
We are looking primarily for an end-user application because we want to include things like hallway testing with potential users.
(Thanks to Pekka Gaiser for raising the question)
2nd update: accepted answer:
Thank you all for your help. I think we'll go for libpurple and its graphical incarnations. The Linux and Windows versions of pidgin are truly a mess... :-)
I would suggest the GIMP - it's a very functional photoshop alternative, but it's not without its confusions...
Instead of choosing to help a project that is already bad, why not look at something heavily used?
There are many web based applications that may (or may not) benefit from a usability review - I'm thinking of things like Wordpress (in fact that's pretty much what I'm thinking of purely because I use it a lot).
It would be interesting to see what a group of "experts" think about Wordpress and how they would improve the UI - purely because any improvements made have the potential of helping/improving the experience for vast numbers of people.
Whether or not the Wordpress team specifically would implement any of your suggestions or changes is an unknown but even having a discussion and recommendations is most likely beneficial to the community.
Perhaps take a selection of projects (again I'm thinking web based because web usability is more defined [in my mind] - CMS/Blogging Software: Drupal, Joomla, Wordpress? Or E-Commerce applications? Forums?
Send out some "feeler" messages to the projects mailing lists to try and get an idea of whether or not they'd be open to the idea of help. I can't imagine many projects would be against the idea? Actually implementing changes may well be more difficult.
If you don't want to look at web applications maybe look at some of the "media" apps. Boxee or XBMC generally or Miro.
None of the projects I've mentioned are neccesarily bad (usability wise) but they're things I'm interested in so, from a slightly selfish point of view, it'd be beneficial to me (and I think a chunk of others) if you looked at something with a large user base.
Anyway, good luck.
Please, please, choose Audacity! That UI could be improved so much it's not funny...
How about Pidgin? It's a relatively popular open source project (I use it all the time) that is fraught with (in my opinion anyway) lots of usability mistakes, both minor and significant.
Usability reviews are ALWAYS useful, as well as being better than nothing.
Do I know actively developed open source projects with poor usability? can fish be shot in a barrel? :D look at the big projects. there's always lots of controversy about them (especially their versions for osx, since osx users tend to have a higher standard). I'd suggest gimp as the prodigal one, but I hear they're making great strides there. or maybe pidgin? I use the os x version (Adium) and the windows one and the contrast is brutal.
that said, the big projects probably won't really care about your input. some of the devs might pay attention, but as a whole, you probably wont steer that titanic unless they've already been spending a lot of time talking about this.
my advice? go on an ubuntu forum and ask the users there what they hate the most about their software. that'll give you good feedback because ubuntu is heavily used, which generally means there's going to be a conversation about this.
either way, if you want to see your recommendations implemented, you'll have to open up a dialog with the devs. you'll need at least one that believes in your cause to implement your thoughts (it may not be merged into the main trunk, but it'll at least be implemented in his branch)
good luck!
I have no idea whether they'd accept your input, but I think it would be interesting to compare KDE version 3 and 4. As a developer, I find version 4 all but unusable (and am switching to Gnome as a result). However, for the vast majority of users, their "award-winning" changes may have been an actual improvement.
If you want to see your changes implemented, be really sure to approach only projects with a high activity rate and people prepared to invest some serious time - you will need very motivated developers if you want to see (possibly fundamental) changes implemented. No matter which project you choose, be prepared for a lot of sometimes tooth-grinding work.
When thinking about web apps, Wordpress comes to mind. The back-end is crap (even though a lot of effort is being put in it), I hear people everywhere complaining about it. It is a very big name which is good for you and the probability to see suggestions actually implemented.
I recommend RIDE -- and IDE for developing robot framework tests. This tool is fairly young and has many classic mistakes, a few good features, and some good ideas with weak implementations. I think it would make an excellent candidate for a usability review.
I make this suggestion not because I want to point out the flaws in RIDE (after all, I was a developer on that project for a short period of time so it might show off some of my flaws), but because I think a) it has the potential for the study to help improve the product, and b) I think the tool makes some common mistakes you and your group could learn from.
It also has the advantage of being cross platform, so it should be suitable no matter what platform you're interested in.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 years ago.
Improve this question
We have a series of closed source applications and libraries, for which we think it would make sense opening up the source code.
What has been blocking us, so far, is the effort needed to clean up the code base and documenting the source before opening up.
We want to open up the source only if we have a reasonable chance of the projects being successful -- i.e. having contributors. We are convinced that the code would be interesting to a large base of developers.
Which factors, excluding the "interestingness" and "usefulness" of the project, determine the success of an open source project?
Examples:
Cleanliness of code
Availability of source code comments
Fully or partially documented APIs
Choice of license (GPL vs. LGPL vs. BSD, etc...)
Choice of public repository
Investment in a public website
There are a several things which dominate the successfulness of code. All of these must be achieved for the slightest chance of adoption.
Market - There must be a market for your open source project. If your project is a orange juicer in space, I doubt that you'll be very successful. You must make sure your project gets a large adoption amongst users and developers. It is twice as likely to succeed if you can get other corporations to adopt it as well.
Documentation - As you touched on earlier documentation is key. Amongst this documentation is commented code, architectural decisions, and API notes. Even if your documentation contains bugs, or bugs about your software it is ok. Remember, transparency is key.
Freedom - You must allow your code to be "free" - by this I mean free as in speech, not as in beer. If you have a feeling your market is being a library for other corporations a BSD license is optimal. If your piece of software is going to run on desktops then GPL is your choice.
Transparency - You must write software in a transparent environment. Once you go open source there is no hidden secrets. You must explain everything you do, and what you are doing. This will piss off developers like no other
Developer Community - A strong developer community is required. This must be existing. Only about 5% of users contribute back to the project. If someone notices there haven't been any releases for a year they wont think "Wow, this piece of software is done," they will think "developers must of dumped it." Keep your developers working on it, even if it means they are costing you money.
Communications - You must make sure you community is able to communicate. They must be able to file bugs, discuss workarounds, and publish patches. Without feedback, it is pointless to opensource the project
Availability - Making your code easy to get is necessary, even if it means pissing off lawyers. You have to make sure your project is easy to download, and utilize. You don't want the user to have to jump through 18 nag screens and sign a contract in order to do this. You have to make things simple, and clean
I think that the single most important factor is the number of users that are using your project.
Otherwise its just a really well written, usefull and well documented bunch of stuff that sits on a server not doing very much...
To acquire contributors, you first need users, then you need some incompleteness. You need to trigger the "This is cool, but I really wish it had this or was different in this way." If you are missing an obvious feature, it's extremely likely a user will become a contributor to add it.
The most important thing is that the program be good. If its not good, nobody will use it. You cannot hope that the chicken-and-egg will reverse and that people will take it for granted until it becomes good.
Of course, "good" merely means "better than any other practical option for a significant number of people," it doesn't mean that its strictly the best, only that it has some features that make it, for many people, better than other options. Sometimes the program has no equivalent anywhere else, in which case there's almost no requirement in this regard.
When a program is good, people will use it. Obviously, it has to have a market among users--a good program that does something nobody wants isn't really good no matter how well its designed. One could make a point about marketing, but truly good products, up to a point, have a tendency to market themselves. Its much harder to promote something that isn't good, so clearly one's first priority should be the product itself, not promoting the product.
The real question then is--how do you make it good? And the answer to that is a dedicated, skilled development team. One person can rarely create a good product on their own; even if they're far better than the other developers, multiple perspectives has an incredibly useful effect on the project. This is why having corporate sponsors is so useful--it puts other developers' (from the corporation) minds on the problem to give their own opinion. This is especially useful in the case that developing the program requires significant expertise that isn't commonly available in the community.
Of course, I'm saying this all from experience. I'm one of the main developers on x264 (currently the most active one), one of the most popular video encoders. We have two main developers, various minor developers in the community that contribute patches, and corporate sponsorship from Joost (Gabriel Bouvigne, who maintains ratecontrol algorithms), from Avail Media (who I work for sometimes on contract and who are currently hiring coders on contract to add MBAFF interlacing support), and from a few others that pop up from time to time.
One good developer doesn't make a project--many good developers do. And the end result of this is a program that encodes video faster and at a far better quality than most commercial competitors, hardware or software, even those with utterly enormous development budgets.
In looking at these issues you might be interested in checking out the online version of a course on open source at UC Berkeley, called Open Source Development and Distribution of Digital Information: Technical, Economic, Social, and Legal Perspectives. It’s co-taught by Mitch Kapur (Lotus founder) and Paula Samuelson, a law school professor. I have a long commute and put the audio of the course on my iPod last year – they talk a lot about what works, what doesn’t and why, from a very broad (though obviously academic) perspective.
Books have been written on the subject. In fact, you can find a free book here: producing open source software
Really, I think the answer is 'how you run the project'.
All of your examples matter, yes, but the key things are how the interaction between developers is managed, how patches etc are handled/accepted, who's 'in charge' and how they handle that responsibility, and so on and so forth.
Compare and contrast (the history isn't hard to track down!) the management of the development of Class::DBI and DBIx::Class in Perl.
I was just reading tonight an excellent post on the usability aspect of successful vs unsuccessful open source projects.
Excerpt:
A lot of bandwidth has been wasted arguing over the lack of usability in open-source software/free software (henceforth “OSS”). The debate continues at this moment on blogs, forums, and Slashdot comment threads. Some people say that bad usability is endemic to the entire OSS world, while others say that OSS usability is great but that the real problem is the closed-minded users who expect every program to clone Microsoft. Some people contend that UI problems are temporary growing pains, while others say that the OSS development model systematically produces bad UI. Some people even argue that the GPL indirectly rewards software that’s difficult to use! (For the record, I disagree.)
http://humanized.com/weblog/2007/10/05/make_oss_humane/
Just open-source it. Most probably, nobody will start contributing yet. But at least you can write on the press-releases that your product is GPL or whatever.
The first step is that people start using it...
And maybe then, after users get comfortable, they will start contributing.
Everyone's answers have been good so far, but there's one thing missing and that's good oversight. Nothing kills an open source project faster than not having some sort of project management. Not to tell people what to do so much as to just add some structure and tasking for the developers you are hoping to attract.
Disorganized projects fall apart fast. It's not a bird you just let go and watch it fly away.