The article presents eladmin, a fully open‑source, Spring Boot‑based backend management platform with Vue front‑end, detailing its architecture, core features, modular project structure, notable design highlights, and instructions for accessing the full documentation and resources.
The article explains the challenges of keeping interface model definitions synchronized between development and testing, compares code‑first and doc‑first approaches, introduces the Go‑based GinDoc library for generating Swagger documentation and client code from annotated routes, and provides step‑by‑step usage examples and integration tips.
JApiDocs is a SpringBoot tool that automatically generates API documentation from controller code without extra annotations, offering a quick‑start guide, code examples, and features like HTML export and client model generation to streamline backend development.
The Omega real‑time reach system uses a custom DSL that unifies input data, standardizes CEP APIs, and leverages an Antlr V4‑based translation framework to generate Python, C++, JavaScript, and Java code for cloud, edge, and front‑end containers, cutting rule development from days to minutes.
This article introduces MapStruct, a compile‑time Java bean‑mapping framework, explains why it outperforms other mappers, shows how to configure Maven, define mapper interfaces, handle custom field mappings, and demonstrates its impressive runtime performance with practical code examples.
This article explains how to leverage IntelliJ IDEA's Live Templates feature—including basic usage, custom template creation, variable functions, and advanced Groovy scripts—to quickly generate repetitive Java code such as loops, loggers, beans, and context‑aware logging statements, thereby boosting development productivity.
This article examines how Lombok reduces boilerplate in Java by generating getters, setters, equals, hashCode, and toString methods, but also introduces version compatibility issues, hidden dependencies, reduced readability, increased coupling, and potential technical debt for backend developers.
This guide walks you through adding a new business module to a locally‑deployed Ruoyi microservice project, configuring Maven and Nacos, generating backend CRUD code, integrating the frontend, and performing end‑to‑end testing to ensure the new service runs correctly alongside existing modules.
This article examines Lombok—a popular Java library that generates boilerplate code—by showing before‑and‑after examples, then detailing five major drawbacks such as JDK incompatibility, forced dependencies, reduced readability, tighter coupling, and overall cost‑benefit imbalance that can turn a seemingly elegant solution into a maintenance liability.
This article introduces MapStruct, a Java annotation‑processor that automatically generates bean‑mapping code, compares it with manual setters and Spring/Apache BeanUtils, and demonstrates how to handle property name differences, collections, type conversions, and multi‑source mappings through clear examples and code snippets.
This guide walks through building a Vue CLI plugin—named vue‑cli‑plugin‑next‑component—that enforces team‑wide naming conventions and directory structures for a component library, detailing the required file layout, service entry, interactive prompts, EJS‑based generator templates, testing workflow, and how it streamlines and standardizes Vue component creation.
This article surveys the landscape of automatic program synthesis for logic code, covering visual programming, example‑driven generation, code‑completion models, intent inference, NL2SQL, NL2IFTTT, and advanced frameworks like TranX and Debuild, while highlighting current challenges and research directions.
This article examines Lombok's ability to auto‑generate boilerplate code such as getters, setters, toString, and equals, demonstrates its usage with Maven dependencies and annotated examples, and discusses its advantages and drawbacks—including IDE reliance, JDK compatibility, and debugging challenges—before concluding with a recommendation for its selective use.
This guide explains what Delombok is, how it transforms Lombok-annotated Java classes into standard Java source files, and provides step‑by‑step instructions—including environment setup, project preparation, script creation, and execution—to de‑compile Lombok code and resolve compatibility issues during upgrades.
This article explains the scenarios, workflow, and implementation details of creating a Java code generator using Freemarker templates, including template design, data binding, and sample code that produces POJO classes automatically.
This article introduces the Screw plugin, a lightweight tool that automates database table structure documentation across multiple databases, supports various output formats, and can be configured via custom Java code or a Maven plugin to streamline enterprise development workflows.
This article explores Alibaba’s effort to automate code generation by converting product requirements into standardized design language and leveraging AI and machine learning to bridge the gap between natural language specifications and executable frontend code.
The article details Meituan’s Flap system, a static‑DSL‑based dynamic Flutter architecture that converts Dart code into JSON, loads it at runtime, and delivers cross‑platform, low‑cost, high‑performance updates, reducing package size and release cycles while preserving native Flutter rendering quality.
This article examines Project Lombok’s ability to cut boilerplate in Java, walks through before‑and‑after code examples, and reveals five major drawbacks—including JDK compatibility, forced adoption, readability issues, increased coupling, and technical debt—helping developers decide whether to embrace or avoid Lombok.
A Bilibili creator named NyeJu generated 120,000 lines of compilable C++ code that, through precise color‑coded patterns, animates a singing, dancing, rap‑performing version of Cai Xukun, detailing the workflow from theme selection to frame‑by‑frame color mapping and automated code generation.
This article examines the trade‑offs of using Project Lombok in Java projects, showing how its syntactic sugar reduces boilerplate but can introduce technical debt, version‑compatibility issues, hidden coupling, and readability problems that may outweigh its short‑term benefits.
After a year of using Project Lombok, the author reflects on how the library initially simplifies Java boilerplate but eventually introduces technical debt, version‑compatibility issues, hidden complexity, and tighter coupling, urging teams to weigh its short‑term convenience against long‑term maintainability.
This tutorial walks through setting up the development environment, configuring generator files, generating channel microservice code, updating Maven dependencies and application settings, testing service endpoints, and publishing the complete PassJava Spring Cloud project with code snippets and deployment instructions.
This article explains how to create a JetBrains IntelliJ plugin that parses MySQL DDL statements, performs lexical analysis to extract table and column information, and automatically generates corresponding Python ORM model classes, illustrating the underlying state‑machine lexer, recursive parsing logic, and sample code.
This guide shows how to integrate the MyBatis Generator Maven plugin into a Spring Boot project, configure generatorConfig.xml, run the plugin to auto‑create entity, mapper, and XML files from database tables, and use the generated code in a service layer.
This article introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering a ready‑to‑use project structure, unified response handling, exception processing, code generation tools, and simple signature authentication to accelerate backend development.
This article details UCloud's engineering of API and SDK management—including unified modeling, code generation, automated testing, and CI/CD pipelines—to dramatically improve the stability, reliability, and release efficiency of its public cloud services.
This tutorial shows how to quickly generate 200 activation codes in the xxxx-xxxx-xxxx-xxxx format using a Python generator and then tally the occurrence of each character with a dictionary, providing both the code and sample output.
This tutorial walks you through installing the EasyCode IntelliJ plugin, setting up a MySQL database, configuring a Spring Boot project, adding necessary Maven dependencies and YAML settings, and using EasyCode to automatically generate entity, DAO, service, controller, and mapper code without manual coding.
This guide walks through installing the EasyCode IntelliJ plugin, setting up a MySQL database, configuring a Spring Boot project, adding necessary Maven dependencies and application.yml settings, and using EasyCode to automatically generate CRUD code for the defined tables.
This article explores how AI-driven front‑end code generation—from design‑to‑code pipelines, product analyses, technical challenges, and layered recognition models—to improve developer efficiency, detailing the D2C system, its real‑world deployment during 2019 Double‑11, and future roadmap.
This tutorial explains how to install the EasyCode plugin, set up a MySQL database, configure IDEA, generate entity, controller, service, DAO, and mapper code for a Spring Boot project, and adjust Maven and YAML settings to run the application successfully.
This tutorial explains how Java developers can use IntelliJ IDEA Live Templates to automatically generate repetitive code such as private fields, loggers, and Spring beans, covering basic usage, custom templates, advanced functions, and practical examples that dramatically improve coding efficiency.
This article recounts how a developer transformed a massive three‑thousand‑line C# data‑center monitoring client into a concise fifteen‑line solution by applying reflection, generics, and systematic refactoring, while sharing practical advice on avoiding code generators, reinventing the wheel, and using unit tests to foster clean architecture.
This article explains how Alibaba's Frontend Intelligent Project automatically generated 79.34% of the Double‑11 page code by recognizing business modules from visual drafts using data‑augmented samples, traditional multi‑class machine‑learning models, and a pipeline of preprocessing, model training, deployment, and OOD handling.
The article introduces the concept of an App Factory—a code‑generation platform that, based on a unified component library and dependency graph, can produce multiple iOS applications on demand while eliminating unused code, and details its architecture, implementation methods, quality controls, and real‑world results within 58.com’s ecosystem.
This article explains how Alibaba's Frontend Intelligent project uses design‑to‑code techniques, component recognition with YOLO, and a full pipeline of sample creation, model training, evaluation, and prediction refinement to automatically generate a large portion of the Double‑11 event code.
This article explains how Alibaba's Front‑End Intelligent project automatically converts UI design images into production‑ready code, covering layout analysis, background and foreground processing, a fusion of traditional image algorithms with deep‑learning detection, GAN‑based complex‑background extraction, experimental results and real‑world deployment.
This article explains Alibaba's front‑end intelligent project that automatically generated 79.34% of the Double‑11 UI code, detailing why images are used as input, the layered image‑processing pipeline, background and foreground analysis, traditional versus deep‑learning methods, fusion techniques, evaluation results, and real‑world deployments.
This article explores the rise of front‑end intelligence, analyzing background trends, competitive solutions, problem decomposition, and technical approaches for automatically converting design drafts into HTML, CSS, and JavaScript, while discussing challenges, model accuracy, data quality, and future roadmap for the D2C (Design‑to‑Code) system.
This article explores six practical ways to accelerate Java development—from hand‑writing and copy‑pasting to Excel formulas, code‑generation tools, and custom generators—detailing their workflows, sample code, advantages, drawbacks, and how to choose the right method for any project.
This article explains the concept of PSI (Program Structure Interface) in IntelliJ IDEA, demonstrates how to obtain PsiFile objects, manipulate PsiJavaFile, PsiClass, PsiField, and add annotations and parameters, providing a practical guide for plugin developers.
Metaprogramming in Dart leverages the Dill intermediate representation and its abstract syntax tree to programmatically generate, transform, or inject code at compile time, enabling features such as custom serialization, AOP hooks, and reflection‑like capabilities without runtime overhead.
This article explains how to parse a Swagger JSON document and automatically generate maintainable Java test code for each API endpoint, detailing the handling of GET query parameters, POST form‑data, RESTful path variables, and header conventions.
This article explains the inner workings of Tapable—the hook library behind Webpack—by detailing its synchronous and asynchronous hook types, registration and invocation methods, the lazy‑compilation code‑generation process, and how these mechanisms give Webpack a performance edge over naïve event loops.
This article explains the concept and practical application of the Annotation Processing Tool (APT) in Android development, demonstrating how to set up an APT project, define annotations, process them with custom processors, and automatically generate Java code for activity navigation using JavaPoet.
AspectD is a compile‑time Aspect‑Oriented Programming framework for Dart that traverses Flutter’s dill intermediate files to inject, call, or execute advice code, allowing non‑intrusive instrumentation, logging, and UI event injection without modifying source, and integrates into the build pipeline via a toolchain patch.
This article explains why Lombok was created to eliminate repetitive Java code, shows how to add the Maven dependency, configure IDE support, describes its annotation‑processing mechanism, and demonstrates the most common Lombok annotations with before‑and‑after code examples.
The UI2CODE pipeline converts image‑derived JSON DSL layouts into Flutter code by constructing a hierarchical DSL tree, partitioning it into rows, columns or stacks, applying unsupervised text‑alignment and padding heuristics, generating templated widget code with separate data models, cutting development effort by roughly two‑thirds and now used internally at Xianyu.
To meet Xianyu’s rapid UI change demands and curb its swelling Android package, the team built a Flutter‑specific dynamic template system that compiles Dart widget code into JSON, streams it to the client, reconstructs the widget tree at runtime, and maintains 55‑60 fps performance while planning further widget support and caching.
UI2CODE, an AI‑powered tool from Xianyu’s tech team, automatically transforms UI screenshots into editable Flutter code by extracting visual elements with machine‑vision, classifying them via deep‑learning, generating a domain‑specific language through a recursive neural network, and mapping this DSL onto syntax‑tree templates to achieve pixel‑level precision, full accuracy, and maintainable output.
This article demystifies how programming languages are transformed by compilers, covering the roles of lexical analysis, parsing, abstract syntax trees, code generation, and linking, with practical Rust examples, diagrams, and references to deepen your understanding of language implementation.
This article explains how to replace cumbersome if‑else or manual map‑based routing in Flutter with a lightweight, annotation‑driven solution that automatically generates a page‑to‑URL mapping at compile time, using Dart's source_gen, build, and analyser packages.
The UI2CODE framework from Alibaba's Xianyu team uses machine‑vision and deep‑learning techniques to automatically interpret design screenshots and generate ready‑to‑use Android, iOS, and web code, dramatically cutting UI development effort.
This guide shows how to use a PHP class that randomly creates realistic Chinese surnames and given names, explains its methods, and provides a ready‑to‑run example for backend developers.
ui‑automation, developed by Alibaba’s Xianyu team, automatically converts Sketch files or PNG images into clean, maintainable UI code for platforms such as Flutter or Weex by extracting visual information, building a hierarchical DSL, and applying template generation, delivering senior‑engineer‑level quality while overcoming the maintainability limits of earlier scanning‑based approaches.
This article provides a detailed tutorial for creating a Spring Boot project with MyBatis, including environment setup, Maven dependencies, configuration files, database creation, MyBatis generator usage, and sample controller, service, and mapper code, enabling pagination with PageHelper and testing via HTTP requests.
This article introduces Lombok—a Java library that eliminates boilerplate code—by showing how to install it in IntelliJ, demonstrating the most common annotations with runnable examples, and revealing the annotation‑processing mechanism that generates the bytecode during compilation.
This article introduces the React‑Sketchapp tool for generating Sketch design assets from code, explains why code‑based design generation is beneficial, provides step‑by‑step setup commands, showcases example components and API usage, and reflects on its impact on design‑development workflows.
By walking through the creation of a custom Android Studio (IntelliJ) plugin that reads protobuf files and auto‑generates Service and Presenter classes, the author shows how VFS, PSI, and project‑model APIs can replace tedious manual coding, delivering roughly 5.5% time savings per requirement.
This article describes the pain points of manual API test script writing, proposes a workflow that parses interface documentation, automatically generates both interface classes and robust test cases using Python and Swagger, and demonstrates significant efficiency gains and future improvement directions.
This article demonstrates how to use Google's ZXing Core library in a Java Maven project to generate QR code images, create random verification codes, and decode QR codes from files, providing complete code examples and step-by-step instructions.
This article explains why a template engine is needed for web applications that mix large static HTML with dynamic data, describes the supported template syntax based on Django, and walks through the implementation of a Python‑based engine that parses templates, compiles them into Python code, and renders the final HTML efficiently.
This article introduces Lombok as a Java code‑simplification tool, explains how to install the IDEA plugin and add the Maven dependency, demonstrates basic and advanced annotation usage, discusses domain‑driven design models, and shows how Lombok can be combined with FreeMarker and MyBatis for automatic code generation.
Recent advances in deep learning have enabled machines to automatically generate code, with research divided into black‑box methods that learn input‑output transformations and code‑generation approaches that produce explicit program fragments, exemplified by systems such as Neural Program Interpreters and hierarchical generative CNN models.
The article presents a serverless‑style solution that replaces a heavy backend with a lightweight, automatically generated CRUD layer, detailing RESTful API conventions, extensions for batch operations, query parameters, foreign‑key handling, and a Rails‑based code‑generation pipeline to streamline development of a high‑availability supply‑chain system.
The article introduces Ctrip DAL, an open‑source Java/C# database access framework that supports sharding across MySQL and SQL Server, provides a code generator and client library, and helps large enterprises manage multi‑team, multi‑database environments while ensuring scalability, consistency, and security.
Ctrip DAL is an open‑source, multi‑language database access framework that supports sharding, code generation, and cross‑team management, enabling large‑scale enterprises to protect existing investments while rapidly scaling their data layer across MySQL and SQL Server.
The article recounts how the author transformed a massive, repetitive three‑tier factory class in a C# data‑center management system into a clean, reflection‑based solution of just a few lines, while sharing practical refactoring lessons, pitfalls of code generators, and advice on unit‑testing and architecture design.
