DEV Community: Brian Shisia

Getting Started With Nmap: A Beginner-Friendly Guide

Brian Shisia — Thu, 27 Nov 2025 21:41:22 +0000

If you’re getting into cybersecurity, ethical hacking, or network engineering, you’ll quickly hear the name Nmap. When I started learning Nmap, it felt overwhelming - so many flags, so many scan types, so many outputs.

At the same time, I’m building a small tool in Go that works like Nmap, which forced me to understand what Nmap actually does behind the scenes.

This article is a simple introduction to Nmap for beginners — no assumptions, no jargon overload.

What is Nmap?

Nmap (Network Mapper) is a free and open-source tool used to discover hosts, open ports, running services, OS information, and much more.

Think of Nmap as a "network Sherlock Holmes" — it asks questions like:

Who is online?
Which ports are open?
What services are running?
What OS might this machine be using?

Why Nmap Is Important (Even for Developers)

Even if you’re not a pentester, Nmap helps you:

Test your own servers for exposed ports
Learn how attackers might discover your infrastructure
Troubleshoot network issues
Understand how protocols behave
Build your own network tools (like I’m doing in Go)

Installing Nmap

Linux (Debian/Ubuntu/Kali)

sudo apt install nmap

Arch

sudo pacman -S nmap

Mac

brew install nmap

Windows

Download the installer from: https://nmap.org/download.html

The Most Important Nmap Commands for Beginners

Let’s go through practical commands you’ll actually use.

1. Basic Host Scan

nmap 192.168.1.10

Scans common ports and shows open ones.

2. Ping Scan (Check if a host is online)

nmap -sn 192.168.1.0/24

Good for discovering devices on a network.

3. Scan all ports (1–65535)

nmap -p- 192.168.1.10

If you want everything, this is the scan.

4. Fast Scan (Top 100 ports)

nmap -F 192.168.1.10

Quick way to get useful info.

5. Stealth Scan (SYN Scan)

sudo nmap -sS 192.168.1.10

Very common in pentesting because it’s fast and less detectable.

6. Get Service Info

nmap -sV 192.168.1.10

This tries to detect what service is running on each open port
(e.g., Apache, SSH version, MySQL version).

7. OS Detection

sudo nmap -O 192.168.1.10

Tries to guess the operating system.

8. Scan Without Ping (Useful for firewalled hosts)

nmap -Pn 192.168.1.10

The Most Common Nmap Flag (For Beginners): `-sS`

If you're wondering "which Nmap flag is the most used?", it’s -sS — the SYN (stealth) scan.
It balances speed, accuracy, and low detection.

How Nmap Works (Simple Explanation)

When you scan a port, you’re basically performing a tiny conversation:

Send a TCP SYN packet → “Are you accepting connections?”
Get a reply:
- SYN/ACK → Port is open
- RST → Port is closed
- No response / filtered → Firewall blocked it

This is the exact logic I'm trying to replicate while building my Go tool.

Building My Own Nmap-like Tool in Go

I wanted to understand scanning deeper, so I started building a simple port scanner in Go.

Here’s a simplified version of checking if a port is open:

package main

import (
    "fmt"
    "net"
    "time"
)

func main() {
    host := "192.168.1.10"
    for port := 1; port <= 1024; port++ {
        address := fmt.Sprintf("%s:%d", host, port)
        conn, err := net.DialTimeout("tcp", address, time.Millisecond*200)
        if err == nil {
            fmt.Printf("Port %d is open\n", port)
            conn.Close()
        }
    }
}

This is the basic idea behind an Nmap-like tool — check if a port accepts connections.

Tips for Learning Nmap Effectively

Start with one command per day
Always scan your own machines (legally safe)
Try different scan types and compare results
Read the built-in help (nmap --help)
Build your own small port scanner to understand the basics

Final Thoughts

Nmap may look intimidating, but once you understand the basics, it becomes one of the most powerful and fun tools in cybersecurity.

🎮 Game On! Understanding `requestAnimationFrame` for Smooth Animations in JavaScript Games

