The Drivers of Modern Software Development

I remember the golden days of Object-Oriented Programming (OOP) and the proud of Sun Microsystems that they Java programming language is 100% pure object-oriented technology in opposite to C++ which support OOP beside the traditional procedural programming inherited from the legendary C language.

The impact of OOP was (and still) great to make source code more organized, reusable, and dynamic (in other words: code is encapsulated; inherited; abstracted and polymorphism-able). And that indeed had thrived the development process with more engineering reflected in what is known with design patterns which tending to solve a repeated business problems.

OOP was a new rising era of code development which led into innovating new design and architecture patterns e.g. SOA . We can’t imaging SOA without OOP, is not?

Design patterns has been thrived with OOP and the way of coding has been changed to be more automated and reusable, but with the cost of complexity and long running process to deliver working software. different frameworks had arisen to provide a platform to develop OOP software based on design patterns as a way to write high quality and reusable code!

OOP design patterns are really a piece of software engineering art, but it was used intensively for a reason or not. It was developed to solve OOP problems which are mainly related to the management of object instantiation and communication in different ways.

OOP is like anything, it could be wisely used, or abused. The rule here is to use things moderately when needed.

What is happened in the Last 20 Years?

At the early days of OOP and SOA, the deployment model was mainly relying on physical server for a web service(s) which was still arising (in terms of technologies and frameworks), so monolithic development was the best standard approach to optimize the cost of development and operation. It was a new era of software development, a transition to a new software architecture styles and code development patterns. That is already added advantages but with the cost of complexity over all SDLC.

In the last 20 years, an acceleration has been happened in the information technology in different areas:

1. IT infrastructure virtualization — represented by the revolution of Hardware and Operating Systems virtualization aiming for better utilization and operation automation. Every node (compute, storage, network, etc.) has been digitalized as software service/application. We can see examples of the infrastructure virtualization in Linux container LXC, application containers (e.g. docker), and virtual network like Citrix or networking in the platform systems like Kubernetes.
2. The improvements in the hardware peripherals specs, parallel processing, and mobilization architecture — The new added capabilities in the rack/blade servers which were still in comparison with mainframes opened the way for more utilization (and control) with an economic and smaller units.
3. The growth of open-source community — actually it was a massive revolution with direct impact on the mindset of software development. It has opened the knowledge for everyone to innovate and to compete. That has been reflected on the technology evolvement rate to be steadily increasing.
4. The progress in development technologies — either a new technologies or evolvement happened on the existing technologies. For example new programming languages (like Go, Rust, etc), new compilers like the portable LLVM compiler, new No-SQL databases, HTTP protocol evolvement for new upper layers like REST and gPRC, and the progress happened in the traditional programming languages e.g. Java, C#, and JavaScript.
5. The new management paradigm — The progress done with information technologies made an echo system with market, as a new benefits has gained by the market from the progress in the information technology which raise a demand to push the investment in the digital products and a high competitive market. That lead the makers of software to adopt new management methodologies like Agile for a rapid software delivery. For more detail about Agile Software principles please refer to this link, and for methodologies and their related frameworks please refer to this link.
6. Software Automation — as result of the revolutionary changes in the information technology, the automation has taken its way to level up. A new model of application development has emerged which rely on a dynamic and virtual infrastructure that can be scaled as required via an automated processes, led into new delivery model of software as a service (aka cloud services ) which is the backbone of the modern infrastructure. Actually automation is a big and focal topic in information technology as an advantage of digital transformation, from code to robot.
7. Machine Learning — the massive heritage of data was a grate input for machine learning and artificial intelligence in every stage of SDLC and on the final products to provide a smart use experience.

There are other changes were happened too e.g. blockchain and fintech but I consider them as part of software products development and not as part of the changes which affect on the way of code development.

The Compass of Software Changes

So before going deeply, here is a compass with three drivers of software changes:

