Erick Johnson

The Johnson Adventure: Our First Newsletter!

Wed, 25 Jun 2025 00:00:00 -0500

Greetings!

It is with great excitement that Erick and I get to present to you our first newsletter as a married couple! So, welcome to the Johnson’s Adventures! May our journey together reflect the Lord’s light, grace, mercy, and love to all and to wherever we go.

We are writing to you from SE Asia! We have been here for 2 weeks now and the Lord has done great things in our journey so far. Erick and I have found that God is at work here in this country in ways that we were shocked to witness. Although this place is a closed country to missionaries and has less than 2% of evangelical Christians (making it an unreached country), God’s presence and work is evident here. There are local churches here in the capital city and locals who are fervent believers wanting to see their country turn towards the Lord.

Meeting New Friends

As we have been exploring different places, God placed us in conversations and situations He has used to bless us with.
Below [photo not available] is a picture of a friend we met as we were sitting by the lake. This little boy came up to us to practice his English. We got to have some fellowship with him and his dad.

Three days after arriving in the capital city, we met a Christian couple who started a coffee shop with the mission of supporting former drug addicts after rehabilitation, providing a home and a job by working in the coffee shop. At this coffee shop, we met Rusell, a Christian counselor specializing in marriages and parenting (he is also from Monee, IL! Small world).

We got to attend a local language-speaking church. There we met the Smiths, who have offered many insights and perspectives regarding the Great Commission. The Beards have been foundational in our understanding of missions here in the capital city. They opened up a coffee shop, Simple Coffee, with the vision of supporting young adults with developmental disabilities. On the 3rd level of the coffee shop, they have a training course called Imago Work where they teach these students social and work skills with the hope of training them to enter the workforce. Simple Coffee hires people with developmental disabilities so that they serve as a model to other companies that they too can be inclusive to this population.

Then we met a couple, the Deals, that focus primarily on church planting and travel to indigenous churches out in the northern villages and focus on Christian leadership.

The Work at Hand

There are several missionaries here creating a path to reach locals and all the different agencies work together to fulfill the one common purpose: The Great Commission.

Although it may seem on a larger scale that this country is ‘reached’ with the Gospel, only about 1% of the country’s 100+ million population identifies as Protestant Christians. There is still work to be done.

Additionally, Erick and I have observed that once you leave the city, things are drastically different. Living conditions are different, the landscape changes to farming fields, almost no one speaks English, and there are more pagodas/temples—not as reached with the Gospel.

As we have observed so many things, talked to so many people, and listened to their experiences, we are left with more questions than answers:

Where would the Lord have us partner with Him to fulfill the Great Commission?
How should we be serving the community we find ourselves in?
Should we open a business based on needs or should we focus on church planting? Which one would be the most effective for ultimately making disciples?

Through so many unknowns, we remain faithful to God’s plan and prayerfully partner with Him, trusting in His plans for us and for His people all over the world.

In just one week, we plan on going to South Asia and exploring what God is doing there with a One Collective catalyst.

Prayer Requests

As we wrap up our last 2 weeks here in the capital city, we would love for you to partner with us in prayer:

Pray that Stella’s visa gets approved to go to South Asia. The process has been long and difficult.
As we come back to the States, pray that God may reveal His plan for us in His timing, as we prepare to go and serve Him overseas.
Pray for all the different people we have encountered. That their work here is fruitful in reaching the locals. Pray for strength and protection over their families and their work.

Classes: Building Our Own Data Structures

Mon, 14 Apr 2025 00:00:00 -0500

Classes: Building Our Own Data Structures

As Data Structures students, we’ve worked a lot with Python’s built-in data types like strings, lists, and dictionaries. We’ve also talked about more intricate data types like stacks, queues and trees. Now, it’s time to level up your skills by creating your very own custom data types using Classes. Classes are the foundation of object-oriented programming (OOP) and allow you to bundle data and functionality together in a way that mirrors real-world objects.

What is a Class?

A Class is like a blueprint for creating objects. Think of it as a template that defines:

Attributes (variables) - the data that describes an object
Methods (functions) - the behaviors or actions an object can perform

For example, if we were creating a video game, we might have a Player class that contains attributes like health, position, and inventory, along with methods like move, attack, and use_item.

Creating Your First Class

Mrs. Johnson really wants a dog. I’m sure a digital Dog that lives in terminal memory will be good enough, right? Let’s start by creating a Dog class:

class Dog:
    # This is the initializer method (constructor)
    def __init__(self, name, breed, age):
        self.name = name    # Attribute
        self.breed = breed  # Attribute
        self.age = age      # Attribute
        self.is_sitting = False
    
    # Methods define what the dog can do
    def bark(self):
        return f"{self.name} says Woof!"
    
    def sit(self):
        self.is_sitting = True
        return f"{self.name} is now sitting"
    
    def stand(self):
        self.is_sitting = False
        return f"{self.name} is now standing"
    
    def birthday(self):
        self.age += 1
        return f"{self.name} is now {self.age} years old!"

Creating Objects from a Class

Once you’ve defined a class, you can create instances (objects) of that class:

# Create two dog objects
my_dog = Dog("Snoopy", "Cocker Spaniel", 3)
your_dog = Dog("Flinn", "French Poodle", 2)

# Use the objects
print(my_dog.name)          # Output: Snoopy
print(your_dog.breed)       # Output: French Poodle
print(my_dog.bark())        # Output: Snoopy says Woof!
print(your_dog.sit())       # Output: Flinn is now sitting
print(your_dog.is_sitting)  # Output: True
print(my_dog.is_sitting)    # Output: False

Each Dog object has its own separate set of attributes, but they share the same methods.

The self Parameter

You might have noticed that methods in a class take a parameter called self. This parameter represents the specific instance of the class that’s calling the method. When you call my_dog.bark(), Python automatically passes my_dog as the self parameter to the bark method.

A More Complex Example

Let’s create a BankAccount class to manage a simple bank account:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transaction_history = []
    
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            self.transaction_history.append(f"Deposit: +${amount}")
            return f"Deposited ${amount}. New balance: ${self.balance}"
        else:
            return "Deposit amount must be positive"
    
    def withdraw(self, amount):
        if amount > 0:
            if amount <= self.balance:
                self.balance -= amount
                self.transaction_history.append(f"Withdrawal: -${amount}")
                return f"Withdrew ${amount}. New balance: ${self.balance}"
            else:
                return "Insufficient funds"
        else:
            return "Withdrawal amount must be positive"
    
    def get_balance(self):
        return f"Current balance: ${self.balance}"
    
    def show_transactions(self):
        if not self.transaction_history:
            return "No transactions yet"
        return "\n".join(self.transaction_history)

Let’s put the BankAccount class into action:

# Create a new account
account = BankAccount("Samuel", 100)

# Perform some transactions
print(account.deposit(50))    # Output: Deposited $50. New balance: $150
print(account.withdraw(30))   # Output: Withdrew $30. New balance: $120
print(account.withdraw(200))  # Output: Insufficient funds
print(account.get_balance())  # Output: Current balance: $120

# Check transaction history
print(account.show_transactions())
# Output:
# Deposit: +$50
# Withdrawal: -$30

Inheritance: Building on Existing Classes

One of the most powerful features of OOP is inheritance, which allows you to create new classes based on existing ones. The new class (subclass) inherits attributes and methods from the existing class (superclass) and can add or override them.

Let’s create a SavingsAccount class that inherits from our BankAccount class:

class SavingsAccount(BankAccount):
    def __init__(self, owner, balance=0, interest_rate=0.01):
        # Call the parent class's __init__ method
        super().__init__(owner, balance)
        self.interest_rate = interest_rate
    
    def add_interest(self):
        interest = self.balance * self.interest_rate
        self.deposit(interest)
        return f"Added ${interest:.2f} interest"
    
    # Override the withdraw method to add a limit
    def withdraw(self, amount):
        if self.balance - amount < 50:
            return "Savings account must maintain a minimum balance of $50"
        return super().withdraw(amount)

Let’s put the SavingsAccount class into action:

# Create a savings account
savings = SavingsAccount("Bob", 1000, 0.05)

print(savings.get_balance())   # Output: Current balance: $1000
print(savings.add_interest())  # Output: Added $50.00 interest
print(savings.get_balance())   # Output: Current balance: $1050
print(savings.withdraw(1000))  # Output: Savings account must maintain a minimum balance of $50
print(savings.withdraw(500))   # Output: Withdrew $500. New balance: $550

Class Variables vs. Instance Variables

So far, we’ve been using instance variables (attached to self), which are unique to each object. Python also supports class variables, which are shared among all instances of a class:

class Student:
    # Class variable - shared by all instances
    school_name = "Mooseheart Child City & School"
    student_count = 0
    
    def __init__(self, name, grade):
        self.name = name    # Instance variable - unique to each instance
        self.grade = grade  # Instance variable
        Student.student_count += 1  # Incrementing the class variable
    
    def display_info(self):
        return f"{self.name} is in grade {self.grade} at {Student.school_name}"

# Create some students
student1 = Student("Jimmy", 12)
student2 = Student("Frank", 10)

print(student1.display_info())  # Output: Jimmy is in grade 12 at Mooseheart Child City & School
print(student2.display_info())  # Output: Frank is in grade 10 at Mooseheart Child City & School
print(f"Total students: {Student.student_count}")  # Output: Total students: 2

# Change the class variable
Student.school_name = "Batavia High School"

# Both students are affected by the change
print(student1.display_info())  # Output: Jimmy is in grade 12 at Batavia High School
print(student2.display_info())  # Output: Frank is in grade 10 at Batavia High School

Encapsulation: Protecting Data

Encapsulation means bundling data and methods together and restricting direct access to some of an object’s components. In Python, we use naming conventions to indicate that attributes or methods should be treated as public, private or protected.

class CreditCard:
    def __init__(self, number, holder, limit):
        self.holder = holder              # Public attribute
        self._limit = limit               # Protected attribute (single underscore)
        self.__number = number            # Private attribute (double underscore)
        self.__balance = 0                # Private attribute
    
    def get_balance(self):
        return f"Current balance: ${self.__balance}"
    
    def charge(self, amount):
        if self.__balance + amount > self._limit:
            return "Transaction declined: over limit"
        self.__balance += amount
        return f"Charged ${amount}. New balance: ${self.__balance}"
    
    def payment(self, amount):
        self.__balance -= amount
        return f"Payment of ${amount} received. New balance: ${self.__balance}"

card = CreditCard("1234-5678-9012-3456", "John Doe", 2000)

print(card.holder)         # Works fine: John Doe
# print(card.__number)     # Error! Can't access private attribute directly
# print(card.__balance)    # Error! Can't access private attribute directly
print(card._limit)         # Works, but convention suggests you shouldn't access it: 2000

print(card.charge(500))    # Output: Charged $500. New balance: $500
print(card.get_balance())  # Output: Current balance: $500
print(card.payment(200))   # Output: Payment of $200 received. New balance: $300

Properties: Controlled Access to Attributes

A more Pythonic way to implement getters and setters is using properties:

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:  # Absolute zero
            raise ValueError("Temperature cannot be below absolute zero")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        self.celsius = (value - 32) * 5/9

temp = Temperature(25)
print(temp.celsius)     # Output: 25
print(temp.fahrenheit)  # Output: 77.0

temp.celsius = 30
print(temp.fahrenheit)  # Output: 86.0

temp.fahrenheit = 50
print(temp.celsius)     # Output: 10.0

# temp.celsius = -300   # Raises ValueError: Temperature cannot be below absolute zero

Static Methods and Class Methods

Python classes can also have methods that don’t operate on instances:

Static methods: Don’t access instance or class data
Class methods: Can access and modify class-level data

class MathHelper:
    pi = 3.14159
    
    def __init__(self, value):
        self.value = value
    
    def square(self):
        return self.value ** 2
    
    @staticmethod
    def is_prime(num):
        """Check if a number is prime"""
        if num < 2:
            return False
        for i in range(2, int(num**0.5) + 1):
            if num % i == 0:
                return False
        return True
    
    @classmethod
    def circle_area(cls, radius):
        """Calculate circle area using the class's PI value"""
        return cls.pi * radius ** 2
    
    @classmethod
    def update_pi(cls, new_pi):
        """Update the PI value for all instances"""
        cls.pi = new_pi

# Static method - doesn't need an instance
print(MathHelper.is_prime(17))  # Output: True
print(MathHelper.is_prime(15))  # Output: False

# Class method - works with class variables
print(MathHelper.circle_area(5))  # Output: 78.53975

# Create an instance for instance methods
math = MathHelper(8)
print(math.square())  # Output: 64

# Update class variable using class method
MathHelper.update_pi(3.14)
print(MathHelper.circle_area(5))  # Output: 78.5

