DEV Community: dzaeltic

Text Processing & Networking with Linux Commands (Part 2)

dzaeltic — Mon, 10 Aug 2026 13:46:35 +0000

This post is a continuation to my post from two weeks ago where I talked about Linux commands for file management.

2>
Redirects standard error instead of standard output. Useful when a command is throwing warnings or errors you want to save separately from its normal output.
Usage: command 2> errors.log

2>&1
Redirects standard error into the same stream as standard output, so both end up in the same place. Commonly paired with > to capture everything a command prints.
Usage: command > output.log 2>&1

!!
Re-runs the last command you typed. Useful for when sudo was forgotten
Usage: sudo !!

TEXT PROCESSING

sort
Sorts the lines of a file or input alphabetically by default. The -n flag sorts numerically instead of as text, -r reverses the order, and -k lets you sort by a specific column.
Usage: sort -n scores.txt

uniq
Filters out repeated adjacent lines, either removing duplicates or, with -c, counting how many times each line occurs.
Usage: sort names.txt | uniq -c

wc
Word Count. Prints the number of lines, words, and bytes in a file. Use -l for just lines, -w for just words, or -c for just bytes.
Usage: wc -l access.log

cut
Pulls out a specific section from each line of input, usually a column in delimited text like a CSV. The -d flag sets the delimiter and -f picks which fields to keep.
Usage: cut -d ',' -f 2 contacts.csv

tr
Translates or deletes characters from input, one for one. Good for quick jobs like changing case or stripping out unwanted characters. It only reads from standard input, so it's always used with a pipe or redirect.
Usage: cat notes.txt | tr 'a-z' 'A-Z'

sed
Stream editor. Reads input line by line and applies an edit to each one, most commonly a find-and-replace using the s/pattern/replacement/ syntax. Add a g at the end to replace every match on a line, not just the first.
Usage: sed 's/http/https/g' urls.txt

awk
A small programming language built for working with columnar text. It automatically splits each line into fields you can reference as $1, $2, and so on, with $0 meaning the whole line. It's overkill for simple jobs but worth understanding once you need conditions or math on your columns.
Usage: awk '{print $1, $3}' access.log

xargs
Takes lines from standard input and turns them into arguments for another command. Many commands, like rm or grep, don't read from a pipe directly, so xargs is what lets you feed piped output into them.
Usage: find . -name "*.tmp" | xargs rm

NETWORKING

ping
Sends small packets to a host and reports how long they take to come back, confirming whether a machine is reachable at all. Runs continuously until you stop it with ctrl+c, unless you cap it with -c.
Usage: ping -c 4 google.com

curl
Transfers data to or from a server over HTTP, FTP, and other protocols. By default it just prints the response body, but flags like -I (headers only), -o (save to file), and -X (set the request method) make it more flexible.
Usage: curl -I https://example.com

wget
Downloads files from the web straight to disk. Where curl is built for talking to APIs and inspecting responses, wget is built for grabbing a file and saving it, including recursively pulling down a whole page with its assets.
Usage: wget https://example.com/file.zip

ip
Shows and configures network interfaces, addresses, and routing on the machine. The older ifconfig command does something similar but is considered deprecated on most modern distros in favor of ip.
Usage: ip a

ss
Lists the network sockets currently open on the machine, such as which ports are listening for connections. The -t flag limits it to TCP, -u to UDP, -l to listening sockets, and -n skips resolving names so it runs faster.
Usage: ss -tuln

dig
Queries DNS servers directly and shows the full result, which makes it the go-to tool for debugging why a domain isn't resolving the way you expect.
Usage: dig example.com

ssh
Secure Shell. Opens an encrypted terminal session on a remote machine, as if you were sitting in front of it. Requires an account on the remote machine, identified as user@host.
Usage: ssh user@192.168.1.10

scp
Secure Copy. Copies files between machines over the same encrypted connection SSH uses. The syntax mirrors cp, just with a user@host: prefix on whichever side is remote.
Usage: scp report.pdf user@192.168.1.10:/home/user/

Hopefully this gave some more insight as to how the Linux terminal can be a powerful place to do online work.

Happy coding!

File Management with Linux Commands

dzaeltic — Mon, 27 Jul 2026 02:42:58 +0000

