Forem: wormondeck

I kept playing with my code and made a function to uppercase a letter instance in a string.

wormondeck — Sat, 05 Oct 2024 17:55:46 +0000

I was messing around with the .upper() method in Codecademy and stumbled upon the forum section where a few devs were asking about uppercasing other letters in a string aside from the first. So I started testing different code and figured out a way to uppercase a specific letter. Here's the forum that inspired me to investigate:

def upper_that_letter(some_str):
  upper_letter = ""
  for letter in some_str:
    if letter == "o":
      upper_letter = letter.upper()
      rep_letter_o = some_str.replace("o", upper_letter) 
  return rep_letter_o

print(upper_that_letter("Hola Mundo"))

The part mentioning coming up with your own function gave me my first line of code to work with, I realized a string is immutable so to begin I created an empty string variable and since strings work similar to lists its only right to iterate for a specific letter, hello for loop. I then added a condition specifying if that letter is in our case: "o" then we would use the upper() method on it and place it in a variable we would call upper_letter.

At this point I got stuck and tried different scenarios to include the string passed in when calling the function but only got the letter "O"s returned in caps. Then I thought about the replace() method! I realized the method replace() takes two arguments, the string to search and replace as well as the string to replace the old value with. There is also a third argument specifying how many occurrences of the old value you want to replace (this ones a plus!). This method made it all connect for my function.

Now to put our replace() method in to play I used it on the some_str parameter with "o" as the first argument to be replaced and the upper_letter variable as its new replacement. Now we shall return our variable replace_letter_o, and call our function with "Hola Mundo" and get our desired output of "HOla MundO"!

I'm sure there's been many ways of getting this done but I wanted to share this not only to provide a solution but most importantly to show how understanding the tools available to you and trying different things on your own can help you find ways to become better at problem solving and enjoying coding!

My first CLI.

wormondeck — Wed, 02 Oct 2024 17:40:59 +0000

Opening Credits

The second it all clicks, consider the project fun. I built a client friendly CLI project to grasp how a class, methods, and properties work.

My directory structure was quite simple:

└── lib ├── models │ ├── __init__.py │ └── actor.py | └── movie.py ├── cli.py ├── debug.py └── helpers.py ├── Pipfile ├── Pipfile.lock ├── README.md
As you can see from the structure I built a one-to-many association where an actor has many movies. From this association my menu came into play.

Current list of actors
Add an Actor
Delete an Actor
Exit the program

My menu above was defined by a function called... menu() which was located in my cli.py file along with the main() which shows the user the CLI menu:

def main():
    while True:
        welcome()
        menu()
        choice = input("> ").strip()
        if choice == "1":
            actor_list()
        elif choice == "2":
            add_actor()
        elif choice == "3":
            delete_actor()
        elif choice == "4":
            exit_program()
            break
        else:
            print("Invalid choice. Try again.\n")

This particular function was the first of many where a while loop along with if/elif/else statements were executed to give our user the ability to navigate our menus with ease.

The cli.py is then concluded with some important code block:

if __name__ == "__main__":
    main()

This code block tells our interpreter (Python) to only run our file if it is called from the command line.

Supporting Cast

There were also helper functions involved in this project which also used a while loop along with if/elif/else statements. One in particular stands out in showing ease of navigation when selecting for example our current list of actors:

def actor_list():

        actor_list = Actor.get_all()

        if actor_list:
            print("\n*** UPDATED LIST! ***")
            for i, actor in enumerate(actor_list, start=1):
                print(f"{i}. {actor.name}")  

            while True:
                choice = input("Press 'a' to add an actor\n"
                                "Press 'b' for actor profile\n"
                                "Press 'c' to return to the main menu.\n"
                                "Press 'd' delete an actor.\n").lower()
                if choice == 'a':
                    add_actor()
                    break
                elif choice == 'b':
                    actor_profile()
                    break
                elif choice == 'c':
                    return
                elif choice == 'd':
                    delete_actor()
                    break
                else:
                    print("Invalid choice. Please try again.") 
        else:
            print("List empty!")
            while True:
                choice = input("Press 'a' or to add an actor\n"
                        "Press 'b' for main menu.\n").lower()
                if choice == 'a':
                    add_actor()
                    break
                elif choice == 'b':
                    return
                else:
                    print("Invalid choice. Please try again.")

