DEV Community: ScottsTechX

[Boost]

ScottsTechX — Fri, 29 May 2026 03:34:13 +0000

ScottsTechX

May 28

How I Built a Custom Programming Language Interpreter in Python

#showdev #python #programming #tutorial

Comments

4 min read

How I Built a Custom Programming Language Interpreter in Python

ScottsTechX — Thu, 28 May 2026 06:56:32 +0000

How I Built a Custom Programming Language Interpreter in Python

Ever wondered how Python actually runs your code? The answer is through an interpreter — a program that reads your source code and executes it line by line. I built my own toy language called ScoLang to understand how interpreters work under the hood.

Why Build Your Own Language?

Deep understanding of how high-level languages work
Appreciation for the tools you use daily (Python, JS, Ruby)
Fun — there's something magical about creating your own syntax
Power — domain-specific languages let you express problems elegantly

Architecture of an Interpreter

An interpreter has 4 main stages:

Source Code → Lexer → Parser → AST → Interpreter → Output

Lexer — Breaks source into tokens (numbers, keywords, operators)
Parser — Converts tokens into a tree structure (AST)
AST — Abstract Syntax Tree, a hierarchical representation
Interpreter — Walks the AST and executes each node

Stage 1: The Lexer

The lexer scans the source code and produces a list of tokens.

import re

TOKEN_TYPES = {
    'NUMBER': r'\d+',
    'PLUS': r'\+',
    'MINUS': r'-',
    'MULT': r'\*',
    'DIV': r'/',
    'LPAREN': r'\(',
    'RPAREN': r'\)',
    'ASSIGN': r'=',
    'IDENT': r'[a-zA-Z_][a-zA-Z0-9_]*',
    'KEYWORD': r'(let|print|if|else|while|fn)',
}

class Lexer:
    def __init__(self, text):
        self.text = text
        self.pos = 0
        self.tokens = []

    def tokenize(self):
        while self.pos < len(self.text):
            matched = False
            for token_type, pattern in TOKEN_TYPES.items():
                regex = re.compile(pattern)
                match = regex.match(self.text, self.pos)
                if match:
                    value = match.group(0)
                    if token_type == 'KEYWORD':
                        self.tokens.append(('KEYWORD', value))
                    elif token_type == 'IDENT':
                        self.tokens.append(('IDENT', value))
                    elif token_type == 'NUMBER':
                        self.tokens.append(('NUMBER', int(value)))
                    else:
                        self.tokens.append((token_type, value))
                    self.pos = match.end()
                    matched = True
                    break
            if not matched:
                raise SyntaxError(f"Unknown character: {self.text[self.pos]}")
        return self.tokens

Stage 2: The Parser

The parser takes tokens and builds an AST.

class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0

    def peek(self):
        return self.tokens[self.pos] if self.pos < len(self.tokens) else (None, None)

    def consume(self, expected_type=None):
        token = self.peek()
        if expected_type and token[0] != expected_type:
            raise SyntaxError(f"Expected {expected_type}, got {token[0]}")
        self.pos += 1
        return token

    def parse(self):
        statements = []
        while self.pos < len(self.tokens):
            statements.append(self.statement())
        return AST(statements)

    def statement(self):
        token, _ = self.peek()
        if token == 'KEYWORD':
            _, kw = self.consume()
            if kw == 'let':
                return self.let_statement()
            elif kw == 'print':
                return self.print_statement()
            elif kw == 'if':
                return self.if_statement()
            elif kw == 'while':
                return self.while_statement()
        return self.expr_statement()

    def let_statement(self):
        name_tok = self.consume('IDENT')
        self.consume('ASSIGN')
        value = self.expr()
        return LetNode(name_tok[1], value)

    def print_statement(self):
        value = self.expr()
        return PrintNode(value)

Stage 3: The AST Nodes

Each node in the AST is a Python class representing a language construct.

class ASTNode:
    pass

class NumberNode(ASTNode):
    def __init__(self, value):
        self.value = value

class BinOpNode(ASTNode):
    def __init__(self, left, op, right):
        self.left = left
        self.op = op
        self.right = right

class LetNode(ASTNode):
    def __init__(self, name, value):
        self.name = name
        self.value = value

class PrintNode(ASTNode):
    def __init__(self, value):
        self.value = value

class IfNode(ASTNode):
    def __init__(self, condition, then_branch, else_branch):
        self.condition = condition
        self.then_branch = then_branch
        self.else_branch = else_branch

class WhileNode(ASTNode):
    def __init__(self, condition, body):
        self.condition = condition
        self.body = body