These are the basic commands that will help you move around and manage your file system from inside the Linux terminal. Before going over any of the commands; though, these are some variables/operators you should know first. This lets us shorthand common things to type and chain commands together in powerful ways.

*
The wildcard. This can represent any text when searching. For example: if you want to search for all photos you could use the wildcard followed by jpg, png, etc. *.png

|
The pipe. This is a very handy operator that lets us take the output from one command and give it straight to the second command following the pipe.

&
The single ampersand. If your command starts a process, appending the ampersand to it will run the process in the background instead of occupying your terminal.

&&
The double ampersand. This operator will only execute the second command following the operator if the first one was successful.

.
The period. This is a shortcut to the current working directory, so you don't have to type out the whole path to where you are.

;
The semicolon. Run many commands in one line if they are separated by this operator. This lets them run independently of each other.

>
This operator takes the output of a command and overwrites the following file with that output.

>>
Similar to the single greater than, but it will append to the file instead of overwriting it.

HELP

--help
A more concise version of the man command that prints to the terminal instead of entering another interface. This command is used as a flag to other commands.
Usage: cat --help

man
The man command is used to pull up the manual on other commands. The manual will be a text interface over the terminal, and can be exited by inputting q. This will have a summary information about usage of the command as well as information about all flags that can be appended to the command. This is also where you can find any arguments a command may take.
Usage: man ls

info
A more detailed version of the manual. This page often includes examples as well as more detailed descriptions.
Usage: info cat

FILE NAVIGATION

ls
This command lists children of the current directory. By default, it does not display hidden files, but they can be toggled on with the -a flag. By default this command will only display the files’ name, but more info can be displayed with the -l flag. This will show user’s privileges on a file such as read, write, and execute privileges, and other info like size.
Usage: ls -l

cd
This command changes the current working directory. It takes one argument of a file path. Use cd .. to move back a directory.
Usage: cd photos

pwd
Print Working Directory. This one is self explanatory. It prints the path to the current working directory.
Usage: pwd

cat
Concatenate files and print to the terminal. Ideal for quickly printing the contents of smaller files.
Usage: cat file.txt

less
Less is like cat but for larger files. Will print the files in pages, so they can be viewed one at a time. Use space to go forward a page and backspace to go backwards. q to quit.

Usage: less file.txt

tail
Quickly print the last few lines in a file to the terminal. This is good to view the end of a file without leaving the CLI.
Usage: tail file.txt

head
Quickly print the first few lines in a file to the terminal. This is good to view the beginning of a file without leaving the CLI.
Usage: head file.txt

grep
This command prints lines from a file where text matching an input pattern is found. The first argument after any option flags or switches is the pattern. The pattern may be a string or regular expression. The second argument will be the files to be searched. Zero or more may be input. The file argument is optional because grep can also be chained with the pipe operator to search that output instead of a file. Grep is especially useful when used like that! The -v flag will reverse grep to print every line not including an input pattern.
Usage: grep “install” README.md

find
Find files and directories based on various criteria. The first argument will specify the directory to start the search in, and the following arguments will be the criteria to search for. For example, we can search for -type f for just files or -type d for just directories. We can also search by name with -name “cat.jpeg”.
Usage: find . -type f -name “*.pdf”

which
This command returns all executable files for a shell command. Packages like unzip, nmap, docker, etc. that have a shell command are located within a directory, and the exact location of the file that executes when these commands run can be found with which.
Usage: which docker

whereis
The whereis command can locate the binary, source, and manual page for a command.
Usage: whereis docker

FILE MANAGEMENT

touch
Touch makes a file. Many file names can be input to make multiple files at once. Touch can also edit the timestamps on files that already exist.
Usage: touch file1.txt file2.txt

mkdir
This command will make a new directory if it does not already exist. Many directory arguments may be passed in to make multiple directories. Permissions may be set with the -m flag.
Usage: mkdir photos

rm
Removes a file. This command cannot remove directories by default. The -r flag must be used for directories, indicating recursive removal. Note: files removed with rm can usually be recovered. Use shred for more assurance that a file will be unrecoverable.
Usage: rm -r photos

cp
Copies files or directories to a target destination. Typically, two arguments are passed in with the first being the source to be copied and the second being the destination to be copied to. The -t flag can flip the order where the first argument is a directory and the following arguments are files to be copied into it.
Usage: cp -t photos cat.jpeg dog.jpeg

