Speed Up Web API Development with AI

Introduction

The world of programming is continuously evolving, and one of the key drivers of this change is the advancement in artificial intelligence, specifically Language Models (LLMs). These AI-powered models have rapidly transformed the way developers approach coding tasks by automating repetitive or time-consuming processes. Web developers can greatly benefit from integrating LLMs into their development workflows.

Imagine having a powerful assistant that takes care of generating boilerplate code, understanding complex error messages, and aiding with numerous additional tasks that would typically eat up valuable time and resources. In this blog post, we will explore how LLMs are reshaping the future of web apidevelopment by automating tasks, such as writing getters and setters, transforming JSON data into classes, explaining errors, and much more.

By embracing these powerful AI tools, developers can unlock new levels of efficiency and productivity in their daily work.

Boilerplate Code Generation

A significant portion of a developer's time is often spent writing boilerplate code, which is necessary but repetitive. Incorporating LLMs into your development process can help automate the creation of such code, allowing you to focus on more critical aspects of your project.  

Data Validation in Getters and Setters

AI can assist in drastically improving the accuracy of data validation operations within the getter and setter methods. With the incorporation of AI algorithms, validation rules can become more intelligent, anticipating potential issues and edge cases without any manual input from developers. This level of automation ultimately enhances data integrity in web APIs by enforcing strict validation checks with minimal effort on behalf of development teams.

They are not complicated tasks, but they must be done sometimes. What do we do? We ask an LLM for help!

Let's take a look at a simple Java class named UserProfile representing a user profile in a web application with three properties: firstName, lastName, and email:

public class UserProfile {
	private String firstName;
  private String lastName;
  private String email;
}

Traditionally, developers would need to manually write getter and setter methods along with validations for each property in this class. However, using AI tools, we can considerably reduce the boilerplate code required. Below is a presentation of the automatically generated methods with extensive features, including proper validation enforcement:

public class UserProfile {
    private String firstName;
    private String lastName;
    private String email;

    // Getter and Setter with validation for firstName
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        if (firstName == null || firstName.trim().isEmpty()) {
            throw new IllegalArgumentException("First name cannot be null or empty");
        }
        this.firstName = firstName;
    }

    // Getter and Setter with validation for lastName
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        if (lastName == null || lastName.trim().isEmpty()) {
            throw new IllegalArgumentException("Last name cannot be null or empty");
        }
        this.lastName = lastName;
    }

    // Getter and Setters with validation for email
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        if (email == null || !email.matches("^[\\w-_\\.+]*[\\w-_\\.]\\@([\\w]+\\.)+[\\w]+[\\w]$")) {
            throw new IllegalArgumentException("Invalid email format");
        }
        this.email = email;
    }
}

In the above example, the AI tool produced the necessary boilerplate code for both getter and setter methods and introduced validations to ensure data integrity. The setFirstName and setLastName methods verify that the inputs are not null nor empty, while the setEmail method confirms that the email address follows a valid format using a regular expression.

By leveraging AI into our development process, we saved valuable time and effort, enabling developers to focus on more critical aspects of web API design and implementation.

Transforming JSON to Classes

LLMs can convert JSON data structures into the equivalent classes, be them in C#, Java or other languages, automatically infer data types, and generate appropriate properties.

This automated process eliminates manual work and accelerates integration with APIs and other data sources.

If there’s a potentially complicated JSON data structure, it could take forever to transform the data to a C# class. Luckily, we don’t have to do it ourselves.  

