Building on the Shoulders of Giants: Calculus to Low-Code Tooling
In Infinite Powers by Steven Strogatz, he writes:
"The fundamental theorem of calculus, from the works of Newton and Leibniz, is a culmination of 18 centuries of mathematical progress. It resolves the crucial backward problem, a challenge that was previously addressed only on a case-by-case basis."
This powerful insight reminds us that every great leap forward in science or technology is built upon the hard-won brilliance of those who came before. Calculus wasn’t born in isolation; it was the result of centuries of incremental advancements, ultimately providing a unified framework to solve a problem that previously had no universal solution.
The evolution of calculus can be traced through several key historical milestones, from ancient foundations to modern developments. Here's a high-level overview:
Built on top of 18 centuries of work and we get the gift of calculus to enable the mankind to mathematically model the change. This became instrumental to paving the path for the human race to move forward - everything from GPS to Medical imaging.
The world of software development is no different. As developers, we stand on the shoulders of giants. Frameworks like Angular, React are the modern-day equivalents of foundational principles in calculus, such as Fermat’s early explorations of tangents or Descartes' visual geometry, which laid the groundwork for Newton and Leibniz to formalize derivatives—powerful abstractions built on centuries of collective wisdom. And yet, just as calculus transformed mathematics, new paradigms are emerging to transform software development itself.
Let’s reflect on the incredible evolution of the software world:
From Standalone to Client-Server Applications In the early days, software was a solitary affair. Applications were standalone, running on individual machines with little to no interaction between users. But as networking became feasible, the client-server model emerged, enabling distributed computing and collaboration. This was the beginning of applications communicating over networks, marking a major step forward in how software was designed and deployed.
The Rise of Web Applications Client-server architecture eventually evolved into web applications, ushering in the era of internet-based computing. These applications allowed users to interact via browsers, making software accessible from anywhere. Web servers like JSP (Java Servlet Pages), IIS (Internet Information Services), and later modern-day frameworks laid the foundation for scalable, interactive web experiences.
Marc Andreessen and Netscape: The Birth of JavaScript Marc Andreessen’s Netscape Navigator was not just a browser; it introduced JavaScript, a scripting language that changed the web forever. Initially dismissed as a lightweight tool for small web interactions, JavaScript quickly evolved into something far more powerful—a foundation for modern web applications.
Birth of JavaScript Ecosystem JavaScript today is a galaxy of its own, powered by frameworks like React, Angular, and Vue. These tools have revolutionized front-end development by making it easier to create rich, interactive user interfaces. Libraries like Bootstrap and Material-UI provide developers with pre-built, responsive components, streamlining design and development.
Double clicking the timeline --> the ecosystem expanded to include independent libraries for nearly every imaginable frontend component—ranging from basic elements like checkboxes to complex components like table grids. There also came commercial offerings like AG Grid, focus exclusively on providing highly optimized and feature-rich table grid components for web applications and other commercially available libraries like Sencha helping developers put together the next new software way faster on top of them.
These frameworks and libraries come at a cost. While they help put things together real fast they add their overheads like tooling and dependencies. For customer facing applications, this cost still makes sense however for internal tools, the cost benefit analysis doesn't add up for below reasons:
1. Tooling and Build Configuration
Challenge: Modern frameworks and tools often require sophisticated tooling and build configurations (e.g., Webpack, Babel, ESLint, Prettier). These can significantly slow down the development cycle for internal tools.
Why It Matters: Setting up, maintaining, and upgrading these build tools can be a headache, especially for teams with limited front-end expertise.
2. Maintaining Dependencies
Challenge: Modern frameworks tend to have numerous dependencies (e.g., Redux, React Router, Axios) and frequently release breaking changes or updates. Keeping everything up-to-date and compatible can become a full-time job, particularly with multiple dependencies.
Why It Matters: The time spent on dependency management and ensuring compatibility can take away focus from building business logic or adding valuable features to the internal tool.
3. Maintenance and Long-Term Viability
Challenge: Modern frameworks often change rapidly. New versions and features are constantly being released, and keeping internal tools up-to-date with new versions of frameworks can add to the maintenance burden.
Why It Matters: Over time, you may encounter issues where older tools become obsolete or harder to maintain, leading to unnecessary refactoring or even a complete rewrite.
This is where low code emerges to push development of apps to another level. Abstracting the underlying frameworks from the developers and letting them focus on core business features & needs. Essentially low code tools puts together different Ui components, backend, versioning and packaging together in a beautiful way. All components like table grid, checkboxes, dropdowns, etc are now packaged in a low code tool for the developer to simply drag & drop rather than select. In modern WYSWYG drag drop panels you will be able to create the entire Ui and bind it to any data resource either via JDBC, REST API or any other way. If you as an engineer were fascinated with scaffolding your apps then this is acceleration of another level. Low code platforms abstract away all complexities like build configurations, dependencies and thereby takes away all the overheads from your engineers into the lap of low code providers. All of the challenges are kind of outsources for you to focus on purely things that matter.
I would argue that frameworks will soon make way to absolutely sophisticated new age tools in time to come. With CoPilots coming along -- low code will only become way faster to build and simpler to maintain. I am excited about this battle of tools vs frameworks emerge. In the niche of internal tools -- surely low code platforms are going to be victorious and beat frameworks hands down.
About Jinen: I run DronaHQ, a low code platform for building admin tools & internal apps. Happy to hear your thoughts & take your questions.