mv
Moves or renames files or directories. If two file names are given, the first will be moved to the second, effectively renaming it. The -t flag works similarly to the cp command.
Usage: mv -t photos cat.jpeg dog.jpeg

This was a basic overview of how to start using commands to interact with your Linux file system. There are many more commands to Linux built in and even more that can be installed through packages.

Happy coding!

Network Ports

dzaeltic — Mon, 13 Jul 2026 03:29:04 +0000

There are two types of "ports". There are the physical ports that are on the back of a network router or switch, and there are the virtual ports that live inside of a computer. They are not so different, though. Both of these ports will have a role in the journey of data transfer.

Data is sent in packets to break up information into smaller bites. Each packet gets attached meta data called headers about where it is going. The IP address tells the packet which network to travel to, and once a packet reaches a network, the physical port tells it which MAC address(computer) it is going to. Then, it will be able to find the correct computer, but only once the network port is read, will the data know how to be processed.

A computer can have many processes, services and applications running at the same time over the same network. One computer can send an email from port 587 at the same time it is receiving video data from a video server over port 443. Because data can be so varied, we need ports to make sure the correct services on our computer receive the right data.

There are over 65000 available ports on a computer, and much of the lower range of them are either well-known ports or registered ports. This lets us organize them by service, and keep better track of what type of data should be flowing through that port and how.

For example. If we see packets coming and going from port 22 and 23, we can expect a TELNET or SSH connection. Both of which allow for remote access of a device. This is the type of connection that lets us configure rented virtual machines and host a server on it. The more predictable packets are, the easier it is to spot malformed or suspicious data.

Historically, some of the well-known ports transferred data in clear text. With the example I just gave, remote access used to be on TELNET first, but all data was sent in clear text, making it easy for hackers to decipher data that could be sensitive. Many times authentication is needed for access to something like a remote access shell, so if credentials get sent in plain text, anyone could intercept those and use it to authenticate themselves falsely. SSH, on the other hand, establishes a secure connection tunnel where data is encrypted during transfer. Other ports have been migrated to support encryption as well. For example, port 80 for HTTP (web services) is encrypted on port 443 for HTTPS.

When checking for a network's vulnerabilities, most attackers start with a port scan. If a port scan returns outdated ports, like TELNET, being open, this could be a clear indicator that intercepting those packets may have sensitive data in plain text. This is exactly what firewalls defend against.

Port scans are an easy terminal command to run, and they can be ran stealthily. Networks may never even know that their network ports were scanned. nmap -sS 192.168.1.1 This command scans thousands of ports per second, and will gives clear, reliable differentiation between open, closed, and filtered states ports may be in.

A simple firewall intercepts packets and reads the headers off of it. Firewalls can be configured to deny traffic (blacklist) or accept traffic (whitelist) to specific ports or IPs. This allows us to close ports that we don't need open. It can also let us allow only specific IP address's into ports.

We can look at an event called WannaCrypt from 2017 to see how devastating this type of thing can be. Port 445. Used for file/printer sharing on windows machines. A specially crafted packet allowed for an attacker to run code on a target with no login credentials needed. Once one machine was infected, it automatically scanned surrounding networks to look for any devices accepting TCP traffic on port 445. It spread by sending the same exploit to all of them.

This hack spread to over 150 countries, infecting an estimated 200,000+ systems with days. It impacted major industries including health, mail, and phone.

Six weeks later, the same exploit was used to hit machines with a credential-stealing tool to also spread to already patched machines.

The worst part about this hack is that it could've been avoided by patching regularly. Microsoft had already known about the exploit before the hack and released a patch about a month before it happened.

Ports are vital for networking and sending data to the right places, but can also be a weak point without proper security precautions.

KEY PYTHON CYBERSEC LIBRARIES

dzaeltic — Tue, 09 Jun 2026 19:48:24 +0000

In this blog, I'm going to briefly break down 4 libraries commonly used in Cyber Security. It's an area I am interested to do more research in. I may make another blog about this field. Now, the libraries I will be exploring are:

Python has even more open-source software(OSS) libraries that suit many cybersecurity needs. The community is active, meaning the tools are ever-growing. Some use cases for this may be networking, cryptography, data serialization, machine learning, math, etc.

