This tutorial shows how to use GitHub Copilot in VS Code to quickly generate a Java application that loads, parses, and prints data from CSV files, including creating example CSV content, adding column‑name output, and downloading CSVs from a URL.
GitHub has launched Copilot X, an AI‑enhanced developer tool powered by GPT‑4 that adds a chat interface, voice commands, Pull‑Request assistance, documentation search, and a CLI, promising up to ten‑fold productivity gains for developers worldwide.
This article introduces the MyBatis‑Plus Generator UI, a web‑based code generation tool for Spring Boot projects, explains its features, shows how to integrate it via Maven and a main class, demonstrates running and customizing the generator, and provides tips for extending templates and UI.
This article introduces the MyBatis‑Plus Generator UI, a highly customizable web‑based code generator for Spring Boot projects, explains how to integrate it via Maven, run it, use its rich features for entity, mapper, service and controller generation, and extend it with custom templates and name‑conversion rules.
This article curates key frontend topics—including how CommonJS and ES modules handle circular dependencies, why Proxy must be paired with Reflect, practical bug‑recording and source‑code navigation, building guide pages without third‑party libraries, plus a look at clustering algorithms and a powerful CRUD code generator—offering concise insights for modern web developers.
This article presents the Design2Code (D2C) tool, detailing its background, core algorithmic concepts, industry landscape, implementation architecture, layout reconstruction techniques, visual constraints, and future plans, aiming to improve front‑end development efficiency by automatically converting design drafts into production‑ready code.
The article explains how to replace repetitive raw SQL and manual row scanning in Go by building a lightweight custom ORM that combines a chainable SQLBuilder for dynamic query construction with a reflection‑based Scanner that maps results to structs, also covering code generation and optional non‑reflection optimizations.
This tutorial explains what MybatisX is, outlines its advantages, and provides a detailed, code‑rich walkthrough for integrating the plugin into a Spring Boot project, configuring the database, generating MyBatis‑Plus entities, and writing a simple controller to query data.
This article demonstrates how to use Apache POI's XSSFWorkbook and SXSSFWorkbook classes in Java to export data to Excel files, addresses memory overflow issues with large datasets, shows code examples, and discusses the role of ChatGPT in assisting programmers without replacing them.
This article presents PDMan, a lightweight open‑source database modeling tool that simplifies schema design, supports automatic code generation for MySQL, Oracle and Java, offers version management, and provides step‑by‑step instructions for installation and usage to boost development efficiency.
ChatGPT is transforming software development by simplifying code creation, accelerating learning, and enhancing workflows, yet it introduces challenges such as incomplete implementations, hidden bugs, and the need for precise prompting, prompting developers to view it as a powerful assistant rather than a full replacement.
This tutorial explains how to install the segno Python package and use it to create simple and customized QR codes for URLs, Wi‑Fi credentials, vCards, artistic designs, and in‑memory images, providing complete code examples and practical ideas for personal and social applications.
This article explains the concept of dependency injection, demonstrates a simple Go example with Message, Greeter, and Event components, and shows how the Google Wire library can automate the wiring of these components through code generation, reducing manual initialization complexity.
This article explains the differences between Java's Annotation Processing Tool (apt), Kotlin's annotation processor (kapt), and the newer Kotlin Symbol Processing (ksp) framework, illustrating their architectures, usage patterns, and code‑generation capabilities with practical examples for Android development.
This article explores the design and implementation of Fklang, a DDD‑guided architecture DSL, detailing its layered syntax, integration with IDEs, infrastructure abstractions, AI‑assisted code generation, mock server creation, and how it aims to industrialize software development through standardized modeling and tooling.
This article explains how the Kotlin Compose Compiler uses the intermediate representation (IR) to generate code, covering IR tree structure, traversal with visitors and transformers, and the process of adding composer parameters and restart groups via custom IrGenerationExtension plugins.
This guide walks you through installing the MyBatisCodeHelper‑Pro IntelliJ plugin, configuring it to generate Java entity, DAO, mapper and service code, customizing type mappings, creating SQL scripts, and using shortcuts to produce find, update, delete, and pagination methods efficiently for backend development.
This guide introduces twelve essential IntelliJ IDEA plugins—including Lombok, Free MyBatis, Translation, Alibaba Java Coding Guidelines, GenerateAllSetter, SequenceDiagram, CheckStyle‑IDEA, JRebel/XRebel, Codota, GsonFormat, Rainbow Brackets, and CodeGlance—that dramatically improve Java coding efficiency, reduce boiler‑plate, and streamline development workflows.
The annotation‑driven auto‑pipeline framework generates a linked‑list responsibility chain from @AutoPipeline‑annotated interfaces, automatically wiring handler implementations to execute sequentially and return the first non‑null result, thereby boosting development efficiency, reusability, and correctness for complex business pipelines such as configuration sources and message throttling.
This article explains Java's verbosity problem, introduces Lombok as a code‑generation tool that uses annotations like @Data to auto‑create getters, setters, equals, hashCode and toString, shows installation and Maven setup, and discusses both the productivity gains and the hidden drawbacks such as team dependency, debugging challenges, inheritance issues, encapsulation concerns, and future JDK compatibility risks.
The article details the design and implementation of a pickup‑code system for SaaS e‑commerce platforms, covering simple single‑table approaches and a globally unique 8‑digit code scheme that embeds database and table identifiers, with strategies for sharding, conflict resolution, dynamic routing, and extensible tenant‑specific configuration.
This article outlines several common pitfalls of the Lombok library in Java, such as StackOverflowError from @ToString, missing no‑arg constructors with @AllArgsConstructor, hash‑based collection issues with @EqualsAndHashCode, and accessor mismatches caused by @Setter/@Getter, providing code examples and recommendations.
The article describes how fragmented real‑time, batch, and online data‑warehouse pipelines suffer from low productivity and inconsistent data quality, and introduces a unified SQL engine built on Apache Calcite that parses, optimizes, and compiles a single SQL statement into executable plans for ODPS, Flink, or Java, leveraging Janino code generation, multi‑backend state storage, and snapshot‑join semantics to boost performance and simplify development.
This article explains how JavaScript’s type coercion rules allow the construction of any code using only six characters—[]()!+—by demonstrating conversions for booleans, numbers, letters, special symbols, and finally assembling arbitrary executable code via the Function constructor, with examples and a link to the online converter.
This article introduces CodeSmith, a template‑driven code generation tool, explains why code generators improve efficiency and consistency, demonstrates how to write and reuse templates—including Java bean generation and data‑type conversion—and shares practical tips for automating model, SQL, and UI code creation.
This article explains how MapStruct simplifies Java object‑to‑DTO mapping by defining mapping rules, demonstrates various features such as default methods, abstract mappers, multiple parameters, @MappingTarget updates, handling of fields without getters/setters, Spring integration, and custom type conversions with clear code examples.
The article demonstrates how to build an offline C# reflection tool using libclang and ClangSharp by parsing C++ headers into an AST, traversing it, generating structured data, and applying Liquid templates, while introducing meta‑attributes via C++ annotate macros for fine‑grained code‑generation control.
This article explains how Lombok uses compile‑time annotations and the Java Annotation Processing Tool (APT) to automatically generate boilerplate code such as getters, setters, and constructors, and provides step‑by‑step examples of defining custom annotations, processors, and compiling them.
The article details the challenges of PHP invoking Java interfaces, compares two existing solutions, and presents a comprehensive refactoring approach that automates code conversion, resolves generic parsing and sandbox debugging issues, and reduces the integration steps from eight to three for more efficient backend development.
This article walks through creating a minimal JavaScript compiler—starting from tokenizing Lisp‑style input, building an abstract syntax tree, traversing and transforming it, and finally generating equivalent C‑style code, illustrating the core parse‑transform‑generate workflow used by tools like Babel.
This article explains how to replace manual BeanUtil mapping with MapStruct, leverage Spring's Converter interface, and use the MapStruct Spring Extensions plugin to automatically register mappers with ConversionService, including custom adapter configuration and integration of built‑in Spring converters.
This article examines whether Go can achieve aspect‑oriented programming by comparing Java's AOP mechanisms, introducing the gohook library for runtime method interception, and demonstrating how to modify Go source code through AST transformations with concrete code examples.
This article examines GitHub Copilot’s code‑completion, comment‑driven generation, and repetitive‑task automation features, evaluates its accuracy and security concerns, and argues that while it can streamline mundane coding, it will not replace skilled programmers.
This article explains the different POJO variants—VO, BO, PO, DTO, and DO—describes their typical usage in layered Java applications, introduces the Simple Object Copy IntelliJ plugin for one‑click conversion method generation, compares it with common mapping tools such as MapStruct and BeanUtils, and discusses performance and flexibility advantages.
This guide introduces Sa-plus, a SpringBoot‑based rapid development framework featuring a built‑in code generator, dual UI skins, and integrated JavaWeb utilities, and walks you through setting up the database, importing modules, configuring the application, and automatically generating full‑stack CRUD code and API documentation.
This article explains how C# source generators introduced in .NET 5/6 can analyze compile‑time metadata and automatically generate HttpClient implementation classes, register them in the DI container, and handle multi‑project assembly analysis for streamlined API consumption.
The final Airbnb Android testing article explains how a Kotlin script automatically generates JUnit tests for every MvRx Fragment, integrates them into a Buildkite CI pipeline that runs only changed fragment tests, shards execution with Flank, reports visual regressions via Happo, aggregates JaCoCo coverage, and posts detailed PR comments, while outlining future enhancements such as deep‑link, end‑to‑end, performance, and R8 testing.
Carnegie Mellon researchers introduced PolyCoder, a 27‑billion‑parameter open‑source code generation model built on GPT‑2, trained on 249 GB of multi‑language code and achieving superior performance to Codex in C while remaining competitive across eleven other programming languages.
The article introduces MyBatis‑Pro, a Spring‑Boot starter that eliminates manual single‑table SQL by generating CRUD methods through naming conventions, explains quick integration, core features, configuration options, entity annotations, logical‑delete strategies, generic services, and provides extensive code examples for developers.
The article outlines the major features of .NET 7 Preview 1, including nullable annotations for Microsoft.Extensions libraries, enhancements to tracing APIs, code‑generation improvements, dynamic PGO and Arm64 support, p/invoke source generation, new System.Text.Json APIs, and expanded hot‑reload capabilities.
This article examines common unit‑testing problems in Java projects, analyzes their root causes such as development and maintenance costs, and presents practical solutions including choosing JUnit5, leveraging Mockito, using in‑memory databases, and employing a custom IntelliJ plugin to automatically generate test code and test data.
Discover the MyBatis Generator GUI tool that streamlines Java POJO and mapping file creation, outlines its six key features, system requirements, and three easy startup methods—including self‑build, IDE launch, and native packaging—so you can quickly generate MyBatis code.
This article explains how design tokens serve as a platform‑agnostic bridge between design tools and front‑end code, improving collaboration, reducing visual‑to‑code errors, and enabling automated, consistent UI implementation across products.
This article provides a comprehensive tutorial on Lombok's @Builder annotation, covering basic usage, generated code details, @Singular collection handling, @Builder.Default defaults, toBuilder feature, and global configuration, with numerous Java code examples and explanations.
This article explains how Spark SQL's Catalyst optimizer performs logical and physical planning, details the Tungsten engine's data‑structure and whole‑stage code generation improvements, compares them with the Volcano iterator model, and provides code examples and PDF resources for deeper study.
The article introduces eladmin, an open‑source, front‑back separated admin platform built with Spring Boot, JPA, Spring Security, Redis and Vue, detailing its features, modular architecture, key functionalities, highlights, and providing a link to its GitHub repository.
This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with delegate‑based syntax, dramatically improves code readability, reduces boilerplate, and achieves up to 20% faster compilation while providing detailed implementation steps, performance results, and practical guidelines.
The article presents a detailed overview of the open‑source eladmin project, describing its Spring Boot‑based backend, Vue front‑end, modular architecture, RBAC permission model, code generation, and various built‑in features such as logging, monitoring, and cloud storage integration.
This article explains Gradle's fundamentals, compares it with Maven, introduces Groovy's abstract syntax tree (AST) concepts, and provides a step‑by‑step demo that parses a Gradle script into an AST, modifies it to inject a dependency, and attempts to write the changes back to the original build file.
This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with concise delegated properties, explains its design and implementation details, demonstrates significant compilation‑time reductions of up to 20% and cleaner code, and provides a step‑by‑step guide for developers interested in building similar compiler extensions.
This article demonstrates how to use Fluent MyBatis, native MyBatis, and MyBatis‑Plus to implement a statistical query on a student_score table, compares their code complexity and generation settings, and provides practical code examples and a summary of each framework’s advantages and drawbacks.
This guide explains how to use IntelliJ IDEA Live Templates to automate repetitive Java code, covering built‑in snippets, creating custom templates with variables, advanced functions like clipboard and groovyScript, and practical examples for declaring loggers, beans, and printing method parameters.
This article reflects on a year of using Project Lombok, showing how its annotations can dramatically shrink Java boilerplate but also introduce version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt that may outweigh its short‑term convenience.
This article compares Fluent Mybatis, native Mybatis, and Mybatis Plus by implementing a student score aggregation query, showing code examples, generation settings, and a summary of advantages and drawbacks to help developers choose the most efficient ORM for complex SQL operations.
The tutorial walks through building a complete LLVM‑based Kaleidoscope compiler—from a tokenizing lexer and recursive‑descent parser, through AST construction, LLVM IR generation with SSA and phi nodes, optimization passes, JIT execution, and mutable variable handling via stack allocation—providing full C++ source examples.
This guide introduces PlantUML, an open‑source text‑based UML tool, shows how to install its IntelliJ IDEA plugin, and provides step‑by‑step examples for creating sequence, use‑case, class, activity, and mind‑map diagrams, highlighting key syntax and the efficiency of code‑driven diagramming.
This article explains how bytecode and code‑generation improve Spark SQL performance, compares Java I/O and MapReduce InputFormats, reviews serialization choices in Spark and Flink, and describes reflection‑based DataFrame creation, storage‑memory eviction, fail‑fast design, and ConcurrentHashMap usage in big‑data frameworks.
This article explains how IntelliJ IDEA's Live Templates feature can automate repetitive Java code creation, covering basic usage, custom template definition, advanced variable functions, and practical examples to boost development productivity.
This article explains what MapStruct is, how to set it up in a Java project, demonstrates various mapping scenarios—including simple, nested, custom, and multi‑source mappings—covers performance benefits, integration methods, and provides complete code examples for practical backend development.
GitHub Copilot unexpectedly generated a fabricated ID for Bilibili CEO Chen Rui, sparking concerns about how large language models trained on public data can inadvertently expose synthetic personal information and highlighting broader privacy and ethical issues in AI‑driven code assistants.
This tutorial shows how to install the filestools library, use its curl2py command to convert cURL requests into ready‑to‑run Python code, and demonstrates the process with a real‑world example, saving time and avoiding manual copying of headers and parameters.
Learn what QR codes are, how to install the Python qrcode library, create simple and advanced QR codes with customizable parameters, and decode them using OpenCV, all with clear code examples and practical tips for safe usage.
This article examines the advantages and hidden risks of using Lombok in Java projects, illustrating how its annotations can dramatically reduce boilerplate code while also introducing version compatibility issues, forced dependencies, reduced readability, increased coupling, and technical debt, and suggests alternative approaches for cleaner code.
This article describes a complete workflow for iOS UI development that centralizes color definitions in a JSON palette, synchronizes them via a CocoaPods post‑integrate hook, and automatically generates Objective‑C/Swift color constants and Xcode code snippets using Ruby and ERB templates, dramatically improving efficiency and reducing manual errors.
This tutorial explains how to install the MyQR library, import it in PyCharm, and use its functions to create standard, image‑based, and colorized QR codes in Python, while also providing an overview of advanced parameters for further customization.
IntelliJ IDEA’s postfix completion lets developers type a dot after an expression and instantly expand it into common code constructs—such as loops, null checks, casts, and return statements—by selecting from a visual list, dramatically reducing manual typing and improving coding efficiency.
This article explores the concept, benefits, and implementation of skeleton screens as progressive loading placeholders, compares manual and automated generation methods—including puppeteer for web and React Native libraries—then presents a custom DSL-driven, low‑code solution that converts Sketch designs into reusable skeleton code, improving UX and developer efficiency.
This article demonstrates how to use Fluent MyBatis, native MyBatis, and MyBatis‑Plus to query a student_score table for term‑wise statistics of English, Math, and Chinese scores, providing complete code examples, SQL statements, mapper definitions, and code‑generation configurations for each approach.
This article examines Lombok’s ability to shrink Java boilerplate, walks through code transformations from verbose getters and setters to concise annotations, and critically evaluates five major drawbacks—including JDK compatibility, forced adoption, readability loss, tighter coupling, and technical debt—offering guidance on when to avoid it.
Uber’s self‑service API gateway provides a unified entry point for all applications, handling routing, protocol translation, rate limiting, authentication, and more, with configurable components such as protocol managers, middleware, handlers, and clients defined via YAML/Thrift, and leverages code generation and a DAG‑based build system to produce scalable, extensible backend services.
The article provides an in‑depth overview of Uber’s self‑service API gateway, describing its role in microservice architectures, the configurable components such as protocol manager, middleware, handlers and clients, the YAML/Thrift‑based configuration and code‑generation pipeline, and the advanced features and challenges involved in building a production‑grade gateway.
This article introduces imove, a visual workflow tool built on antv‑X6 and form‑render, explaining how it improves development speed, enables reusable logic components, supports synchronous and asynchronous JavaScript code, and provides detailed integration steps, shortcuts, and export mechanisms for modern frontend projects.
This article explains how to set up the MyBatis Generator plugin in a Maven project, configure generatorConfig.xml and jdbc.properties, and demonstrates practical CRUD operations such as deleting users, updating team information, and performing fuzzy and range queries with generated Example classes.
This article examines the evolution of Java SQL‑mapping frameworks, compares MyBatis, MyBatis Plus, MyBatis Dynamic SQL, JOOQ and the newer Fluent MyBatis, highlights Fluent MyBatis’s code‑centric design, IDE support, dynamic table naming, and provides practical code examples to illustrate its advantages.
This guide shows how to configure IntelliJ IDEA to automatically insert Javadoc class and method comments, including author, date, @param and @return tags, using File and Code Templates and Live Templates with custom Groovy scripts.
This comprehensive guide walks you through MyBatis-Plus fundamentals, non‑intrusive features, quick project setup, CRUD operations, automatic field filling, optimistic and logical locking, powerful wrapper queries, pagination, and the built‑in code generator, all illustrated with runnable examples and code snippets.
This article chronicles Alibaba’s three‑year evolution of frontend intelligence, detailing the origins of AI‑driven code generation, key technologies like imgCook, BizCook and UICook, the methodology, toolchain, organizational integration, and future directions for boosting development efficiency and business value.
This article provides a step‑by‑step guide for using MyBatis‑Plus with Spring Boot, covering database and table creation, entity and mapper definitions, CRUD examples, automatic field filling, optimistic and logical deletion, performance plugins, query wrappers, and a code generator for rapid development.
The article challenges typical objections to using Lombok—such as JDK version issues, forced plugin installation, reduced readability, increased coupling, and perceived technical debt—by providing detailed rebuttals that argue Lombok remains practical and beneficial for Java backend development.
The article presents a three‑stage pipeline that automatically transforms Sketch design drafts into a DSL view tree, infers layout and style properties, and generates Meituan‑compatible static front‑end code, while offering visual tools for layer cleanup, component recognition, and property adjustment to ensure high‑fidelity mobile UI reproduction.
The article examines typical criticisms of the Lombok library—JDK compatibility, forced adoption, reduced readability, increased coupling, and perceived drawbacks—while providing detailed rebuttals that argue Lombok remains useful for Java backend development despite these concerns.
The article systematically refutes typical criticisms of Lombok—such as JDK compatibility, forced adoption, reduced readability, increased coupling, and technical debt—by arguing that these concerns are overstated and that Lombok remains a valuable tool for Java backend development.
The article challenges typical criticisms of Lombok—JDK compatibility, forced adoption, reduced readability, increased coupling, and perceived technical debt—by providing counter‑arguments that emphasize stable JDK usage, minimal learning curve, alternative Lombok features, and the practicality of the library in modern Java development.
The article presents eladmin, a fully open‑source, front‑back separated admin platform built with Spring Boot, JPA, Spring Security, Redis and Vue, detailing its features, modular architecture, code‑generation capabilities, and highlights that make it a valuable learning resource for developers.
Screw is an open‑source, lightweight Java plugin that automatically generates database design documentation in HTML, Word, or Markdown for a wide range of databases, offering customizable templates, extensible modules, and Maven integration to streamline documentation maintenance and reduce manual effort.
This article explains the limitations of Lombok's @Builder annotation when dealing with inherited fields, demonstrates the issue with a sample ItemDTO class, and shows how the newer @SuperBuilder annotation overcomes these constraints by correctly handling superclass members, including code examples and internal implementation details.
This guide walks through setting up a MySQL database, configuring a Spring Boot project with MyBatis‑Plus, defining entities and mappers, and demonstrates CRUD operations, pagination, logical and physical deletes, optimistic locking, performance monitoring, and code generation, providing complete code snippets and configuration details.
This talk explains Alibaba’s P2C (PRD‑to‑Code) system, detailing how extending design‑to‑code pipelines to product requirement documents, combined with intelligent labeling and logic‑point extraction, enables front‑end engineers and product designers to automate code generation and accelerate development across the entire product lifecycle.
This talk explains Alibaba’s P2C product that extends design‑to‑code automation to PRD‑to‑code, detailing its layered architecture, annotation workflow, logical‑point extraction, code generation, and roadmap toward AI‑driven zero‑annotation development for front‑end engineers and product designers.
This tutorial explains how to replace verbose MyBatis mapper XML files with the modern Dynamic SQL API, covering setup, Maven dependencies, configuration, code generation, CRUD operations, advanced queries, subqueries, joins, conditional updates, and one‑to‑many mappings for Java backend development.
This article explains how to integrate MyBatis Generator into a Spring Boot project, configure it to generate entity classes, mapper XML and CRUD methods, and extend its capabilities with custom comment generators, advanced queries, and one‑to‑many/one‑to‑one mappings, reducing manual coding effort.
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.