Brian Shisia — Tue, 01 Jul 2025 19:42:29 +0000

Ever wondered how browser games move objects smoothly across the screen, like a character jumping or a ball bouncing?

The secret is requestAnimationFrame, a built-in browser method designed for smooth, efficient animations.

In this article, we’ll explore what requestAnimationFrame does, why it’s awesome for games, and how to use it in a simple game loop.

What Is `requestAnimationFrame`?

requestAnimationFrame is a JavaScript method that tells the browser:

“Run this function before the next repaint.”

This makes it perfect for smooth animations because:

It's synced with the screen’s refresh rate (usually 60 FPS).
It pauses automatically when the tab isn't visible (saving power).
It’s more efficient than using setInterval() or setTimeout() for game loops.

🎮 Why Use It in Game Development?

In games, we often update the position of things (players, enemies, obstacles) every frame.

Instead of using setInterval(() => update(), 16), which can be jittery or misaligned with screen refresh, use requestAnimationFrame(update) — it makes animations smoother and less CPU-intensive.

Simple Game Example: A Bouncing Ball

Let’s create a small demo to see requestAnimationFrame in action — a ball bouncing around the screen!

HTML

<canvas id="gameCanvas" width="500" height="300"></canvas>

CSS

canvas {
  border: 2px solid #444;
  display: block;
  margin: 20px auto;
  background-color: #f0f0f0;
}

JavaScript

const canvas = document.getElementById('gameCanvas');
const ctx = canvas.getContext('2d');

let x = 50;
let y = 50;
let dx = 2;
let dy = 3;
const radius = 20;

function drawBall() {
  ctx.beginPath();
  ctx.arc(x, y, radius, 0, Math.PI * 2);
  ctx.fillStyle = '#3498db';
  ctx.fill();
  ctx.closePath();
}

function update() {
  // Clear the canvas
  ctx.clearRect(0, 0, canvas.width, canvas.height);

  drawBall();

  // Update position
  x += dx;
  y += dy;

  // Bounce off walls
  if (x + radius > canvas.width || x - radius < 0) dx = -dx;
  if (y + radius > canvas.height || y - radius < 0) dy = -dy;

  // Call this function again on the next frame
  requestAnimationFrame(update);
}

// Start the game loop
update();

What's Happening?

We clear the canvas each frame.
We draw the ball at its new position.
We check for wall collisions and reverse direction if needed.
requestAnimationFrame(update) schedules the next frame.

This loop runs as fast as the browser allows — typically 60 frames per second — resulting in smooth, fluid motion.

Pro Tips for Game Dev with `requestAnimationFrame`

Always clear the canvas each frame to prevent "ghosting."
Use delta time (time difference between frames) for consistent movement across devices.
Combine with keyboard or mouse input to make interactive games!

What’s Next?

Now that you’ve seen requestAnimationFrame in action, try adding more features:

Paddle & ball collision (like Pong 🏓)
Gravity for jumping characters
Enemies, scores, or game over logic

✅ Final Thoughts

`requestAnimationFrame` is the go-to tool for making smooth animations in the browser. Whether you're building a bouncing ball, a side-scroller, or a full 2D game — it’s essential for any modern web-based game engine.

Want to Learn More?

Let me know if you want a follow-up article on:

Handling input for movement
Creating a basic platformer
Building a tiny game engine from scratch

Ready to make your browser games buttery smooth? Game on! 🕹️

Getting Started with WebSockets: Real-Time Web Communication Made Easy

Brian Shisia — Wed, 28 May 2025 13:15:57 +0000

In today’s web, real-time features like live chat, notifications, and multiplayer games are everywhere. But how do these apps update instantly — without needing to refresh the page?

The secret is WebSockets — a powerful technology that lets the browser and server talk to each other instantly.

In this beginner-friendly guide, we’ll explain what WebSockets are, when to use them, and how to build a tiny real-time app to see them in action.

💡 What Are WebSockets?

WebSockets let your browser and server send messages back and forth over a single, always-open connection.