Classes in Python allow you to create organized, reusable code that models real-world objects and concepts. As you’ve seen, they provide powerful features like inheritance, encapsulation, and properties that help you write cleaner, more maintainable code. When designing classes, think about:

What attributes (data) the object should have
What actions (methods) the object should be able to perform
How objects will interact with each other
Whether you need inheritance relationships between classes

With these principles in mind, you’re well on your way to building complex, object-oriented programs in Python. Thanks for reading and happy coding!

Functions & Modules in Python

Sun, 13 Apr 2025 00:00:00 -0500

Functions & Modules in Python

At this point in your programming journey, you’ve become familiar with reading and writing the basics. You should be able to understand the core concepts of writing scripts that accomplish a small task - and that’s great!

Softtware development in the real world is almost always in the context of a larger system. As computer scientists, we need to be able to break down the larger, abstract puzzle into smaller pieces.

Imagine you’re building a video game. If you just wrote one huge script handling every aspect of the game, you’d end up with:

Probably a ridiculously long script
A debugging nightmare
Something that would be hard for other developers to understand
A lot of extra work to expand or modify your game in the future

Instead, let’s break down the bigger ideas into bite-sized pieces that accomplish a single task. These are called functions. In Python, you can define a function using def. Developers all over the world expect to read and write code that looks like this:

def move_character(direction, speed):
    # Code to move character on screen
    
def attack_enemy(weapon_type, enemy_health):
    # Code for combat calculations
    
def open_inventory():
    # Code to display inventory screen
    
def save_game(player_data):
    # Code to save game state

This design paradigm is called Top-Down Design. We use it everywhere in the professional world for all kinds of projects big and small. Note that proper function design means confining a function to a single task. It can be tempting to take shortcuts and cram more code into a single function call, but its always best to just break it down further.

After reducing our big-picture game into bite-sized chunks, the main gameplay loop might look something like this:

while game_running:
    player_input = get_player_input()
    
    if player_input == "move":
        move_character("north", player_speed)
    elif player_input == "attack":
        attack_enemy("sword", enemy.health)
    elif player_input == "inventory":
        open_inventory()
    elif player_input == "save":
        save_game(player)

This approach has many benefits:

Each function has a single responsibility
Code is more readable and organized
Functions can be reused (we don’t need to write movement code multiple times)
Testing becomes easier as we can test each function separately
Collaboration improves as different team members can work on different functions
Maintenance is simpler since changes to one function don’t affect others

Functions are the building blocks that turn complex problems into manageable pieces - essential for any project bigger than a few dozen lines!

So, what is a Function?

A function is simply a block of code which only runs when you tell it to - just like in math class. Think of functions as little machines that take inputs, do something with them, and potentially provide an output.

Defining Functions with def

To create a function, use the keyword def followed by a name and parameters:

def simple_calc(num1, num2):
    # Function code goes here

Python functions are flexible:

Use any type of variable as parameters
Call with or without arguments depending on your design
Functions may require several parameters to run properly

If you’re not sure how many parameters you’ll need, use the asterisk:

def simple_calc(*nums):
    # Now nums will be a tuple of all arguments passed

Keyword Arguments

You can send arguments as key-value pairs to make your code more readable:

def simple_calc(num1, num2):
    # Function code using num1 and num2
    
# Call with keyword arguments
simple_calc(num1=10, num2=5)

This way, the order doesn’t matter and your code becomes easier to understand!

Arbitrary Keyword Arguments

If you need ultimate flexibility, use the double asterisk (**) to receive arguments as a dictionary:

def flname(**student):
    print("His last name is " + student["lname"])
    
flname(fname="Berthier", lname="Lombo")

Default Parameters

Make your functions more forgiving by defining default values:

def name_func(fname="Kristian"):
    print("His/her first name is " + fname)

name_func("Prince")  # Uses "Prince"
name_func()           # Uses default "Kristian" 
name_func("Jeannine") # Uses "Jeannine"

Return Statements

Some functions become much more useful when they give something back. Use return to send data back to the caller:

def name_func(fname="Jimmy"):
    fname_string = "His/her first name is " + fname
    return fname_string

first_name1 = name_func("Frank")
first_name2 = name_func()
first_name3 = name_func("Phanuel")

Python Modules

Think of Python modules as pre-built toolboxes:

Module: A library of Python classes and functions that can be imported
Package: A collection of related modules