One advantage of having these libraries is that it abstracts away a lot of the complexity behind the scenes and lets professionals put out scripts in only a few lines. This allows counter-attacks to happen ASAP.

SCAPY
Scapy is a tool used to "send, sniff, dissect, and forge network packets... Scapy can easily handle most classical tasks like scanning, tracerouting, probing, unit tests, attacks or network discovery."

A packet is just a small portion of a larger piece of data. They are relevant to cybersecurity because they have information about the source and destination IP address. They can also be manipulated to form malicious attacks, overwhelming a system with too many packets (DDoS) or exploiting a system's vulnerabilities. This is a versatile tool because of its ability for surveillance and attacks alike.

Scapy prides itself in this versatility. Apparently, "90% of network probing tools can be rewritten in 2 lines of Scapy."

>>> p = sr1(IP(dst="www.slashdot.org")/ICMP()/"XXXXXXXXXXX")
Begin emission:
...Finished to send 1 packets.
.*
Received 5 packets, got 1 answers, remaining 0 packets
>>> p
<IP version=4L ihl=5L tos=0x0 len=39 id=15489 flags= frag=0L ttl=42 proto=ICMP
 chksum=0x51dd src=66.35.250.151 dst=192.168.5.21 options='' |<ICMP type=echo-reply
 code=0 chksum=0xee45 id=0x0 seq=0x0 |<Raw load='XXXXXXXXXXX'
 |<Padding load='\x00\x00\x00\x00' |>>>>
>>> p.show()
---[ IP ]---
version   = 4L
ihl       = 5L
tos       = 0x0
len       = 39
id        = 15489
flags     =
frag      = 0L
ttl       = 42
proto     = ICMP
chksum    = 0x51dd
src       = 66.35.250.151
dst       = 192.168.5.21
options   = ''
---[ ICMP ]---
   type      = echo-reply
   code      = 0
   chksum    = 0xee45
   id        = 0x0
   seq       = 0x0
---[ Raw ]---
      load      = 'XXXXXXXXXXX'
---[ Padding ]---
         load      = '\x00\x00\x00\x00'

Scapy runs from the terminal, so it is very quick to run prompts, and variables that are made (like p in this example) get saved to your current session.

As we can see above, the sr1 function sends a packet and receives the first answer. p.show() allows us to display details about that packet. By default, it will show everything, but the display can be filtered.

Scapy pairs well with a packet analyzer software like wireshark, so you can view packets moving on your network live.

REQUESTS
Requests is simply a tool to make http requests. It is designed to be highly readable and quick to implement. "There’s no need to manually add query strings to your URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling are 100% automatic." This lets requests get made in a single line.

All instantiations of Request will have access to many methods like text, headers, encoding, json, etc., so viewing certain parts of the response are easy.

Here is an example of making a basic request and viewing it's url:

payload = {'key1': 'value1', 'key2': ['value2', 'value3']}

r = requests.get('https://httpbin.org/get', params=payload)
print(r.url)
# https://httpbin.org/get?key1=value1&key2=value2&key2=value3

Requests also has a Session class, so we can save some params or cookies to be used across all request made in that session.

Here is an example from Ayushman Dubey in an article from TryHackMe where data is extracted from an IP using the requests library:

import requests
import json  # Need to parse recieved data

def iplookup(public_ip):
    r = requests.get("http://ip-api.com/"+public_ip) 
    if r.status_code == 200: # If success 
        data = json.loads(r.text) # Load the recieved data in json object
        for key, value in (data).items(): # This will iterate over dictionary
            print("{}:{}".format(key, value))
    else:  # If error occurs
        print("Error Occured while making request")

if __name__ == "__main__":
    try:
        ip = input("Enter IP: ")
        iplookup(ip)
    except:
        print("Error Occured!")

CRYPTOGRAPHY
Data encryption is important for good security, and this library is perfect for that. It offers many encryption formulas, although, the developers do not suggest using the "hazmat" level of encryption without a good understanding first.

The encryption is made with a key that the key holder must keep safe, as that is their method of decrypting the hidden data. It looks like this:

>>> from cryptography.fernet import Fernet
>>> key = Fernet.generate_key()
>>> f = Fernet(key)
>>> token = f.encrypt(b"my deep dark secret")
>>> token
b'...'
>>> f.decrypt(token)
b'my deep dark secret'

