DEV Community: Puncoz Nepal

This week in tech

Puncoz Nepal — Fri, 21 Mar 2025 15:13:11 +0000

Weekly #12-2025: Astro 5.5, Tailwind Plus, TypeScript 7, and More

Madhu Sudhan Subedi for Weekly ・ Mar 21

#softwaredevelopment #tailwindcss #ai #cloud

Leveraging the power of Postman for API Development

Puncoz Nepal — Wed, 20 May 2020 03:23:35 +0000

While developing API, either RESTful or GraphQL or SOAP, testing and debugging are crucial. But creating a form to consume those API, just for the sake of debugging, is not very efficient and effective. Hence, some kind of API client, capable of consuming or querying GET/POST or any other kind of HTTP request to the endpoint, is required.

Among the vast selection of GUI tools available for this purpose, I find Postman quite easy and really powerful. Here, I will list some of the advanced features of Postman to increase productivity as an API developer.

Postman Collections

Every time we send a request to some API endpoint, the request information (its URL, request parameters and response data ) is stored in the History Tab of the postman. It makes it easier to re-send the same request from history later as required. But as the number of requests increases, finding a particular request in the history tab will be time-consuming.

Postman Collections are a group of saved requests, organized in folders and sub-folders structure. This way we can manage API requests. Here is a guide on how we can create postman collections.

Besides this, there are other benefits to creating postman collections.

Sharing a Postman Collection

Postman collections we created can be shared with other teammates and people who are concerned with our API.

Sharing with Teams and other workspaces

Our workspaces can be shared with other teammates by inviting them in the workspace or by creating another common workspace. This way, the collections will always stay in sync for all teammates.

Sharing as a JSON file or URL

If you do not want people to add in your team, but still need to share postman collections, you can export collections as a JSON file or generate a URL of JSON data which afterward can be imported in postman as a collection.

Here is a more detailed guide to share a postman collection.

Creating and Publishing API Documentation

Postman generates and hosts browser-based API documentation from the collection which can be shared to privately as well publicly. This API documentation is beautifully formatted on a web page which can reduce extra efforts to document API separately. More about API documentation can be read from here.

Environment and Global Variables

Variables in Postman are static identifiers used to store dynamic value to be used in requests and responses of API calls. A straightforward use-case of the variable is to define an API base URL for local, staging, and production servers. This way, we do not need to create three different API requests or change the URL manually. As shown in the figure above, we can use {{url}}, a postman variable storing different URLs for different environments.

Another useful use-case of the variable is to store the user authentication token. Storing user token in variable enables us to request another request by automatically sending an updated token from the variable.

To store authentication token from response to an environment variable token, the following scripts should be written in Tests tab of API request panels.

var jsonData = JSON.parse(responseBody);
postman.setEnvironmentVariable("token", jsonData.token);

More about the environment and global variables are in postman’s documentation.

Test Scripts

A very cool and useful feature of Postman is Test Scripts where we can write test cases for every API request. Postman supports javascript, hence we can use any javascript test library (such as jasmine, mocha, etc.) or postman’s native test library.

A sample test scripts using the PostmanBDD library. Here, I stored PostmanBDD in a global variable with key postmanBDD. Below the Test Scripts to test a typical API response with Chai assertions.

var jsonData = JSON.parse(responseBody);
eval(globals.postmanBDD);
describe("response", () => {

    it("should return a 200 response", () => {
        response.should.have.status(200);
    });

    it("should have the json content type header", () => {
        response.should.have.header('content-type', 'application/json');
        response.should.be.json;
    });

    it('should return keys: title, content, id', () => {
        assert.containsAllKeys(jsonData,['title', 'content', 'id']);
    });

    it("'title' key should be provided title", () => {
        jsonData.title.should.be.an('string').and.equal(environment.create_title);
    });

    it("'content' key should be as provided", () => {
        jsonData.content.should.be.an('string').and.equal(environment.create_content);
    });

    it("should have 'id' property", () => {
        jsonData.id.should.be.an('number');
    });

});

