DEV Community: antony

Axios : Simplifying HTTP Requests in JavaScript

antony — Thu, 29 May 2025 09:44:35 +0000

Whether you're building a weather app, consuming a RESTful API, or submitting form data, making HTTP requests is a fundamental part of modern web development. That's where Axios shines. In this post, we’ll explore what Axios is, why it's useful, and how to get started with it.

What is Axios?

Axios is a promise-based HTTP client for the browser and Node.js. It makes it easy to send asynchronous HTTP requests to REST endpoints and perform CRUD operations (Create, Read, Update, Delete).

You can think of Axios as an advanced version of fetch(), but with a cleaner syntax and additional features.

Installing Axios

bash

npm install axios

Or using yarn:

yarn add axios

In a browser-based project, you can also use a CDN:

<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>

Making Your First Request

Here’s a simple GET request to fetch some JSON data:

import axios from 'axios';

axios.get('https://jsonplaceholder.typicode.com/posts')
  .then(response => {
    console.log('Data:', response.data);
  })
  .catch(error => {
    console.error('Error fetching data:', error);
  });

Using Async/Await (Modern Approach):

const fetchPosts = async () => {
  try {
    const response = await axios.get('https://jsonplaceholder.typicode.com/posts');
    console.log('Data:', response.data);
  } catch (error) {
    console.error('Error:', error);
  }
};

fetchPosts();

Common HTTP Methods in Axios

🔹 POST Request

axios.post('https://example.com/api/posts', {
  title: 'New Post',
  body: 'This is the content.',
})
.then(response => console.log(response.data))
.catch(error => console.error(error));

🔹 PUT Request

axios.put('https://example.com/api/posts/1', {
  title: 'Updated Title',
});

🔹 DELETE Request

axios.delete('https://example.com/api/posts/1');

Sending Headers and Auth

axios.get('https://api.example.com/user', {
  headers: {
    Authorization: 'Bearer your-token-here',
  }
});

Creating Axios Instances

const api = axios.create({
  baseURL: 'https://api.example.com',
  timeout: 1000,
  headers: { 'X-Custom-Header': 'foobar' }
});

api.get('/users');

Error Handling Best Practice

try {
  const response = await axios.get('/some-endpoint');
} catch (error) {
  if (error.response) {
    console.error('Server Error:', error.response.status);
  } else if (error.request) {
    console.error('No Response:', error.request);
  } else {
    console.error('Error', error.message);
  }
}

Final Thoughts

Axios is a powerful, battle-tested HTTP client that simplifies API communication in your JavaScript applications. Whether you're just starting out or building large-scale apps, Axios helps you write cleaner, more reliable code.

"How to Write Clean and Maintainable Go Code"

antony — Mon, 12 May 2025 06:16:58 +0000

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”

— Martin Fowler

Go is known for its simplicity — but clean, readable, and maintainable code doesn’t write itself. Whether you're building microservices, CLIs, or REST APIs, good Go code follows a few golden rules.

Let’s walk through some practical tips and real Go examples to help you write cleaner and more idiomatic code.

🧠 1. Use Clear, Descriptive Names

Don’t try to be clever. Clarity beats brevity every time.

❌ Bad:

func f(u int) {
    fmt.Println(u)
}

✅ Good:


func printUserID(userID int) {
    fmt.Println(userID)
}

Use camelCase for variables and functions. Reserve abbreviations for widely recognized terms like id, url, db.

⚡ 2. Keep Functions Focused and Small

One function = one responsibility. Break up logic when possible.

❌ Bad:

func handleOrder(o Order) {
    validate(o)
    saveToDB(o)
    sendEmail(o)
}

✅ Good:

func handleOrder(o Order) {
    if err := validate(o); err != nil {
        log.Println("Validation failed:", err)
        return
    }
    if err := storeOrder(o); err != nil {
        log.Println("Database error:", err)
        return
    }
    notifyCustomer(o)
}

func storeOrder(o Order) error {
    // logic to store in database
    return nil
}

func notifyCustomer(o Order) {
    // logic to send email
}