"The result of this encryption is known as a 'Fernet token' and has strong privacy and authenticity guarantees."

More specifications about how data is encrypted with Fernet can be found here.

These are very basic libraries, but there are more advanced ones for doing things like pen-testing and ethical hacking! If you're interested in that, I would check out pwntools. This is a very broad library with a wide range of use, so I didn't touch on it this blog. It deserves its own blog.

Automation in Python

dzaeltic — Mon, 01 Jun 2026 12:47:29 +0000

This is a basic introduction to scripting and automation. After introducing these topics and explaining why Python should be the go to tool for these types of tasks, I'll show some code examples.

What is a Script?

I want to bring this up because when I started researching about automation, I went into it coupling the idea of scripting and automation together, and I didn't even really know why. When I really started to understand what a script actually is, I understood why it is fundamental for anything automated with code. They are the recipes that set up your robot cook to be able to start cooking.

A script is really just a focused piece of code that does something. For example, it can convert a large data sample into a readable report for you. It could take an email template and a list of recipients and send them all a personalized email. It can convert all the images in a specific file to jpegs. You get the idea. Then, chain scripts together to get more complex outputs/functionality and schedule them to run without needing human input; now you're automating!

What made this all so confusing to me at first was figuring out the difference between a programming language and a scripting language. The difference isn't hugely important in the context of this blog except that scripting is much easier in languages considered "scripting languages" like JavaScript or Python.

Cool, now that we understand what a script is; let's give our robot cook some recipes, so it can start cooking.

What is Automation?

Let's say I'm the head chef of a brand new startup food truck. The opening was rushed, so the menu is really small. I want time for R&D so I can expand the menu, but my truck's popularity is really starting to pick up. I don't have enough time on my hand! This is the core concept behind why we automate. When we can offload menial tasks to our machine it frees up two of our most precious resources: time and mental capacity. If I had a robot cook to operate my fryers automatically, I'd declutter my mind to have better connections with my customers and have time to R&D new menu items while we're slow! Also, my new robot is probably a better fry cook than even me. He never messes up his timers!

Okay, that was a pretty niche example; I know, so let's take a look at some more tangible ones if you're still not seeing how powerful this could be for you. I can give all my employees key cards to login, automating security checks and what they have access to on an individual level. I can automatically scrape large customer data sets and monitor who my best customers are. Maybe even give them a promo discount. I could even automate a portion of my paycheck to go straight into savings when I get paid. The list goes on.

So, Why Python?

Interaction with Operating System
Scripts being run in the terminal and modules like os, sys, and shutil let Python touch system files, settings and OS easily.

Extensive Library
The list of available packages that help with automation are massive. This makes automating tasks related to data science, web scraping, web browsing, file management etc. very easy.

Ease of Access
Python is fast to write and easy to understand, saving developers time and getting scripts up and running quickly. This is especially useful in fields like cybersecurity where counter-attacks need to launch as soon as possible.

The Ecosystem
This is the way that it developed over time. JavaScript was built around web design, and its ecosystem reflects that. Python was built around being easy and fast to write, and it shows. The frameworks available for it are diverse and powerful, ranging from web development to science to game development to security. As time goes on, people will keep pushing the general purpose uses of Python even further.

Example Time

So, hopefully I've opened you're eyes to why Python is an amazing tool for automation. Let's look at what it might look like practically.

This a script written by Devesh Tiwari and Josh Vinson. You can find the link to the github repository here. I chose this example because it shows how easily Python scripts can touch system files. It isn't really automated, but it is a really good example of a type of script that Python might excel in over JavaScript. If we hooked this up to happen whenever a large folder system gets added to my computer, that would be automating it.

import os
import shutil
from datetime import datetime

def categorize_file(filepath):
    filename, extension = os.path.splitext(filepath)
    categories = {
        ".jpg": "images",
        ".png": "images",
        ".pdf": "documents",
        ".docx": "documents",
        ".mp4": "videos",
        ".avi": "videos",
        ".mkv": "videos",
        ".exe": "apps"
    }
    return categories.get(extension.lower(), "other")