Here not only did I became accustomed of the while loop and if statements but also reap the benefits of appearance and order by using enumerate() with a for loop to iterate with an index in python allowing all the lists thru out the project to be an ordered list.

Show Some Class

Our two main characters of course are the Classes Actor and Movie. Both consist of similar code in terms of class methods when creating, updating or deleting an instance of that particular class, but there are differences:

Let's take our Movie class for example:

class Movie:

    all_movies = {}

    def __init__(self, movie, genre, actor_id, id=None):
        self.id = id
        self.movie = movie
        self.genre = genre
        self.actor_id = actor_id

Since we have our project setup where an actor has many movies, our movie class will have a unique actor_id parameter/attribute to establish a link between the movie instance and a specific actor, allowing easy reference to the actor's information.

Now look at this code block in our Actor class:

   def movies(self):
        from models.movie import Movie
        sql = """
            SELECT * FROM movie
            WHERE actor_id = ?
        """
        CURSOR.execute(sql, (self.id,),)

        rows = CURSOR.fetchall()
        return [
            Movie.instance_from_db(row) for row in rows
        ]

Here we have our movies() method retrieve all the movies associated with the current Actor instance by querying the movie table using the actor's ID. This will then return a list of Movie objects, establishing a "has-many" relationship between Actor and Movie.

The code blocks discussed were the primary areas of the project where I focused on grasping more understanding. Overall this project served as a good exercise to enhance my skills in python.

Harnessing the Power of useEffect.

wormondeck — Mon, 15 Apr 2024 16:50:29 +0000

Intro

React has revolutionized the way developers build user interfaces, offering a robust and efficient framework for creating dynamic web applications. Among its many features, React hooks stand out as a powerful tool for managing state and side effects in functional components. One such hook, useEffect, plays a crucial role in synchronizing component lifecycle events with external actions, offering developers unparalleled flexibility and control. In this blog, we'll delve into the coding experience involving React and explore the myriad benefits of leveraging useEffect.

Understanding React.js and useEffect

React.js is a JavaScript library that allows developers to build reusable UI components. It employs a declarative approach, where developers describe how the UI should look at any given point in time, and React takes care of efficiently updating and rendering the components when the underlying data changes. However, managing state and side effects in React components can be challenging.

Coding with React.js and useEffect:

Let us illustrate the coding experience involving React.js and useEffect with a practical example. Suppose we have a component that fetches data from an external API and displays it on the screen. We want to fetch the data when the component mounts and update it whenever a certain prop changes. Here's how we can achieve this using useEffect:

import React, { useState, useEffect } from 'react';

const DataComponent = ({ prop }) => {
  const [data, setData] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      try {
        const response = await fetch(`https://api.example.com/data/${prop}`);
        const jsonData = await response.json();
        setData(jsonData);
      } catch (error) {
        console.error('Error fetching data:', error);
      }
    };

    fetchData();
  }, [prop]);

  return (
    <div>
      {data ? (
        <ul>
          {data.map(item => (
            <li key={item.id}>{item.name}</li>
          ))}
        </ul>
      ) : (
        <p>Loading...</p>
      )}
    </div>
  );
};

export default DataComponent;

Here we define a functional component called DataComponent that takes a prop as input. Inside the component, we use useState to manage the state of the fetched data. We then use useEffect to fetch the data from the API when the component mounts or when the prop changes. The useEffect hook ensures that the side effect (fetching data) is executed at the appropriate times, thus keeping our component logic concise and efficient.

