Longevity software

Best of all, after the transition, programmer productivity increased dramatically and the time spent treading water in maintenance dropped proportionately, so allowing a subsequent up-tick in the rate of introducing new functionality into the architecture. The resulting code simplifications were only outweighed by the massive increases in performance and scaling we were able to realize at the same time.

The same was true of switching to the new GUI platform which ultimately delivered improved visualizers, and enabled rapid development of the data-driven GUI approach to previously unthinkable levels. The whole experience, while traumatic at the time, made it clear that COTS cobbling is the enemy not only of productivity, but also adaptability, functionality, performance, generality, cost flexibility, and a whole host of other metrics that we had previously though to be immutable facts of software life.

Not so, poor scores on these dimensions over time turn out to be largely driven by the compromises that COTS dictate. It became clear that we should not stop there, but should re-examine the three remaining COTS items to see if even they could be eliminated to achieve greater performance. Depending on S or P programs will usually be the undoing of an E-program. In other words, its not just about how you structure and maintain your own code, longevity is also just as much about the number and type of the external technologies you rely on.

External reliances introduce as much if not more entropy than sloppy maintenance changes ever could. Figure 2 above from onwards shows a smooth process of increased programmer productivity, core abstraction functionality, and gradual independence from the remaining COTS components.

Such independence remains our top technical goal. Alas, few programmers ever work on one large code base for so long, mainly because few projects survive this long, which in turn is because the developers rarely get to see how damaging external COTS can be over a multi-decade software lifespan. It is a vicious cycle that few can even perceive, and which by its very scale prohibits serious academic investigation. Trust me though, it is real. One more COTS component bites the dust. Other minor dependencies have also been systematically eliminated.

Starting in , a new core-abstraction based universal renderer approach has incrementally replaced the use of the 3rd party Genesis GUI framework through a kind of background coding task when time permits. Different widgets can pick different preferred renderers there are now others so that at this point of time Genesis is used only in a few places mostly visualizers. The moral of the story? Overview This project is a simple ish application to explore the features and functionality of an event driven architecture for use in an embedded microcontroller.

The software will flash an LED for mS every second while a button is pressed, there is also unfinshed functionality for: Detecting timer overflows. Detecting incorrect configuration of the GPIO pins.

Microcontroller The hardware intended to be used with this project is the AtmegaP Microcontroller, clocked from an 8MHz oscillator. Architecture overview The application is split into three distinct sections: Device specific code This code is what talks directly to the hardware registers. Files in this section are named starting with "AtmegaP" for this device. Hardware Abstraction code This code is the interface between the device specific code and the application code.

Files in this section are named starting with "Hardware". Full text search our database of , titles for Software Longevity to find related research papers. Blockchain Technology for Global Social Chan Emerging technologies continue to affect a variety In Stock. Encyclopedia of Information Science and Tech Information acquisition and management has always Churn prediction, recognition, and mitigation have Simultaneous Localization and Mapping for Mo The software that enables all of our thoughts and dreams is now built to such a low standard and at such breakneck speeds and aimed at such ludicrous commercial interests, that its very survivability is in question.

Even the biggest software firms can no longer protect our information. The flashiest start-ups close. Formats and standards disintegrate in 5 years or less. Data is turned to dust every day. Our revolutionary, paradigm-shifting 21st-century business plan is to keep your information ready for the 22nd century.

The notes you write now should be there for you in a years. That's our killer app. We are complexity bigots. Fussy code decreases its durability. It forces users to alter habits for no reason. Clutter makes code obsolete before it's finished and it makes it impossible to adapt. Complexity creates user problems, it introduces bugs, and decreases performance.