Coding has been in a process of change these past couple of years. The need to provide apps faster and better than ever has also changed the way developers approach new development projects. 

Technologies that enable you to reuse pieces of code, implementing new functionalities faster are used more and more. Also, having tech that helps even non developers create their own mini-apps comes in handy and allows developers to focus on bigger, more challenging projects.

HCL has taken on the challenge of providing the tools that both hardcore developers and roockie developers need in order to make their job easier.

In the mind of a software engineer there will always be a conflict: on one hand there will be highly trained engineers that make all that hardware shine with their apps, on the other hand software engineers try to also provide apps that look good and are intuitive and easy to learn for the users.

This is where the need to have tools that help you create not just effective apps but also have a certain beauty to them comes in. Because it’s not enough to have efficient software you need to have software that looks modern.

The first software programs were written in a notebook because the computers of that time did not handle writing, so programming in itself was a lot harder than it is today. The code that Steve Wozniak wrote all those years ago can still run today on an Apple 1 computer for the content and memory location, so we can call it the first software for the future.

The question which arises is how did we get from code which was elegant and simple to code which is suffocated by libraries and dependencies up to the point where it won’t compile even. 

The answer to this dilemma can be summarized as: The Added Complexity Cycle:

Building Software For The Future

You got a lot of Bloat and Technical Dept which leads to your product not moving fast enough and your inability to keep up with your competitors. In order to add new functionalities and options you will resort to adding libraries and more complexity in order to make things move faster.

For a while, this approach might help you, enabling you to deliver new functionalities faster, but as you might expect there is a catch:  once you can go faster and do more things there is also an increase in demands on creating new functionality, new capabilities and so the maintenance of those libraries that you added to put a new layer on top of that bloat and technical debt is not being done. You don’t maintain them if they are internal, don’t evolve them so they get stuck where they were when you first started using them. 

The next layer of problems that you will need to solve is in a new technology which sounds good in a presentation but may not be appropriate for your solution taking into consideration your legacy code and un-maintained libraries.

The tip of this mountain we have been building will be the increasing number of defects that will appear. We have not solved the problems we originally had, the legacy code but rather created a new layer of abstraction on top of what we had, and we did not even maintain that. These decisions usually lead to an increased number of defects in our product which of course will lead to support issues.

Some of the consequences of going on this path are:

  • Slow and Tedious Installation: more and more things to install and administer takes elegance and renders chaos
  • Expensive and Complex Upgrades: Multiple parts all of which need to be tested in place by customers, installed, configured, tailored, etc
  • Stifling of Innovation: While it seems that you are going faster, actually it’s a trap. You cannot move forward and you will drag more and more complexity along.

Here is a comparison between two great apps: Notes 7 vs HCL Notes 11. The first thing that you will notice is the sheer size of the installer: Version 7 is 203MB while V11 is 1.07GB. This is the result of adding layers instead of optimizing and simplifying things with a focus on customers’ needs.

The good news is that times are changing and with them so is the way we code. HCL has taken on the challenge of breaking the adding complexity cycle. In order to achieve that these are the steps that will be taken:

Building Software For The Future1

With that in mind, maybe it’s time we start optimizing the code of our apps and not just adding layers upon layers on top and improve both our developers lives but our users’ as well.

If you need help in your software development journey, drop us an email.