This way we can test our API response to avoid manual testing. Test results can be seen in the Response panels of Postman. Read more at documentation.

Collection Runner

A collection runner is another useful feature of Postman. This allows us to run a group of API requests together within a collection with just a single click. This is useful when we have test scripts written and want to automate API testing. This will save a lot of time testing each and every request one by one. Read more.

Postman monitoring

Postman monitoring is another cool feature of the postman, which runs a collection just like postman runner does but periodically to check for its performance and response. We can set up a monitor to run as frequently as 5 minutes to check if all the requests in your collection are up and healthy.

Monitoring is priced per request made with some limited number of free monitoring calls per month.

Mock servers

Postman’s mock servers is a feature, especially useful for API consumer (front enders) to simulate each endpoint and its corresponding response and work with API before back enders provide actual API. Not just front-enders, API developers can also use mock servers to design and plan their API before diving into the actual development.

For more tips and tricks about Postman, follow these links

https://blog.getpostman.com/

That's all about Postman. If you are using it in your API development share how are you using it? If you have any interesting tips and tricks about the postman, do share :)

Also if you have any other alternatives, share that as well in the comment.

This article was originally published at YoungInnovations Blog

Understanding Node.js: Single-Threaded Server-Side Language

Puncoz Nepal — Fri, 07 Feb 2020 11:47:54 +0000

Most of the server-side languages, like PHP, ASP.NET, Ruby, JAVA servers, follow multi-threaded architecture. That means, every request by the client results in the instantiation of a new thread or even a process.

However, in Node.js, all requests are handled in a single thread with shared resources. Then how does Node.js handle concurrent traffic or requests? It follows “Single Threaded Event Loop Model” architecture that runs on top of a single V8 engine instance.

Node.js is event-driven that implements background workers to achieve non-blocking asynchronous behavior. We called it the Observer Pattern. Node thread keeps an event loop and whenever a task gets completed, it fires the corresponding event which signals the event-listener function to execute as illustrated below.

As soon as Node.js starts, it initializes the event loop, processes the provided input script (i.e. initiates variables and declares functions) which may make async API calls, schedule timers, or call process.nextTick(), then begins processing the event loop.

As shown in the figure above, each phase has a FIFO queue of callbacks to be executed.

Overview of the Phases:
timers: this phase executes callbacks scheduled by setTimeout() and setInterval().

pending callbacks: executes I/O callbacks deferred to the next loop iteration.

idle, prepare: only used internally.

poll: retrieve new I/O events; execute I/O related callbacks (almost all with the exception of close callbacks, the ones scheduled by timers, and setImmediate()); NodeJs will block here when appropriate.

check: setImmediate() callbacks are invoked here.

close callbacks: some close callbacks, e.g. socket.on('close', ...).

More detail on this can be read from the official docs.

As shown in the above block diagram, Node.js listens and passes every concurrent traffic in a queue, which will be executed by an event loop as explained above. Let’s see an example to observe this single-threaded architecture of a Node.js web application.

const app = express()

let visitorCount = 0

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

    res.send(`Hello World, visitor counter is: ${visitorCount}`)
})

const port = 8002
app.listen(port, () => {
    console.log(`Start listening at port: ${port}`)
})

In the above example, we are using express-js which we need to install from npm. To run the above script, simply type the following command in your terminal.

$ node server.js         // here, server.js is the name of the file

Now, if we browse localhost:8002 in the browser, on every request, the visitorCount gets updated. Isn't that magic? In other programming languages, to achieve this, we will need to store that counter in some persistent storage. Here, as per the output, on every request, the visitorCount variable is being updated. That means, for all requests, Node.js is running the same instance (thread/process) and visitorCount variable is the same for all the requests.