Short, specific functions are easier to test and reuse.

🧰 3. Format Code with gofmt or goimports

No one wants to argue about tabs or spacing. Let the tools handle it.

gofmt -w .
goimports -w .

They’ll format your code and manage your imports automatically. Clean code is also consistent code.

💬 4. Comment Why, Not What

Don’t write comments for things that are self-explanatory. Focus on why a decision was made.

❌ Bad:

// Add two integers
func Add(x, y int) int {
    return x + y
}

✅ Better:

// Add returns the sum of x and y.
// Used in the calculator to combine user inputs.
func Add(x, y int) int {
    return x + y
}

Use Go-style doc comments for exported functions and packages.

✅ 5. Write Tests (and Use Table-Driven Ones)

Go makes testing easy — no excuses.

import "testing"

func TestAdd(t *testing.T) {
    tests := []struct {
        name string
        a, b int
        want int
    }{
        {"positive", 2, 3, 5},
        {"zero", 0, 0, 0},
        {"negative", -2, -3, -5},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := Add(tt.a, tt.b); got != tt.want {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, got, tt.want)
            }
        })
    }
}

Use go test -cover to check coverage, and don’t forget BenchmarkX when performance matters.

♻️ 6. Don't Over-Abstract

Avoid the trap of premature abstraction. Repetition isn’t always evil.

❌ Over-abstracted:

func logStart() { fmt.Println("starting...") }
func logEnd() { fmt.Println("ending...") }

✅ Simple and reusable:

func logPhase(phase string) {
    fmt.Printf("%s...\n", phase)
}

Rule of thumb: if code is used more than twice and not tied to specific context — abstract it. Otherwise, duplicate with purpose.

📁 7. Structure Projects by Responsibility

Go prefers flat, not deep. Organize based on what the code does.

/cmd/myapp         // app entry point
/internal/handlers // HTTP or CLI handlers
/internal/db       // DB logic
/pkg/utils         // reusable helpers

Avoid generic package names like common or base.

👥 8. Code Like Someone Else Will Maintain It

Because someday… they will (and it might be you).

Ask yourself:

Would a junior developer understand this code?

Is it easy to test or extend?

Are errors clear and helpful?

Your code should invite collaboration, not fear.
🔚 Final Thoughts

Writing clean Go code isn’t hard, but it requires discipline.

✅ Use meaningful names
✅ Write focused, testable functions
✅ Format everything with gofmt
✅ Test like you mean it
✅ Comment only when needed
✅ Keep it simple, not clever

🗣️ What’s your favorite Go coding tip?
Drop it in the comments!

👉 Follow me for more Go content, real-world project tips, and practical dev advice.

Why I Prefer Go Over Node.js for Backend Development

antony — Wed, 07 May 2025 08:44:21 +0000

As a softwar developer, choosing the right language and tools can make a huge difference in how efficiently you build, maintain, and scale applications. While Node.js is widely adopted in the backend world, I personally prefer Go (Golang) for several key reasons. Here's why.

⚙️ 1. Performance and Concurrency

Go is a compiled language with built-in support for concurrency through goroutines and channels.

Whether it's handling multiple HTTP requests or processing data-heavy tasks, Go offers consistent and high performance with minimal memory overhead. Its lightweight concurrency model is often simpler and more efficient than JavaScript’s event loop and async/await system.

🏗️ 2. Static Typing = Fewer Runtime Surprises

Go is statically typed, which helps catch errors early during compilation.

In my experience, this leads to more robust code and reduces the kind of silent runtime bugs that can creep in with JavaScript's dynamic typing. Type safety also makes refactoring easier and safer.

🔐 3. Simpler Dependency Management

With Go modules (go.mod, go.sum), managing dependencies is straightforward and built right into the language.

You don’t have to deal with complex dependency trees or massive node_modules folders. It’s clean, fast, and predictable.

🔧 4. Better Tooling Out of the Box

Go comes with powerful built-in tools like:

go fmt for automatic code formatting
go run to quickly test code
go test for unit testing
go vet and golint for catching subtle issues

This strong tooling ecosystem promotes consistency and code quality without needing third-party packages.

🧼 5. Minimalist, Clean Code

Go encourages simplicity and readability. There's often "one right way" to do things, reducing bike-shedding and helping teams write uniform, maintainable code.

In contrast, Node.js projects can get bloated with middleware, wrappers, and utilities for even simple tasks like routing or parsing JSON.

📉 6. Resource Efficiency

Go binaries are compiled and self-contained, meaning they require no external runtime.

This makes deployment easy—just build and ship the binary. No need for managing multiple layers of dependencies or setting up a runtime environment like you would with Node.js.

✅ Conclusion

Node.js has its strengths, especially for real-time applications and when working closely with frontend teams. But for clean, efficient, and scalable backend development, I’ve found Go to be more reliable, maintainable, and performant.

🗣️ What’s Your Take?

Have you used Go or Node.js for backend development?

Which one do you prefer and why? I'd love to hear your thoughts in the comments!

Building Web Applications with Go

antony — Wed, 17 Jul 2024 12:34:35 +0000

Go (Golang) is an excellent language for building web applications due to its simplicity, performance, and robust standard library. This guide will walk you through the process of creating a basic web application using Go, including setting up a web server, handling routes, and rendering HTML templates.

Setting Up Your Go Environment

First, ensure that you have Go installed on your machine. You can download and install it from the official Go website.

Next, create a new directory for your project:


bash

mkdir go-webapp
cd go-webapp

Initialize a new Go module:


bash

go mod init go-webapp

Creating a Basic Web Server

Create a new file main.go and add the following code to set up a basic web server:


package main

import (
    "fmt"
    "net/http"
)

func homePage(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the Home Page!")
}

func main() {
    http.HandleFunc("/", homePage)
    fmt.Println("Server started at :8080")
    http.ListenAndServe(":8080", nil)
}

Run the server:


bash

go run main.go

Open your browser and navigate to http://localhost:8080 to see your web server in action.

Handling Routes

To handle multiple routes, define additional handler functions:


func aboutPage(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the About Page!")
}

func main() {
    http.HandleFunc("/", homePage)
    http.HandleFunc("/about", aboutPage)
    fmt.Println("Server started at :8080")
    http.ListenAndServe(":8080", nil)
}

Rendering HTML Templates

Go’s html/template package allows you to render HTML templates. Create a templates directory and add an index.html file:

html

<!-- templates/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Home Page</title>
</head>
<body>
    <h1>{{ .Title }}</h1>
    <p>{{ .Content }}</p>
</body>
</html>

Modify main.go to use the template:

package main

import (
    "html/template"
    "net/http"
)

type PageData struct {
    Title   string
    Content string
}

func homePage(w http.ResponseWriter, r *http.Request) {
    data := PageData{
        Title:   "Home Page",
        Content: "Welcome to the Home Page!",
    }
    tmpl, _ := template.ParseFiles("templates/index.html")
    tmpl.Execute(w, data)
}

func aboutPage(w http.ResponseWriter, r *http.Request) {
    data := PageData{
        Title:   "About Page",
        Content: "Welcome to the About Page!",
    }
    tmpl, _ := template.ParseFiles("templates/index.html")
    tmpl.Execute(w, data)
}

func main() {
    http.HandleFunc("/", homePage)
    http.HandleFunc("/about", aboutPage)
    http.ListenAndServe(":8080", nil)
}

Using a Framework

For more advanced web applications, consider using a Go web framework like Gin:

Install Gin:



bash

go get -u github.com/gin-gonic/gin

Update main.go to use Gin:

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Welcome to the Home Page!",
        })
    })

    r.GET("/about", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Welcome to the About Page!",
        })
    })

    r.Run(":8080")
}

Conclusion

Building web applications with Go is straightforward, thanks to its powerful standard library and the availability of frameworks like Gin. This guide provides a basic introduction, but there is much more to explore, including middleware, database integration, and authentication. Happy coding!