I taught myself programming, hands-on and from the ground up, and that perspective has never left me.

During high school, I discovered computers after borrowing one from my local Boy Scout Explorers to take home. I taught myself to program in Basic but quickly delved into electronics to understand how these single-board things worked, from building circuits for robots, writing in Assembler, and even getting down to the timing diagrams. In Reggae songs, there is a useful word for this, "overstand."

Every discovery was enchanting to me until I experienced Windows 3.0 reliably crashing from menu bar selections. After some Homer Simpson-like repetition due to disbelief, I stopped thinking of software as a flexible variant of hardware. I realized shipped software could be complete trash, in a way hardware wasn’t afforded. Soon after I encountered Linux and was so impressed by this “big” OS fitting on mere mortal’s machines that I regained some faith in software.

Even after graduate school, I still conceptualize everything from programming languages, algorithms, numerical methods, operating systems, frameworks, and all kinds of abstractions, as executing in the same primitive way I learned back at high school. I want mastery of the machine, virtual or not, and all the programming tools are in my hands.

The time-proven software tools of the past decades shaped our sense of programming esthetics and expectations of the developer experience. But everything is now bigger, stronger, yet takes longer, and more complicated (and I have to do DevOps?).

There are too many processes in the software development process.

The software industry defines multiple stages (i.e., CI/CD) of development, and has a product for each part of the process. But software creation is the point of it all, “the thing.” Can we just talk about software creation? And can I get from the idea to deployed code quickly?

I welcome the new programming tools that are true steps forward from the classical world of compiler/linker/interpreter/IDE/CI/CD/DevOps. In this post, I explore the new software tools where ideas quickly become deployed code.

New Software Creation Tools

Machine learning and the no-code trend have introduced tools and services that dramatically reduce the work to create quality software. However, a no-code solution should free you from having to create software with the standard chain of tools (the classic way), instead, the focus is on standing up a minimally configured product and iterating in the product space, not on source code.

Tools based on Software Repositories

Model-driven programming methods such as machine learning have radically changed the classic software development landscape. Instead of text editing specific instructions and algorithms, a model is trained with highly curated data.

One kind of dataset that is plentiful, and with indicators useful for curation, is software repositories. Software is produced by all industries and found in public sites such as GitHub/GitLab and within private corporate silos. GitHub’s Copilot (copilot.github.com) is a product that suggests code as you type. This is a more powerful form of the code suggestion feature found in IDEs. This application of machine learning is built on the GitHub dataset and, while still in the initial phases, will improve over time from the usage data. Interestingly, it helps clarify the definition of software creation because it is not software creation; it helps you as you write code. In contrast, creating software results in an artifact that runs, which is “the thing” you want.

kodou.io has expressed this idea,

The software you want to write has been written at least 100X already but buried somewhere in an open source or corporate repository. Don’t rewrite it. Find the code on kodou.io and it is ready to be called.

Kodou is built on an expanding corpus of software (eventually, a mirror of available software repositories).

The code is indexed and in executable form, ready to be called via an API. It looks like "Lego" code, where bricks are substituted with software. We explore kodou.io later.

No-code emerges

No-code ideas are not new. Database as a service is an early form of no-code solution. You shouldn’t need to write a database, but if you decide to do so, it should be the goal and not a necessary component of the application.

Webflow is no-code for webpages, it puts up the page for you, simplifying the design work with templates and widgets you tweak, rather than build from scratch. We use Webflow at kodou.io.

Recently, the 2021 No-code Conference, sponsored by Webflow, reviewed the growing no-code movement and highlighted their new offerings. We found the taxonomy they presented interesting and offered commentary on Twitter.

‍

In the conference opening talk/video they claimed the “three pillars” of no-code software development using a Venn diagram taxonomy. A screenshot of the conference video is below.

‍

The Webflow product already does the UI and has a CMS, so two circles are covered. They introduced Logic as a new feature to specify simple decisions based on UI or Data.

The Logic feature while well designed seemed, in a way, shallow, compared to the hefty UI and CMS parts. That thought was quickly followed by the questions, why be limited, and why not Software as the third pillar? Is there no-code software that matches our expectations of the depth and breadth of software?

I made the following version of the Venn diagram.

‍

No-code Software

Of the three pillars, no-code software may be the broadest space and the most challenging if not constrained. For example, Stripe might be considered no-code software limited to the payment space (Twilio limited to digital media, etc.).

MuleSoft and Zapier are popular products for easily connecting the myriad of technology products used in businesses of all sizes. Use the UI to connect your database, email, payments, or Salesforce and Slack systems to mirror your business' workflow. Interestingly, businesses that already pay for critical technology products are expressing that their needs were not met and are willing to pay for more products to better connect them. Likely, there remains a need for software to make their existing technology stack more useful.

These products are no-code API connection products and are not no-code software products.

Our favorite IDEs provide code suggestions as you type. But this feature is a text-to-text mapping: give some text as input and get some as a result. The text written at any point in time forms the question: what should be next? It is the seemingly endlessly repeated step to creating software.

However, the complete programming workflow includes executable code, because that is “the thing” we and every stakeholder want. If the executable artifacts are what we want, why don't we just ask for the executables?

