Forem: dzaeltic

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!