Code Generation: Boost Programming with Lost Techniques

In the realm of software development, the quest for efficiency and reliability is never-ending. While modern frameworks and tools offer abstractions to simplify the coding process, some fundamental programming techniques have faded from common knowledge. This article delves into the power of code generation, a technique that can significantly reduce bugs and improve code maintainability. It's about rediscovering and applying valuable principles that, while seemingly forgotten, offer profound benefits in today's development landscape. This article advocates for revisiting and revitalizing these 'lost' techniques to enhance our programming practices.

What is Code Generation?

In software development, code generation is the automated process of creating source code, machine code, or other forms of code from a blueprint or template. It has long been a cornerstone of efficient software creation, often overshadowed by modern frameworks that provide abstraction but don't fully realize the potential of targeted code creation. Code generation can drastically reduce the amount of boilerplate code developers need to write manually, leading to fewer errors and faster development cycles. However, many modern developers are unfamiliar with the best uses, having been raised with languages that do a lot of heavy lifting for them behind the scenes. According to this video, code generation involves using a template file along with variants to produce code for the different scenarios. If there are too many abstractions, you will encounter a lot of bugs.

Core Programming Principles: KISS and DRY

Code generation thrives at the intersection of two vital programming tenets:

• KISS (Keep It Simple, Stupid): The simpler the code, the easier it is to comprehend and debug. Straightforward, verbose, and easily readable code reduces cognitive load and minimizes the likelihood of errors. The KISS principle promotes clarity over cleverness. The more straightforward, verbose and simple your code is, the easier it is to understand and debug.
• DRY (Don't Repeat Yourself): Avoiding code duplication is paramount. Reusing code reduces the risk of introducing bugs in multiple places and simplifies the maintenance process. When changes are needed, they only need to be applied in one place. Try not to put the same block of code in two or more places. That way, when you need to make a change, you can only change it in one place, and then it'll propagate through all the places it's used. You don't have to worry about a bug showing up over there and fixing it and then having it show up over here, too, because you forgot to fix it there.

The Dilemma: Abstraction vs. Code Duplication

Often, developers face a trade-off. To adhere to DRY, they might introduce complex abstractions or inheritance structures to avoid code duplication. This can lead to code that's difficult to understand and troubleshoot, violating the KISS principle. So, you've got a bunch of different screens or a bunch of different models that all have the same kind of functionality in them. But you don't want to repeat the code, so you end up pulling it all into some kind of abstraction inheritance or something weird.

• Increased Complexity: Abstractions can hide the underlying logic, making debugging a challenge.
• Debugging Nightmares: Tracing issues through layers of abstraction can be time-consuming and frustrating. And that means when you go to debug it because you're trying to troubleshoot it, things have gotten a lot more complicated, and that leads to anything but simple.
• Maintenance Overheads: Understanding and maintaining complex abstractions requires specialized knowledge, increasing the burden on developers.

This is where code generation shines: a balance between reducing code duplication and maintaining clear, easily understandable code. The intersection of two really important programming principles KISS and DRY is really code generation.

Code Generation: The Best of Both Worlds

Code generation allows you to write templates that produce the necessary code variations, effectively eliminating boilerplate without sacrificing readability. The answer to this as far as I'm concerned is called code generation. It can be used to write very easily troubleshot and debugged code without repetition.

• Reduced Boilerplate: Code generation automates the creation of repetitive code blocks, decreasing manual coding efforts.
• Clear and Understandable Output: Generated code, when well-templated, remains easy to read and debug, adhering to the KISS principle.
• Simplified Maintenance: Changes can be made to the code generation templates, automatically updating all generated code. By strategically utilizing code generation, teams can produce high-quality, easily maintainable codebases while minimizing the risks associated with excessive abstraction or unchecked duplication. This helps produce bug-free code and enhance security.

The Problem with Modern Code Generation via AI

In modern times, AI code generation has come onto the scene, promising to deliver a brand new way of writing code. Unfortunately, much of it comes up short. Often the code that's generated the AIs is just bad. Rather than using modern AI code generation, use traditional code generation techniques for more efficient code.

Classic Code Generation: A Reliable Alternative

Unlike the unpredictable nature of AI-generated code, classic code generation, where the parameters are more readily available to the code writer, offers predictability. Because this technique is guaranteed to be useful in a wide range of situations, whereas often the code that's generated the AIs is just bad. It can be guaranteed that the code is useful in a variety of situations, making it more useful than AI generation.

Understanding the Case

The presenter points out a classic use case, writing getters and setters in the 1990s with Java 1.2. Without auto-completion available, code generation was a great timesaver for this boilerplate code. With modern languages like Kotlin, you can accomplish the same thing in a fraction of the code. Compare that to the equivalent code in current Kotlin. You go from, you know, 10 or 20 lines to one. Now you don't need to do it for that. Because it will create things for you. There are easier tools for doing that now!

Step 1: Identify Repetitive Code Patterns

The initial step involves scrutinizing your existing codebase to pinpoint recurring patterns or boilerplate structures. These patterns represent opportunities for code generation.

For instance:

• Data access objects (DAOs) with CRUD operations
• View models for different UI screens
• Serialization and deserialization routines
• API client code from a schema

Step 2: Create Templates

Develop code generation templates that capture the essence of the identified patterns. Templates should contain placeholders for variables or parameters that will be dynamically injected during the code generation process.

Consider these factors when designing templates:

• Clarity: Ensure the generated code is easily readable and understandable.
• Flexibility: Design templates that can accommodate various use cases by adjusting parameters.
• Maintainability: Aim for templates that are easy to update and modify as requirements change.

Step 3: Define Variants

Create specifications of the code that the templates are generating. One method discussed involved a .csv file. You will want to have a method to automatically generate that code if any changes are made. Then put that like in a convict file or something and then have part of your early build process run a search and replace text script that creates one of those variants for each one of those things.

Step 4: Automate the Generation Process

Integrate code generation into your build process or development workflow. This ensures that code is automatically generated whenever changes occur in the templates or input data.

Use tools like:

• Makefiles
• Build scripts (e.g., using Gradle or Maven)
• Custom scripts in languages like Python or Perl

Step 5: Review and Refactor

After generating code, conduct thorough reviews to ensure the output meets coding standards and functions correctly. Refactor as necessary to maintain code quality and address any potential issues.

Best practices for reviewing generated code:

• Run automated tests: Verify the generated code by automated testing to ensure reliability.
• Perform manual code reviews: Have experienced developers review the generated code to identify potential improvements.

Yellicode: Pricing Details

Yellicode is free and open source under the MIT license. Yellicode is free and open source

Telosys: Pricing Details

Telosys is free and open source. Telosys is free and open source

Yellicode

Yellicode is the extensible code generator. It enables the user to build your own code generation templates with Typescript. It's model driven. [t: 854]

Telosys

Telosys is a lightweight and pragmatic Code Generator. [t: 854]

Where is code generation needed?

Code generation can save programmers time for different aspects of development:

• CRUD operations on databases
• Code deployment to server
• Setting up project directories