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.
Chinese languageartificial intelligencecode generation
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.
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 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.