Gemini Code Assist - Code Refactoring

---

---

Code refactoring is vital to keeping your program optimized, maintainable, and bug-free. Gemini Code Assist simplifies this process by providing intelligent suggestions and automating refactoring tasks directly within your development environment.

Here, we will see different prompts used for code refactoring along with project scenarios to better understand the benefits of code refactoring.

What is Code Refactoring?

You can refactor any code in your current project, and it will make the code more compact while keeping it simple and scalable. Here, the logic does not change but the internal structure changes, eliminating redundant logic, and unwanted loops and increasing readability. Your task of further modifications to your project code becomes easier.

How Gemini Identifies Refactoring Opportunities?

Gemini uses advanced static code analysis which its trained upon along with dependency mapping to scan the codebase and suggest areas for improvement. Below are key ways it detects refactoring needs −

• Static Code Analysis − Identifies code logic, anti-patterns, and potential improvements or further simplifications if required.
• Detecting Code Variables − It flags issues like long methods, deep nesting, and redundant variables.
• Integration with Linters − Gemini can suggest immediate fixes based on style guides (like PEP8 in Python or ESLint for JavaScript).
• Dependency Analysis − Through this, Gemini ensures refactoring doesnt break links between modules or cause unexpected behavior in the project.

Supported Refactoring Techniques in Gemini

Gemini automates various refactoring tasks, including −

• Renaming Variables/Methods − Ensures meaningful naming conventions across the project and looks for the previous variable names if used.
• Extracting Methods − Breaks down complex logic into smaller, reusable methods.
• Inline Refactoring − Moves logic from separate functions into the main body when there is no need for those unnecessary sections.
• Simplifying Control Structures − Replaces deep if-else chains with cleaner logic.
• Loop Refactoring − Converts loops into functional code, such as map/filter functions.

Code Refactoring Examples Using Gemini

Lets take some examples of code refactoring using Gemini Code Assist −

Python Example: Extracting Methods

Here is a simple function of calculating an average of given numbers.

Before Refactoring,

def process_data(data):
   result = sum(data) / len(data)
   print(f"The average is {result}")
   print(f"Data has total {len(data)} elements")

process_data([10, 20, 30, 40, 50])

You can add a prompt to Gemini like: Suggest method extraction for large functions in Python. It will make the above code more generalised and scalable.

After Refactoring with Gemini Suggestions,

def calculate_average(data):
   return sum(data) / len(data)

def print_data_info(data):
   print(f"The average is {calculate_average(data)}")
   print(f"Data has total {len(data)} elements")

print_data_info([10, 20, 30, 40, 50])

This example demonstrates a method extraction in the above function. Ultimately, it promotes modularity by breaking the logic into smaller, focused methods.

JavaScript Example: Refactoring Control Structures

Before Refactoring,

function getUserAccess(role) {
   if (role === 'admin') {
      return 'Full Access';
   } else if (role === 'editor') {
      return 'Edit Content';
   } else {
      return 'View Only';
   }
}

Add suggestions to Gemini like: Simplify if-else conditions with an object-based pattern.. This refactoring uses an object map to simplify conditional logic and improve readability.

After Refactoring,

function getUserAccess(role) {
   const access = {
      admin: 'Full Access',
      editor: 'Edit Content',
   };
   return access[role] || 'View Only';
}

Java Example: Loop Refactoring with Streams

Before Refactoring,

int sum = 0;
for (int i = 1; i <= 10; i++) {
   sum += i;
}
System.out.println("Sum: " + sum);

Use prompts like: Refactor loops into functional streams in Java.. It will simplify and replace the loop with a functional stream for better readability and performance.

After Refactoring,

int sum = IntStream.rangeClosed(1, 10).sum();
System.out.println("Sum: " + sum);

You can refactor any code in any programming language with Gemini, which works across different platforms, frameworks and several types of personalised projects.

Automation in Refactoring with Gemini Code Assist

• Real-Time Suggestions − This feature is integrated directly within IDEs to provide immediate feedback, also when it is used as a lightweight extension.
• Batch Refactoring − Proper prompting will automate the renaming functions and method extraction across multiple files in the same project.
• Version Control Integration − Keep track of changes to avoid conflicts during collaborative development.
• Rollback Mechanism − When there is an unwanted refactor of code, it safely reverts changes to the original code, especially while facing any issue or scalability error.

