DEV Community: Reece Crook

My Flatiron Experience

Reece Crook — Thu, 23 May 2024 22:07:38 +0000

Intro

Studying at Flatiron has been an incredibly valuable experience for me. 2024 has been a roller coaster of a year, but it has also been a year of immense learning. Through Flatiron, I have not only gained technical skills but also learned a lot about myself. I have thoroughly enjoyed coding from the day I picked it up, and now that I know how to build more complex projects, my passion has only grown. I always struggled with motivation in traditional school, but Flatiron showed me that studying the right things makes all the difference.

My Future

I am committed to continuously challenging myself by building projects in my free time. I want to keep learning new languages and libraries to expand my capabilities. My goal is to secure a full-stack role where I can gain experience, learn from my peers, and contribute meaningfully. I am forever grateful for the opportunities I’ve been given, and I am determined to prove my worth through hard work and dedication. The ever-evolving tech landscape excites me, and I’m eager to stay at the forefront of innovation. In addition, I plan to participate in coding events to further sharpen my skills, network with like-minded professionals, and build some confidence.

My next project

I have a project in mind that I’ve been excited about for a while. Now that I have the time, I am eager to start. I plan to build a website using Beautiful Soup and Selenium to scrape websites with auto parts tags from the Google Places API. My father is a gearhead, and I’ve inherited that passion, particularly for older vehicles. Finding parts can be challenging, so I came up with this idea early in my schooling. I am dedicated to making this my first post-graduation project, and I want to create something I am truly proud of. This project is not only a technical challenge but also a tribute to my father’s influence on my interests. I envision creating a user-friendly platform that helps enthusiasts like myself easily find parts for their projects.

Flaws I'm Working On

I have always been a very nervous person with little confidence in my abilities. I am trying to challenge myself more to overcome this and have high hopes that once I gain more experience in a job, I will find my groove. One challenge I face is my poor memory, but I’ve been improving by keeping notes and structuring my days better to manage it.

Conclusion

Over the past year, I have learned so much about myself, my interests, and my strengths. While I am still nervous about what lies ahead, I am determined to face it with a 'fake it till you make it' mentality to boost my confidence. I am very happy with my experience at Flatiron and grateful to my instructors. I will continue to improve on my coding journey, building fun projects that bring me joy and meaningful projects that make me proud. The supportive community at Flatiron has been instrumental in my growth, and I am excited to carry forward the lessons I’ve learned. My journey is just beginning, and I am ready to embrace every challenge and opportunity that comes my way.

My Phase-4 Experience at Flatiron

Reece Crook — Thu, 25 Apr 2024 00:26:19 +0000

Intro

2024 has been the most unpredictable year of my life, filled with constant hurdles that detracted from my learning experience. However, despite these challenges, whenever I would code, nothing else would occupy my mind. Even after completing a coding session, I found myself contemplating it long after. Coding is one of the few things that truly captivates me, even during the learning phase. While I often face frustration, I have rarely felt as endlessly interested in anything as I do in coding. Typically, I struggle to enjoy the learning process itself and instead eagerly anticipate applying my knowledge. However, from the moment I said, "Hello, World!" in my terminal to building my first basic commissioned website, I have experienced a unique sense of accomplishment and motivation that only coding provides. I am incredibly grateful for the opportunities I've been given to explore the world of coding, especially through studying at Flatiron.

First Impressions of SQLAlchemy and Flask RESTful vs Now

Initially, learning how to use SQLAlchemy and Flask RESTful was a source of many headaches as I struggled to comprehend the concepts. Even when I managed to get things working, understanding eluded me, and looking back, I find some of my initial challenges amusingly self-explanatory. While working on my Phase 4 final project, many gaps in my understanding were quickly filled by scouring through numerous Stack Overflow threads. After achieving a basic RESTful setup, I couldn't help but reflect on the time spent on certain concepts, realizing how much simpler they seemed in retrospect. For instance, understanding how serialize_rules worked consumed nearly an hour of my time. Once I grasped the fundamental principles of backend development, subsequent concepts fell into place more naturally as I progressed through my Phase 4 project.

About My First Experience Working on a Full-Scale Project

