

Ask HN: How to ignore guilt while using open source code? - realrocker

Whenever I want to use an open source code(marginally non-trivial functionality, properly licensed), I have this irresistible feeling of guilt and shame. There is something in my head which says, "This code is easy. You are a cheat for using such a simple code. You should write your own". But then I remember the advice of more experienced programmer's about code reuse and focusing on unsolved problems. Even right now, I am in an internal strife between writing my own or using an existing solution. Why do I feet guilt? And how do I completely ignore it?And should I ignore it?
======
Rk0bizaN
Is your identity wrapped up in being a super-competent programmer who can do
everything by himself?

<http://www.paulgraham.com/identity.html>

I can suggest three approaches to not feeling guilt over using other people's
code:

1) Get "writing difficult programs" out of your system by writing some really
difficult programs. Don't let it contaminate your more practical work.
Optimize separately.[1]

2) Notice inconsistencies related to the guilt - can you do more good in the
world with the time and money saved by reusing existing code? Know the
concrete thing you're trying to achieve, and remind yourself of it when you
feel guilt over trivial things. Another inconsistency: you probably don't feel
guilt over using Intel processors or Linux or all the amenities of
civilization.

3) The nuclear option - hundreds of hours of meditation. If you can notice the
guilt over and over again, or repeatedly ask yourself _who_ is feeling the
guilt, you are almost certain to attain mastery over these unwanted thought
patterns. See [2]

[1]
[http://lesswrong.com/lw/6z/purchase_fuzzies_and_utilons_sepa...](http://lesswrong.com/lw/6z/purchase_fuzzies_and_utilons_separately/)

[2] [http://sharanam.tumblr.com/post/865951869/kenneth-folk-a-
sys...](http://sharanam.tumblr.com/post/865951869/kenneth-folk-a-systematic-
approach)

~~~
realrocker
You are making a lot of sense. Especially "writing difficult programs" out of
your system". I am going to attempt this. Thank you.

------
greatergoodguy
I don't feel guilty using open source code. I have more confidence in using
code that has been battle-hardened and there is more time saved. And since
it's open sourced, if something doesn't work right, I can go in and fix it.
I'm a results driven guy. I care about getting quality results. Perhaps you
are more into coding for the sake of coding?

------
csense
You should be optimizing for value produced per programmer-hour spent. If an
open-source solution lets you do this better, then go with it; if it doesn't,
then don't.

Note that "value" may be different for different situations.

* If you're writing code for a bootstrapped one-person startup, i.e. this is a software product, website, or service that you're going to sell, then you would probably measure value as expected profit.

* If you're writing code as part of your job, you should probably be trying to maximize the things that the software's supervisor(s) / user(s) want the software to do. This is usually (but not always) aligned with expected future profit/revenue for the business.

* If the project is a learning experience to improve your own understanding and capabilities, then you should seek out unfamiliar technologies and interesting problems, and not worry so much about polishing the rough edges.

------
dvt
That's like feeling guilt when hammering a nail because you didn't forge the
hammer or cast the nail.

Sometimes I also feel that way. But then I remember that I'm not writing a
data-structures library or ORM framework, I'm trying to build a product.

------
ksk
Sorry your guilt make no sense. If your goal is to write code then write code.
If you want to create something new/cool then do that. Goals and means are two
separate things.

------
_mpf
Open Source is designed for re-use, you also can give something back. It could
be a code, documentation or support for community in any valuable means.

------
bmelton
Everybody's nailed everything I already wanted to say, except for this... if
you make improvements, send back a pull request.

There's absolutely no shame in using battle-tested code that somebody else
wrote. If you really do experience guilt though (you shouldn't), the easiest
way I can think to mitigate that is to just promise yourself to contribute any
improvements you make, and don't worry about whether or not those improvements
are accepted.

------
6d0debc071
You can't really cheat unless there are rules.

As for not feeling guilty, maybe you should give something back to the
community? Work on an open-source project or something, maybe?

Or maybe you can put it on the same level as something you're happy with. Like
working with other programmers in your company, whose code you could probably
write.

~~~
realrocker
I do that. But I am not very regular. I should change that.

