“usability” != “design”; design is about creating something useful (and/or pretty), whereas usability is discovering how well something works — usability tests are useful to see if a design works, but usability test alone usually won’t point a way to fix issues… design helps fix problems after they’re discovered, and helps to prevent problems in the first place

a lot of designers are quite tech-savvy (especially us designers already in the open source world), but many aren’t — regardless, it’s okay to not know everything (especially about programming corner-cases or project-related esoterica)

think about the people using the software as people using the software, not as “users” (using the term “users” is degrading (similar to “drug ‘users'”) and sets up an “us-versus-them” mentality)

If you want an offline map on an Android phone, I suggest opening up the KML file with Maps.Me (proprietary OpenStreeMap-based app, but nice) or the GPX on OSMand (open source and powerful, but really clunky).

You can also use the Google Maps Engine version with Google Maps Engine on your Android phone, but it doesn’t really support offline mode all so well, so it’s frustratingly unreliable at best. (But it does have pretty icons!)

“Patches accepted.” It’s one of the most offensive things you can say to people who genuinely want to help with your project.

Why you should reconsider using the phrase

Not everyone is a programmer. Even those of us who do know how to program might not meet your expectations, and we would likely waste hours (or sometimes even days) writing and formatting a patch exactly how you might like it. And even then, we might be rejected again and again.

Instead: You, an expert programmer, could spend a little bit of time to thoughtfully discuss an idea and possibly consider implementing it. All of us who are better at things other than programming could possibly help you out in other ways too.

The pain of perfect patches

Developers often assume everyone should write perfect code in their project’s language, to their coding style (tabs? spaces? how many spaces? K&R? KNF? how many comments? what types of comments?). Thinking that everyone will send you free code exactly how you like it is not only arrogant; it dismisses other contributions.

Software is much more than the code that goes into it

Contribution is more than just patches; design, documentation, marketing, translation, localization, security audits, testing, discussion, and advocacy all are crucial for software to be good software.

“Patches welcome” ends any kind of meaningful discussion for potential other contributors.

Simple solutions: words & phrases

The words we all use matter. There are often special meanings in phrases we choose.

“Contributions are appreciated” is much better phrase to say than “patches accepted”. It’s not only what you say, though — it’s also what you mean, and we all need to shift our mindsets too.

The differences can be summed up simply:

Be inclusive — people can help out in many different ways.

Be thankful — everyone’s time is valuable, and they could choose to spend theirs doing something else entirely. Instead, they decided to talk with you and spend a bit of their time on your project, to try to help.

Community participation is not only about code.

Sometimes you simply can’t work on an idea or fix a bug in your project due to various constraints, such as lack of time, being sick, or even a lack of skill. That’s okay; everyone has moments like these. If you’re up-front with people, they will likely understand and may think of you and your project more highly with the explanation. (Every once in a while, someone else may even see that there’s help needed and jump in because of your pleasant conversation too.)

Conclusion

If initial conversations are handled correctly, it could be the start of a beautiful symbiotic relationship to make your software better.

I was on a call the other day where someone told me that they wouldn’t ever give me negative feedback. I replied: “No! Please give me negative feedback, especially if it’s constructive. Tell me when what I do sucks. If you can, please tell me why it sucks too. If it’s good or great, tell me about that too. Please let me know what you think.”

After working in the FOSS community as a designer for a decade and a half, one must have a thick skin. Us designers often produce highly visible things, sometimes with controversial ideas (sometimes for bad, sometimes for awesome).

I hope all of us in the community can work together and be respectful of each other enough to say when things produced (designs of any sort, code, documentation, etc.) might be good or bad… and also have the courtesy to point out why we hold whatever opinion we may have.

It’s important to have some respect for people when doing this. Even the most awesome people produce the worst ideas sometimes, and that’s fine. It’s all on the path to working together to make things better. We need to foster open communication whenever we can and separate the design from the designer, the code from the coder, the writings from the writer, the managing from the management, etc.

In other words, attack stuff within reason (either with negative feedback or attacks of awesomeness) and elaborate, but be careful not to hurt each other.