At the onset of my project, I eagerly deployed both the backend and frontend to render, eager to apply my recent learning's. However, my enthusiasm quickly waned as I spent the majority of my first day troubleshooting integration issues. It dawned on me that development in a local environment was far more conducive to productivity. Despite this initial setback, I proceeded with outlining my basic model ideas, which initially progressed smoothly. Queries returned as expected, and database commits rendered desired outcomes. However, when I delved into defining a many-to-many relationship table, I encountered unexpected challenges. Despite the simplicity of the concept, I found myself grappling with it for hours. The table was real simple:
favorites = db.Table('favorites', metadata, db.Column('user_id', db.Integer, db.ForeignKey('users.id'), primary_key=True), db.Column('blog_id', db.Integer, db.ForeignKey('blogs.id'), primary_key=True), )
My experience with one-to-many relationships had left me overconfident, and I must have created a dozen different seed files while trying to understand what in the "Hello, World" was going on. Through this process, I discovered that I learn best through hands-on experience and thorough examples. Watching a few suitable, albeit somewhat outdated, YouTube videos and scouring relevant Stack Overflow threads provided the breakthrough I needed. I often find that even with clear explanations, I struggle to apply concepts until I witness the process of building examples firsthand rather then just a good expatiation of the built out example.

Conclusion

While my Phase 4 project proved to be the most challenging thus far, it also provided the greatest learning opportunities. Even after graduating from the Flatiron boot camp, I intend to rebuild this project, recognizing my tendency to forget and realizing the potential for improvement to transform it into a more robust and real-world application like. Experience truly is the best teacher, as I have been reminded countless times, and I am grateful for the lessons learned both in software development and self-discovery throughout my curriculum. Thank you for taking the time to read this, and I wish you the best.

My Experience learning Python and SQL

Reece Crook — Fri, 22 Sep 2023 20:18:47 +0000

This blog is based off my Phase-3 learning exerience at flatiron school.

Introduction

After learning JavaScript and React.js I anticipated that React.js would become my preferred language due to its aesthetic appeal. However, upon gaining better familiarity with Python, my perspective shifted. Python's clean and efficient design made it stand out, making the coding experience feel less cluttered and more intuitive.

Prior to enrolling at Flatiron School, my exposure to programming was limited to Python. I learned Python through Zed A. Shaw's book, "Learn Python the Hard Way Third Edition." This resource was invaluable in imparting fundamental knowledge, and I enjoyed experimenting with creating small programs, such as file sorters and terminal games. However, my journey at Flatiron School exposed me to a new side of Python, especially in conjunction with SQL. I had minimal prior exposure to databases, erroneously perceiving them as primarily utilized by large corporations. To my surprise, setting up and working with databases, especially when integrated with Python, was far more accessible and user-friendly than I had initially envisioned.

Learning about Python

Exploring Python from multiple perspectives has given me a deeper appreciation for why it is highly regarded in the programming community. Its versatility is striking, and despite my ongoing learning journey, I have already encountered a multitude of features that appeal to me. Among these features, the capability to employ pass for creating a preliminary outline and the flexibility of utilizing different loop types like range loops stand out to me as tools I anticipate using frequently. This functionality allows for the easy creation of an initial structure, providing a clear roadmap for future development and refinement. As I continue to broaden my Python knowledge, I anticipate uncovering even more facets of this multifaceted language.

def function_a():
    pass

def function_b(number_of_hello, name):
    for range(number_of_hello):
        print(f"Hello {name}!")

Learning about SQL

Structured Query Language (SQL) provided a refreshing departure from conventional programming languages. The simplicity and logical structure of SQL made it highly comprehensible and facilitated a sense of organization and expansiveness in projects. Working in tandem with Python, SQL elevated the dynamism and organization of projects, even for smaller-scale applications. I found SQL's syntax to be remarkably self-explanatory, exemplified by statements like:

SELECT x
FROM y
WHERE z = ?

Leveraging SQL in conjunction with Python proved to be a potent combination, offering tremendous capabilities. Although I acknowledge that I still have much to learn and explore in this realm, establishing a robust foundation in SQL and Python provides me with a clear trajectory for further growth and development.

Learning about ORM

Object-Relational Mapping (ORM) is the technique of accessing a relational database using an object-oriented programming language. Utilizing Structured Query Language (SQL) and Python in conjunction to craft an ORM significantly streamlines the process of coding a program, enhancing overall efficiency and ease of development. Here is a poignant quote from Flatiron that clarified the concept of ORM for me:

"An ORM is really just a concept. It is a design pattern, a conventional way for us to organize our programs when we want those programs to connect to a database. The convention is this:

When "mapping" our program to a database, we equate classes with database tables, and instances of those classes with table rows.

You may also see this referred to as "wrapping" a database, because we are writing Python code that "wraps" or handles SQL." -Flatiron School

When constructing my ORM's, I have predominantly employed Sqlite but also explored SQLAlchemy. Both of these tools have proven highly valuable in aiding my familiarity with SQL and ORMs. Utilizing these tools significantly reduces the need for excessive boilerplate code that often accompanies writing an ORM, thus further streamlining the process.

Conclusion

I have thoroughly enjoyed my experience at Flatiron thus far, and I wish I had more time to completely immerse myself in my curriculum, as I find programming exceptionally fulfilling. While there are various resources available for learning programming free of charge, I am genuinely appreciative of the opportunity I was given to learn from Flatiron. The guidance and support from Flatiron have not only been instrumental in my programming education but have also been invaluable in imparting non-programming aspects, such as being an active part of a community, preparing for job interviews, developing good foundational habits, and effective strategies for learning new programming languages. Now that I have established a solid foundation with Python, SQL, and JS/React.js, I am eagerly anticipating the chance to apply all that I've learned in a meaningful project.

My Experience Learning React JS

Reece Crook — Wed, 19 Jul 2023 20:20:10 +0000

Introduction

Out of the handful of programming languages I have dabbled in so far JavaScript has been the most interesting so far, but after learning about React I have come to realize just how little I knew. Before learning about React I barely read about libraries thought they were hardly used and so I never really learned much about them however, since learning React JS I have learned much more about libraries and frameworks. Tools like React really reinforce the feeling that programming has endless possibilities and a big reason I got into programming was because I loved the style of creativity that came with it.

Learning about React

When I started learning React, my first impression was like living with an organized person after living with a very unorganized person. While I didn't know it when programming with base JavaScript now that I have worked with React, base JS almost gives me eye strain. I still enjoy base JS however, the more that I used React it supported my thoughts on how much better it felt to work with. React is a very helpful library with some amazing features, the feature I favorited and is overall, one of if not the most used features, has to be useState.

React State

The useState hook is something every React developer will use constantly and can be used in a plethora of ways. To use state you have to first import it from React wherever you are trying to use the hook like so:

import React, { useState } from "react";

The useState hook returns an array with two variables, the current state and a setter function.

const [value, setValue] = useState(0)

Note: When using destructuring like above the names inside the brackets can be anything but the first variable will always represent the current state and the second variable will always be the setter function

Whatever is in the parentheses after useState is the initial state, in this case, it's 0. Currently, since the setter function has not been used, value === 0 but the setValue function allows you to change the state.

setValue(1)

console.log(value)
//Output: 1

Whatever is in the parentheses after the setter function will become the state's value. The value passed to the setter function can be just about anything like an array, object, or a string:

setValue("Hello, world!")

/*
setValue(["bob", "joe", "Dre"])

setValue({
   "username": "Jane",
   "password": "1234GoodPassword",
   "email": "JanesEmail@email.net"
  })
> Note: To access this ^ data is the same as normal arrays and objects. So value[0] would return "bob" and value.username would return "Jane".
*/

console.log(value)
//Output: "Hello, world!"

An important part of using the setter function is that when called, the component the state is in will re-render and if the component has any children components they will re-render as well. This is very helpful when using useState for things like controlled forms. Controlled forms are very common use for React State and allow you to track the information in forms, here's an example.

import React, { useState } from "react";