What is it?

No-code software is executable and composable code that matches the description you provided.

• Executable - Code is always live. Infrastructure provided.
• Composable - A single function could be the solution or compose multiple to solve the problem.
• Search-to-code - Ask for the executable code you want. Any available input text such as files, search terms, etc., are used to drive the search/suggestion engine. The results are choices of executable code that best match the query.
• Simple Developer Experience - Get to deploy code quickly after initial description. No need to learn new programming paradigms or skills.
• Speed - All of the above serves the need for speed to idea realization.

Iterating with Executables

The no-code developer experience is all about executable code and speed. The developer can begin with working code that matches their idea and iterates on the executables. Thus, the developer works with executables in the deployment space. This is in contrast to the text editing iterations we all know well.

If not limited, the no-code software problem/solution space is broad. Composability makes no-code software possible. One function may solve the problem, or a few composed together. The mental load is light because no-code software reduces to names, function arguments, return values, and composition operations.

Kodou

Kodou is a software creation cloud-based service with powerful enhancements in developer experience and security.

Users describe the desired function or the problem on the app.kodou.io search page. The results are choices of executable functions called “live functions” because they are immediately available to be called.

The Value

Kodou is a portfolio of technologies (compiler, runtime, suggestion engine, and infrastructure) that enable the no-code abstractions described above and enhance the developer experience.

• No-code software - Code is built on the universe of open source and available corporate repositories. Developers are not constrained by Kodou's internal decisions.
• Live functions (executables) - The executable code is a micro micro-service staying close to the functional paradigm.
• Transparency - Executables link back to the source (some exceptions exist)
• Interactive - Play with code before deciding to deploy it.
• Search-to-solution - Contribute your solutions for others to find. Be part of the Kodou network to share your solutions.
• Security - Nothing is downloaded from kodou.io. Security through isolation is a major strategy.
• Speed - We measure the developer experience metrics in seconds. Your coding loops operate on executables, not source code, and no CI/CD.

No Limits Software

Kodou is software built upon open source software repositories like GitHub/GitLab or your corporate resources. Kodou crawls across software repositories and breaks up software into the functions that comprise it. Point it at a monolith and it breaks out the functions as independent executables.

Kodou "Lego" Code

The concept of "Lego" code can be useful. With a palette of "code" bricks of various functionality, we could build anything.

The "Lego" code perspective on Kodou is a bit more specific. Instead of building a new Lego model from basic bricks, imagine a universe of completed Lego models where you can break off parts (across any models) that pertain to your desired novel model and compose them together. Kodou performs, in the same way, using live functions from across software repositories.

kodou.io

The app.kodou.io search page takes your input and finds the best functions that match. Once a function is selected it can be requested as a service behind our API, api.kodou.io. That’s the whole workflow.

The technology underpinning Kodou enables cross-language code usage. You can use functions from different languages and compose them. This allows the choice of the "best" solution for a particular problem independent of the programming language.

Please look at our documentation on kodou.io and other blogs posts on this site for details on using Kodou.

Developer Experience

Kodou's developer experience encourages submissions as much as discovery and usage. A great software solution might be missing one composable piece. Someone who creates that piece can make it available to other Kodou users. We call those clever folks Komposers. Custom software solutions are easily submitted and shared.

Kodou goes further and brings interactivity to elevate the developer experience. You can treat it like an interpreter environment to play around with things for understanding or to build confidence.

The transparency of Kodou software allows for different levels of scrutiny. Code selection can be based on metadata or down to the syntax level.

The full power of cloud infrastructure and our technologies is applied to software creation. Kodou's cloud resources will always dwarf a developer's laptop.

Security and Isolation

Nothing is downloaded from kodou.io. All usage is via API calls to api.kodou.io This prevents many security problems that begin at the development phase, including exposure to a compromised supply chain.

Impressions

We believe Kodou is a major win for software companies, which is almost every company, and developers specifically. Here we highlight some of the conversations about Kodou we've had across the software industry.

• Chief Software Security Officer at a major social media site - The software security team developed secure versions of vulnerable code for the firm’s engineers to use, but are unable to make the software engineers do so. Kodou's search for code workflow allows for the secured code to appear above other selections.
• Software Tools Evangelist at one of the top tech firms - The software tools evangelist felt Kodou is a solution to the growing software dependency conflict problem. He said only Google and Netflix had publicized a complete solution.
• Multiple Engineers at one of the major tech firms - In separate conversations, software engineers felt Kodou was a Google-for-the-rest-of-us version of Google's mono-repo.

The Trends are Clear

The trend of simplifying complex software technology for broader usage is everywhere. From data analytics to machine learning, simpler products appear and existing products get more streamlined.

Complex software technology can be replaced with a minimally configured working version. The user quickly iterates on the product to reach the desired goal. Kodou and other companies serve as proof of this approach.

We will continue to build technology on the time-proven multistage software development process but our focus is shifting to new developer tools and new technologies. The no-code trend is clear and over time will cover more technology areas. As someone who doesn't mind complexity, I welcome it.

‍

‍