DEV Community: Vikas Yadav

💡Advance Coding Tips: Object Reuse for Performance Win

Vikas Yadav — Tue, 08 Apr 2025 09:27:42 +0000

🎯 TL;DR

If you're allocating memory or creating objects repeatedly inside loops when the data doesn’t change—stop. Build once, reuse, and only clone when needed. This small change can lead to huge gains in performance, especially in high-frequency or large-scale systems.

🧠 The Principle: Avoid Repeated Allocations

Creating the same object(s) multiple times inside a loop causes:

Higher memory usage
Increased CPU cycles
More frequent garbage collection (GC)
Slower performance

Instead, build shared data structures once, and reuse or clone them only when needed.

📜 Real-Life Analogy: The Form Copying Example

Let’s say you’re filling out a form with mostly static data and need 10 copies.

❌ Inefficient: You retype the entire form 10 times. Waste of time and energy.
✅ Efficient: You fill out one master form and photocopy it 10 times. Fast and smart.

This is exactly how object creation in loops works in code. The CPU is your typist. Memory is your paper.

Before vs After: Code Comparison

for (int i = 0; i < 10; i++)
{
    var data = new List<string>
    {
        "sensor1",
        "sensor2",
        "sensor3"
    };

    Process(data);
}

- Above code Creates a new list each time.
- Allocates memory 10 times.
- Creates GC pressure.

Optimized Code (Allocate Once, Clone When Needed)

var baseData = new List<string> { "sensor1", "sensor2", "sensor3" };

for (int i = 0; i < 10; i++)
{
    var clonedData = new List<string>(baseData); // shallow copy
    Process(clonedData);
}

- Above Creates the base list once.
- Clones it for each iteration to avoid shared references.
- Saves memory and CPU cycles.

The Concept: "Reduce Unnecessary Allocations"

❌ What's the problem?
If you're creating new objects inside a loop that don’t need to change every time, you’re doing unnecessary work. That leads to:

More memory allocations (objects on the heap).
More garbage collection.
More CPU cycles wasted rebuilding the same thing.

✅ The solution:
Build it once outside the loop if it’s static. Then, clone it inside the loop only if it needs to be modified per call to avoid shared reference issues

Key Takeaways Points

"If it doesn't change, don’t build it more than once."
Use analogies like form photocopying.
Show side-by-side code examples.
Explain how repeated allocations lead to higher GC frequency and slower execution.

🧩 Bonus Tip

Even in test code, performance matters—especially when tests run hundreds of times in CI/CD pipelines. Optimizing test code leads to faster pipelines and happier devs.

Setup Code Coverage for Monorepo - SonarQube

Vikas Yadav — Tue, 23 Apr 2024 08:06:48 +0000

In a Monorepo setup, generating a coverage report for each library or app separately is common.

However, tools like the Sonar scanner may encounter difficulties in combining these reports into a single comprehensive one.

This issue arises when running tests with tools like nx affected, where only affected projects generate coverage reports, leaving unaffected projects out.

Consequently, SonarQube may raise quality gate errors due to missing coverage data.

Propose Solution Implemented

To resolve this problem, a custom script can be added to merge coverage reports into one file.

Below is a simple JavaScript function named coveragemerger.js for this purpose:

const glob = require('glob');
const fs = require('fs').promises;
const path = require('path');
const util = require('util');

const REPORTS_DIR_NAME = 'coverage';
const GREEN = '\x1b[32m%s\x1b[0m';
const BLUE = '\x1b[34m%s\x1b[0m';
const REPORTS_DIR_PATH = path.resolve(process.cwd(), REPORTS_DIR_NAME);

const globPromise = util.promisify(glob);

/**
 * Fetches all lcov.info files from coverage directories, excluding node_modules.
 * @returns {Promise<string[]>} A promise that resolves with an array of file paths.
 */
const getLcovFiles = function () {
  return globPromise(`**/coverage/lcov.info`, { ignore: '**/node_modules/**' });
};