Compare that to regular HTTP:

Protocol	Behavior
HTTP	Client sends a request → Server responds. Then it’s over.
WebSocket	Connection stays open → Client & Server can send messages anytime.

Why is that cool?
Because it means instant updates without waiting for the browser to "ask" again — perfect for real-time apps.

🧠 When Should You Use WebSockets?

Use WebSockets when your app needs instant communication:

🗨️ Live chat apps
🎮 Multiplayer games
📍 Real-time location tracking
📈 Live stock/crypto prices
🔔 Instant notifications

For simpler updates that aren’t frequent, HTTP polling or Server-Sent Events (SSE) might be enough.

🛠️ Let’s Build a Simple WebSocket App

We’ll use Node.js and a WebSocket library called ws.

1. Create a WebSocket Server

Make a new file called server.js:

// server.js
const WebSocket = require('ws');

// Create WebSocket server on port 8080
const server = new WebSocket.Server({ port: 8080 });

server.on('connection', socket => {
  console.log('🔌 New client connected');

  socket.on('message', message => {
    console.log('Received:', message);
    socket.send(`Server received: ${message}`);
  });

  socket.on('close', () => console.log('❌ Client disconnected'));
});

Install the required package:

npm install ws
node server.js

2. Connect From Your Browser

Open your browser’s DevTools and paste this into the console:

const socket = new WebSocket('ws://localhost:8080');

socket.onopen = () => {
  console.log('✅ Connected to server');
  socket.send('Hello from the browser!');
};

socket.onmessage = (event) => {
  console.log('💬 Message from server:', event.data);
};

socket.onclose = () => {
  console.log('🔒 Connection closed');
};

You’ll see real-time communication between your browser and the Node.js server — no refreshing, no reloading.

How It Works (In Simple Terms)

The browser (client) opens a WebSocket connection to the server.
The server accepts it and keeps the connection open.
Either side can send messages at any time.
The connection stays open until one side closes it.

Quick Tips for Real Projects

Use wss:// (WebSockets over HTTPS) in production for security.
Handle disconnections and retries (networks aren’t perfect).
WebSockets are great for live features, but don’t overuse them if polling would do the job.

Real-World Example: Real Time Forum

To test WebSockets in a real-world app, I built SocialSphere — a mini social network with live features like:

Real-time chat
Create and interact with posts
Likes and 💬 comments
Instant notifications for:
- New messages
- Likes/comments
- New posts by friends

Tech Used

Frontend: JavaScript (React), HTML, CSS
Backend: Node.js, Express
WebSocket Engine: ws / Socket.io
Database: MongoDB

How WebSockets Power It

New messages are pushed instantly to users.
Likes/comments send real-time notifications.
No need to refresh — updates just appear.

🔗 GitHub Repo

🎯 Final Thoughts

WebSockets can seem complex at first — but once you try a simple example, you'll get it.

They’re incredibly useful when you want instant communication between users and your server.

Whether you're building a chat app or a dashboard, learning WebSockets is a great way to level up your web dev skills.

Got Questions?

Drop a comment below if you need help or want to share how you're using WebSockets in your projects!

Technical Article: Implementing a Simple Command-Line Calculator in Go

Brian Shisia — Sun, 30 Mar 2025 23:12:39 +0000

Introduction

In this article, we will explore a simple command-line calculator program written in the Go programming language. This program demonstrates basic Go concepts such as command-line arguments, string manipulation, and simple arithmetic operations. We will walk through the code, explaining each part and its functionality from the basics to the complete implementation.

Prerequisites

To follow along with this article, you should have:

Basic understanding of Go programming language.
Go installed on your machine.
A code editor or IDE of your choice.

Code Overview

The program takes three command-line arguments: two integers and an arithmetic operator. It performs the specified arithmetic operation on the integers and prints the result. The supported operators are +, -, *, /, and %.

Let's start by looking at the overall structure of a Go program.

Package Declaration

package main

Every Go program starts with a package declaration. The main package is a special package in Go, which is used to define an executable program. The main function within this package serves as the entry point of the program.

