For your proprietary projects at work?

Problems I can imagine are: more dlls (can be a problem when for example you have to include a big DLL but you only need few functions in that library), a lot of license statements you have to take care of when releasing your product, the reliability of the library, etc.

Any other potential problems? What is your opinion? (info: I'm using .NET at work)

closed as primarily opinion-based by user40980, Ixrec, user53019, durron597, ratchet freak Apr 24 '15 at 15:40

Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise. If this question can be reworded to fit the rules in the help center, please edit the question.

  • 3
    The "more DLLs" bit depends a lot on what you're doing, but many free third party libraries are available in source form, and can be statically compiled into your application if needed. License restrictions may be a big issue if you intend to sell your software as a closed source product - check the license terms before you start using a particular library. Another significant issue may be management perception of the quality and availability of support for those libraries. Usually this is pretty good, but a mature library may not need lots of updates, so may seem abandoned. – Steve314 Dec 23 '10 at 4:06
  • 1
    @steve: you could also make that an answer, I suppose – Louis Rhys Dec 23 '10 at 6:02
  • 1
    ALWAYS check the license terms before using any third-party code. The advantage of Free/Open Source software here is that they use a limited number of licenses, most of them discussed in various places, so you can familiarize yourself with each, and come up with a list of acceptable licenses. – David Thornley Dec 30 '10 at 16:37

Why you should always consider an existing library over the complete rewrite your fellow developer is proposing, usually because it will be “better”:

  • Authors are experts in the domain covered by the library. This ensure that you will get perfect implementation. A good example is SharpMap. The authors are experts in geospacial softwares.

  • They will be more stable than your own as it is used by hundred if not multiple thousands of other users. You will certainly encounter problems, but most of them have already been encountered by others and fixed by authors. If they don't fix them, it's a good opportunity for you to contribute!

  • You will learn from others code or design. Many popular libraries are written by top notch developers and usually put in light good coding practices and design. You will learn by using them.

  • Save tons of money. The equivalent of hundred if not thousands man days of work for free or at the very worst one man day.

  • Get premium support. Paid libraries usually comes with free support from top notch developers you can contact 24h a day. Many developers of free libraries also provide that level of support. Exposing your team to those developers with be beneficial for them.

  • New features will appears automatically without efforts in your product. If you are using the reporting engine from vendor X, and vendor X releases the new feature Y. You will be able to provide that Y feature to your customer at no cost, with very low effort. You can then consider the authors of your libraries as other teams working for you, for free or very little money!

Unless your are an expert in the domain, you have thousands of users, you have nothing to learn from otehrs, you have tons of money, you don't need any support and you have plenty of resources, there is no reason to reinvent the wheel.

In response to Lenny's comment below, I will use this fact: when reporters asked Shepard what he thought about as he sat atop the Redstone rocket, waiting for liftoff, he had replied,

The fact that every part of this ship was built by the low bidder

Do you think NASA would have been able to send men to the moon if they tried to build the components of their rocket themselves?

  • and to think I've never used a library (in Java) in my life. shudder – test Dec 23 '10 at 9:24
  • 9
    The more code you use, the more things can go wrong. If you use third-party code, it's code that in theory you don't need to write/extend/fix yourself. Problems might get nasty when bugs are not fixed because those people don't care about your version of operating system, tool chain or they are not available to them. – LennyProgrammers Dec 23 '10 at 9:31
  • @Lenny: I edited my answer and added some historical fact I like – user2567 Dec 23 '10 at 9:43
  • 3
    @Pierre 303: The lesson from the NASA story is that NASA developed and applied their own methodological rigor to verify the low bidder's work, to the point that it is good enough for a manned test flight within their acceptable risk. (And they started the half-century pursuit of "methodologies") At that time such rigor was possible on a national scale of patriotism, but nowadays it is commercially out of reach of many software companies. – rwong Dec 24 '10 at 17:12
  • 2
    -1 for beeing so single-edged. All your points are correct, but your answer completely ignores that there are lots of situations where it is better not to use a third-party library. – Doc Brown Oct 2 '13 at 16:30

Use libraries that are stable. What would the alternative be anyway? Rewriting the code from scratch?

  • "Stable" is often not enough; don't forget that safety of investment may be at least equally important. – Doc Brown Oct 4 '13 at 8:39
  • Stable is often in the eye of the beholder. When the 3rd-party lib crashes because your particular use case is not covered by any one of the (hopefully existing) test cases and thus nobody spotted the bug, you got a problem. The fact that it was declared "stable" will not help you much. – JensG Nov 3 '13 at 16:43

IMO third party libraries are very good thing, but I have a rule that can use only libraries that have source code. On my previous job we used Delphi and that policy saved our butts so many times since many Delphi 3rd party vendors went out of the business, you never know.

  • One one project, we used Oracle's OCCI (their C++ database interface). It was very nice, but since there was no source available we were very restricted in the exact platform we used. We had to abort a promising move to openSolaris because Oracle's Sun compilation used the older libraries rather than stlport. If we'd had source available, we could have attacked our performance issues partly by using better compilers. – David Thornley Dec 30 '10 at 16:35
  • +1, having the source is one good way of assuring the safety of investment. – Doc Brown Oct 4 '13 at 8:41

It's good as long as you have good management on it. As you concern, it may take time to harness other works, and bad libraries sometimes even produce unexpected results.

I try to use the popular library that have a huge community. So when there's a problem, I can ask provider/other users for support.


Using 3rd party libraries is almost always a good thing. But sometimes, when I would only need one little helper method, I look at how the 3rd party lib implements it, and then implement it myself to limit dependencies (if I'm allowed to do so).


The obvious answer is that you should use library. It should almost be your default answer to that question. What you should really ask if whether you need to do something by yourself instead. Reasons where it may make sense:

  • it is doing something that fits right into your core competence as a company
  • it is crucial to your company (no replacement, very central to what you do)
  • you actually have the time to do it
  • none of the existing library does what you need as you need it (not fast enough, requires too much memory, etc...)

It is a sign of bad programmers to think those reasons almost always apply, especially the last two ones. They actually almost never apply.


It's rare, but there are situations, when you can't install 3rd party libraries, or even if it would be comfortable/effective. I think, it's a good design issue to isolate the part of the project, where libs can't be used.

We're developing a home aut. system, where the back-end is running on small Linux machines. In this environment we can't use the usual Linux goodies, as Apache, MySQL, PHP, or smart libraries. Our home aut. server uses only stdlib, pthreads and optionally Alsa. We have to compile to ARM, PPC, AVR, MIPS and other non-X86 systems, which are sometimes extremly restricted.

So, we've made the following design decisions:

  • The functionality of the server should be minimal. The most complex function of it is a simple webserver, which can provide files and 2 type of AJAX request. The server is modular, the components are very small. We use dataflow architecture, which makes it possible.
  • The developing environment for the server is complex. We have 2 extra layers - a configurationa and a dataflow layer - before the GNU toolchain. Using buzzwords, I should say that we moved the complexity from run-time to compile-time. We have no limits when we prepare and compile stuff, e.g. our dataflow compiler is written in PHP - it's not optimal, but we don't care, it produces the appropiate result. Also, configuration tools are written in JS-AJAX/PHP, earlier we used Excel(!) to quickly set up a configuration.
  • The UI is an AJAX-based WebApp, where we have no limits again. The UI sends only atomic requests to the server, all heavy stuff is done by JavaScript. Also, we use a JS framework (DomAssistant).

So, from the 3 subsystem (server, toolchain, UI) only the server is where we can't enjoy the richness of libraries and platforms.

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