This is how Node.js works. Due to all these architectural implementations of Observer patterns, Node.js is pretty fast compared to similar other server-side languages and technologies.

This article was originally published in YIPL Blog.

Weekly trending Links for Backend Developers, #1

Puncoz Nepal — Thu, 06 Feb 2020 11:05:12 +0000

Starting this week, we have started a weekly handpicked collection of links and resources hot and trending in the tech industry.

Today, we have picked some of the Github Repo we find useful by the awesome people.

**Disclaimer: Contains in these articles are directly from the different sources whose links are provided.

Best practices in Laravel

This is a Github repo by alexeymezenin, which is not just a Laravel adaptation of SOLID principles, patterns, etc. but the best practices which are usually ignored in real life Laravel projects.

-> https://github.com/alexeymezenin/laravel-best-practices

eSQLate

eSQLate is an attempt to give small teams a quick and easy form of administration panel which is significantly more powerful than CRUD based systems but also as easy to set up.

-> https://github.com/forbesmyester/esqlate

Clean Code concepts adapted for JavaScript

Javascript is a hot tech stack of 2020. From server-side side script to client-side, from the web to mobile, javascript is being adopted everywhere. Hence, it is not just a small line of code, but the whole software application is now being written in Javascript. Hence, writing clean and maintainable code is necessary. This Github repo consists of Software engineering principles, from Robert C. Martin's book Clean Code, adapted for JavaScript.

-> https://github.com/ryanmcdermott/clean-code-javascript

Awesome Node.js Utils

This is a repository by justjavac which contains a handful list of utility packages for Node.js developers.

-> https://github.com/justjavac/awesome-node-utils

The Art of Command Line

As an engineer, although fluency in command line improves our flexibility and productivity in both obvious and subtle ways, but often neglected or considered arcane. There is a Github repo by jlevy where notes and tips on using the command-line useful when working on Linux are curated and maintained as a single page. Some tips are elementary, and some are fairly specific, sophisticated, or obscure. This repo is not long, but if we can use and recall all the items there, we know a lot.

-> https://github.com/jlevy/the-art-of-command-line

Path to a Software Architect

A software architect is a software expert who makes high-level design choices and dictates technical standards, including software coding standards, tools, and platforms. This Github repo lists the path to become a Software Architect.

-> https://github.com/justinamiller/SoftwareArchitect

Zero trust architecture design principles

Zero trust architecture is a relatively new and evolving approach to network design but it's also part of a wider mindset: remove inherent trust from the network, treat it as hostile and instead gain confidence that we can trust a connection. This Github repo provides us Ten Principles to help us design and deploy a zero trust architecture.

-> https://github.com/ukncsc/zero-trust-architecture

Trax: a path to advanced deep learning

Trax is a Github repo actively used and maintained by the Google Brain team. It helps us to understand and explore advanced deep learning mainly focus on making Trax code clear while pushing advanced models like Reformer to their limits.

-> https://github.com/google/trax

Build your own technology

Whether you want to create your own search engine, or your own 3D renderer, or your own BitTorrent Client or your own Blockchain / Cryptocurrency. This Github repo contains the curated list of resources for various technology we think or is thinking to create on our own.

-> https://github.com/danistefanovic/build-your-own-x

OneDev: All-In-One DevOps Platform

One dev is a full-fledged tool for DevOps, which includes features such as Auto-Refreshing Issue Boards with the Custom Issue States and Fields, Docker First Kubernetes Native Build Farm, Easy to navigate and search, Discussions and Comprehensions of code in a web IDE, Flexible Pull Request Review Policies and many more.

-> https://github.com/theonedev/onedev

That's all for this week.

Do comment on the one which you like the most 😎. Also, post anything else you find interesting and useful.

Lastly, we have another series of weekly updates about the frontend's technology. Do follow that as well.

https://dev.to/weekly/frontend-collective-week-1-26d2

See ya' next week.

🖐🖐🖐🖐🖐