Generating Perfect Test Cases for Refactored Code

Testing is essential after refactoring to ensure functionality remains intact. It can automatically generate test cases based on the refactored code to validate all possible outcomes.

Gemini scans the code and identifies the key inputs and outputs. It ensures all code paths, including edge cases, are covered by tests. The examination of dependencies generates test cases for edge cases and includes any interacting component in the function.

Example: Generating Test Cases in Python

Refactored Function −

def multiply(a, b):
   return a * b

Prompt − Generate parameterised tests for multiplication in Python using pytest.

Test Case Using Pytest −

import pytest
pytest.mark.parametrize("a, b, expected", [(2, 3, 6), (0, 5, 0), (-1, 4, -4)])
def test_multiply(a, b, expected):
   assert multiply(a, b) == expected

Example: Generating Test Cases in JavaScript (Jest)

Refactored Function −

function add(a, b) {
   return a + b;
}

Prompt − Create Jest test cases with multiple inputs for an additional function.

Test Case Using Jest −

test.each([
   [2, 3, 5],
   [0, 0, 0],
   [-1, 4, 3]
])('adds %i and %i to give %i', (a, b, expected) => {
   expect(add(a, b)).toBe(expected);
});

Real-Life Scenario: Refactoring a Web Application to Optimize Performance

Lets consider a Python-Django web application for managing employee records in an organisation. Initially, the code was written with minimal optimization, leading to performance issues, such as slow database queries and redundant logic.

Gemini Code Assist helps refactor the project step-by-step to enhance performance, readability, and maintainability.

Initial Problem: Un-optimized Code Structure

The original code retrieves employee data from the database, filters it manually, and then renders it to the front end.

Before Refactoring −

The above function retrieves all employees from the database and performs filtering manually. However, the logic within the view function can be extracted to a service layer for reuse.

Refactoring Database Queries

Prompt − "Can I Optimise these Django ORM queries for filtering employee salaries above 50,000?"

Gemini's Code Suggestion −

Here, the factors like filtering, ordering by salary, indexing, caching, pagination, and query optimisation are taken into action and provide a refactored code which can create a more efficient and scalable Django app for filtering employee salaries above 50000.

Extracting Logic into a Service Layer

Prompt − "Extract the employee filtering logic into a separate function for better code reuse."

Gemini's Code Suggestion −

This refactoring improves code reusability by encapsulating the logic into a separate function so that you can apply this logic in other parts of your application.

Generating Test Cases for Refactored Code

Prompt − "Generate pytest test cases to validate employee filtering logic."

Gemini's Test Case Suggestion −

The test case validates the filter_high_earners function and ensures the filtering logic works correctly with employees in the database.

Performance Testing with Gemini

Prompt − "Analyse the refactored function's performance and suggest improvements."

Gemini's Suggestion −

Use select_related() to reduce the number of queries if foreign keys are involved.

Apply caching for frequently accessed data to further enhance performance.

Impact of Refactoring on Project Performance

The following are the impact of refactoring on performance of a project −

• Improved Efficiency
• Better Maintainability
• Reduced Technical Debt
• Increased Collaboration

Best Practices for Refactoring with Gemini Code Assist

The following are the best practices for refactoring with Gemini Code Assist −

• Refactor in Small Steps − Avoid making multiple changes at once.
• Commit Regularly − Use version control to track changes incrementally.
• Run Tests Frequently − Ensure all functionality is intact after each change.
• Monitor Code Metrics − Track cyclomatic complexity and maintain code quality.
• Teamwork Reviews − Collaborate with team members to validate refactoring efforts.

Conclusion

Overall, the logic you write inside your project app must be precise and final. Gemini will look at this logic that you had written and suggest refactoring code in small snippets. These code suggestions are well understood by the developers and can be highly scalable in nature. All you need to do is to write perfect prompts and get the perfect output, without adding too much unnecessary information. This will not only enhance productivity but also reduce the time taken to make a scalable application which is more optimized and reliable.