Stage 4: The Interpreter

The interpreter walks the AST and executes each node.

class Interpreter:
    def __init__(self):
        self.variables = {}

    def eval(self, node):
        if isinstance(node, NumberNode):
            return node.value
        elif isinstance(node, BinOpNode):
            left = self.eval(node.left)
            right = self.eval(node.right)
            if node.op == '+': return left + right
            elif node.op == '-': return left - right
            elif node.op == '*': return left * right
            elif node.op == '/': return left // right
        elif isinstance(node, LetNode):
            self.variables[node.name] = self.eval(node.value)
        elif isinstance(node, PrintNode):
            print(self.eval(node.value))
        elif isinstance(node, IfNode):
            if self.eval(node.condition):
                for stmt in node.then_branch:
                    self.eval(stmt)
            elif node.else_branch:
                for stmt in node.else_branch:
                    self.eval(stmt)
        elif isinstance(node, WhileNode):
            while self.eval(node.condition):
                for stmt in node.body:
                    self.eval(stmt)
        elif isinstance(node, IdentifierNode):
            return self.variables.get(node.name)

Putting It All Together

def run(code):
    lexer = Lexer(code)
    tokens = lexer.tokenize()
    parser = Parser(tokens)
    ast = parser.parse()
    interpreter = Interpreter()
    for node in ast.statements:
        interpreter.eval(node)

# Test it
run('''
let x = 10
let y = 20
print x + y

let fact = fn(n) {
  if n < 2 { 1 }
  else { n * fact(n - 1) }
}
print fact(5)
''')

Output:

30
120

What ScoLang Supports

Variables: let x = 10
Arithmetic: +, -, *, /
Functions: fn(a, b) { a + b }
Conditionals: if x > 5 { print x } else { print 0 }
Loops: while x > 0 { x = x - 1 }
Print: print x + y

What I Learned

Everything is a tree — programs are just hierarchical data structures
Simplicity wins — my first attempt was too complex; stripped it down to basics
Testing matters — wrote a test suite to catch bugs as I added features
Interpretation is slow — compiled languages (C, Rust) are faster for a reason

Try It Yourself

The full source code is on my GitHub. Clone it, run it, and extend it with your own features:

Add string support
Add arrays and loops
Add a standard library
Compile to bytecode instead of interpreting AST

GitHub: github.com/fredscottsbulls
Website: scottechx.com

Building Your Own Cybersecurity Toolkit: 20 Essential Tools in 2026

ScottsTechX — Thu, 28 May 2026 06:55:27 +0000

Building Your Own Cybersecurity Toolkit: 20 Essential Tools in 2026

A great cybersecurity professional is only as good as their toolkit. After years of red-teaming and penetration testing, I've distilled the essential stack every security researcher needs — and the best part? They're all free and open source.

Why Build Your Own Toolkit?

Pre-packaged distros like Kali Linux are great starting points, but building your own toolkit gives you:

Full control over what you install
Reproducible setups you can replicate across machines
Clean, lean installs with no bloat
Deeper understanding of each tool's purpose

The Essential 20

Recon & Discovery

1. Nmap — The network mapper. Port scanning, service detection, OS fingerprinting.

nmap -sV -sC -p- 192.168.1.1  # Full scan with scripts

2. Amass — Subdomain enumeration. OWASP's tool for mapping attack surfaces.

amass enum -passive -d example.com

3. Subfinder — Fast passive subdomain discovery.

subfinder -d example.com -o subdomains.txt

4. ffuf — Fast web fuzzing. Directory brute-forcing, vhost discovery.

ffuf -w wordlist.txt -u https://target.com/FUZZ

Vulnerability Scanning

5. Nikto — Web server scanner. Detects misconfigurations, outdated software, dangerous files.

nikto -h https://target.com

6. Nuclei — Template-based vulnerability scanner. 3000+ detection templates.

nuclei -u https://target.com

7. SQLmap — Automated SQL injection. Database fingerprinting, data extraction, shell access.

sqlmap -u "http://target.com/product?id=1" --batch --dbs

Web Application Testing

8. Burp Suite Community — Web proxy for intercepting and analyzing traffic.

9. OWASP ZAP — Free automated scanner with active/passive scanning.

10. ffuf — Already mentioned, but also excels at parameter fuzzing.

ffuf -w params.txt -u https://target.com/api?FUZZ=value

Password Attacks

11. Hashcat — GPU-accelerated password cracking. Supports 200+ hash types.

hashcat -m 0 -a 0 hashes.txt wordlist.txt

