Less code does not mean that the complexity of the software is reduced, but the expression of the programming language is stronger. Too many developers are obsessed with the framework, over-pursuing software flexibility, composability, and so on, forgetting whether they really need them.
Before there was software, there was only darkness. Since the dawn of the era, there has been a constant fact: companies want to build lower-cost, faster-running software.
Of course, this is an understandable and commendable goal - especially if you have spent time dealing with software developers. Every engineer should fully support this goal, and under the constraints of the current environment, it should always strive to create products as efficiently as possible.
However, in fact, we often cannot do this. Not intentionally, but as time goes by, the software will be in trouble because of unforeseen complexity, so it is self-training to find border cases, gap analysis, and all the hidden faults that may have originated from the same requirements point.
We are bewildered by the sheer complexity and mentality of designing elegant solutions: another layer of abstraction! Dry up! Separate related quantities! Inheritance composition! This is also understandable, but in this process, we often ignore the business problems being solved, and forget that management complexity is an important responsibility of software developers.
Why is it causing such a situation now?
Software has become simpler in some ways
Over the past few decades, the software industry has succeeded in reducing the amount of custom code required to write most of the software.
This reduction is mostly achieved by making the programming language more expressive. Languages ​​such as Python, Ruby, or JavaScript can achieve similar functionality using less than a third of the code in the C language. Writing programs in C instead of assembly language also brings similar advantages. It can be predicted that in the future, language design is unlikely to bring about the same improvement as in the past decades.
However, there are many other ways that do not require language to be more expressive, which can streamline the amount of code that builds software. As of now, our greatest gain over the past two decades is open source software (OSS). If there were no individuals and companies investing money in the software that they gave to the community for free, without so much cost and effort, then most of the software we build today will not be realized.
These projects enabled us to stand on the shoulders of giants to solve problems and use tools to make us more focused on solving business problems rather than spending time building infrastructure.
In other words, business is complicated. It's ridiculously complicated, and it's only going to be more. Open source software is very suitable for generating frameworks and tools for building systems, but to a large extent to get attention, it must solve the problems shared by a large number of people. Therefore, most open source projects are either relatively generic or in very popular areas. As a result, most of these tools are great platforms for building systems, but in the end we still need to build all business logic and interfaces in increasingly complex and demanding systems.
So what we have left is a stack that looks like this (for web applications)...
The "Our Code" section eventually became very complicated because it reflected the business and its processes. If we have custom business logic and custom processes, then we only need to write the interface, workflow, and logic to build the application. Of course, we can try to log this logic in different ways (remember the business rules engine?), but in the end, no one else will write business logic for your business. Actually there seems to be no way to solve this problem... at least until the robot arrives and rescues us from our work.
Don't like code, so what about Low-Code?
If we have to develop the application's interface, workflow, and logic, it sounds like it's hard for us, right? To some extent, yes, but we still have several options.
For most developers, software is equal to code, and reality is not the case. There are many ways to develop software, one of which is the use of visualization tools. Before the popularization of the Internet, visual development and RAD tools occupied a greater position in the market. Tools such as PowerBuilder, Visual Foxpro, Delphi, VB, and Access all have visual design capabilities that allow developers to create interfaces without entering any code.
These tools cover the code that needs to be written, but overall, you can design the application intuitively and then write a lot of code to implement the application logic. In many cases, you still use programming interfaces because interfaces built using these tools are usually static. However, for a large number of applications, these tools have achieved tremendous productivity by discarding other performance, mainly at the expense of flexibility.
Since the rise of the Internet, these tools may no longer be popular, but the company's desire for them has not been reduced, especially because the overwhelming demand for software continues. The latest trend in the industry is the "low code" system. Low-code development tools are modern terms for the latest generation of drag-and-drop software development tools. The biggest difference between these tools and other tools is that they are primarily Web-based (and mobile) and are often hosted on cloud platforms.
Many companies are active on these platforms. Companies such as Salesforce (App Cloud), Outsystems, Mendix, and Kony promise to be many times faster than "traditional" application development. Although many of their arguments may be exaggerated, they also have some credibility. Relying on all the drawbacks of the above-mentioned platforms may indeed result in some types of programs being faster than traditional program development using .NET or Java.
So what's the problem?
There are indeed several issues. First, experienced developers often hate these tools. Most serious developersTM like to write real softwareTM using Real CodeTM. I know it sounds like I'm catering to a group of choking babies (maybe I'm kinda), but if the core value you deliver is technology, then using tools that top developers don't like to use is not a good idea.
Second, people like me looked at these encapsulated platforms and said "No, don't build applications here." This is a reasonable concern and it is the most troublesome thing for me.
If you built an application with PHP 10 years ago, the application may be old, but it can still be heard now. Languages ​​and ecosystems are open source and maintained by the community. You need to keep the application up-to-date, but you don't have to worry about vendors deciding that it's no longer worth the time.
People like me look at these encapsulated platforms and say "No, don't build apps here." This is a reasonable concern and it is the most troublesome thing for me.
If you chose a vendor with its own platform 10 years ago, you might be forced to rewrite programs if they close tools or change tools frequently (remember Parse?). Or worse, your system will stagnate on a platform that stops updating and no longer supports services.
There are many reasons to be wary of such platforms, but for many companies, building software with less effort is too temptible to resist. The complexity of the software is still continuing. Unfortunately, software engineers can't help.
What needs to change?
There is an efficient platform that allows us to build real software TM with real-world code TM, but unfortunately, the software industry is too worried about following the tech giants to realize that their tools do not add any value to the project. .
I can't tell you how many times I met developers and told me that building a single-page application (SPA) does not increase overhead compared to simply rendering HTML. I have heard developers say that all applications should be developed based on the NoSQL database, and the relational database is gradually declining. Developers have also been questioned why applications were not written using CQRS and event traceability.
It is this thinking process and the usual overhead that led the company to think that software development is too expensive. You might say, "But the source of the incident is so elegant! Setting up a SPA on a microservice is so tidy!" Of course, it may be, but not for people like you who are writing ten microservices. This extra complexity is often unnecessary.
As practitioners, we need to find ways to simplify the process of building software without neglecting the reasonable complexity of the business. We need to acknowledge that not every application needs the same level of interface complexity and operational scalability as Gmail. There are many applications that require a well-thought-out interface, complex logic, solid architecture, smooth workflows, and more. No need for microservices, AI, chatbots, NoSQL, Redux, Kafka, Containers, or any similar tools.
Many developers today seem to be so fascinated by technological capabilities that they can't take a step back and ask if they really need it.
Like people on MasterChef, they enter the market as a molecular gastronomy peddler. They divide raw materials into different components, use scientific methods to match tastes, and then use lots of carbon dioxide and liquid nitrogen to make the most creative foods you have ever seen. Then they will be kicked off after a couple of episodes because they have forgotten most of the core principles of cooking, which means food needs good taste. They seem to be really surprised that no one likes the fennel and mango essence pearls they have fermented, and the salmon that has been rubbed with salmon foam.
The obsession with flexibility, composability, and alertness is causing us tremendous pain and forcing the company away from our favorite platforms and tools. It does not mean that the tools I listed above do not add value. Although large companies encounter typical problems in large-scale operating systems, the tools are only created to solve the real pain points.
What I'm saying is that we need to go back to the simplistic direction and begin to create things in a simpler way, instead of just talking about simplicity. Perhaps we can rely on more integrated technology stacks to provide out-of-the-box models and tools so software developers can create software more efficiently.
We will add more and more businesses to "low-code" platforms and other tools that reduce software costs by simplifying and removing code that was originally written.
The programs we need to stop pretending to be twenty lines are unique tapestries that need to be carefully hand-sewn.
Focus on simplicity
After writing it, I seem to hear the sound of a million developers scrambling, but I believe if we continue to adhere to the following direction: want to write everything, configure everything, write all the content, no matter how large-scale issues use the same Stack, then we will add more and more business to "low code" platforms and other tools that reduce software costs by simplifying and removing the code that was originally written.
Our increasingly complex answer to business does not increase the complexity of the development process – no matter how elegant it looks.
We must manage to manage complexity by simplifying the development process. Because management complexity is an important responsibility, we must always remember the most important responsibility of software developers: use software to achieve value.
Lithium Battery,Lithium Batteries,Lithium Polymer Battery,Lithium Iron Phosphate Battery
Power X (Qingdao) Energy Technology Co., Ltd. , https://www.solarpowerxx.com