Footnote if the Previous Footnote Is Exactly the Same and You Dont Want to Copy It Again

My initial machine included Microsoft visual C++ 2005 runtime (x64 and x86 on a window 7 64 fleck bone ?). Then on four/29/13 Microsoft added visual C++2008 (x64 and x86) so on 7/1/13 they added the visual C++2010 (x86 simply on 64 scrap bone arrangement??). Nosotros do non use this motorcar to program or for gaming. Information technology is used for email and equally a digital paper. None of the Microsoft visual C++ 2005/2008/2010(x86/x64) redistributable programs are listed in the programs list. So the question is do I really need the Microsoft visual C++ 2005/2008/2010 redistributable downloads??????

Yes, I'm sorry to say, yous probably practice.

When I started looking into this a little more securely on ane of my own Windows machines, I was pretty shocked to find no fewer than 59 different files all related to the Microsoft Visual C and C++ runtime. L-nine!

This is a symptom of a trouble faced by software vendors that, at information technology'southward core, is unsolvable in whatever pragmatic sense. The problem even has a name: DLL Hell.

Trying not to reinvent the wheel

The origin of the trouble is very unproblematic: programmers trying not to indistinguishable piece of work that'southward already been done.

For example, let'south say equally I'k working on a program, I write a little bit of code that does something moderately useful; perhaps it's a elementary role to catechumen all alphabetic characters in a string to lower example.ane It takes a cord of characters like "Inquire Leo!" and converts it to "ask leo!".

Information technology'due south not at all uncommon for many different programs to require that characteristic. Then rather than writing or including a case-conversion function into every program that might desire it, we package it up into what'southward chosen a "library". Any program that wants to convert a cord of characters to lower case simply uses this library part. The software developers don't accept to write, examination, and include their own version of that function.

The Microsoft Visual C++ Runtime is naught more than than a large collection of those kinds of functions. They're not nearly as simple equally only changing the case of characters in a string (though it is included), simply they are things that are very mutual to programs written in Microsoft Visual C++ (a programming language), specifically for Windows.

The idea is that by providing all this functionality in 1 package, programs are easier and faster to write, since they don't accept to duplicate all this effort.

And that much, at least, is by and large true.

Progress versus compatibility

Equally time goes on, several things happen:

• Programs change and meliorate in response to customer and market need.
• The software that those programs are built on – like Microsoft Visual C++ – are asked to alter and improve as well, to provide the functionality required to brand those customers and market place happy.
• Bugs (errors) are created and bugs are fixed.
• New versions are released.

In an platonic world, version 2 of a support library would work exactly similar version i, plus new and useful functionality.

Nosotros don't alive in an ideal world. In do, version 2 works mostly similar version 1, and has some new functionality.

What that means is that a program built (and shipped) using support library version ane might accept issues if that support library were updated to version 2.

The uninstall problem

In that platonic world – yous know, the one we don't live in – there would only exist ane re-create of the support library on each machine, and all the programs that needed it would use it. And, indeed, that was the original vision.

Only you know where this is headed: version changes turn out to exist a problem, because when a new version of the support library is released, information technology has to be installed in such a mode that it does not overwrite the previous version. Older programs that rely on the previous version continue to use that, and programs that are prepare for the new one use it.

Then far, so good. This manner you might accumulate unlike versions, just at least there would be simply 1 re-create of each version, which everyone who needed that version could share.

The globe turned out to exist even less platonic than we thought.

Consider this scenario: y'all install program "A" and it uses library version 1. You so install program "B" and it also uses library version 1, and then information technology doesn't demand to install it – it can just use the copy that's already in that location courtesy of program "A". Now you uninstall program "A". Three things can happen:

• It uninstalls the library because it installed it and it should clean upward afterwards itself, not realizing that some other plan relies on the library. Program "B" breaks as a result.
• It never uninstalls the library considering another program might be using it. Equally a upshot, libraries check in, only they never go out.
• Nosotros devise some method of tracking how many installed programs are using the library, and only remove it when the last one is uninstalled. Unfortunately, any single programme'south failure – be it a programming error or a failure to install or uninstall properly – breaks this technique. At all-time, you're left with copies of the library yous no longer need, and at worst, uninstalling 1 program can cause one or more than other unrelated programs to fail.

It'southward a mess. In fact, it's such a mess that most programs at present don't bother to attempt and share at all.

Putting your fate in someone else's hands

Ultimately, application vendors realized that past relying on shared libraries similar this, they were putting their fate into the easily of every other application that happened to use the same version of the same library. If but ane of them made a fault, and the library was accidentally removed or updated when it shouldn't have been, it put all the others at risk.

So, application vendors typically at present install their own copy of the library that they manage and that they can rely on. Disk space is cheap – much cheaper than the errors and frustration that were happening when they tried to share.

And so at present, on my machine, many different applications all behave with them their own copy of the Microsoft Visual C++ Runtime.

And each is more stable as a result, past virtue of being in control of their own destiny.

Versions, versions and versions

Ane of the well-nigh entertaining2 scenarios of this problem is that of large application suites. It's not at all uncommon for two things to be true:

• Even if the bulk of the suite is written for a 64-bit platform, in that location may still be 32-bit utilities included (which run just fine on 64-scrap operating systems). This ways both 64-bit and 32-bit versions of the runtime libraries need to exist included.
• Even if the majority of the suite is written for version "X" of the runtime library, there may nonetheless be portions that rely on version "Y", or even version "Z". Which ways that both or all three must be included, and possibly in both 32- and 64-bit flavors.

I practise want to be articulate that my 59 files were not 59 dissimilar copies of different versions of the same thing. My test was a quick scan for annihilation that looked similar a Visual C++ Runtime, and I'm certain I picked upwardly a few faux positives. But withal, checking for duplicate files showed that roughly half of the files were identical copies of ane another. (Every bit an aside, this is one reason duplicate-file finders can cause impairment – every bit we've seen, it is not safe to delete copies of things similar the Visual C++ Runtime out from underneath applications that installed them.)

Information technology could accept been improve, just information technology's not

I'm certain there are ways that this problem could have been approached differently from the outset. The fact that this isn't nearly every bit big a deal on non-Windows platforms is, perhaps, the single biggest indication of that. Those platforms either didn't try this type of code sharing, or do it in less interdependent means.iii

And while developers all the same benefit from not needing to re-invent the wheel each fourth dimension they demand information technology, they practice end up shipping and installing that wheel with every programme that needs it. They save some work by non starting from scratch each time, but your system becomes littered with different versions of (essentially) the same thing.

What we ultimately don't know is exactly the same thing those install and uninstall programs don't know: we don't know what'south safe to delete.

Thus the safest arroyo, by far, is to leave well enough alone and delete nix.

Podcast audio

1: Programmers, please rest assured that I know most things like lcase() and strtolower() and the existing functions to practice exactly this. I'm choosing a elementary example to make my indicate.
2: I chose "entertaining" over "depressing".
3: In other operating systems, the duplication of the content of those files is nevertheless there, it's just more than commonly carried around inside applications themselves.

moyercaltin.blogspot.com

Source: https://askleo.com/do-i-need-so-many-copies-of-the-microsoft-visual-c-runtime/

Share this post