12. John the Ripper — Multi-platform password cracker. Great for /etc/shadow files.

john --wordlist=rockyou.txt hashes.txt

13. Hydra — Parallelized login brute-forcer. SSH, FTP, HTTP, SMB, and more.

hydra -l admin -P passwords.txt ssh://target.com

Network Attacks

14. Metasploit Framework — The exploitation framework. Payloads, encoders, aux modules.

15. Responder — LLMNR/NBT-NS/mDNS poisoner. Capture hashes on local networks.

responder -I eth0

16. Bettercap — Swiss army knife for MITM attacks. ARP spoofing, DNS spoofer, packet sniffer.

Post-Exploitation

17. CrackMapExec — Network pivoting. Pass-the-hash, credential dumping, lateral movement.

18. Empire — PowerShell post-exploitation framework.

19. Evil-WinRM — Windows Remote Management shell for post-exploit access.

OSINT & Logging

20. theHarvester — Email, subdomain, and personnel OSINT gathering.

theHarvester -d example.com -b google

One-Command Installer

Want all 20 tools on a fresh box? Use my ScottsTool-Installer:

git clone https://github.com/fredscottsbulls/ScottsTechX-Tool-Installer && cd ScottsTechX-Tool-Installer && python3 install.py

Setup Tips

Use a VM or VPS — Never run offensive tools from your primary machine
Use a separate testing lab — Isolated network with vulnerable VMs
Keep tools updated — apt update && apt upgrade regularly
Learn the fundamentals first — Nmap without network knowledge is just noise

CTF Bonus: Quick Win Commands

# Fast port scan
nmap -T4 -F target.com

# Web enum
dirb http://target.com /usr/share/wordlists/dirb/common.txt

# Quick hash identify
hashid.py hashes.txt

# Find exploits
searchsploit software version

The Mindset

Tools are only as good as the operator. The best researchers understand why a vulnerability exists, not just how to exploit it. Build your knowledge alongside your toolkit.

GitHub: github.com/fredscottsbulls
Website: scottechx.com

How I Built a Telegram Bot That Monitors My Server in Real-Time

ScottsTechX — Thu, 28 May 2026 06:45:40 +0000

How I Built a Telegram Bot That Monitors My Server in Real-Time

Ever wished you could get instant alerts when your server goes down — straight to your phone? In this guide, I'll walk you through how I built a production-ready server monitoring Telegram bot that keeps you notified 24/7.

The Problem

When your server goes down, you need to know — immediately. Email alerts are too slow. Third-party monitoring services are expensive and overkill for small projects.

The Solution

A lightweight Telegram bot that pings your server every 30 seconds and alerts you the moment something goes wrong.

Tech Stack

Python 3.10+
python-telegram-bot library
psutil for system metrics
SQLite for logging

Key Features

CPU/RAM Monitoring — Get alerts when resource usage exceeds thresholds
Disk Space Warnings — Never run out of storage unexpectedly
Service Health Checks — Monitor HTTP endpoints and custom ports
Alert Routing — Different severity levels to different chat IDs
Incident Logging — All events stored in SQLite for review

The Code

import telegram
import psutil
import time
from datetime import datetime

class ServerMonitor:
    def __init__(self, token, chat_id):
        self.bot = telegram.Bot(token=token)
        self.chat_id = chat_id
        self.thresholds = {
            "cpu": 80,
            "ram": 85,
            "disk": 90
        }

    async def check_system(self):
        cpu = psutil.cpu_percent(interval=1)
        ram = psutil.virtual_memory().percent
        disk = psutil.disk_usage("/").percent

        if cpu > self.thresholds["cpu"]:
            await self.send_alert(f"CPU alert: {cpu}%")
        if ram > self.thresholds["ram"]:
            await self.send_alert(f"RAM alert: {ram}%")
        if disk > self.thresholds["disk"]:
            await self.send_alert(f"Disk alert: {disk}%")

    async def send_alert(self, message):
        await self.bot.send_message(
            chat_id=self.chat_id,
            text=f"[{datetime.now()}] {message}"
        )

    def run(self, interval=30):
        while True:
            asyncio.run(self.check_system())
            time.sleep(interval)

Setup Instructions

Create a bot via @botfather on Telegram
Get your chat ID using @userinfobot
Install dependencies: pip install python-telegram-bot psutil
Configure thresholds in the script
Run with: python monitor.py &

Result

Instant alerts, zero monthly cost, full control over your infrastructure.

GitHub: github.com/fredscottsbulls
Website: scottechx.com