Importing Packages

import (
    "fmt"
    "os"
    "strconv"
)

Next, we import the necessary packages:

fmt: Provides formatted I/O functions.
os: Enables access to command-line arguments.
strconv: Contains functions for converting strings to other data types, such as integers.

Validating the Operator

func validateOperator(test string) bool {
    op := []string{"+", "-", "*", "/", "%"}
    for _, res := range op {
        if res == test {
            return true
        }
    }
    return false
}

We define a function called validateOperator to check if the provided operator is valid. This function takes a string test as input and compares it against a list of supported operators (+, -, *, /, %). If the operator is valid, the function returns true; otherwise, it returns false.

Main Function

The main function is the entry point of our program. Let's break it down step-by-step.

Reading Command-Line Arguments

func main() {
    args := os.Args[1:]
    if len(args) > 3 || len(args) < 3 {
        fmt.Print("The len of args should be three")
    } else {
        // further code here...
    }
}

We start by reading the command-line arguments using os.Args[1:]. This skips the first argument, which is the program's name, and stores the remaining arguments in the args slice.

Next, we check if the number of arguments is exactly three. If not, the program does nothing and exits.

Operator Validation

if !validateOperator(args[1]) {
    fmt.Println(0)
} else {
    // further code here...
}

We validate the operator using the validateOperator function. If the operator is invalid, the program prints 0 and exits.

Converting Strings to Integers

premier, _ := strconv.Atoi(args[0])
second, _ := strconv.Atoi(args[2])

We convert the first and third arguments to integers using strconv.Atoi. This function returns two values: the converted integer and an error (if any). For simplicity, we ignore the error.

Arithmetic Operations

if args[1] == "%" && second == 0 {
    fmt.Print("No Modulo by 0\n")
} else if args[1] == "/" && second == 0 {
    fmt.Print("No division by 0\n")
} else if args[1] == "+" {
    fmt.Println(premier + second)
} else if args[1] == "-" {
    fmt.Println(premier - second)
} else if args[1] == "*" {
    fmt.Println(premier * second)
} else if args[1] == "/" {
    fmt.Println(premier / second)
} else {
    fmt.Println(premier % second)
}

The program performs the specified arithmetic operation based on the operator:

For % and /, it checks if the second integer is 0 to avoid division or modulo by zero errors.
For each operator, it performs the corresponding arithmetic operation and prints the result.

Complete Code

Here is the complete code for our command-line calculator program:

package main

import (
    "fmt"
    "os"
    "strconv"
)

func validateOperator(test string) bool {
    op := []string{"+", "-", "*", "/", "%"}
    for _, res := range op {
        if res == test {
            return true
        }
    }
    return false
}

func main() {
    args := os.Args[1:]
    if len(args) > 3 || len(args) < 3 {
        fmt.Print("The len of args should be three")
    } else {
        if !validateOperator(args[1]) {
            fmt.Println(0)
        } else {
            premier, _ := strconv.Atoi(args[0])
            second, _ := strconv.Atoi(args[2])

            if args[1] == "%" && second == 0 {
                fmt.Print("No Modulo by 0\n")
            } else if args[1] == "/" && second == 0 {
                fmt.Print("No division by 0\n")
            } else if args[1] == "+" {
                fmt.Println(premier + second)
            } else if args[1] == "-" {
                fmt.Println(premier - second)
            } else if args[1] == "*" {
                fmt.Println(premier * second)
            } else if args[1] == "/" {
                fmt.Println(premier / second)
            } else {
                fmt.Println(premier % second)
            }
        }
    }
}

Running the Program

To run the program, save the code to a file (e.g., calculator.go) and execute it from the command line with three arguments:

go run calculator.go 5 + 3

This should output:

Conclusion

In this article, we created a simple command-line calculator in Go. We covered basic concepts such as reading command-line arguments, validating input, converting strings to integers, and performing arithmetic operations. This program serves as a good starting point for understanding Go's standard library and its capabilities.