def create_folders(directory):
    os.makedirs(os.path.join(directory, "images"), exist_ok=True)
    os.makedirs(os.path.join(directory, "documents"), exist_ok=True)
    os.makedirs(os.path.join(directory, "videos"), exist_ok=True)
    os.makedirs(os.path.join(directory, "other"), exist_ok=True)
    os.makedirs(os.path.join(directory, "apps"), exist_ok=True)

def sort_files(source_directory, target_directory):
    for root, _, files in os.walk(source_directory):
        for filename in files:
            filepath = os.path.join(root, filename)
            file_category = categorize_file(filename)
            target_path = os.path.join(target_directory, file_category, filename)
            try:
                shutil.copy2(filepath, target_path)
                file_date = datetime.fromtimestamp(os.path.getmtime(filepath))

                # Replace colons to avoid invalid filename errors
                sanitized_date = file_date.isoformat().replace(":", "-")
                new_filename = f"{sanitized_date}-{filename}"

                os.rename(target_path, os.path.join(os.path.dirname(target_path), new_filename))
            except Exception as e:
                print(f"Error moving '{filepath}': {e}")

def main():
    source_directory = input("Sorry to bother you Lord Vinson, but I'll need the source directory:")
    target_directory = input("Sorry to bother you once again Lord Vader, but I'll need the destination directory:")

    create_folders(target_directory)
    sort_files(source_directory, target_directory)

    print("File organization completed!")

if __name__ == "__main__":
    main()

The script takes an input target file path and destination file path. It then sorts them by what type of file they are, and copies them over to the new destination. It also prepends the date and time that they were moved to the file name. One thing to note about this script is that it makes copies of the original files and does not delete them, so this is a great script if you wanted to export a folder but keep them how they are on your machine.

Automating things is easier than ever. The are so many free tools available for pretty much anything you can think of with Python. I encourage you to do some more research on this topic if you found this interesting. Here are some good resources to get you started:

Python automation: 9 scripts to automate workflows | Zapier

Learn how to automate tasks with Python and boost your productivity. Try out these Python automation scripts for web scraping, data processing, and more.

zapier.com

datacamp.com

IT Automation with Python | ActiveBatch BlogIT Automation with Python | ActiveBatch Blog

Learn More about IT Automation with Python and how it can help you and your company streamline repetitive workflows and increase efficiency.

advsyscon.com

Python as a JavaScript Dev

dzaeltic — Mon, 25 May 2026 12:47:59 +0000

This blog is an introduction to Python, and it assumes that you have a good knowledge of JavaScript as a language already. I will cover a lot of the basics we use to write code every day, and how they will look in Python compared to JavaScript. This is not to see if one language is better than the other, but rather a resource to aid JavaScript developers who want to start coding in Python for the first time. It is not comprehensive, but I do hope it helps get your foot in the door.

BASIC SYNTAX DIFFERENCES
Python typically uses snake_casing instead of camelCasing, and has no variable declaration keywords. We can simply say something like:

my_name = 'dev'
num = 24

Although, there is no required keyword, we can include "global" or "nonlocal" to add our variable to a scope outside of the one it was declared in. "global" will put in the global scope, and "nonlocal" will put it in the enclosing (but not global) one.