You can download modules via PIP (or PyPI) or just make your own!

Using Third Party Modules

First, download the package you want via PIP: pip install numpy Some key concepts to understand:

Virtual Environment: A separate location for specific versions of installed packages Dependency: Software components your project needs to function properly

Use installed modules by importing them:

import requests
from bs4 import BeautifulSoup

# Now you can use these modules
link_text = requests.get(link).text
soup = BeautifulSoup(link_text, 'html.parser')

Documentation == Your Best Friend

Documentation: Detailed breakdown explaining how to use the software

Usually found online or via the help function in the terminal
When in doubt, always check the docs!

Docs will (nearly) always be more accurate than AI.

Helpful Documentation Links

Python 3.13: https://docs.python.org/3/index.html
VSCode: https://code.visualstudio.com/docs
pip: https://pip.pypa.io/en/stable/ or simply pip help
Pandas: https://pandas.pydata.org/docs/
Numpy: https://numpy.org/doc/2.1/

And so much more you’ll find along the way. Happy function writing! Mr. Johnson

Debugging Tips & Tricks

Tue, 18 Mar 2025 00:00:00 -0500

Debugging Tips & Tricks for new developers

Welcome programming students! Debugging is an essential skill for every programmer. It involves identifying, analyzing, and fixing errors in your code. In this post, we’ll explore what debugging is, how to avoid common pitfalls, and practical tips to make your debugging process more efficient.

What is Debugging?

Bug

A bug is an error, flaw, or fault in your code that causes it to behave unexpectedly or produce incorrect results. Bugs can range from simple typos to complex logic errors.

Debugging

Debugging is the process of finding and resolving these bugs. It’s not just about fixing errors but also about improving the overall quality and reliability of your code.

What Counts as a Bug?

Bugs can manifest in various ways. Here are some common types:

Python Errors: These include syntax errors, runtime errors, and exceptions that prevent your code from running or functioning correctly.
Performance Problems: Your code might run without errors but be inefficient, slow, or resource-intensive.
Incorrect Instructions/Output: Your code might produce unexpected or incorrect results, even if it runs without errors.

Avoid Debugging By…

1. Understanding the Problem

Before writing code, take time to fully understand the problem you’re trying to solve. Break it down into smaller, manageable tasks and plan your approach. Trust me, your time in the long run will be better spent writing code that doesn’t need to be rewritten.

2. Starting Small

Write and test small pieces of code incrementally. A good rule of thumb is to start by testing every few lines if possible. This makes it easier to identify where errors occur and confirms that each part of your program works as expected before moving on to the next.

3. Finding Small Improvements

Continuously refine and improve your code. Look for ways to simplify logic, remove redundancy, and enhance readability. Following best practices can help prevent your bugs from creeping in.

Debugging Tips

Everybody is a Suspect… Except for Python

When debugging, assume that the issue lies in your code, not in Python itself. Python is a well-tested language, so errors are more likely due to logic mistakes or incorrect assumptions.

Don’t Make Too Many Assumptions

Avoid assuming that your code works the way you think it should. Test your assumptions by printing out variables, intermediate results, or using debugging tools.

x = 10
y = 5
print(f"x: {x}, y: {y}")  # Confirm values of x and y
result = x / y
print(f"Result: {result}")

Play Detective

Look for clues in error messages, logs, and outputs. Trace the flow of your program to identify where things go wrong.

