Updatability is one of the most important aspects a Software. It is the core that creates good User Experiences for Web sites, but especially for applications. There are environments, types of apps and use cases where the different variations are good idea and some that are bad. You could read here some of the available options, ideas and some code implementations of software updatability.
Modes of updating:
- In the background
- with or without application restart
There are certain environments that the users may want to inspect and monitor every single small change. Many of them are software development related major changes in servers, databases, migrations, etc, but not only. Anything that is especially life or materially endangering, financially and mass and broadly affecting, should be changed after multiple deep analysis and verification by multiple individuals, before going to production – to the mass public.
When an update requires a change in the core of a software, in many places the recommended way is manually. This is especially true with application servers serving clients without a pause. One of the big ugly fame of Microsoft Windows was the need of – off and on again – after updates, because of frequent changes that are not applicable into the system without a restart.
The Script Based Application Languages are easier to update – because there is a need for just – swapping the files. The Systems that run endlessly are a little bit harder. The Java Programming Language had an OSGI Framework and it adds some frames to the code and logic organization in services, because it manages the class loaders internally and it needs to be able to swap implementations. There is also JRebel that has the Hot Swapping feature build into the JVM on a lower level. I’m not competent to say what is the condition for other Application Server Types of Platforms that handle requests with soft threads instead of processes.
The systems that have integrated automatic installation of updates are actually fulfilling the purpose of technology – to execute the work and minimize human labor. True actual independence from human rarely exists. Some input arrives from somewhere – either from sensors of the environment or from human interaction with a software and hardware – somewhere in the interconnected chain.
The move to cloud based systems has forced developers and all kinds of IT experts to learn the tools that will start workflows of actions.
- The developer pushes the programming code to a repository.
- The repository starts an action (or a shell or batch script with several commands)
- Intermediate nodes could be validation and integration tests, simulated application or system start-up for pre-production checks
- Deployment to staging or production servers.
After a new version is online, the users and the clients may download it via push notifications for critical updates or with version checks by pulling or startup checks.
Notifying User About the Version of Software.
There are endless options for notifying users for new versions:
- Push Notification
- Social Media or some other Custom System Messages
- Banners or Buttons within the apps that are notifying the users for the presence of a new version
The implications I’ve made myself for software updatability are small and simple. On Predefined for an app URL address, I am publishing a file containing an integer. There is also a hardcoded integer in the apps that is – the current running version. At startup or after check for update buttons – an app checks the hardcoded value with the deployed to the server file. If they match – the app is up to date. If they are not identical – there is a newer version.
The standard and recommended way of publishing an update is through the application stores. This way – the store owners could check the software for viruses, malware and other ill-advised actors. The Apple App Store has actually included a policy restricting out of store updates.
As Android Ecosystem is little bit more open, it is possible to install Apps outside of the stores. I’ve done such workflows in the past and it increased the speed of publishing process. The Core code that I’ve used I’ve shared on GitHub: https://github.com/tomavelev/UpdateBasis
Java Desktop Code
I also have a code for Java Desktop program Updating, but I need to clean it up from application specific code and document it better, before opening it to the world. Anyway – an important thing to notice is to think carefully about threads. Input/output operations should be always away from the UI thread – in the background.