function ControlledForm(){

   const [formValue, setFormValue] = useState("")

   return (
     <form onSubmit={e => e.preventDefault()}> 

       <input type="text" value={formValue} onChange={event => {
         setFormValue(event.target.value)} />

    </form>
   )
}

export default ControlledForm

In the example above the state is set to an empty string so the text input is blank initially. The formValu will always be what is typed into the text input because every time something is typed it activates the onChange and sets the formValue to what is typed (event.target.value). Because setFormValue re-renders the component the user will always see the updated formValue. The controlled form method is extremely convenient and allows for precise control over various data types.

useEffect

The useEffect hook is used to create side effects wherever you need them. The hook takes in a callback function(the side effect) and a dependency array. Here are some example's of the useEffect hook:

import React, { useEffect } from "react";

useEffect(() => {
   console.log("I will run once after the component loads")
}, [])

useEffect(() => {
   console.log("
     I will run once after the component loads and every time the 
     'value' is changed after
    ")
}, [value])

In the example above the first useEffect's empty array tells it to only run the first time and the second useEffect's array tells it to re-run as a side effect of the 'value' prop being changed. There are many uses for the useEffect hook but are most commonly used for data fetching and DOM updates.

Conclusion

While I still have a lot to learn I have thoroughly enjoyed my time using React. The various hooks in React made my experience much more interesting compared to base JavaScript. I'm very proud that I get to become a part of such a brilliant community. In my time learning I keep getting surprised by how far programming has come in the short time it has been around. For a much better explanation of React and its hooks please refer to the React Docs.

Learning About JavaScript Functions

Reece Crook — Wed, 17 May 2023 20:29:59 +0000

Introduction

Functions in JavaScript are the most interesting facet I have learned while coding, to date. Coding as a whole is astounding in that it has no limits, only possibilities. Programming can be applied to any aspect of modern living, from medical applications to space travel, or as common as doing laundry. I am thankful to have been born in this era because I get to experience coding at such a vital time in history. Realizing that I have barely scraped the surface of coding leaves me motivated to dig deeper.

About JavaScript Functions

Functions are a crucial part of JavaScript, they are versatile building blocks that are used consistently when communicating with JavaScript. Functions can be written in a few ways: Function declaration, function expression, and arrow functions. Function declaration is the default or traditional type of function and is the most similar to other languages.

function declarationStyle(parameter1, parameter2){
  console.log(parameter1, parameter2);
}

Function expressions can be constructed in multiple ways, one that includes a function name and one without. A named function expression is a function assigned to a variable and works similarly to the standard function declaration.

const varName = function expressionStyle(parameter1, parameter2){
  console.log(parameter1, parameter2);
}

However, a function expression without a function name(an anonymous function) is often useful when you do not need to re-purpose or alter the function elsewhere, and just want to use the data returned by the function. An anonymous function expression could commonly be used as a parameter for another function.

const varName = function(parameter1, parameter2){
  console.log(parameter1, parameter2);
}

Finally, there are arrow functions. These are the most unique of the three, primarily because they can be written in many different ways. One of which is formatted using a single line, unlike the previously mentioned functions.

parameter => console.log(parameter)

Note that parameters only need parentheses if there is more or less than one parameter, if there is only one parameter it may be written without parentheses like in the example above. This applies to all arrow functions.

Also, similar to function expressions they can be written named or anonymous. Named arrow functions may look like this:

const varName = (parameter1, parameter2) => {
  console.log(parameter1, parameter2);
}

While anonymous arrow functions may look like this:

(parameter1, parameter2) => {
  console.log(parameter1, parameter2);
}

Arrow functions are used in many different situations similar to and vastly different from the examples above. I highly suggest reading Mozilla's for a more in-depth explanation of arrow functions(Or any of the function types) I have briefly mentioned above.

Why I Love JavaScript Functions

JavaScript, out of the few languages that I have experienced so far, I've found to be the most interesting due to the broad yet streamlined application created by its functions. Functions are very similar to how I view decision-making. When met with a decision, I often think something like, "If I choose decision1 I will take x actions and if I choose decision2 I will take y actions." Next, I can make a decision based on which one I believe will lead to the optimal outcome. To me, that sounds awfully similar to pseudocode:

function decisionsAreHard(decision1, decision2){
  if(decision1 > decision2){
    return decision1
  }else{
    return decision2
  }
}

Ever since I started learning about JavaScript my thought process has slowly altered in such a way that I try to turn as many of my actions into functions, like the one above, as I can. They may not always make sense but I find doing this oddly satisfying and genuinely helpful for remembering new expressions and syntax.

Conclusion

Software Engineering is constantly growing and improving, as it always has and always will. Coding has come such an astonishingly long way in the short amount of time it has been around, making me so thankful to be a part of its growth. My outlook on programming throughout my learning experience has consistently evolved. However, one thought that never changed was how eager it has made me to pioneer in the software industry. Software engineering has rapidly become one of the many building blocks in the modern world and it still has such an untapped amount of potential that I can not wait to see how far it will go in my lifetime. I often feel as though I'm learning a deciphered alien language to improve our technological capabilities because I am constantly being impressed by all I am learning about software and what it can do.

Sources

I got my imformation from: Mozilla, FlatIron School(Specifically the software engineering course I am attending), and GeeksForGeeks.