Python has no semicolons or curly braces. In JavaScript we are able to be very loose with how our whitespace looks because we can indicate the end of a line with a semicolon, and curly braces to define blocks. You could even write an entire JavaScript file in one line because of this (pls don't). However, Python is very strict about whitespace. There is a whole error for these types of mistakes in Python called IndentationError. New lines of code must _be broken by a line break, and code blocks like function bodies _must be indented and start with a colon.

Parenthesis are reserved for Tuples (See collection section), so if statements and for loops will not need their conditionals/control statements wrapped inside ().

Pythons number variables are called integers, and there is another variable type, float, specifically for decimals.

Some popular collection methods like .map and .filter appear as native functions on the global scope in Python:

.map(cb) -> map(cb, col)
.filter(cb) -> filter(cb, col)
.length() -> len(col)
.sort() -> sorted(col)

COLLECTIONS

LISTS
A list in Python is what we think of as an array in JavaScript. Python lets us access specific items in the list with bracket notation as well, but a lot of the array methods we know and love like slice are included in bracket notation in Python. Some functionalities will still need to be accessed through a method. For Example: .append method. This one behaves like the .push method in JavaScript. The .pop method is named the same in both languages.

nums = [0, 1, 2, 3, 4] 
print(nums[1:3]) # [1, 2]

notes:

this would not mutate nums
console.log() = print()
comment = #

Some more things you can do with bracket notation:

nums[:2] #<- starts on index 0
nums[1:] #<- includes through last index
nums[1:-1] #<-includes until last index
nums[1:2] = [5] #replaces 1 with 5

note: last example is similar to .splice method!

We can concatenate lists with the plus operator in Python!

nums = [0, 1, 2]
names = ["greg", "linda"]
combined = nums + names # [0, 1, 2, "greg", "linda"]

Python lets us manipulate lists in some more very interesting ways. We can achieve something really similar to a map and filter chain by using a loop inside of a list literal. Let me show you:

nums = [1, 2, 3]
double_even_nums = [num * 2 for num in nums if num % 2 == 0] # [4]

notes:

num * 2 -> what we return into the list
for num in nums -> iterate through each number in nums
if num % 2 == 0 -> only return num into new list if it passes even check

TUPLES
Tuples are similar to lists, and are indicated by parenthesis. The main difference is that Tuples cannot be added to or removed from. Let's go over unpacking since it is helpful for tuples and lists. Similar to deconstructing in JavaScript, we can unpack values in these types of collection into other variables with handy syntax. An error will get thrown if there are too many values to unpack in a collection and not enough provided variables.

nums = (1, 2, 3, 4)
a, b, *c = nums # a = 1, b = 2, c = [3, 4]
a, *b, c = nums # a = 1, b = [2, 3], c = 4
a, b, c, d = nums # a = 1, b = 2, c = 4, d = 4

note: The asterisk lets me fill a variable with remaining variables to avoid an error.

DICTIONARIES
A dictionary is similar to what we think of as an object in JavaScript. A dictionary literal will be enclosed in curly braces, and similar to JSON, the key names must be in quotes.

We cannot use dot notation to access dictionary values, and must use bracket instead. If you lookup something that is not included in the dictionary, it will throw an error. To avoid this, though, use the .get method. The second argument for .get will specify what to print if the key you specified was not found.

There are still many methods you will recognize like .keys and .values (these will return lists). To grab the key/value pairs use .items (this will return a list of tuples).

person = { "name": "dev", "age": 23 }
print(person["name"]) # "dev"
print(person.get("fav_food", "not found")) # "not found"

CODE BLOCKS

IF STATEMENTS
Python is "strongly typed", so there is only one equality comparison operator: ==. There is one exception for comparing integers to float. These can return true on equality comparison even though they are technically different variable types.

We can also check if two objects occupy the same space in memory by using the keyword "is". This is super handy to be built into the language!

Instead of saying "else if", Python uses the keyword "elif". Keywords "and", "or", and "not" are used instead of &&, ||, and !

if age >= 16 and has_license == true:
    print("You can drive")
elif age < 16 or not has_license:
    print("You cannot drive")
else:
    print("How did we get here?")

FOR LOOPS
We use the keyword "range" to specify how long to loop. There are still for in loops to go through collections, and they are comprehensive in Python, meaning it will work for any collection.

animals = {"dog": "Spike", "cat": "Tom", "mouse": "Jerry"}
for animal, name in animals.items():
    print(animal, name) # "dog" "Spike" "cat" "Tom" "mouse"...

for i in range(5):
    print(i) # 1, 2, 3, 4, 5

FUNCTIONS
Functions are the only exception to the fact that variables do not need a keyword upon declaration in Python. The reason is that we have many keywords to specify the type of function that we are writing:

def - basic function (default)
lambda - defines a callback function
class - defines a class object

def add(x, y):
    return x + y


nums = [2, 4, 6]
double_nums = list(map(lambda num : num * 2, nums)) # [4, 8, 12]


class Cat:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def named_meow(self):
        return f"meow says {self.name}"

    @staticmethod
    def meow()
        return "meowwww"

tom = Cat("Tom", "gray")

notes:

"self" behaves like "this" in classes, and must be passed in as a param
init is like a super function
If a method does not use "self", define it as a static method
A formatted string (f"string") lets us use a template literal. Similar to backticks in JavaScript
Must wrap map() in list() because map does not return a list by default, but rather a map object. It returns this to save memory if conversion is not necessary

Well, this covered a lot, and I'm sure you experienced JavaScript developers still have some questions about how to do things in Python that I didn't answer. There were some things like maps, sets, etc... that I left out for time sake. I also didn't explain how any of these pieces work because, like I said earlier, this blog assumes you already know how to write code in JavaScript. I know it is a little bit of a niche, but hopefully it helps someone! Happy coding!

What makes a good codebase?

dzaeltic — Thu, 30 Apr 2026 01:59:10 +0000

I am a currently student in a coding bootcamp. We have been focusing a lot on JavaScript, as we start to build fundamentals. Recently, as we have started exploring GitHub, CSS, and HTML, I've started to get exposed to larger codebases, and I've realized there is a lot that can be going on in one project. Collaboration is huge in development it seems, so having good fundamentals with how I layout codebases seems really important to me.

I say collaboration, and you probably immediately were thinking with other developers. While, yes, I was, I want to clarify that I am also talking about development with A.I. I know that my teachers don't really want me using A.I. to write code and I completely understand. It is a super powerful tool, and can easily become a crutch that hinders my learning largely. But, I would be a fool to not explore some coding with A.I on the side, and as I have, I have noticed that it can be hard to reign in the A.I. to actually fix the problem I need it to fix or even understand what the problem may be. Obviously, this is largely about the prompts I am giving it which could be improved upon. Communication is key to reaching a good codebase whether you are working with a person or AI!!

With clear instructions, the A.I is great at writing our code, saving us lots of time, but as a codebase grows, it gets harder and harder to communicate our vision and what our codebase should be doing as a whole. When it just solves problems through a lens without understanding the bigger picture, it leads to more modules. Simpler, but more. This gets harder to organize and navigate and becomes a problem as other developers struggle to understand what is happening in your codebase. Good codebases rely on more complex modules that have simpler interfaces, more functionality, and hidden complexity!

Tests, tests, tests! You have probably heard of T.D.D. (test driven development), but do you understand why it is important. This is what helps us communicate and focus on our main goal. Writing a test forces you to start with functionality. How does my code actually need to function? What possible bugs will I run into? These types of larger picture goals help to bridge the gap between two developers or AI and developer, so that goals can be reached more efficiently.

There is still a lot I don't understand in this field, but I can draw on my other life experiences to know that these things are key to building a good codebase. I didn't try to give micro-level tips and tricks because I am in no position to do so. Most people who read this will probably be more experienced at making codebases than I am.

I'm excited to start making my own codebases and applying what I've learned so far. I want to focus on designing architecture, making layouts that a toddler could understand. I want my code's purpose to be clear, and easy to edit. This is what makes a good codebase.

Also, I want to give some code examples of smaller snippets of code that may lead to larger problems when designing codebases.

▲ In this example, it is hard to tell what these variables actually mean, so it is more encouraged to use named variables. This helps collaborators tell what is going on. Like this ▼

▲ In this example, we can see many if statements nested into each other. This can get confusing for readers, and it is more encouraged to instead use operators to fit this logic into one line. Like this ▼

▲ What is 86400?? How will collaborators know what you are referring to? Try to give context to your variables ▼

Communication is huge, and we can become better communicators in our code as well as our English.

jQuery

dzaeltic — Mon, 27 Apr 2026 14:51:47 +0000

jQuery is a JavaScript library that makes it easier to interact with elements on your page. It uses this syntax:

$(selector).action()

You can select HTML elements by #class, .id, or with a tag like

. Non-existing elements can also be selected with the $ function, and they will be created.

By selecting an HTML element, we create an array-like object that stores many useful methods. We can add elements before and after with append and prepend, add a class, animate, and much more. It is important to not that it is an array-like object for iteration over selected elements.

One important method to note is .css. We can grab an html element, and edit any css property on the fly in our JavaScript code. It would look something like this:

$('p').css('color', 'black')

Note that many jQuery methods will return the object with all the methods in it, so chaining them together is possible.

Lastly, jQuery is great for handling events! Using the .on method, we can define an event like 'click' or 'hover', and write a function to be executed upon such an event. This allows to create dynamic elements on our page that the user can interact with.

It's important to know jQuery because of it's broad usage over the course of the internet's history, but it is also important to note another library called react. React may be imperative to use if your project involves a large number of elements, as it is more efficient with these types of projects. I would encourage looking it up and comparing the pros and cons of both!