Let’s look at an example (the data comes from https://www.govtrack.us/api/v2/role?current=true&role_type=representative&limit=438):  

{ 

  "meta": { 

    "limit": 438, 

    "offset": 0, 

    "total_count": 441 

  }, 

  "objects": [ 

     { 

      "caucus": null, 

      "congress_numbers": [ 

        118 

      ], 

      "current": true, 

      "description": "Representative for New York's 9th congressional district", 

      "district": 9, 

      "enddate": "2025-01-03", 

      "extra": { 

        "address": "2058 Rayburn House Office Building Washington DC 20515-3209", 

        "office": "2058 Rayburn House Office Building", 

        "rss_url": "http://clarke.house.gov/news/rss.aspx" 

      }, 

      "leadership_title": null, 

      "party": "Democrat", 

      "person": { 

        "bioguideid": "C001067", 

        "birthday": "1964-11-21", 

        "cspanid": 1022875, 

        "fediverse_webfinger": null, 

        "firstname": "Yvette", 

        "gender": "female", 

        "gender_label": "Female", 

        "lastname": "Clarke", 

        "link": "https://www.govtrack.us/congress/members/yvette_clarke/412221", 

        "middlename": "D.", 

        "name": "Rep. Yvette Clarke [D-NY9]", 

        "namemod": "", 

        "nickname": "", 

        "osid": "N00026961", 

        "pvsid": "44741", 

        "sortname": "Clarke, Yvette (Rep.) [D-NY9]", 

        "twitterid": "RepYvetteClarke", 

        "youtubeid": "repyvetteclarke" 

      }, 

      "phone": "202-225-6231", 

      "role_type": "representative", 

      "role_type_label": "Representative", 

      "senator_class": null, 

      "senator_rank": null, 

      "startdate": "2023-01-03", 

      "state": "NY", 

      "title": "Rep.", 

      "title_long": "Representative", 

      "website": "https://clarke.house.gov" 

    }, 

[…] 

This json has many properties. Why not ask our AI friend to help? Here’s what class it came up with for that data:
‍

public class Meta 

{ 

    public int Limit { get; set; } 

    public int Offset { get; set; } 

    public int TotalCount { get; set; } 

} 

  

public class Extra 

{ 

    public string Address { get; set; } 

    public string Office { get; set; } 

    public string RssUrl { get; set; } 

} 

  

public class Person 

{ 

    public string BioguideId { get; set; } 

    public DateTime Birthday { get; set; } 

    public int CspanId { get; set; } 

    public string FediverseWebfinger { get; set; } 

    public string FirstName { get; set; } 

    public string Gender { get; set; } 

    public string GenderLabel { get; set; } 

    public string LastName { get; set; } 

    public string Link { get; set; } 

    public string MiddleName { get; set; } 

    public string Name { get; set; } 

    public string NameMod { get; set; } 

    public string Nickname { get; set; } 

    public string OsId { get; set; } 

    public string PvsId { get; set; } 

    public string SortName { get; set; } 

    public string TwitterId { get; set; } 

    public string YoutubeId { get; set; } 

} 

  

public class Object 

{ 

    public string Caucus { get; set; } 

    public List<int> CongressNumbers { get; set; } 

    public bool Current { get; set; } 

    public string Description { get; set; } 

    public int District { get; set; } 

    public DateTime EndDate { get; set; } 

    public Extra Extra { get; set; } 

    public string LeadershipTitle { get; set; } 

    public string Party { get; set; } 

    public Person Person { get; set; } 

    public string Phone { get; set; } 

    public string RoleType { get; set; } 

    public string RoleTypeLabel { get; set; } 

    public string SenatorClass { get; set; } 

    public string SenatorRank { get; set; } 

    public DateTime StartDate { get; set; } 

    public string State { get; set; } 

    public string Title { get; set; } 

    public string TitleLong { get; set; } 

    public string Website { get; set; } 

} 

  

public class ApiResponse 

{ 

    public Meta Meta { get; set; } 

    public List<Object> Objects { get; set; } 

} 

General Rules

To take full advantage of LLMs' ability to write boilerplate code for your Web API, follow these steps:

1. Choose an appropriate LLM tool based on your requirements, considering aspects such as ease of integration, code generation accuracy, and associated costs. You may choose from e.g., GitHub Copilot, AWS CodeWhisperer, and many others.
2. Integrate the LLM into your development environment (e.g., Visual Studio or Visual Studio Code) to streamline the code generation process.
3. Provide clear and concise prompts to the LLM for generating required code snippets, and carefully review the generated code to ensure consistency with your project requirements.

AI-Assisted Error Explanation and Troubleshooting

Developing applications comes with its fair share of errors and bugs. LLMs can be invaluable in identifying these issues and providing guidance on how to resolve them.  

AI-powered Language can be incredibly helpful in resolving errors related to API development by providing suggestions and guidance based on their knowledge of programming patterns, best practices, and common issues. These automatic helpers can:

1. ‍Analyze Error Messages and Logs: AI can parse error messages, server logs, and other relevant information to pinpoint the root cause of the problem, thereby helping developers quickly identify and address the issue.
2. ‍Identify Incorrect Route Configurations: By examining the existing route configurations and controller attributes, AI can suggest corrections or improvements in the routing setup, ensuring that requests are directed to the appropriate endpoints.
3. ‍Examine Access Modifiers: AI can help ensure that all controllers and action methods have the proper access modifiers, such as making sure they are defined as public to be accessible to incoming API requests.
4. ‍Verify Controller Registration: AI can inspect the project's assemblies and configuration to confirm that all necessary controllers are included and registered correctly with the application.
5. ‍Provide Best Practices and Troubleshooting Resources: AI can recommend best practices and resources related to C# API development, which can help developers learn about prevention and resolution of common issues. Of course, models won’t only know C#; if you are a Node.js, Java or even a Rust developer, you are in luck.
6. ‍Real-time Code Analysis: Integrating AI with the development environment can enable real-time code analysis, offering developers immediate feedback on potential issues and suggestions to fix them, thus speeding up the debugging process. Here, you will have to install, e.g., a plugin for Copilot, but it is well worth it.

Syntax and Semantic Error Detection

Since neural networks have consumed enormous amounts of data, they will also know languages’ syntax, and how to write apps, often being taught by the core teams, too.  

Identifying common coding mistakes:

LLMs can spot syntax and semantic errors in your code, highlighting areas that may cause issues or do not adhere to best practices.

This allows developers to correct mistakes early in the development process, reducing the risk of bugs making it to production.  

Offering guidance on resolving issues:

Models can provide suggestions on how to fix detected errors, speeding up the troubleshooting process and decreasing the time spent on debugging code.

Troubleshooting Assistance

Memory leaks are a potentially rare, but painful errors. Let’s look at this JavaScript Express code which introduces a memory leak:

const requests = new Map(); 

app.get( "/", (req,res) => { 

    requests.set(req.id, req); 

    res.status(200).send("Hello World"); 

}); 

It isn't the most complicated of issues to resolve, but we asked our AI colleague where the issue is, and how to fix it. Here is the response we have received:  

In the provided code snippet, a potential memory leak occurs due to the `requests` Map object, which stores a reference to each incoming request object (`req`) when the root endpoint ("/") is accessed. This map will continue to grow as new requests arrive, and the stored references can prevent the garbage collector from releasing the memory associated with these request objects, ultimately leading to a memory leak.

To fix the memory leak, you need to reconsider the purpose of the `requests` Map and its intended functionality. If you're using it simply to track or count incoming requests, an alternative approach can be introduced while avoiding the memory leak:

let requestCounter = 0;
‍
app.get("/", (req, res) => {
   requestCounter++;
   res.status(200).send("Hello World");
   console.log(`Total Requests: ${requestCounter}`);
});

In this solution, we replace the `requests` Map object with a `requestCounter` variable that maintains the count of incoming requests. The request objects are no longer stored in memory, which allows the garbage collector to free up memory as required.

However, if the original purpose of the `requests` Map was to persistently store request information for another reason, consider implementing an appropriate data management strategy, such as:

1. Storing only essential request information, not the entire request object.
2. Implementing a cleanup or eviction mechanism, like using a least-recently-used (LRU) cache or setting a maximum size for the `requests` Map.
3. Periodically offloading or persisting request information to an external data store or database to free up memory in your application.

Providing insight based on error messages:

Copilot or other models can interpret error messages and compiler output, helping developers pinpoint root causes of issues and offering potential solutions.

This accelerates the debugging process and enables developers to more effectively troubleshoot and resolve complex problems.

Streamlining the debugging process:

By integrating AI into the development environment, developers can quickly resolve errors and iterate on their code, reducing the overall time spent on debugging and improving project timelines.

Let’s look at an example:  

using System; 

  

namespace ExampleApp 

{ 

    class Program 

    { 

        static void Main(string[] args) 

        { 

            Console.WriteLine("Enter a number:"); 

            int userInput = Console.ReadLine(); 

            Console.WriteLine("Your number squared is: " + userInput * userInput); 

        } 

    } 

} 

Upon compiling, the developer encounters this error message: CS0029: Cannot implicitly convert type 'string' to 'int'.

Of course, it’s a trivial case, but will show the possibilities. How AI can help:

The AI-driven Language Model (LLM) analyzes the error message and identifies the issue in the code. From the error message "Cannot implicitly convert type 'string' to 'int'", the AI recognizes that the developer is trying to perform a type conversion that C# does not allow implicitly.

In this specific scenario, the AI can pinpoint the problem in the line int userInput = Console.ReadLine();. It understands that Console.ReadLine() returns a string, which cannot be directly assigned to an integer variable.

The LLM then suggests a solution for the developer, recommending using the int.Parse() or int.TryParse() methods to convert the string input into an integer before performing the desired calculations.

The updated code with AI's suggested fix:

using System; 

  

namespace ExampleApp 

{ 

    class Program 

    { 

        static void Main(string[] args) 

        { 

            Console.WriteLine("Enter a number:"); 

            string userInputStr = Console.ReadLine(); 

  

            // Using int.Parse() to convert the string to an integer 

            int userInput = int.Parse(userInputStr); 

  

            Console.WriteLine("Your number squared is: " + userInput * userInput); 

        } 

    } 

} 

By decrypting the error message and providing specific guidance on how to resolve the issue, the AI-powered LLM helps the developer quickly fix the problem and streamline the development process.

Automation of Other Repetitive Tasks

Language Models are not just limited to code generation and error explanation; they can be used to automate various other tasks that usually consume a significant amount of a developer's time while offering little in terms of creativity or intellectual challenge.  

Code Refactoring and Optimization

LLMs, familiar with best practices and programming patterns, can suggest ways to improve your code's performance, maintainability and readability by identifying areas that can benefit from refactoring or optimization.   

For example, we asked GPT to optimize the naive way to get nth Fibonacci number. Our naive way:

import java.io.*;
class fibonacci {
    static int fib(int n)
    {
        if (n <= 1)
            return n;
        return fib(n - 1) + fib(n - 2);
    }
 
    public static void main(String args[])
    {
        int n = 9;
        System.out.println(fib(n));
    }
}

Here is what GPT came up with:

import java.io.*;
class Fibonacci {
    
    static int fib(int n)
    {
        int[] f = new int[n+2];
        f[0] = 0;
        f[1] = 1;

        for (int i = 2; i <= n; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f[n];
    }
 
    public static void main(String args[])
    {
        int n = 9;
        System.out.println(fib(n));
    }
}

Implementing Best Practices for Maintainability

LLMs can ensure that your C# code conforms to industry-accepted best practices and standards, making it easier for other developers to navigate and maintain the codebase.   

Examples:

• The LLM can recommend adopting the SOLID design principles or appropriate design patterns to improve the code's overall structure.
• It might suggest using dependency injection to make the code more flexible and testable.

Documentation Assistance

LLMs can help create meaningful comments for your functions, classes, and variables, ensuring that the code is well documented and easier to understand for both you and other developers on your team.  

Examples:

Given a function for calculating the area of a rectangle, the LLM can generate an explanatory comment like: "This function calculates the area of a rectangle given its width and height as input parameters."

For a class representing a customer, the LLM can generate comments explaining the purpose of the class and its properties, such as the customer's name, address, and contact information.  

Ensuring code is accessible for other developers: High-quality documentation, generated with the help of LLMs, can make the codebase more accessible for other developers, reducing the learning curve and enabling more efficient collaboration.

Simplifying Code Conversions        

While working with e.g., C#, developers might often need to integrate code from another language, like JavaScript or Python. LLMs can help with the appropriate conversion, allowing developers to minimize the cumbersome manual work required for such integrations.

Examples:

• Translating Python scripts for data processing into C# for better integration with existing C# applications.
• Converting snippets of JavaScript code into C# to embed web interface logic into a C# backend.  

Bridging gaps in understanding across programming languages:

LLMs can quickly find relevant resources, such as code examples or tutorials, for learning new programming languages or libraries, making it easier for developers to adapt to new technologies or expand their knowledge.  

Sometimes learning a new programming language can be a challenge, because all you have ever learned are programming concepts as implemented in e.g., JavaScript. If you are having problems with adapting to e.g., strongly typed languages, then you may ask the AI to explain the concept you're not clear on.

Conclusion

LLMs hold immense potential for enhancing developer productivity and optimizing the software development process, especially for C# developers. By automating repetitive tasks such as writing getters and setters, converting JSON to classes, debugging errors, and refactoring code, LLMs are shifting the focus towards creative problem-solving and designing robust, high-quality software.

Embracing these AI-driven tools can bring new levels of efficiency to your C# development, allowing you to focus on delivering innovative solutions that drive results.