File "c:\Users\ejohnson\Documents\intro_to_programming\debugging\debugging_practice1.py", line 14 ## This will tell me which line is problematic
    y = int(input("Enter another number: )) ## The arrow underneath this line of code is a hint 
                  ^
SyntaxError: unterminated string literal (detected at line 14) ## Each word here is a clue: "unterminated", "string", "literal"...

Types of Errors

Syntax Errors

Syntax refers to the rules and structure of a programming language. Syntax errors occur when your code violates these rules.

Example:

print("1. Addition (+))  # Missing closing quote

This will raise a SyntaxError because the string is not properly closed.

Fix:

print("1. Addition (+)")  # Corrected syntax

Syntax errors are usually easy to spot because Python will point them out with clear error messages. However, they can sometimes be tricky, especially if the error message is unclear.

Runtime Errors

Runtime errors occur after your code has passed the initial syntax check and begins executing. These are also called exceptions.

Common causes include:

Illegal operations: For example, dividing by zero.
Misspelled or incorrectly capitalized variable/function names.
Unexpected input: For example, passing a string to a function that expects an integer.

Example:

10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    10 * (1/0)
          ~^~
ZeroDivisionError: division by zero
4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    4 + spam*3
        ^^^^
NameError: name 'spam' is not defined
'2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    '2' + 2
    ~~~~^~~
TypeError: can only concatenate str (not "int") to str

Semantic (Logic) Errors

Semantic errors occur when your code runs without errors but produces incorrect results. These are often the hardest to debug because there are no error messages to guide you.

Example:

def calculate_area(length, width):
    return length + width  # Incorrect logic; should be length * width

area = calculate_area(5, 10)
print(f"Area: {area}")  # Outputs 15 instead of 50

Fix: Carefully review your logic and use test cases to verify correctness.

def calculate_area(length, width):
    return length * width  # Corrected logic

area = calculate_area(5, 10)
print(f"Area: {area}")  # Outputs 50

Try-Except: A Smarter Error-Handling Approach

The try-except block is a powerful tool for handling errors gracefully. It allows you to test a block of code for errors and handle them without crashing your program.

Example:

try:
    num1 = int(input("Enter a number: "))
    num2 = int(input("Enter another number: "))
    result = num1 / num2
    print(f"Result: {result}")
except ValueError:
    print("Error: Please enter valid numbers.")
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
else:
    print("Division successful!")
finally:
    print("Execution complete.")

try: Tests the code for errors.
except: Handles specific errors.
else: Runs if no errors occur.
finally: Runs regardless of whether an error occurred.

Raising Exceptions

You can raise custom or predefined exceptions to catch potential issues early.

Example:

x = -1
if x < 0:
    raise ValueError("Error: Negative numbers are not allowed.")

This helps you enforce rules and catch problems before they cause unexpected behavior.

Use the Debugger!

Debugging tools can save you a lot of time and effort. If you’re using Visual Studio Code (VSCode), follow these steps:

Install the Python VSCode Extension.
Open your Python file.
Click “Run and Debug” in the sidebar.
Choose Python Debug as the configuration.
Start setting breakpoints on suspicious lines of code by clicking to the left of the line numbers.
Click “Run and Debug” to step through your code, inspect variables, and identify issues.

Debugging is a critical skill that improves with practice. By understanding the types of errors, using tools like try-except blocks and debuggers, and following best practices, you can become a more effective and efficient programmer. Remember, the goal is not just to fix bugs but to write clean, reliable, and maintainable code.

Check out these resources for more examples and more detailed explainations:

Happy debugging!

Stacks, Queues and Trees in Python

Thu, 13 Mar 2025 00:00:00 -0500

Understanding Data Structures: Stacks, Queues, and Trees

Welcome! We’ve been exploring how complex data structures are fundamental to computer science and software development. They provide organized ways to store and manage data, enabling efficient access, modification, and problem-solving. In this post, we’ll explore three essential data structures: stacks, queues, and trees. We’ll also demonstrate their implementation in Python using practical examples.

Stacks: Last In, First Out (LIFO)

Check out the “Next Level Coding Concepts” presentation to learn more about how a stack works.

A stack is a linear data structure that follows the Last In, First Out (LIFO) principle. I like to think of a pile of cards: You can only add cards to the top of the pile, and you draw them from the top as well. Stacks are commonly used in scenarios like managing function calls (the call stack), undo operations, and parsing expressions.

While Python lists can be used to implement stacks, they are not optimized for stack operations. Instead, the deque (double-ended queue) from the collections module is a more efficient choice.

Here’s how to implement a stack using deque:

from collections import deque

# Initialize a stack
stack = deque()

# Add items to the stack
stack.append('a')  # Push 'a' onto the stack
stack.append('b')  # Push 'b' onto the stack

# Remove items from the stack
print(stack.pop())  # Output: 'b' (LIFO)
print(stack.pop())  # Output: 'a'

Read more about stacks at this GeeksforGeeks article.

Queues: First In, First Out (FIFO)

A queue is another linear data structure, but it follows the First In, First Out (FIFO) principle. Think of a queue as a line at a ticket counter: the first person in line is the first to be served. Queues are useful in scenarios like task scheduling, print job management, and breadth-first search algorithms.

Like stacks, queues can be implemented using Python’s deque for better performance. Here’s an example:

from collections import deque

# Initialize a queue
queue = deque()

# Add items to the queue
queue.append('a')  # Enqueue 'a'
queue.append('b')  # Enqueue 'b'

# Remove items from the queue
print(queue.popleft())  # Output: 'a' (FIFO)
print(queue.popleft())  # Output: 'b'

For more details on queues, check out the GeeksforGeeks article.

Trees: Hierarchical Data Structures

A tree is a non-linear data structure that represents data hierarchically. Each element in a tree is called a node, and nodes are connected by edges. A parent node can have multiple child nodes, but each child node has only one parent (except the root node, which has no parent). Trees are used in file systems, organizational charts, and database indexing.

Unlike other languages (like Java), Python does not have a built-in tree data structure. Instead, the anytree library provides an easy way to create and visualize trees. Here’s an example of a family tree:

from anytree import Node, RenderTree

# Create nodes
mr_j = Node("Mr. Johnson")
data_structures = Mode("Data Structures", parent=mr_j)
itp = Mode("Intro to Programming", parent=mr_j)
web_design = Mode("Web Design", parent=mr_j)
phanuel = Node("Phanuel", parent=web_design)
anthony = Node("Anthony", parent=data_structures)
frank = Node("Frank", parent=itp)
frank2 = Node("Frank", parent=web_design)
kristian = Node("Kristian", parent=data_structures)
jeannine = Node("Jeannine", parent=web_design)
samuel = Node("Samuel", parent=itp)
jimmy = Node("Jimmy", parent=data_tructures)
prince = Node("Prince", parent=itp)

# Render the tree
for pre, fill, node in RenderTree(mr_j):
    print(f"{pre}{node.name}")

This code creates a family tree and prints it in a hierarchical format. Trees are powerful tools for modeling relationships and organizing data.

Note that there are several kinds of trees with different use cases. We’ll explore how we can manipulate large quantities of data with the right tools in order to solve complex problems in the best way possible.

For further reading, check out these resources:

Welcome to erickrj.tech!

Mon, 17 Feb 2025 00:00:00 -0600

Hello, and welcome to my little corner of the internet! My name is Erick Johnson, and if you want to read about me for some reason then you’ve come to the right place.

A Little About Me

On October 12, 2024, I married the love of my life Stella. Together, we’ve made our home in Aurora, IL living out the Great Adventure. Stella makes all of life worth so much more! Plus, without her, I’d have nobody to (purposely) lose to in Mario Kart on a regular basis.

What I Love

I’m a man of many interests, and I’m passionate about using my skills and hobbies to make a positive impact in the world. Here are a few things that I anjoy doing:

Software Development: I love solving problems and creating solutions through code. Between building full-stack applications, automating tasks, or learning new technologies, software development is both a career and a creative outlet for me.
Teaching: I’d say I’m a guy who knows a little bit about a lot of things. I’ve taught high school programming, competitive marching band, Bible studies, wrestling class, and probably other things too.
Brazilian Jiu Jitsu: Currently, I am a BJJ blue belt and technically a Judo green belt, but I’ve been grappling for many years. I teach a wrestling class at my local gym, and have coached at the high school level.
Music: Ever since high school, music has always been a big part of my life. To me, it’s all the proof I need that God is real and loves us deeply. I’m a euphonium player primarily and loved marching for the Madison Scouts and Boston Crusaders back in the day.

My Greatest Passion

Above all else, my life is dedicated to worshiping my Lord Jesus Christ. My faith is the foundation of everything I do, and my greatest passion is fulfilling the Great Commission by proclaiming the Gospel among the world’s most unreached places. I believe that every person deserves the opportunity to hear the good news of Jesus Christ, and I’m committed to playing my part in making that happen.

Why This Blog?

This blog is a space for me to share my journey, insights, and experiences. Whether it’s a reflection on faith, a tutorial on software topics, or a story from my travels, my hope is that this blog will inspire, educate, and encourage you. Most importantly, I want to glorify God in everything I do and point others to Him.

Let’s Connect

I’d love to hear from you! Whether you share similar interests, have questions, or just want to say hello, feel free to shoot me an email at erickrj003@gmail.com. Let’s learn from each other and grow together.

Thank you for stopping by, and I look forward to sharing more with you in the posts to come!

Blessings, Erick Johnson