/**
 * Creates a temp directory for all the reports.
 * @returns {Promise<void>} A promise that resolves when the directory has been created.
 */
async function createTempDir() {
  console.log(BLUE, `Creating a temp ${REPORTS_DIR_NAME} directory...`);
  try {
    await fs.mkdir(REPORTS_DIR_PATH, { recursive: true });
    console.log(GREEN, 'Done!');
  } catch (err) {
    console.error('Error creating directory:', err);
  }
}

(async function () {
  try {
    // Fetch all lcov.info files
    const files = await getLcovFiles();
    console.log("files are", files);

    // Create temp directory
    await createTempDir();

    // Read all files and join their contents
    const mergedReport = await Promise.all(files.map(file => fs.readFile(file, 'utf-8'))).then(contents => contents.join(''));

    console.log(BLUE, `Copying the coverage report...`);

    // Write the merged report to a new lcov.info file
    await fs.writeFile(path.resolve(REPORTS_DIR_PATH, `lcov.info`), mergedReport);

    console.log('Code coverage has been saved!');
  } catch (err) {
    console.error('Error:', err);
  }
})();

Azure Pipeline Integration

To integrate this into your pipeline, add the following command to your Azure Pipeline file:

- script: |
    node coverageMerger.js
  displayName: 'Merge Coverage Reports'

SonarQube Analysis Report

Reference:
use this site to check coverage from LCOV https://lcov-viewer.netlify.app/

Introduction to Bruno Scripting

Vikas Yadav — Sat, 20 Apr 2024 17:46:22 +0000

In the dynamic world of API development and testing, automation is key.

Bruno offers scripting support to help you add additional functionality to the tool such as data generation, validation, and integration with other tools and systems, including sending intermediate requests, parsing response data, updating environment variables, etc.

Secrets Management

Problem Statement

In any collection, there are secrets that need to be managed. These secrets can be anything such as API keys, passwords, or tokens.

A common practice is to store these secrets in environment variables.

There are two ways in which developers share Bruno collections:

Check in the collection folder to source control (like git)
Export the collection to a file and share it

In both these cases, we want to ensure that the secrets are stripped out of the collection before it is shared.

Solution

Bruno offers two approaches to manage secrets in collections:

DotEnv File
Secret Variables

Core Features of Bruno Scripting

Bruno is a scripting framework built to providing advanced functionality and automation capabilities. With Bruno, developers can elevate their API testing and development workflows by enabling tasks such as data generation, validation processes, integration with other tools and systems, and much more.

Let's explore some of the core features and functionalities that Bruno brings to the table:

1. Data Generation and Validation

Bruno allows for seamless data generation within the testing environment, enabling developers to simulate various scenarios and edge cases. Furthermore, it facilitates robust validation processes, ensuring that APIs behave as expected under different conditions.

2. Integration and Interoperability

One of Bruno's strengths lies in its ability to integrate with other tools and systems seamlessly. Whether you're orchestrating complex workflows or incorporating third-party services, Bruno streamlines the process, enhancing collaboration and efficiency.

3. Intermediate Requests and Response Parsing

With Bruno, developers can execute intermediate requests within their workflows, enabling sophisticated test scenarios and intricate API interactions. Moreover, Bruno simplifies the parsing of response data, making it easier to extract and manipulate relevant information.

4. Environment Management

Bruno empowers developers to manage environment variables effortlessly, facilitating configuration management and ensuring consistency across different testing environments. Whether it's updating variables or accessing environment-specific data, Bruno simplifies the process, enhancing workflow efficiency.

Translating Postman Scripts to Bruno Commands

To illustrate Bruno's capabilities further, let's translate some common Postman scripts into Bruno commands:

Description	Bruno Command	Postman Command
Tests confirm API is working	`bru.test("check status code", function() { expect(res.status).to.equal(200); });`	`pm.test("check status code", function() { pm.response.to.have.status(200); });`
Set Collection Variable	`bru.setVar("auth_token", res.body.userid);`	`pm.collectionVariables.set("auth_token", "abc123");`
Get Collection Variable	`bru.getVar("auth_token");`	`pm.collectionVariables.get("auth_token");`
Set Environment Variable	`bru.setEnvVar("api_key", "xyz1712");`	`pm.environment.set("api_key", "xyz1712");`
Get Environment Variable	`bru.getEnvVar("api_key");`	`pm.environment.get("api_key");`
Order Next Request	`bru.setNextRequest("Token_SSO");`	`pm.setNextRequest("Token_rock");`

Conclusion

In conclusion, Bruno enables advanced automation, customization, and flexibility, helping developers deliver high-quality APIs with confidence.

Bruno supports loading any npm module to use in your scripting workflows.

You need to add a package.json file where your collection is stored.


json
{
  "name": "bruno_api_demo",
  "version": "1.0.0",
  "description": "With Bruno CLI, you can now run your API collections with ease using simple command line commands.",
  "author": "vikas.yadav",
  "license": "ISC",
  "keywords": [
    "bruno",
    "api testing"
  ],
  "scripts": {
    "test": "bru run Oauth-Login --env test_vikas --format junit --output results.xml"
  },
  "dependencies": {
    "@usebruno/cli": "~1.11.0",
    "@faker-js/faker": "8.3.1"
  }
}

Bruno: Secure API Testing Solution

Vikas Yadav — Thu, 11 Apr 2024 13:27:49 +0000

Bruno: A Secure and User-Friendly Alternative for Postman

Bruno is a new and innovative API client, designed to challenge the status quo represented by Postman and similar tools.

Bruno's unique approach involves storing your collections directly on your filesystem. We utilize a plain text markup language, Bru, to save information about API requests. This means you have full control over your data and can easily track changes.

Moreover, Bruno's design allows you to use Git or any version control system of your choice to collaborate on your API collections. This makes Bruno not just an API testing tool, but a platform for efficient and effective team collaboration.

Why Switch from Postman and Insomnia?

In the world of API testing, Postman and Insomnia have been popular choices. However, recent changes have raised concerns about data security and offline functionality.

Postman announced in May 2023 that it would gradually phase out its Scratch Pad model with offline capabilities. Most functions will now require cloud access and user login. The extent of data upload to the cloud during testing, potentially compromising security, remains uncertain.
Read more here

Insomnia released version 8.0 on September 28, 2023, intensifying its reliance on the cloud. Full functionality now requires user login, and Scratch Pad features are limited without it. The security implications of potential data transmission to the cloud during testing are unclear.

Given these changes, there's a growing need for an API testing solution that keeps workspace data isolated from third-party servers. Enter Bruno.

Why Choose Bruno?

Bruno offers a secure, user-friendly alternative for your API testing needs. Here's why you should consider making the switch:

Open Source: Bruno is open-source software under the MIT License, fostering a collaborative and transparent development environment.
Cross-Platform Support: Bruno supports Mac, Linux, and Windows, making it a versatile choice for diverse teams.
Offline Client: Unlike its competitors, Bruno has no plans for cloud synchronization, prioritizing your data security.
Script Import: Bruno supports script import from Postman and Insomnia (limited to API request scripts, excluding test scripts), easing the transition process.
Active Community: Bruno boasts a relatively active community and a clear product development roadmap, ensuring continuous improvement and support.

Seamless Transition with Bruno

One of the standout features of Bruno is its ability to import existing collections from various tools. This means you can easily transition your API testing workflow without starting from scratch.

Postman Collections: Bruno supports the import of Postman collections. This allows you to bring in all your saved API requests, maintaining the organization and structure you're familiar with.
Insomnia Collections: If you're coming from Insomnia, Bruno has you covered. You can import your Insomnia collections, ensuring your API testing continues smoothly.
OpenAPI v3 Spec: Bruno also supports the import of OpenAPI v3 specifications. This means you can leverage your existing API design and documentation, making Bruno a versatile choice for API testing.

This import functionality makes Bruno a flexible tool that adapts to your needs, reducing the friction typically associated with switching to a new API testing platform.

For more information, check out the official documentation and the comparison with Postman.