I often develop an application entirely myself. But did I really?

I feel strange about that claim and never know when that is true.

I mean I designed it, coded it, but I used XYZ plug-in. Can I still claim that I did it all myself even though I didn't create the plugin I used?

Consider this conversation?

ME: I designed and developed this app entirely myself.

Other: Cool, how did you program XYZ part?

ME: I didn't program that part I used XYZ plugin.

Other: So you didn't really program it ALL yourself than did you?

I mean if I must give them credit for the plug-in I used, then do I have to give the language authors credit for the language I used and the IDE authors credit as well? Where do I draw the line?

This is just something that always crosses my mine as soon as I am about to take full credit for a project, and was wondering others opinions on the matter.

  • Did you write the interpreter/compiler yourself? Probably not. Using libraries is so common that its acceptable to me for taking credit. Sep 14 '10 at 18:56
  • When you say "plugin" do you mean dependency or some helping IDE plugin?
    – TheLQ
    Sep 14 '10 at 21:33
  • @THELQ I meant like a control, like the jquery-ui.
    – JD Isaacks
    Sep 16 '10 at 13:06

That depends on what "XYZ part" does. Most code libraries are pretty modular things that take care of one simple task. Even if someone else designed that, you're the one who integrated it into the overall vision of what your program is supposed to do.

Unless the third-party code takes care of a major part of the application logic itself--for example, building a video game on top of an existing engine--it's just a component. Saying that you didn't really build the program yourself because you used third-party controls is like saying that you didn't really build the house yourself because you bought premade nails, boards, drywall, wiring, etc...

  • To be fair, if I buy pre-fab shack and attach it to the side of my house with some bolts, I can't really take credit for building it can I? I'm not disagreeing with you, but simply trying to highlight some of the gray area in your argument. Sep 14 '10 at 19:17
  • @Nathan: Yeah. Like I said, it depends on what (or how much) the third-party code does. Sep 15 '10 at 0:16

Fundamentally be honest - at the end of the day you put the site or the app together so you can take credit for the end result as ultimately you did build it.

If you used a plugin you deserve credit for being smart enough to find and to know to use the plugin but in my case I do acknowledge (in some cases make a point of acknowledging) that there are tools that make it easier (possible even) to achieve the results I've achieved.

Take jQuery and jQueryUI for example - it makes some things very easy so if you use it then say so but its not the app and sometimes you have to work to wire it in right and get the app, as a whole, to do what is required. So I don't expend effort on a datepicker but I do then have to expend effort combining a number of controls on a page (that includes a couple of text boxes with attached date pickers) to produce a more complex interaction. The interaction was me, I'll take credit, the datepicker wasn't.

One last thought:

  • The end user usually doesn't care so long as it does what they need - if you've delivered that you get the credit.
  • Other devs will either know what you're using and will appreciate that you're smart enough to use the right tools for the job or won't and will appreciate learning about new toys to put in their toolbox. In both cases give credit (for the plugin) where due 'cos that will get you appropriate respect from your peers.
  • +1 for "The end user usually doesn't care so long as it does what they need - if you've delivered that you get the credit."
    – TheLQ
    Sep 14 '10 at 21:32

In a professional, work-for-hire or contract job, a client that cares about how each specific part was implemented and who implemented it is not a very good client. If you used a plugin in accordance with its license, there's no need to specifically state "I didn't really do the whole project because I didn't personally do X, Y, and Z."

If a client is interested in talking shop about the project, that's fine: I generally say things like "I pulled together a bunch of different things to get the final result you were looking for."

Otherwise, it's not the client's place to ask who did what specifically: it's not middle school where a teacher needs to make sure you didn't plagiarize your book report. A client needs to implicitly trust that you've done your job adequately and be able to determine that by the final product.

I should note that if the implementation details are a selling point, by all means tell them. When I use an open-source project as a base, I like to mention it as a way to convince the client they are buying something that'll be maintained even when I'm long gone.

I'd even extend the above to talking shop with friends, family, and peers. If you want to divulge what exactly you used, that's fine: it's just as fine to say it's a trade secret.

The only time you should feel obligated to give others credit is when the license demands it. Using gcc doesn't mean you need to put it in your acknowledgements, but if you use something that's CC-BY licensed, you must.

Beyond that, acknowledge things that you feel are worth acknowledging: I would limit to things that really stood out as giving you a leg up and you want to inform others that they should use it too.


In casual conversation, just say that you built it. Reasonable people know that you did not start out by making the CPU yourself from beach sand and force of will and working up from there.

In the thing itself, it's nice to give credit. In the publishing world there's something called a colophon, where you credit the tools and/or the people involved in printing, and that's a reasonable model for web sites. In movies and video games, you often see credits at the end. In desktop software, that info often ends up in an about box.

However you do it, it's pretty easy to tell your fellow craftspeople what you used and who helped. Few actually care, but those who do care a lot, so I think it's worth it.


It depends how big a portion the plug-in is. If its a little corner piece or a control in a web page, then I would say its your application. But if its only a page to host a plugin control, where nearly everything is in the plug-in you didn't write, then, well, the plugin author(s) deserve most of the credit.


As @Murph said, the end user doesn't really care what plugin you use, as long as it works and does what they want it to do. Only if the dependency did more than 50%, like a game engine or drag and drop IDE, should you quote the source.

On the developers/source code side, I would say that just the existence of the dependency (jar, dll, do, [insert your language dependency file type]) is giving enough credit. You might offhand mention "Thanks to X, this class was so much easier to write", but such a comment is entirely optional. If the dependency exists and is named the name of the dependency, your quoting the source. And when you import it into your current file, its also quoting the source.

So don't worry about quoting what you used, you are perfectly fine now.


If most of your application will function with just the plugin and not your code, give the plugin credit. Otherwise, I would only mention it if asked or I liked the pluggin so much that I wanted to promote it to other developers.

Not the answer you're looking for? Browse other questions tagged or ask your own question.