This tutorial demonstrates how to set up a simple MySQL database, create a Spring Boot project, add Mybatis-Plus dependencies, install the MybatisX plugin, configure the connection, generate entity, mapper, service, and controller code, and verify the integration with a sample REST endpoint.
This article explores how code large models and AIGC are transforming software development, covering their impact on developer skills, collaboration, cost control, the evolution of Copilot and Agent modes, multi‑agent architectures, retrieval‑augmented generation, and future directions for intelligent development tools.
This article explains how AI-powered code generators create high‑quality code, outlines their capabilities such as language translation and documentation assistance, discusses safety and copyright concerns highlighted by research, and emphasizes that while popular, these tools should augment rather than replace developers.
This article explains what Kotlin Symbol Processing (KSP) is, why it outperforms KAPT, how to migrate existing projects, the API it exposes for code generation, and how to leverage incremental compilation to dramatically reduce Kotlin build times.
This article introduces a self‑built tool that automatically generates database, service, DAO, and controller code for CRUD operations based on table definitions, explains its underlying template‑and‑parameter mechanism, demonstrates usage with a sample product table, and provides customizable templates and dynamic parameters for extensibility.
This article introduces Google Wire, a static‑analysis‑based dependency injection tool for Go, covering its key features, installation steps, core usage patterns—including defining dependencies, creating providers, generating code, and best practices such as modular management, interface abstraction, and testing with mock implementations.
A graduate student’s lab cut the time to process 150 GB of medical imaging data from one week for three people to two days for one person by using Baidu Comate’s AI‑driven code generation, annotation, and private‑knowledge enhancement features, achieving over nine‑fold productivity gains.
The article examines Baidu Marketing Service's AI‑native transformation using the Wenxin large model and Baidu Comate, detailing how real‑time code recommendations, open‑platform integration, and generative AI dramatically improve developer productivity, reduce coding time, and increase marketing ROI.
At the iTechClub summit, Baidu unveiled Comate Code Knowledge Enhancement 2.0—the nation’s first AI‑driven code assistant with real‑time web retrieval, over 10,000 built‑in GitHub repositories, API‑call generation, test case creation, and deep private‑doc understanding, now producing 27% of Baidu’s daily new code and topping VSCode and JetBrains plugin ratings.
This article explains the motivation, architecture, resource estimation, code generation algorithms, data modeling, database partitioning, caching strategies, and implementation details for building a scalable short URL system that handles billions of links and high QPS workloads.
After a year of using Project Lombok, the author reflects on how its annotations dramatically shrink boilerplate but also introduce version incompatibilities, hidden dependencies, reduced readability, tighter coupling, and technical debt, urging developers to weigh its benefits against long‑term maintenance risks.
Baidu Comate, built on the Wenxin large model and embedded as an IDE plugin, delivers a 24/7 AI coding assistant that helps developers think, write, and review code through context‑aware generation, error fixing, test case creation, rapid sub‑600 ms responses, fill‑in‑the‑middle editing, prompt‑engineered personalization, AutoWork automation, and an open Comate+ platform for extensibility.
Microsoft’s newly released TypeSpec language offers a lightweight, open‑source, API‑centric approach that lets developers describe APIs with minimal types, compile to OpenAPI, JSON Schema, and Protobuf, and leverage modern tooling for faster, more reusable code.
This article showcases several handy Lombok annotations—@onX for custom constructor injection, @Delegate for method delegation, @Cleanup for automatic resource release, the @Singular/@Builder combo for fluent object creation, and @With for immutable copies—illustrating their usage with Spring and Java code examples while warning against overuse.
This article introduces MyBatisX, an IDEA plugin that streamlines MyBatis development with navigation, GUI‑based code generation, customizable templates, JPA‑style method hints, and icon settings, providing step‑by‑step instructions and visual examples to enhance backend productivity.
This article explains several powerful Lombok annotations—including @onX, @Delegate, @Cleanup, @Builder with @Singular, and @With—showing how they simplify Spring‑based Java code through automatic constructor generation, method delegation, resource management, and fluent builders, while also warning against overuse.
This article introduces the latexify-py Python library for converting Python functions into LaTeX mathematical expressions, covering installation, version checking, example code using decorators, and displaying the generated LaTeX output, with screenshots and links for further reference.
This article explains how to use PHP functions and open‑source libraries to generate QR code images and decode them back into text, providing step‑by‑step code examples for both creation and decoding processes.
This tutorial walks through setting up a simple Spring Boot project, adding MyBatis‑Plus dependencies, configuring MybatisX in IntelliJ IDEA, generating entity, mapper, service, and controller code, and handling common connection issues, providing a complete end‑to‑end example of rapid MyBatis development.
Google has introduced the CodeGemma series, expanding its Gemma AI models with new variants optimized for code generation and reasoning, featuring 2B‑7B parameter models trained on 500 billion tokens, delivering full‑code block generation, strong benchmark results, and availability on Kaggle, Hugging Face, and Vertex AI.
This article introduces TypeSpec, a lightweight, extensible language for describing REST, OpenAPI, gRPC and other APIs, outlines its key features, demonstrates how to generate OpenAPI, JSON Schema and Protobuf files, and provides step‑by‑step instructions for installing the compiler, setting up the VS Code extension, creating a project, and compiling a sample service.
This article explains the unconventional Go switch without an expression, shows how it works like ‘switch true’, compares it with equivalent if‑else logic, examines the generated assembly, and discusses when this compact pattern is useful for prefix‑based checks.
This tutorial introduces the EasyCode IntelliJ IDEA plugin, explains how to install it, connect a database, configure generation settings, and automatically produce Java CRUD components such as entities, DAOs, services, and controllers, concluding with integration steps in a Spring Boot application.
LangChain, an open‑source framework that combines large‑language‑model capabilities with code understanding, enables automatic code generation, intelligent code analysis, documentation creation, and interactive programming tutoring, offering software engineers a powerful tool to accelerate development, improve quality, and stay ahead of emerging AI‑driven programming trends.
This article showcases clever Lombok tricks—including @onConstructor, @Delegate, @Cleanup, @Singular, @Builder, and @With—demonstrating how they simplify Java code, improve readability, and integrate with Spring for dependency injection while warning against overuse.
The article examines the evolution of AIGC, outlines Baidu’s Comate AI coding assistant, analyzes its underlying technologies and internal adoption, and explores how AI-driven code generation can boost developer efficiency across front‑end, back‑end, and multi‑language projects.
The article examines Jensen Huang’s claim that AI will make programming obsolete, discusses existing AI coding tools, highlights their limitations, and argues that human expertise in design, reasoning, and error‑checking remains essential for software development.
The article examines why large language models (LLMs) cannot fully replace human programmers, compares major models like Gemma, Code Llama, GPT‑4 and Claude, discusses trust and copyright concerns, and explores how smaller, specialized LLMs may shape the future of software development.
StarCoder2, the latest open-source large language model from ServiceNow, Hugging Face, and NVIDIA, offers three sizes—30B, 70B, and 150B parameters—delivering performance comparable to the original 150B StarCoder while being more efficient and freely accessible under the BigCode Open RAIL‑M license.
This article reviews the 2023 surge of large language models in software engineering, evaluates their current code generation, testing, and knowledge‑query capabilities, highlights persistent challenges in design and maintenance, and proposes concrete recommendations for advancing toward higher‑level intelligent development.
This article explores how generative AI is integrated into the AutoDev tool to add ArkTS language support, automatically generate ArkUI pages, and migrate existing Android, iOS, and mini‑program code to HarmonyOS, while discussing technical challenges and future improvements.
This article explains JD's design‑to‑code platform that leverages AI to automatically transform design drafts into front‑end code, detailing the typical frontend workflow, the platform's capabilities and limitations, and how it improves development productivity for financial app teams.
The article explores how a developer generated billions of if‑statements in C to decide odd or even for 32‑bit numbers, scaling the approach with Python‑generated code, custom assembly, memory‑mapped binaries, and discusses the practical limits and performance of such an extreme solution.
This article introduces PlantUML, explains how to install its plugins for IDEs, demonstrates various diagram types such as activity, class, component, and sequence, and provides a practical code example for modeling authentication flows, making it a comprehensive guide for creating UML diagrams efficiently.
This article introduces Baidu Comate, an AI-powered coding assistant built on the Wenxin model, explains how to install it, demonstrates its real-time code completion, comment generation, test creation, and optimization features across multiple languages and IDEs, and highlights its benefits for developers.
This article introduces the MyBatis‑Plus Generator UI, a highly customizable web‑based code generation framework that supports multiple databases, explains its core features, provides step‑by‑step integration with Spring Boot, and demonstrates how to extend templates and configure naming conventions for efficient backend development.
This tutorial explains why BeanUtil.copyProperties is discouraged in Java projects and shows how to install and use the Bean Converter IDEA plugin to automatically generate setter injection code, streamlining bean mapping and improving development efficiency.
This article introduces a SpringBoot‑based code generation tool that automatically creates entity classes, DAO interfaces, service implementations, and controller code from database tables, explains its design principles, demonstrates usage with screenshots, and provides a comprehensive set of customizable templates and dynamic parameters for developers.
ZapCraft is a Laravel package that automates the creation of entity‑related files, enforces SOLID and DRY principles, and integrates with Laravel‑Modules to streamline backend development while providing ready‑made repositories, services, requests, resources, and API routes.
This article introduces MyBatis-Plus, an enhancement layer for MyBatis, and walks through its core features—non‑intrusive CRUD, Lambda queries, primary‑key strategies, automatic field filling, optimistic locking, pagination, logical delete, performance analysis, condition builders, and a code generator—providing complete code examples and configuration steps for Spring Boot integration.
This article introduces the MyBatis-Plus Generator UI, a web‑based tool that streamlines Spring Boot code generation for entities, mappers, services, and controllers, explains how to integrate it via Maven, configure databases, customize templates, and extend its functionality with custom name converters.
By inserting a custom AopTransformer into Flutter’s front‑end compilation pipeline before optimization, the proposed Dart AOP solution automatically injects logging hooks that capture full‑stack user interaction paths and business state without modifying business code, delivering zero‑impact, maintainable instrumentation for improved debugging and app stability.
CodeFuseEval is an enterprise‑grade, multi‑task benchmark that evaluates code‑generation large models across six languages and thousands of real‑world tasks using both objective metrics (pass@k, BLEU, CodeBLEU) and expert human review, with an open‑source framework, continuous dataset expansion, and a focus on correctness, efficiency, robustness, and service‑level quality.
This comprehensive guide explains what ASM is, its core and tree APIs, common use cases such as Spring AOP and JDK lambda support, and provides step‑by‑step code examples for generating interfaces and classes, modifying bytecode, adding timers, printing parameters, handling control structures, and using handy tools for inspection.
This article introduces Javaassist, a Java library for runtime bytecode manipulation, and demonstrates how to view compiled bytecode, add Maven dependencies, generate new classes, modify existing ones, insert fields and methods, and apply AOP‑style enhancements without changing source code.
This article explores how generative AI, integrated into intelligent IDEs, can accelerate the analysis, redesign, and migration of legacy systems by providing scenario‑driven code enhancement, automated testing, custom actions, and living documentation, while also addressing validation and customization challenges.
This document presents a series of real‑world examples showing how ChatGPT can assist cloud‑trading developers with backend tasks such as resource scheduling, regex interpretation, CSV generation, JavaBean‑to‑JSON conversion, Spring IoC learning, JSON formatting, Java 8 stream processing, and CI pipeline error analysis.
This article introduces QR codes, explains their diverse personal and social applications, and provides a step‑by‑step guide using Python’s segno library—including installation, creating simple and artistic QR codes for URLs, Wi‑Fi, vCards, and advanced in‑memory handling—along with creative ideas for everyday use.
This article introduces AI‑powered tools Copilot and Cursor, explains their capabilities such as code completion, diagram generation, refactoring, SQL optimization, batch processing, and unit‑test creation, and provides practical best‑practice tips, shortcut keys, and efficiency analysis for each stage of software development.
The article explains AutoDev 1.4.0’s new Team Prompts feature, showing how shared, code‑based prompts enable TDD workflows, living documentation, and integrated code review within IDEs, while also detailing prompt syntax, interaction modes, and open‑source resources for teams seeking AI‑driven productivity gains.
This article shows programmers how to harness ChatGPT beyond simple Q&A by using advanced prompting techniques for knowledge summarization, task decomposition, code reading, refactoring, generation, unit‑test creation, and plugin integration, turning AI into a practical development assistant.
Ant Group’s open‑source CodeFuse is a large‑scale code‑generation model featuring multi‑task fine‑tuning and 4‑bit quantization, achieving a 74.4% HumanEval score that outperforms GPT‑4, supporting tasks from code synthesis to bug fixing, and can be deployed on a single high‑end GPU.
This article introduces Lombok, explains how it leverages Java's annotation‑processing (JSR‑269) and abstract syntax tree (AST) modifications to generate boilerplate code at compile time, and provides a step‑by‑step guide to manually implement a @Getter annotation processor with full Maven project examples.
This article demonstrates how to use GPT to accelerate code development, automate script creation, and integrate AI-driven suggestions into real‑world business scenarios such as e‑commerce promotion, providing practical tips, example prompts, and ready‑to‑run code snippets.
This article explains how to use Thrift as an interface definition language to automatically generate TypeScript client code, covering the definition syntax, annotation for request mapping, code generation architecture, and practical examples that boost frontend development efficiency.
The article describes how the author used ChatGPT to generate over 5,000 lines of code for a WeChat mini‑program community app, outlining the AI‑Driven Development (AIDD) workflow, detailed login and post‑list module implementations, multiple iteration cycles, code snippets, and reflections on efficiency and reuse.
This article explains how to embed the ChatGPT API into a low‑code development plugin to automatically translate Chinese variable names into English, preset Prompt templates, and generate fully typed Vue code for CRUD pages, complete with code examples and configuration steps.
Code Llama, Meta’s specialized extension of Llama 2, is a large language model fine‑tuned on code data that can generate, complete, and debug software across multiple languages, supports up to 100 k tokens, and is freely available for research and commercial use.
This article explains how AI-powered plugins like CodeGeeX can automate code writing, explain existing code, provide intelligent completions, and translate code between languages, helping developers dramatically improve productivity and reduce repetitive coding tasks.
The article presents yapi-to-all, an interface‑driven tool that automatically generates TypeScript definitions, service functions with useRequest, and page templates from YAPI documentation, eliminating repetitive coding, improving project management and code quality, already producing over 50,000 lines across seven projects, with future AI‑enhanced extensions planned.
This article introduces the MyBatis‑Plus Generator UI, a web‑based code generation framework that supports multiple databases, offers highly customizable templates, and integrates seamlessly with Spring Boot to accelerate backend development through automated creation of entities, mappers, services, controllers, and SQL‑based code.
The article shows that in the AIGC era a programmer who leverages AI tools like Copilot and GPT‑4 can deliver projects far faster and more cost‑effectively than a veteran relying on manual coding, urging developers to upskill, adopt AI‑assisted workflows, and focus on higher‑level design and ethical considerations.
This article surveys AI‑assisted coding tools—highlighting their core capabilities, comparing features, pricing, and security of GitHub Copilot, Codeium, Code Whispere, CodeGeex and Bito—while offering practical usage tips and recommendations for developers seeking to boost productivity with AI.
This article explains the fundamentals of JSX, why JSX expressions must have a single root element, and provides a step‑by‑step guide with complete code to implement a minimal JSX parser that translates JSX syntax into plain JavaScript createElement calls.
This article explains Python's dynamic code execution and code generation techniques, covering the exec function, code templates, and six practical examples such as dynamic module import, class loading, function invocation, class definition, function creation, and runtime modification of classes or functions.
This guide walks you through installing the CodeGPT extension in Visual Studio Code, configuring your OpenAI API key, and using its features—code generation, explanation, refactoring, and unit test creation—to boost productivity with AI-assisted programming.
This article explains how Codex, built on the GPT‑3.5 architecture, is trained and fine‑tuned to give ChatGPT the ability to generate code, detailing the data collection, supervised fine‑tuning, evaluation using HumanEval and the pass@k metric, and presenting performance comparisons with GPT‑3 and Codex‑S.
This article explores how ChatGPT can boost developers' productivity by generating code, refactoring and debugging, explaining code line‑by‑line, clarifying programming concepts, and automatically creating test cases, encouraging programmers to embrace AI as a daily tool.
This guide introduces GitHub Copilot and Copilot Labs, explains their AI‑driven code generation features, shows how to install them across various IDEs, and demonstrates practical usage such as custom functions, language translation, and automated testing to accelerate software development.
The article explores how generative AI and large language models are enabling automated code creation, self‑repair, and continuous‑integration workflows, while highlighting challenges in code quality, industry experiments at Google and Stack Overflow, and the future impact on developers and software engineering practices.
The article shares the author’s hands‑on experiments with ChatGPT, demonstrating how the AI model can generate code, translate scripts, create test cases, assist with debugging, and improve game‑testing workflows while also comparing its strengths to New Bing and discussing safety considerations.
This article introduces MapStruct, explains the challenges of JavaBean conversion, shows how to add dependencies, define POJOs and DTOs, create mapper interfaces with @Mapper, demonstrates basic and advanced mapping scenarios—including custom methods, nested objects, and dependency injection—while highlighting its performance and debugging benefits.
Learn how to use IntelliJ IDEA Live Templates to automatically generate repetitive Java code, from simple snippets like for-loops to advanced templates with variable functions, Groovy scripts, and custom configurations, dramatically reducing manual typing and improving development efficiency.
This article introduces MapStruct, explains why JavaBean conversion is challenging, shows how to add Maven dependencies, define POJOs and DTOs, create mapper interfaces, run tests, and explores its performance benefits, simple usage, debugging advantages, and advanced features such as custom mappings, multi‑source mapping, bean updates, and integration with dependency injection.
This article introduces the MyBatis-Plus Generator UI, a web‑based tool that wraps MyBatis‑Plus code generation to quickly produce Spring Boot compatible entities, mappers, services and controllers, explains how to integrate it via Maven and a main class, and demonstrates its rich customization and UI features.
This article demonstrates how to leverage ChatGPT's ability to produce textual code snippets together with PlantUML to automatically create various UML diagrams—such as sequence, class, flow, state, and use‑case diagrams—from Java‑style pseudocode, providing a step‑by‑step workflow and example prompts.
This article explains how AI large models such as ChatGPT can assist developers throughout the full workflow—from requirement analysis, technical design, and code generation to testing, deployment, and operations—while highlighting practical tips, potential pitfalls, and security considerations.
The article demonstrates how ChatGPT‑4 outperforms its predecessor in logical reasoning and code generation, helping developers craft regexes, refactor Go functions, implement business logic, fix parsing bugs, and suggest clearer names, while rapidly producing unit tests and accelerating low‑risk development tasks without fully replacing engineers.
This article reviews Alibaba’s Tongyi Qianwen large‑language model by testing its self‑introduction, code generation, literary creation, mathematical reasoning, Chinese language understanding, and casual chatting abilities, summarizing strengths, weaknesses, and overall performance compared with other LLMs.
This article introduces MapStruct, a compile‑time Java bean‑mapping code generator, explains its core concepts, shows step‑by‑step examples—including Maven dependencies, entity and DTO definitions, mapper interfaces, custom conversions, and advanced configurations—while comparing its performance to other copy utilities and highlighting deep‑copy behavior.
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.