1. Automation as a continues and important business requirement to maximize the business capability . That, won’t be happened without DevOps as backbone, while the level of automation is directly affected by the level of DevOps maturity level. And , I consider code generation as part of automation so moving to low code development techniques is a future. Also, the ready-made reusable building blocks is essential in the process of automation composition.
2. Portability in terms of resources virtualization and application mobility. The resilient infrastructure and the variety of options to access software application from everywhere with less effort as much as possible.
3. Artificial Intelligent, going beyond the traditional digital solutions to a smartness solutions. Moving from reactive application to a hybrid (reactive and proactive) behavioral application.

I consider the above three drivers as the main parts of the reactor which is fed with business requirements to produce modern digital solutions.

Modern Code Paradigms

All of that events happened in the las 20 years was leading into adopting more flexible paradigms that can cope with the accelerated changes in market.

The new paradigms has skipped the strict concepts and went with more practical concepts:

• OOP technologies (like C# and Java) has adopted declarative programming features (e.g. lambda functions) side by side with the traditional OOP procedural programming in a bold action to break the 100% OOP concept which returned with more strength and flexibility on the technology.
• Moving from stateful applications to stateless applications and adopting disposable service deployment pattern to minimize the footprint on the hosting environment, building reactive ecosystem, and automate deployments.
• The switch happened in someway and intuitively to use out of the box features in HTTP protocol to exchange information in unstructured format like text or images which improved latter to be in the form aka REST APIs.
• Break giant services into mini, macro, and micro services, moving toward lean programming and rapid development to deliver business features as soon as possible. What a greedy business!
• Adopting Serverless applications for some business cases
• Moving carefully to low-code application development
• The rise of Internet of Things and its great impact on the life style and quality.
• And the interesting coming from the behind (with more shine) the legendary C and its based languages

That were some examples of the changes happened in the software industry.

In short words, follow a hybrid paradigm which benefit the business and comply with coding and architecture principles.

(1)

Multi Paradigm Programming Language

First of all I am not fan of rust language. The main idea here is to give an example for how the new paradigms led the way of innovating new programming languages and new methodologies which are more suitable to respond to the changes.

Lets introduce Rust as per Wikipedia: Rust is a multi-paradigm, general-purpose programming language. Rust emphasizes performance, type safety, and concurrency. Rust enforces memory safety without requiring the use of a garbage collector or reference counting present in other memory-safe languages, Rust’s borrow checker tracks the object lifetime and variable scope of all references in a program during compilation. Rust is popular for systems programming but also offers high-level features including functional programming constructs.

From the brief intro of Rust, I will quotes the key words that matching the new paradigms mentioned in the previous section as follows:

1. Multi-paradigm — which means flexibility to write OOP and functional programming as you need.
2. Emphasized performance & Memory safe — which means better utilization of the CPU and memory resources
3. General purpose & Popularity — which means productivity

Also, I can add the fourth feature in RUST which is so important

4. Portability — which let rust suitable for a wide rang of systems and devices. Rust binary is self-exactable by default as the compiler produce exactable binary which is statically linked to the required libraries. Java VM and .NET runtime are still heavy but I think they will do some progress to be on the right future track.

Another example for a flexible and multi-paradigm programing language is C#. I am fan for this powerful language which is adapted to cope with business needs. it is a real example for what this article wants to say.

(2)

Code Organization

I want to say, we are in different era than the era of OOP, we have different demands and different circumstances, and nothing is fixed in software development but basic principles. The future will have different demands too.

So, there is no need to pay effort to develop code as you have alternatives e.g. manage configuration using hosting environment like K8S configmap. And no need to pay much effort in code complexity where it could be simple.

I am not against OOP design-patterns, but to use it moderately, for example creating a utility tool or simple data CRUD operation might not need a specific design pattern. The idea is to have some freedom which allow you to innovate better approach. Also I am not against writing a well-design code, but to write an organized code that can be managed in the present and in the future. As per my experience, code has a lifetime, so we have to consider that in the development process is to write a replaceable code modules. And finally I am not against OOP, but in case of the existing of other options which is fit better than OOP so going with other options is the best.

The rule here is: Build a renewable code.

That is requires your code to be replaceable with new code and without making a break changes on the system. To be detailed in another article.

(3)

Code Categorization

I see we can categorize the code we develop for a specific software product or service as follows:

1. Business Code — Represent the business logic written to respond to the workflow of a business domain . And, we can have sub-categories of such business code as Reactive UI, Special Business domain logic, and Common Business domain (e.g. the common business cases of school management business which can be reused by different school types as per each special school demands).
2. Environment Code — Represent the automation scripts from A to Z written for CI/CD.
3. Reusable Code — Represent the code which can be reused from one product to another. This type of code could be categorized into sub-categories as Aspect (or cross-cutting concern) e.g. logging, application Infrastructure e.g. data access and integration, or Tool. The output of reusable code could be represented either as a binary library which can be linked to the code project or as a shared system service accessed via standard protocols like tcp, http, grpc, etc.

I’d prefer to organize source code using file system convention and to make reusability on the level of source code and not on the level of the output binary e.g. source code fork on github reused in other projects with custom updates and configuration.

So, How can we organize code?

The idea here is, to reduce code layers as possible, and the law is: one extra layer one extra mile. Or, to be an organize code in a convention way that allow continues evolvement without the need to make a break changes and keep the code nimble to be updated as required.

It is up to you to organize code in the way which guarantee the evolvement with considering the provirus three software change drivers (automation, AI, and portability)

As an example to the code organization, I’d introduce the Intuitive code development (iDevelopment) and the code seed template which will be detailed in a later article, so here are the steps:

1. Arrange code into folders like file system.
2. Level #1 folders are independent software modules.
3. Level #1 folders can be grouped under one software project or mapped as one folder per project.
4. Each layer in the module is represented by a sub-folder so Level #2 folder is a layer or sub-component.
5. Independent folders could be reused from one software project to another.

The idea is to work on a compact code which can be maintained and changed easily by convention. It is something like Python file convention and the open source community code reusability.

That is has a benefit on the software agility like:

1. Building a code seed, started simple and growing with business.
2. Adding or removing code into software project can go straight forward without break changes.
3. Code generation can be straight forward without the need of sophisticated tools.
4. Code automation can be achieved with the required customization based on the system configuration.
5. Full control over the source control e.g. use one code repo or multiple, merging, splitting, etc. even the software project is decoupled from the source code.

(4)

Code Principles

Here is a briefed list of the principles which can help in developing more practical code:

1. Drive code by need
2. The secret ingredient is: Keep code organized
3. Keep code moderated
4. Write a renewable code
5. Working software is the target
6. Add your working recipe that will beloved by others
7. Do not seek perfection — seeking 100% by book code is impossible or result in a high cost.
8. Reusability coms after business
9. Hybrid paradigm allow code flexibility (e.g. imperative and declarative)
10. Loss is an essential part in Win (e.g. we cannot collect everything in one basket (or boat), so we have to waive some items for other essential items)

References

• Agile Principles: https://agilemanifesto.org/principles.html
• 12 Factor: The Twelve-Factor App (12factor.net)
• LXD: https://linuxcontainers.org/lxd/introduction/#application-containers-vs-system-containers
• Docker Overview: https://docs.docker.com/get-started/overview/
• LLVM: https://llvm.org
• Rust: https://en.wikipedia.org/wiki/Rust_(programming_language)
• Introduction of Programming Paradigms: Introduction of Programming Paradigms — GeeksforGeeks
• Rust(Programming Language): https://en.wikipedia.org/wiki/Rust_(programming_language)
• programming rust: fast, safe system development https://www.amazon.com/Programming-Rust-Fast-Systems-Development/dp/1491927283?asin=1491927283&revisionId=&format=4&depth=1 Read chapter one, why rust?
• What Are the Important Topics in Machine Learning?: https://www.analytixlabs.co.in/blog/machine-learning-topics/