AI Coding Assistant Lingma:Best practices for knowledge base as context for code completion

Backend scenarios

• [Recommended] Select high-frequency code snippets or files: Choose code snippets that appear often or are reused in the current project. These snippets are highly reusable and suitable for inclusion in a knowledge base. Organize these snippets into a separate repository and upload them to a separate knowledge base for easy management and retrieval.

• Code of the current project: You can also upload the entire current project to a knowledge base for comprehensive retrieval. This improves code reusability and development efficiency. However, if the project contains interfering or low-quality code, this may affect the performance of code completion enhancement.

Frontend scenarios

• [Recommended] Frontend template page code repository: Assemble enterprise custom components into templates for highly reusable frontend pages, such as logon, registration, account display, and fund transfer pages. If your enterprise has a template library, we recommend uploading it to the enterprise code knowledge base.

• Code repository of the current project: Upload well-structured and high-quality project code to the enterprise knowledge base for comprehensive retrieval. Low-quality or interfering code in the repository may affect code completion performance.

Case 1: Reuse of enterprise framework and middleware logic

An enterprise requires a unified distributed lock mechanism for its inventory management system. This can be done by integrating business frameworks into its code knowledge base. Developers can then easily use these code snippets when writing new code in their IDE. This improves development efficiency, reduces repeated development, enhances code quality, and ensures business logic consistency.

Below are some tips to select and get ready a code repository:

Figure out the required business needs and implementations:

• Identify key business modules that require a unified implementation in your system, such as the inventory control, order processing, and payment systems.

• Set up how to handle specific business scenarios: For example, the inventory system has different tasks like reducing stock, checking stock level, and locking stock, and each task needs a different implementation mechanism.

Choose code files for the business frameworks and upload them to a code knowledge base:

• Filter business frameworks to find core code that handles key business logic, organize it, and upload it to a separate code knowledge base. For example, if distributed locking is required to keep them save while being updated, find the main code that implements this locking.

  /**
   * Use the enterprise-developed distributed locking mechanism to implement concurrency control
   */
  @Service
  public class InventoryService {
      
      @Autowired
      private DistributedLockFramework lockFramework;
      
      @Autowired
      private InventoryRepository inventoryRepository;
      
      /**
       * Use the distributed locking mechanism to ensure concurrency security during inventory deduction
       * @param productId, which specifies the product ID.
       * @param quantity, which specifies the deduction quantity.
       * @return, which specifies whether deduction is successful.
       */
      public boolean deductInventory(Long productId, int quantity) {
          String lockKey = "inventory:" + productId;
          return lockFramework.withLock(lockKey, 30, TimeUnit.SECONDS, () -> {
              Inventory inventory = inventoryRepository.findByProductId(productId);
              if (inventory == null || inventory.getQuantity() < quantity) {
                  return false;
              }
              inventory.setQuantity(inventory.getQuantity() - quantity);
              inventoryRepository.save(inventory);
              return true;
          });
      }
  }

Case 2: Reuse of core enterprise business logic

An enterprise wants to set up a single, personalized recommendation policy for its products. In this case, you can integrate enterprise-developed business frameworks into a code knowledge base of the enterprise. Then, developers can easily recall and reuse standardized code snippets when they write business logic in an IDE. This improves development efficiency, reduces repeated development, enhances code quality, and ensures the consistency and stability of business logic.

Below are some tips to select and get ready a code repository:

Determine the required business modules and implementations:

• Identify key business modules: Find the parts of your business that need a unified implementation in your system, like the commodity recommendation system.

• Define business actions and main steps. For example, a personalized recommendation policy includes these steps: collect user behavior data, figure out user interest features, get a list of possible products, score and rank these products, and show the top choices. You can use pre-written code to implement these steps.

Choose code files for the business frameworks and upload them to a code knowledge base:

• Find the main code that handles key business logic, organize it, and upload it to a separate code knowledge base. Here is an example of a personalized recommendation policy:

  /**
   * The recommendation engine service
   * Implement personalized recommendation based on user behavior and commodity features
   */
  @Service
  public class RecommendationService {
      
      @Autowired
      private UserBehaviorRepository userBehaviorRepo;
      
      @Autowired
      private ProductRepository productRepo;
      
      /**
       * Generate a recommendation list for a specified user
       * @param userId, which specifies the user ID.
       * @param limit, which specifies the maximum number of commodities that can be recommended.
       * @return, which specifies the IDs of recommended commodities.
       */
      public List generateRecommendations(Long userId, int limit) {
          // Obtain user behavior data
          List behaviors = userBehaviorRepo.findRecentByUserId(userId, 100);
          
          // Extract user interest features
          Map userInterests = extractUserInterests(behaviors);
          
          // Obtain a candidate commodity pool
          List candidateProducts = productRepo.findRecentlyActive(1000);
          
          // Calculate and rank commodity scores
          List scoredProducts = candidateProducts.stream()
              .map(product -> new ScoredProduct(product, calculateScore(product, userInterests)))
              .sorted(Comparator.comparing(ScoredProduct::getScore).reversed())
              .collect(Collectors.toList());
          
          // Return the top-scoring commodities
          return scoredProducts.stream()
              .limit(limit)
              .map(sp -> sp.getProduct().getId())
              .collect(Collectors.toList());
      }
      
      // Other auxiliary methods
  }

Case 3: Reference existing projects to improve new project efficiency

When an enterprise starts a new project, it can use the code of similar core modules in an existing project. This saves time and money, and makes the new project better and more stable.

Below are some tips to select and get ready a code repository:

Identify key business modules based on the required business and scenarios:

• Identify similar functions or methods. For example, if both the new and old projects have functions such as user management, commodity display, and order processing, list the related modules.

• Check code quality: Make sure that the existing project code has been fully tested and is stable and reliable. Remove extra files and configurations to keep the code clean and easy to use.

Define specific business actions and core actions:

• Extract core functions: From the existing project, extract the code of key functional modules that can be reused. Examples:

  • User management: user registration, logon, and information modification

  • Commodity display: commodity list, details page, and search function

  • Order processing: placing order, handling payment, and updating order status

Choose code files of the related business frameworks and upload them to a code knowledge base. Reorganize the code of the existing project using a modular structure. This separates the code for different teams that are responsible for specific modules in the new project. Create a separate code repository for each module:

• Code knowledge base isolation: Upload the code of the existing project to the proper knowledge base. For example, upload the code of the user management, commodity display, and order processing modules to separate knowledge bases.

• Permission management: Set up permissions so only right teams can access specific code. This prevents interference during code completion in IDEs.