<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Matthew Draghi on Medium]]></title>
        <description><![CDATA[Stories by Matthew Draghi on Medium]]></description>
        <link>https://medium.com/@mtd5264?source=rss-3e52958f6edc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*FgZphHQBuF3LMudyyrAteA.jpeg</url>
            <title>Stories by Matthew Draghi on Medium</title>
            <link>https://medium.com/@mtd5264?source=rss-3e52958f6edc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 10:51:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mtd5264/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[My Flatiron Journey]]></title>
            <link>https://medium.com/@mtd5264/my-flatiron-journey-791efa9538a3?source=rss-3e52958f6edc------2</link>
            <guid isPermaLink="false">https://medium.com/p/791efa9538a3</guid>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[full-stack-developer]]></category>
            <dc:creator><![CDATA[Matthew Draghi]]></dc:creator>
            <pubDate>Wed, 20 Apr 2022 19:18:08 GMT</pubDate>
            <atom:updated>2022-04-20T19:18:08.464Z</atom:updated>
            <content:encoded><![CDATA[<p>Six months ago I made a difficult decision. After having had some encounters with different variations of programming over the course of my collegiate and professional careers, I realized programming was my passion. My curiosity took over me as I asked friends and other connections how someone with my background can break into the field. I tried self teaching myself Python but quickly came to learn that this wouldn’t be the best way for me to become a software engineer. I just didn’t have the time or resources to effectively learn the language. It was at this point that I decided if I wanted to commit, I would need to go all in. Two months later, I left my full time job to pursue education with Flatiron School’s software engineering program.</p><h3>Phase 1</h3><p>Flatiron’s program is broken down into five different phases. The first of these phases is by far the most difficult. Looking back, it isn’t the content that is harder, but rather the fact that this is the first step in becoming a software engineer. The course work seems overwhelming and by the end of the first week, you feel like you might have bit off more than you can chew. Fear and doubt start creeping in. Should I have left my job? Am I in over my head? I’ll never learn this and become a pro. You come to realize that this is normal. Every other member of your cohort is in a similar position. Each person taking the risk to journey into this new stage in life. You slowly accept the fact that it’ll be hard, but you can do this.</p><p>Phase 1 covers vanilla JavaScript and it is an introduction to DOM manipulation. The concept of the DOM is one that took most of the first phase to understand, but the more practice you get, the more it just begins to click. The DOM is what I call a “speed bump”. Throughout all of Flatiron’s course there are nuggets of information that make you slow down and second guess yourself. At the end of the day, they are just small hurdles to go over before jumping back into the fast-paced program.</p><h3>Phase 2</h3><p>Sweet, you mastered vanilla JavaScript! Things will surely calm down a bit… right? Kind of! Phase 2 builds on Phase1 in terms of JavaScript knowledge. Knowing the capabilities of JavaScript is important, but being able to write less code in a cleaner manner is even more important. Enter React.</p><p>At first, React seemed intimidating, but throughout the first week it began clicking. React is still JavaScript — just some syntactical differences that allowed for more functionality to be condensed into a smaller amount of code. Phase 2 definitely moved faster than the first phase, with the occasional speed bump for topics such as state, but overall there was a lot more confidence in my ability to complete the course throughout this phase.</p><h3>Phase 3</h3><p>The first two phases dealt with frontend technologies. Phase 3 shifted our focus to the backend with Ruby and object-oriented programming. This felt like starting from scratch. There were a few concepts that initially took some time to understand, but this phase did bring a valuable skill: being able to be agile.</p><p>When moving from Phase 1 to Phase 2, you are in the same mindset. JavaScript, JavaScript, JavaScript. Not only do you need to pick up a new language, but new backend principles and concepts. This is something that will be common over the course of your career — different companies use different languages in the front and back. As a full stack developer, being able to flip the frontend and backend switch while picking up new languages is a beneficial one that will help you advance your career.</p><h3>Phase 4</h3><p>The previous section on Ruby used Sinatra as its framework. Phase 4 focuses on the more popular Rails framework. This section acts similarly to Phase 2. It builds upon the foundational knowledge learned in the previous phase. Similarly to the shift from Phase 1 to 2, there is a small learning curve but it ultimately ends up being a quick learn.</p><p>The end of this phase is capped with a full stack project. Working on this project was a speed bump in itself. Developing a solid workflow for a full stack application is not an easy task, but the sense of accomplishment is one that will make it seem like the journey so far is worth it.</p><h3>Phase 5</h3><p>Phase 5 is the culmination of everything that has come before it. Three weeks of full stack project mode. This phase has been grueling, stressful, and most importantly — rewarding. Every obstacle that came with previous technologies, as well as new technologies, became that much more exciting to overcome.</p><p>For me, this final Flatiron project is not the end, but a jumping off point. Although MVP was reached for this project, my excitement for expanding my application further is through the roof. I look forward to taking every lesson learned from Flatiron and bring them with me as advance to the start of my software engineering career.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=791efa9538a3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tackling the Full Stack]]></title>
            <link>https://medium.com/@mtd5264/tackling-the-full-stack-e657145a81f4?source=rss-3e52958f6edc------2</link>
            <guid isPermaLink="false">https://medium.com/p/e657145a81f4</guid>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[full-stack]]></category>
            <dc:creator><![CDATA[Matthew Draghi]]></dc:creator>
            <pubDate>Thu, 31 Mar 2022 14:14:34 GMT</pubDate>
            <atom:updated>2022-03-31T14:14:34.205Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hiU17ei_cnLLpOyb221pXg.png" /></figure><p>A major hurdle to overcome as a developer is learning how to tackle your first full stack application that deals with complex pieces in the frontend and backend. Without the proper approach, this task can not only be daunting, but it can lead to many headaches. The following is the approach that I took on my first fully fleshed out full stack web app. My hope is that this can help act as a guide for how to work through planning and creating your application in a way that will lead to less hiccups throughout your app’s development.</p><h3>User Stories</h3><p>When developing an app, you want to make sure a user is able to perform different actions. Enter user stories. User stories are different actions that dictate what actions a user should be able to take while using your application. These actions are the foundation for the rest of your planning and will help inspire the design of your frontend and backend. When creating a user story, you want to create a list of actions in the form of, “As a user, I can ___.” Each action will fill in the blank, giving you an idea of what specific functionality should be achievable by your application. An important note is to know your limits here. It can be easy to want your app to achieve every bit of functionality possible, which is why setting actions for your Minimum Viable Product (MVP) will help keep your functionality checklist realistic for the timeline you are given. User stories can also include stretch goals, which are those bits of functionality that aren’t completely necessary to the core functionality of your app, but would help make the user experience a bit better. Take a look at these sample user stories for my first web app below to give you an idea of what this piece might look like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*XFnjstMv_k5NuXTlc_7Qqw.png" /></figure><h3>Wireframes</h3><p>Once the user stories are complete, you can begin envisioning what your application may look like based on your listed user actions. Wireframes are diagrams that can range in complexity, but for the most part are basic blueprints of what your application will look like on the frontend. For example, based on the above user story of being able to login to their profile, I would draw up a wireframe of a login page. This lets me start thinking about the different components and tags that will make up the frontend. The following image is a sample wireframe based on this user story (excuse my illegible handwriting)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tl875UrJG8FoyGwUdbgshg.png" /></figure><p>In this wireframe sample we can start to see a few things that will be necessary: a form with three inputs (one type email, one type password, one type submit), a header tag, and a separate header component that would be consistent across pages. Once I have an idea of what my frontend needs, I start to begin thinking about what that means for my backend. I will likely need a user table that has attributes of an email and a password_digest (password and password_confirmation). If you do this for each of your user stories, you will be in a solid place to start building out your frontend. A few ways to create your wireframes are by using a pencil and paper, or using online applications like <a href="https://www.figma.com/">Figma</a>, <a href="https://excalidraw.com/">Excalidraw</a>, and <a href="https://balsamiq.com/">Balsamiq</a>. However, there is one other important piece to plan out before diving into React.</p><h3>Entity Relationship Diagram</h3><p>Handling data and how it is manipulated is the main reason for building out a backend. Before we begin writing any code, we need to plan out how our data will look. An Entity Relationship Diagram (ERD) might be one of the more complicated pieces of the planning phase, but based on our wireframes and user stories we can begin to plan out what the data in our database will look like, as well as how that data is related to other pieces of data. When creating an ERD, I like to use a tool like <a href="http://draw.io/">draw.io</a> or, since I use VS Code as my editor, create a file in my project with the .drawio extension. Other tools like <a href="https://dbdiagram.io/">dbdiagram.io</a> also exist out there and might me more what you are into. An ERD will include the table name, the tables attributes, a listing of the data types for the attributes, and an indication of whether an attribute is a primary or foreign key. The ERD will also connect the tables using relationships, such as one-to-many or one-to-one. Below is a simple ERD that was used for one of my web apps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*DvhSDELIRV1V8HRyCgNqfQ.png" /></figure><p>My iteration of this sample ERD started out looking nothing like this. When creating your ERD (and your wireframe as well), know that the first iteration might not be exactly what your final product looks like. You will probably have to go back and make some changes to match what works best for your apps functionality. The initial diagram will help give you a bit more direction when you start developing, but be open to changing it around if you realize a different connection, attribute, or even table will work best.</p><h3>Developing Functionality — Front to Back</h3><p>Once all your planning is done, you can finally begin building out your app. Where do you start? I mean, you do have a frontend and a backend to choose from. Every developer prefers a different style of tackling their application. One instructor I had said he preferred a back to front approach. The first time I tried this, I ended up in limbo. It didn’t work for me, but that doesn’t me it won’t work for you. My preferred method of app development is front to back. For me, starting out by creating the different React components based on my wireframe will allow me to realize what API methods I will need to create along the way. I build my backend based on the needs of the frontend, but for others, you may build your backend and tune the frontend to the data. It really depends on what works best for you, so give both methods a try. Whatever method you do choose, there is one commonality in how you should tackle the development — one feature at a time.</p><p>When creating an application, I won’t start out by building all my components before moving to the backend. I will begin working on one component and then, as I realize a need for data exists in that component, will move to the backend and create the necessary migrations, models, and controller actions. The backend can work the same way — begin building out a migration for one piece of your table, develop the model, create the controller actions one bit at a time, and then create the component where that data will be sent to. The diagram below gives a sample of how this might look (Note: the features listed in each column are different than the samples above).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/472/1*MODrxxkvDKygekukai0ltQ.png" /></figure><p>This methodology of working on each feature in vertical slices will allow for less headaches — trust me. If you bite off more than you can chew, you will get overwhelmed and frustrated. Take it one function at a time, one row at a time, and you will make it through your full stack app with a lot less hiccups.</p><h3>Final Thoughts</h3><p>When I first started coding, I thought I was better than planning. As I went headfirst into smaller assignments, I became very overwhelmed and realized that I needed to step back and do what everyone advised — take the time to plan things out. If you take the time to plan out your full stack app and avoid going headfirst into all functions at once, you will walk away feeling accomplished and ready to move on to the next project. Development is hard as is, so why make it harder for yourself? Trust the process, make a plan, go one function at a time.</p><p>Good luck!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e657145a81f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Macro Magic]]></title>
            <link>https://medium.com/@mtd5264/macro-magic-814a217d3979?source=rss-3e52958f6edc------2</link>
            <guid isPermaLink="false">https://medium.com/p/814a217d3979</guid>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[macro]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[dry-programming]]></category>
            <category><![CDATA[ruby]]></category>
            <dc:creator><![CDATA[Matthew Draghi]]></dc:creator>
            <pubDate>Thu, 03 Mar 2022 22:34:46 GMT</pubDate>
            <atom:updated>2022-03-03T22:45:43.648Z</atom:updated>
            <content:encoded><![CDATA[<p>Coming from a career where Excel was used frequently, I had the chance to experiment with <strong>macros</strong>. These macros would allow me to automate tasks like formatting a spreadsheet, saving time and requiring less action on my part. When I began learning Ruby, I was re-introduced to the idea of macros for programming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*oI91rs0VPmQYfhm7lbFm0A.png" /></figure><p>In programming, a macro is a piece of code that runs another code block. Think of a function (JavaScript) or method (Ruby), but instead of returning data, we get back more code. This is incredibly useful as it can help us as developers writer cleaner code in less lines. Macros also help us follow the “DRY” principle, or “Don’t Repeat Yourself”. Let’s take a look at what I mean.</p><p>In Ruby and other object-oriented languages, two common methods that need to be created are the “<strong>setter</strong>” and “<strong>getter</strong>” methods. They would like like this:</p><pre>class Movie</pre><pre>  #setter method<br>  def title=(title)<br>    @title = title<br>  end</pre><pre>  #getter method<br>  def title<br>    @title<br>  end</pre><pre>end</pre><p>The example above is in Ruby. In this sample, the setter method is taking an argument of “title” and <em>setting</em> that value as the value of our instance variable “@title”. The getter method below the setter method just takes the instance variable of “@title” and returns, or <em>gets</em>, the value. We use these methods like so:</p><pre>#first we create a new instance of the Movie object<br>  <br>  movie = Movie.new</pre><pre>#now we can use the title= method to set the value of our movie&#39;s title</pre><pre>  movie.title=(&quot;Pulp Fiction&quot;)</pre><pre>#with our title set, we can use our getter to retrieve the value of our title</pre><pre>  movie.title #=&gt; &quot;Pulp Fiction&quot;</pre><p>The setter and getter methods are simple methods, but when our objects start requiring more attributes, it can quickly take up a large portion of our class file…</p><pre>class Movie</pre><pre>#setter method<br>  def title=(title)<br>    @title = title<br>  end</pre><pre>#getter method<br>  def title<br>    @title<br>  end</pre><pre>  def director=(director)<br>    @director = director<br>  end</pre><pre>  def director<br>    @director<br>  end</pre><pre>  def stars=(stars)<br>   @stars = stars<br>  end</pre><pre>  def stars<br>    @stars<br>  end</pre><pre>  ...</pre><pre>end</pre><p>…you get the point. Even by just adding two more attributes, we see the file can become pretty hefty. Lucky for us, Ruby has some built in macros that help us clean this up a bit more. The attr_accessor, attr_reader, and attr_writer macros are just a few macros that Ruby has to offer which help us create the setter and getter methods. Let’s take a look at our Movie class when we use these macros.</p><pre>class Movie</pre><pre>  attr_accessor :title, :director, :stars</pre><pre>end</pre><p>This is a lot cleaner and succinct than what we did above. The attr_accessor macro does the work of creating a setter and getter for us. The other macros I mentioned work in a similar way — the attr_writer method creates the setter and the attr_reader creates the getter. What we are telling Ruby to do here is create the setter and getter methods for the different attributes listed (title, director, and stars). This allows us to call the methods on our instances as we normally would, but without the hassle and mess of creating the methods in our class file.</p><p>As we can see, macros can make a developer’s experience on a project a much more enjoyable one. Setters and getters aren’t the only application for macros. We can see through gems like Active Record that macros can be used for other things like SQL queries. Once we start getting into complex databases, the belongs_to and has_many macros are just two ways to make pulling specific data from related tables based on foreign keys easier. Being as powerful as they are, be sure to take time to experiment with the common macros. Getting an understanding of how they work can help you write more clean code that is DRY.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=814a217d3979" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Unraveled Web]]></title>
            <link>https://medium.com/@mtd5264/the-unraveled-web-c159f5322023?source=rss-3e52958f6edc------2</link>
            <guid isPermaLink="false">https://medium.com/p/c159f5322023</guid>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[front-end-web-development]]></category>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[second-chances]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Matthew Draghi]]></dc:creator>
            <pubDate>Thu, 17 Feb 2022 01:35:25 GMT</pubDate>
            <atom:updated>2022-02-17T01:37:41.083Z</atom:updated>
            <content:encoded><![CDATA[<p>As a college student, I would log into Twitter and endlessly scroll through the content that populated my feed. Memes, sports news, and the latest trailers from Hollywood were all I cared about while swiping my thumb up across the screen and occasionally hitting the empty heart. After learning vanilla JavaScript, my mind started to open up a bit more about the anatomy of a website. “Maybe there is an event listener here and a PATCH request there…” It wasn’t until starting my second phase of the Flatiron School software engineering program that I really began to notice how these websites are made.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y6C4nSvy2Woe0m7bWEn4BA.png" /><figcaption>return &lt;img src=”react-logo.png” alt=”React Logo” title=”An icon to front-end devs”/&gt;</figcaption></figure><p>Components are the backbone of React. When we were first introduced to this concept it made sense, but knowing how to properly create and implement the different components was the hard part. For me to fully grasp this concept, I thought of a bicycle. I’ve ridden a bike many times, but never really took the time to break down how the bike works. Taking a closer look at the different components of a bike, you have the seat, the handle bars, the wheels, the chain, etc. Alone, these components can be used for other purposes. Together, they function to give us a working bicycle. That is exactly how components work — they are different functioning parts that can be used in different pieces of an application in combination with other parts. Now when looking at a website, I see components such as the header, search bar, or, in the case of Twitter, an individual tweet.</p><p>Running with Twitter as the example web application, interacting with tweets is a key part of the platform. How does your feed populate? Where does your tweet go when you press “Tweet”? What happens when a tweet is favorited? Is your tweet still “in the cloud” when you hit the “Delete”? Communication with the servers are constantly occurring in web apps. GET requests fetch the tweets for a specific user, POST requests will allow a user to add new tweets to their account, PATCH requests help update the properties of an object (user/tweet), and DELETE requests ensure that whatever you want gone from the server is no longer part of a GET. React has helped deepened my knowledge of http requests, and has cemented my knowledge of when to use which type of requests.</p><p>Components and server communication are only two pieces of the React puzzle. Just being aware of these two concepts can help make the web seem more clear. Once someone is able to get a good grasp on React and its core concepts, websites start appearing differently. You can see the moving parts of the bicycle working together in real time. Typing this blog, I can’t help but think of the controlled component being used to accept my input and save it to state, waiting for me to hit the “Publish” button so a submit event can be triggered, adding this blog to the <em>Medium</em> servers. Breaking the web down from a front-end perspective like this is fascinating. Having had the opportunity to cement my knowledge of React has changed how I view websites forever. I cannot wait to see what await when we move to the next gem of a language…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c159f5322023" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>