187
votes
Why do library developers deliberately break existing code?
A major version upgrade literally means they intend to break things. You shouldn't upgrade to a new major version unless you're prepared to deal with it. Most build systems have a way to specify you'...
- 148k
94
votes
Accepted
How to deal with fear of taking dependencies
... We are forced to stay on the lowest API level of the framework (.NET Standard) …
This to me highlights the fact that, not only are you potentially restricting yourselves too much, you may also be ...
- 39.4k
89
votes
Accepted
PM opting for an overly-complex setup which nobody has experience with
Once we were halfway the project, the PM stated we had to use third party message queue capabilities instead of threads and had to implement load balancing
This isn't an appropriate thing for a PM to ...
- 26.8k
55
votes
Why do library developers deliberately break existing code?
My point, and question, is: Why do library developers knowingly break existing code like this? Why not at least have it default to either true or false, whichever is the most reasonable?
Because ...
- 54.9k
51
votes
How to deal with fear of taking dependencies
We are forced to stay on the lowest API level of the framework (.net standard). The reasoning behind this is that a new platform could one day arrive that only supports that very low API level.
The ...
- 1,747
30
votes
PM opting for an overly-complex setup which nobody has experience with
What would be stupid is to let yourself get death marched.
What you are describing is that you've lost critical feel. There is no sense of control and no clear way back to it.
The last thing you ...
- 112k
21
votes
Accepted
If there are two ways of approaching a task, how should one choose between them?
You perform a cost/benefit analysis on each of the approaches, and choose the approach that has the highest overall benefit/cost ratio.
In the case of competing libraries that perform essentially the ...
- 200k
18
votes
If there are two ways of approaching a task, how should one choose between them?
As an addendum to Robert Harvey's excellent answer, here my 2 cents:
Pick the one approach which appears to be the least effort to start with, but make sure you keep the door open for switching to a ...
- 212k
16
votes
Accepted
Why are developers still using proprietary third-party libraries?
Three obvious reasons:
There's no open source equivalent,
The company wants paid-for support that they can rely on.
They are a bit behind the times and do not yet trust open source libraries.
- 39.4k
16
votes
Accepted
How do I handle malformed compressed input data, which crashes external library?
If you are going to use a native library which might crash (regardless whether the input data is malformed, or that library has a bug), the only safe way to prevent your own application against being &...
- 212k
12
votes
Why do library developers deliberately break existing code?
Some good answers already, however, let me add my two cents from some real-world experience.
More than often, though usually acting in good faith, some API designers are pretty ignorant what kind of ...
- 212k
11
votes
What to do when third party won't fix bug
This is one of the drawbacks of using third-party libraries: as you get more and more dependent of them, you're at the mercy of the company which develops those libraries. Not only they can set the ...
- 136k
11
votes
How to deal with fear of taking dependencies
On the whole these things are good for your customers. Even a popular open source library might be impossible for them to use for some reason.
For example, they may have signed a contract with their ...
- 78.6k
10
votes
PM opting for an overly-complex setup which nobody has experience with
This should really be on workplace.stackexchange.com, because the problem is not really a software development question, but about workplace relationships.
If you are sure that your simple approach ...
- 46.7k
10
votes
How can I reduce the manual effort for wrapping third party libraries with a larger object model?
Don't unit test that code. Write integration tests instead. In some cases, unit testing, mocking, is tedious and painful. Ditch the unit tests and write integration tests that actually make vendor ...
- 11.7k
10
votes
What is the correct way of adding third-party code into a C or C++ project?
@17of26 gave a lot of good reasons why #2 is dangerous, and why #1 makes more sense. But I think there is one thing missing, for which I recommend the following:
download the code of the library you ...
- 212k
9
votes
Accepted
How do open source libraries like Apache Commons fit into the microservices architecture?
It's about libraries created by you to share common functionality when you're trying to avoid rewriting the same code in your multiple microservices. It creates a situation where you have a (loose) ...
- 1,960
8
votes
Accepted
How do you use external libraries in git?
Adding a library in your git repo would make you a maintainer of another version of the library. You want to avoid that as much as possible.
Depending on the library and the target OS, the most ...
- 2,601
8
votes
Accepted
Need to call private method in third party library. Copy all class or use reflection?
If the functionality is not part of the library's API, you shouldn't use it. There's no guarantee it will still be available in future versions, and that it won't change. So using reflection to access ...
- 135k
7
votes
How can a programmer know whether he has to program a method or search for it in a library?
Search the official Java documentation.
No luck there? Then go to Stackoverflow and enter [java] Thing I want to do into the search bar. The most upvoted answer to the first question you find will ...
- 23.4k
7
votes
Accepted
Put source code for dependencies within the project itself
Yes, this is called bundling. It has known weaknesses (for instance, you don't get security updates or bugfixes for the third-party library unless you re-import their sources, and it is probably more ...
- 110k
7
votes
How to deal with fear of taking dependencies
Short answer is that you should start introducing third-party dependencies. During your next stand-up meeting, tell everyone that the next week at work will be the most fun they have had in years -- ...
7
votes
Accepted
Best practice for storing third party tools
It makes fully sense to store and keep installers of any third party tools you are using in your development process (not just your build process) in a location under your control. It does not matter ...
- 212k
7
votes
Accepted
Software Design: Decoupling when highly dependent on a third party library
heard that coupling is a bad thing and should be avoided as much as possible
I think this is overly dogmatic.
In some cases it makes more sense to just accept the tight coupling. This is especially ...
- 5,880
6
votes
Accepted
Should you include libraries and code-unrelated files in your git project and upload them to Github?
As a rule, you should list somewhere the OS, compiler version, tools that I need to run your code, and then I should be able to clone your repository, follow your build instructions, and be able to ...
- 46.7k
6
votes
What is the correct way of adding third-party code into a C or C++ project?
You always want to package any dependencies with your project.
Your software is going to be built and tested with a particular version of a specific library. It's not guaranteed to work with any ...
- 4,829
6
votes
Accepted
Should we include the entire sources of the libraries used in our project?
Putting the entire source of a library in your project allows you to:
Maintain and update the library in the event that it is abandoned.
Make alterations to the library to advance goals for your ...
- 200k
5
votes
Accepted
How can I reduce the manual effort for wrapping third party libraries with a larger object model?
Assuming you're not looking for a mocking framework, because they're ultra-ubiquitous and easy to find, there are a few things worth noting up front:
There is "never" anything you should "always" do....
- 15.2k
5
votes
How to VCS a large-scale, “atomic” refactoring?
Splitting a large commit in those squashed single-use commits won't matter from the point of view of downstream merge conflicts - since they're squashed they'll still appear as a single large commit ...
- 887
Only top scored, non community-wiki answers of a minimum length are eligible