Soconto Source Code Generator
Do you still program yourself. Compiliable Delphi source code with the soconto source code generator. From the data model to the DelphiTM source code fast, efficient and practical uniform, clean and safe code. Generierated features a.o. creating, deleting and storing display as table or by data object syntax- und key-check printing, sorting- and copying indentation and language adjustable.
Full Specifications
WHAT’S NEW IN VERSION 1.10.1
GENERAL
Release
November 7, 2008
Date Added
November 10, 2006
Version
1.10.1
OPERATING SYSTEMS
Operating Systems
Windows 2000, Windows 98, Windows Me, Windows, Windows XP, Windows NT
Additional Requirements
Windows 98/Me/NT/2000/XP
Software-Development for optimization software. Soconto is specialized in Windows applications with a scientifical background. Software-Development for optimization software. Soconto is specialized in Windows applications with a scientifical background.
The current state (Spring 2019) of code generation is that it is everywhere.
Today, code generation happens at every layer of the software stack, including Java libraries such as swagger CodeGen, the latest crop of cross-compilers/transpilers like Babel for JavaScript apps, and full-stack generators such as Starter StackGen(tm) which combine both. (Full disclosure I am the developer of StackGen.)
The explosion in the sheer number of REST apis has resulted in a bevy of API client generators for any number of programming languages and environments being developed during the past decade.
Like some kind of vast digital Turducken, REST APIs and their generated clients are seemingly capable of connecting anything to anything.
So let’s take a look at the Turkeys, Ducks, and Chickens involved in the code generation menagerie…
Code Rewriting
One extensive form of automated coding is Code Rewriting — used to convert one language version syntax to another, and sometimes to another language entirely.
For example languages such as Scala essentially rewrite your code into Java-compatible code under the hood.
The famously odd Project Lombok basically rewrites your Java code as you type, generating phantom methods so you can focus on greatness.
And as any good JavaScript dev can attest “transpilers” like Babel rewrite your advanced ES2017 into dumbed down 10 year old browser-compatible JavaScript so you can write modern code without worrying how the browsers will behave.
Letting computers do the dirty work?? Sweet!
Template-Based Generation
The React ecosystem has been especially active in creating template-based application frameworks including React’s “create-react-app” CLI command.
Other template-based code generation is rampant throughout the software industry. HTML templating and popular new static site generators all leverage template parsing typically using the popular mustache or handlebars template engines.
On the server template engines such as Velocity as well as server-based implementations of mustache and handlebars spit out pre-rendered source files such as HTML and increasingly JavaScript.
Runtime Dynamic Code
Templating is not the only approach to code generation.
Running code can be “self-aware” via introspection such as with languages like Java and the Java Reflection API and Ruby Metaprogramming the options to build truly dynamic applications really expand once your code becomes self-aware.
At Starter we used Java to build the StackGen generator engine which meant we were able to use the convenient JavaPoet library to dynamically construct Java class files including functionality that is dynamically synthesized during runtime. Interestingly, these classes can be compiled in memory and loaded by the classloader without ever being written to disk.
And they say that Java is not a dynamic language!
This type of Dynamically generated code is exciting because not only does it save us time and money in developing in writing code manually, but it provides an opportunity to create responsive behavior in our application at runtime without human intervention — and potentially based upon AI decisioning — making our apps and digital experiences more engaging and useful than ever.
But Generated Code Sucks!
Sadly, the history of the Software industry is littered with examples of code generators, code-free development tools, WYSIWYG front end generators and haunted by the general horrors of cryptic source code spit out by venerable platforms that never seem to die ( I am looking at you DreamWeaver Ultradev or should I say Drumbeat 2000?!).
Who wants to work on code that was spit out by a machine when it is full of obscure techniques and mangled variable names? The generated code of yore was just demoralizing and sad, and just nothing you would want to build upon.
Luckily, times have changed
in 2019 tools and software development best practices have evolved to the point where humans and the machine can truly meet in the middle. Code generators such as APIcur.io, StackGen, and Microsoft PowerApps have evolved to overcome the limitations of the past while combining the best of all code generation techniques into a modern development tool.
The Pros of Code Generation
- No hand-coding = less errors
- Massive time savings possible implementing larger and more complex schemas
- Fast go-to-market turnaround for simple apps and PoCs
- Stable underlying architecture means less time wasted
- CI/CD friendly, Code generation can be added as a step to any CI pipeline or dev workflow
- End-to-end generation eliminates errors when dealing with multiple source files and file types
- New functionality can be rolled into the underlying templates to implement across large codebases in a single build
But this is not to say that code generation does not have downsides…
The Cons of Code Generation
- Not all applications will benefit from code generation
- Code generation can be more inflexible vs. hand-selecting each code library, pattern, and coding style
- Changes to the underlying templates will be rolled out to all generated files, so changes must be highly compatible and tested thoroughly
- Generated code must be carefully isolated in the codebase from developer code — the risk of overwriting developer code exists and regeneration should be possible without impacting any existing code
- Code generation involves some increased complexity — for example, to really understand and work with generators you need to understand what is being generated and why — on top of the normal issues of your codebase
- The mental paradigm of writing code that writes other code can get squirrelly especially when writing apps that generate other apps
LCDP and Pushing Innovation to the Edge
LCDP (Low Code Development Platforms) are gaining traction as the latest incarnation of “code free development” and the new way to bridge the power-user / jr. developer gap.
As the demand for new functionality and systems grows, developers are stretched thin, and many users are stuck with over-loading Excel spreadsheets, or are simply going without software functionality they need due to expensive and scarce developer resources at every level.
Consumer SaaS solutions are there for many one-off tasks, but a hodge-podge of random web apps and services is not a reliable foundation for many needs.
And on the other end, hugely expensive Enterprise systems are simply not an option for many organizations.
In addition to saving cost on development, empowering “citizen developers” to build their own solutions when appropriate is a major driver of the LCDP value proposition.
Code generators are squarely in the middle of the solution domain.
Generating End-to-End with OpenAPI and StackGen
StackGen take a holistic approach to code generation — based upon OpenAPI/Swagger schemas.
Development starts at the beginning with an emphasis on designing a great API using OpenAPI/Swagger.
This design discipline then allows you to generate a robust stack with predictable behavior and extend it precisely with any custom logic and front end design from there.
To achieve this level of flexibility, StackGen uses 3 code generation steps with 3 different implementations.
The multiple generation techniques are used by the 3 main components of the system: Swagger CodeGen, MyBatis Generated DAOs and Mappings, and for the upcoming StackGen PRO, ReactJS front end generation.
Mustache is used by both the Swagger CodeGen and the StackGen React code to generate React content from Mustache template files.
- Mustache
- JavaPoet
- Swagger CodeGen
- MyBatis Generator
The advantage of our this approach is it is pluggable and allows us to generate both on the fly, and prior to compilation.
By generating quality source code, in developer-friendly format, modern code generators force multiply the efficiency of full stack developers while providing a modern highly scalable and robust baseline codebase.
Automatic code generation capabilities continue to evolve within programming languages, IDEs and tools that work at compile time. This coding technique has proliferated because it can reduce mundane programming grunt work, and developers have found that it improves turnaround times and accuracy.
Let’s examine automatic code generation, some tools for developers to consider and potential use cases in an enterprise setting.
Benefits and headaches
Fast turnaround times and accuracy are key advantages of automatic code generation. There’s less customization, but automatic code generation tools allow developers to create code faster, said Eric McGee, senior network engineer at TRG Datacenters. Since the tools handle code generation from project descriptions, developers can instead focus on reducing code mistakes or working on other projects.
These tools can create problems. “Autogenerated code usually becomes a hindrance for developers who want to tweak it later on,” McGee cautioned. Teams should plan to restrict these tools to only certain parts of the SDLC, such as where they can act as facilitators in smaller, less complex situations.
Different code generation types
Before organizations introduce automatic code generation, project leaders need to explicitly lay out what they mean by this development concept. Doing so will improve discussions across teams, said Jonathan Bartlett, senior research and development engineer at Specialized Bicycle Components, a sporting goods retailer headquartered in Morgan Hill, Calif.
Automatic code generation likely means one of three things to an organization:
Reflection support. Reflections in dynamic languages such as Ruby can automatically generate code within a running program. Reflection support works in a similar fashion to a smart search and automation process, which inspects the code within the language and acts in response.
Automatic code generation. Developers can use external tools required for statically typed languages — such as Go — to automatically generate source code.
IDEs. Visual Studio and similar IDEs allow developers to build logical structure declaratively using XML. This can then be translated into code.
The IDE scenario falls somewhere between reflection support and external code generation. It’s cleaner because of standardized code generation and the wholly managed development environment. However, this angle’s potential benefits are more limited.
Automatic code generation use cases
Teams need to consider the tradeoffs between reusable blocks of code to accomplish a task and automated code generation. Any kind of repetitive coding can slow development progress and introduce mistakes. Developers can mitigate these flaws with functions or by code generation. “These two options are actually more similar than people generally realize,” Bartlett said, as they both eliminate manual coding work.
Code generation can automate API development in one system to match another, Bartlett said. For example, it’s often simpler to use a code generation tool to write a code handler than to do so manually, because the tool automatically analyzes the database.
With automatic code generation, it’s also easier to keep an API in sync with the database, since the tool can identify errors at compile time — rather than as part of a separate testing step. Automatic code generation can also simplify code migration as companies adopt newer technology stacks.
“Our R&D team needs to reimplement the Bonita user portal every other year or so to stay up to date with web technologies and continue to offer our end users the best user experience,” said Nicolas Chabanoles, CTO at Bonitasoft, an open source business process management tools provider.
A few years ago, the company moved to model-driven development and automatic code generation for the portal. As a result, Bonitasoft now saves several months of development time each time it updates the portal.
“It’s only a matter of changing the code generator, while the essential information is kept in the model,” Chabanoles said.
Common enterprise workflows
Steve Speicher, senior manager for product management at Red Hat, commonly sees three kinds of code generation workflows used by enterprise developers:
- creating starting templates
- identifying and updating dependencies
- generating program artifacts
At the beginning of many projects, developers might navigate a library of patterns or blueprints, select what’s appropriate, fill in a few fields and the tools automatically create an application template. While this example is often associated with new applications, teams can also use it when they want to add health checks, monitoring or other capabilities. The biggest challenges relate to reducing the blueprints to only what the team needs and organizing them in an effective way.
Dependency-scanning tools automate the identification of dependencies with known vulnerabilities, which makes it easier to respond when a team discovers new security risks. In this case, the code generation automates the process of provisioning a quick fix for applications that use the dependency.