I am a beginner in computer programming with C/C++. I have previous experience in programming for the web. There is some confusion that I am having with the software development process in desktop applications.
Web applications are easy to upgrade because it is basically a bunch of source files, but I have a question about desktop applications. The major thing I notice about desktop applications is that they are released in different versions. This requires the user to go through the uninstall/re-install process in order to obtain a newer version of the software.
In C/C++ software for various platforms, how would a programmer implement an “upgrade” option that would allow a user to update an already installed application without having to go back to a website. How hard is it to upgrade an executable file on platforms like Windows and Linux. I understand that the process may be different for different platforms.
Say, for example, I have a desktop application (version 1) that the user has already downloaded and installed onto their own PC. After a while, I make some changes to the software and make improvements that the user would want applied to their software. The user has made customizations to the software, but would like to upgrade to version 2 without having to re-customize their application all over again. Originally, I thought that an “upgrade” feature would replace certain parts of an executable file, but is that really what you would have to do?
My main question is: How exactly would someone go about accomplishing this “upgrade” process? Is it possible?
6
Upgrading software which is packaged is complex and is best done with a software installation tool. This is a classic case of build vs. buy. You couldn’t build something yourself that does the job of InstallShield, for example.
Upgrading software which has been customized is a very tricky proposition. In general this is next to impossible to do in an automated way.
If you knew in advance that some kinds of customization needed to be supported, you could architect your application to have features that are modular in nature. Perhaps a plugin architecture or some method of table driven logic configuration. In this kind of scenario you can automate the replacement of your application’s core without disturbing the modules or data stores that contain the customizations.
This type of customization must necessarily be limited in nature. Some kinds of changes that you might eventually want to make to your core application are bound to break even the most carefully planned and isolated user configurations/customizations.
If you build package software and also perform customizations on that software, then you are sooner or later going to have to either branch your code and let some customers live with the old version or you’re going to have to reapply some customizations. Just ask anybody who has bought a major ERP like SAP.
2
You are probably using customized in a wrong way. The desktop application (coded in C++, and distributed as a packaged binary executable) has not been customized, but user configured.
Customizing a desktop application means that some developer (internal to -or subcontractor of- the company where that application is used) has gotten, studied, and improved the desktop application’s source code. This is uncommon and very costly.
You should ensure that the user configuration (e.g. preferences) are compatible from one version to the next (perhaps by having a functionality to transform that configuration).
Some (rare) applications indeed can be “customized” thru plugins (on Linux the application would dlopen(3) some shared object at runtime, during startup). If your application can have plugins, the plugins need to be written by a professional programmer (not by the random user), and you should have carefully designed and documented a good plugin interface. If you change that interface old plugins won’t work with newer versions of your software.
Other applications embed a scripting language interpreter (like e.g. Lua or Guile). This is a very strong design decision and you should decide that before even starting coding your application.
Upgrading a software while it is still running is a research subject (and is never done for desktop applications). Read about persistence, continuation, calll stack, software package…
Notably on Linux, study the source code of some free software applications. It will teach you a lot.