Benefits of useEffect:

The useEffect hook offers several benefits that enhance the coding experience with React.js:

Declarative Side Effects: useEffect allows developers to declare side effects directly inside functional components, promoting a more declarative and readable coding style.
Efficient Lifecycle Management: By replacing traditional lifecycle methods, useEffect streamlines the management of component lifecycle events, leading to cleaner and more maintainable code.
Dependency Tracking: The optional dependency array in useEffect enables precise control over when the effect should run, minimizing unnecessary re-renders and improving performance.
Flexibility and Reusability: useEffect can be used to perform a wide range of side effects, such as data fetching, DOM manipulation, and subscription handling, making it a versatile tool for building complex applications.
Hooks Composition: useEffect can be combined with other hooks like useState and useContext to create custom hooks, allowing developers to encapsulate and reuse logic across components.

In conclusion, React.js and useEffect offer a powerful combination for building dynamic and efficient web applications. By leveraging useEffect, developers can manage side effects in functional components with ease, leading to cleaner code, improved performance, and enhanced developer productivity. Whether you're fetching data from an API, subscribing to events, or updating the DOM, useEffect provides a flexible and intuitive solution for handling side effects in React.js applications.

Showing Phase.

wormondeck — Tue, 02 Jan 2024 17:48:25 +0000

The Road Ahead-Black and White is a photograph by Douglas Barnard which was uploaded on February 16th, 2013

Ready?

In this post I'll be discussing my journey thus far as I conclude my Phase 1 course in Flatiron School.

What did I get myself into?

Let's be honest. The prep-work did not "prep" us for the mountain ahead. I'll admit, stepping into the software engineering realm for the first time built anxiety in a good way. Once prep-work was conquered with a few functions and objects becoming familiar Phase 1 was at the end of the road waiting for me with a toothpick in its mouth.

The Struggle

Clearly, as I fought my way thru Phase 1, it felt like the Rocky vs Drago bout, guess who played rocky? Honestly, I'm not here to instill how tough the field of software engineering is. This has been the smartest decision I've made for myself. I signed up literally for a bootcamp, and its been very militant since. As tough as its been I've learned a valuable lesson which in turn made learning to code thanks to Flatiron School, awesome!

Now I get it

Aside from learning to code. I've learned mental techniques which as a result made coding a sport in my mind. Nothing made sense until I kept showing up for practice, plain and simple. Once distractions got eliminated, I learned the syntax, once I applied the importance of knowing the fundamentals in JavaScript, it became a language that made more sense. Basically, I gave my undivided attention to bits and pieces of the phase and suddenly the phase started giving back to me.

You're on your own, figure it out

My main question has always been, how does one memorize all of this information? I had nightmares of array iterators chasing me out of my home. I stopped having those once I faced them on one of my labs. Now I'm great friends with the for...of and forEach loops, since they're my go to's for iterating thru arrays. Overall, one has the tools in front of them to sharpen their skill as a software engineer you just need to apply yourself and have fun!

Making it a habit

Coding got much more kindly when Flatiron School made me realize that once you make it a habit to code "anything" things start to make sense. The tools at your disposal begin to lose dust as your able to put them to good use. I became aware of this as soon as I began to get a passing check on a lab in Codecademy. I made it a habit to figure out more ways to write code and achieve the same passing result within the same page and thru the use of DevTools. Suddenly I was retaining the language, I was problem solving on my own and most importantly, having fun!

To be continued

As I conclude my Phase 1 course in Flatiron School I reflect on how far I've gotten and I realize the amount of progress I've made has been insurmountable. I've gained so much confidence going thru the ups and downs on figuring out how to get a code to work, how to debug and how to stay in the fight, I mean look how it turned out for Rocky.

Ready, set...code!

wormondeck — Tue, 10 Oct 2023 16:24:51 +0000

JavaScript, here, we...go!