<?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 Isaiah Jefferson on Medium]]></title>
        <description><![CDATA[Stories by Isaiah Jefferson on Medium]]></description>
        <link>https://medium.com/@ijandicos90?source=rss-9f31c78dfd0e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Isaiah Jefferson on Medium</title>
            <link>https://medium.com/@ijandicos90?source=rss-9f31c78dfd0e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 01:53:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ijandicos90/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[Classes and Instances of a Class in Ruby]]></title>
            <link>https://medium.com/@ijandicos90/classes-and-instances-of-a-class-in-ruby-d60224940f5a?source=rss-9f31c78dfd0e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d60224940f5a</guid>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[flatiron-school]]></category>
            <dc:creator><![CDATA[Isaiah Jefferson]]></dc:creator>
            <pubDate>Sat, 13 Aug 2022 01:27:49 GMT</pubDate>
            <atom:updated>2022-08-13T01:27:49.222Z</atom:updated>
            <content:encoded><![CDATA[<p>I got introduced to a very important concept in phase 3 which is Object-Oriented Programming with Ruby as the basis for which I’m learning. All the way back in Pre-work of learning JavaScript thoroughly there was a segment in the last module where it was revealed that everything was an object not just an array or an….object. Also it was revealed that every object had an ancestor and also methods that they inherit based on their ancestor. I was left in suspense in what the implications of this detail could all mean and now in this phase I’m starting to understand the power and versatility of Objects and the implications of having an ancestor as far as object functionality with certain methods.</p><p>Ok so to start, Ruby is an Object Oriented Programming Language used to operate the backend in order to create dynamic API’s for the frontend to work with. Setting a class is very instrumental in this process and also instrumental in how the code runs for the language since everything is an object. For instance, &quot;String&quot; is an object that has inherited methods from the String class. For example,</p><pre>a_string = &quot;String&quot; <br>a_string.methods</pre><pre>// .methods will give you an array of methods you can use just by inheriting from the string class, [:unicode_normalize, :unicode_normalize!, :ascii_only?, :unpack, :unpack1, :to_r, :encode!, :%, :include?, :*, :+, :count, :partition, :+@, :-@, :&lt;=&gt;, :&lt;&lt;, :==, :===, :sum, :=~, :next, :[], :casecmp, :casecmp?, :insert, :[]=, :match, :match?, :bytesize, :empty?, :eql?, :succ!, :next!, :upto, :index, :rindex, :replace, :clear, :chr, :getbyte, :setbyte, :scrub!, :scrub, :undump, :byteslice, :to_c, :freeze, :inspect, :capitalize, :upcase, :dump, :downcase!, :swapcase, :downcase, :hex, :capitalize!, :upcase!, :lines, :length, :size, :codepoints, :succ, :split, :swapcase!, :bytes, :oct, :prepend, :grapheme_clusters, :concat, :start_with?, :reverse, :reverse!, :to_str, :to_sym, :crypt, :ord, :strip, :end_with?, :to_s, :to_i, :to_f, :center, :intern, :gsub, :ljust, :chars, :delete_suffix, :sub, :rstrip, :scan, :chomp, :rjust, :lstrip, :chop!, :delete_prefix, :chop, :sub!, :gsub!, :delete_prefix!, :chomp!, :strip!, :lstrip!, :rstrip!, :squeeze, :delete_suffix!, :tr, :tr_s, :delete, :each_line, :tr!, :tr_s!, :delete!, :squeeze!, :slice, :each_byte, :each_char, :each_codepoint, :each_grapheme_cluster, :b, :slice!, :rpartition, :encoding, :force_encoding, :valid_encoding?, :hash, :unicode_normalized?, :encode, :clamp, :between?, :&lt;=, :&gt;=, :&gt;, :&lt;, :dup, :itself, :yield_self, :then, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :frozen?, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :clone, :display, :class, :singleton_class, :public_send, :method, :public_method, :singleton_method, :define_singleton_method, :extend, :to_enum, :enum_for, :!~, :nil?, :respond_to?, :object_id, :send, :__send__, :!, :!=, :equal?, :__id__, :instance_eval, :instance_exec]</pre><p>Also if I put a_string.class I’ll get back the String class since every string inherits from the String class just like every array inherits from the Array class etc.</p><p>The awesome part about classes is that it allows an object to inherit methods that belong to its parent class and that allows us to ultimately be able to create our own Class with our own customized methods.</p><pre>class Example</pre><pre>def example_method<br>puts &quot;example of output&quot;</pre><pre>end</pre><pre>end</pre><pre>example = Example.new <br>example.example_method // output &quot;example of output&quot;</pre><p>Here I created a class called example ad then made a method inside of that class called example_method that outputs a string to the console. Then I create an instance object of that class in order to call that method. Since the object instance belong to that class it will inherit all it’s methods which means that I can create a plethora of methods in the class for any instantiated object I make with the class I made. That methods that are called on an instantiated object are called instance methods.</p><p>Another thing I’d like to showcase that I learned is the fact that you can also create a class method with the self keyword.</p><pre>class Loop</pre><pre>def self.loop_puts_hello<br>10 times do<br>puts &quot;hello&quot;<br>end<br></pre><pre>end</pre><pre>def self.loop_one_to_ten</pre><pre>(1..10).each{ |i| puts i }</pre><pre>end</pre><pre>end</pre><p>Now if I put Loop.one_to_ten I’ll get an out of 1 to 10 in the console as a loop and if I put Loop.puts_hello I’ll get an output of hello ten times in the console. Each of these methods are called on the class itself and it allows you to ultimately have a shared helper function amongst all the instance objects you create for this particular class.</p><p>Classes can also have instances that inherit methods from a superclass for instance</p><pre>class Laker<br> def player<br> puts &quot;Kobe&quot;<br> end<br>end</pre><pre>class Team &lt; Laker<br>def player<br>super<br>end<br>end </pre><pre>shooting_guard = Team.new </pre><pre>shooting_guard.player // output &quot;Kobe&quot;</pre><p>When I have the Team class inherit from the Laker class I essentially make the Laker class the superclass of the Team class. This allows me to place the super keyword in a shared method inside the method of the child class I created. The super keyword can also be called multiple times inside of the child method. This is called inheritance and it allows us to use the methods of a parent class while also created more functionality to the same method that is pertinent to the child class.</p><p>In summary, I learned that this structure is the basis to how I’m able to do array, string, number etc methods in my code. Since everything is an object then everything has the ability to have instance methods and inherited methods from a superclass. Since now I understand the implications of Object Oriented Programming I’m able to take this knowledge with me when I learn other OOP languages like Java(the next language I’m going to learn once this bootcamp is over) or Python while also deepening my understanding of Javascript. Phase 3 was an eye-opener for me and made me even more intrigued with programming. In the next blogpost I’ll be discussing the Ruby on Rails library and how it can be used to create a backend server. Till next time, thanks for reading.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d60224940f5a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Phase 2 Project aspirations]]></title>
            <link>https://medium.com/@ijandicos90/phase-2-project-aspirations-2bc824ef818e?source=rss-9f31c78dfd0e------2</link>
            <guid isPermaLink="false">https://medium.com/p/2bc824ef818e</guid>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react-project]]></category>
            <dc:creator><![CDATA[Isaiah Jefferson]]></dc:creator>
            <pubDate>Tue, 05 Jul 2022 03:04:14 GMT</pubDate>
            <atom:updated>2022-07-05T03:04:14.067Z</atom:updated>
            <content:encoded><![CDATA[<p>Even though I finished my project for phase 2 by getting all the deliverables done, I’m not completely satisfied. When I set out to do the project I had pretty big stretch goals I want to achieve that I couldn’t due to running out of time and emergencies in my personal life. The goal for this blog is to explain my project and also write about some functionality that I want to incorporate in the future, because this is one of those projects I’ll retouch and make look better and have much more functionality. So I’ll begin with the index.js component and then explain how my App component allows it’s child components to interact with each other on this single page application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_i68NwdnslnE7jFSccb7eQ.png" /></figure><p>In this index.js file I’m rendering the div element in the index file with an id of &quot;root&quot; . I store that element in a variable called root and from here I import React, ReactDOM , BrowserRouter(for navigation purposes), index.css and bootstrap. I enclose the App component in the BrowserRouter Component so I can utilitize client-side routing , since the App component will be the parent component of all my components it makes since to put the BrowserRouter here.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BnLxalcJT36-qd6vNZefqw.png" /></figure><p>In the App component I immediately got started on the routing, I added a NavBar component and the Routes and Router which satisfies the deliverable of client-side functionality in my app. I essentially want the App to be the parent of the bookstore and it will be in charge of passing the data from the fetch onto the BookStore Component and the BookCart Component. The goal of my App is to present a solid skeleton of an online bookstore by presenting cards of each book and with an add to cart button. The handleClick is function allows the button to update a separate piece of state for my BookCard component(Child of BookStore and BookList) by passing book object to it’s current state of booksInCart. There’s a map function in the CheckOutCard(a child component of BookCart)that updates by presenting each book and it’s price in the cart card, there’s even a running tally for the total price all utilizing the current state of booksInCart. The Delete function allows you to delete the book from the database, I pass that function down as a prop to my BookCard aswell so that I can delete the book from the database. The user of this website will be a owner of the website, that’s why there is a link to a page that allows you to add a Book along with it’s inventory and price.</p><p>The stretch goals I had in mind was too have the stock reduce in number each time I click add to cart, once it hits zero the image is replaced with an out of stock message, I would use state in order to keep track of the stock for each card and the state would reside in the BookCard component. Also there is a form in my CheckOut card component that takes in information from the customer, I’d like to make that a controlled form and post it to a secure back-end so that I can be able to put the customer on an email list to receive promotion sales events of the company. The opening page is blank, I’d like to make the background a logo and or some place holder image. There is also a comment out piece of code that is of useContext, I want to use the useContext hook to pass down the booksInCart variable directly to the CheckOutCard component. Each of these things are doable and will be done. When I make these additions I’ll make another blog post on how I went about these changes and how I incorporated a back-end method using Ruby instead of a db.json server. I had fun doing this project even tho I was pressed for time and could only primarily focus on satifisfying the deliverables, but I can honestly say I learned a whole alot about thinking in React by doing a Project and I look forward to making many more in the fututre.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2bc824ef818e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Technical Code Series part 2: Destructuring Props in React]]></title>
            <link>https://medium.com/@ijandicos90/technical-code-series-part-2-destructuring-props-in-react-98f7973f8e86?source=rss-9f31c78dfd0e------2</link>
            <guid isPermaLink="false">https://medium.com/p/98f7973f8e86</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[codingbootcamp]]></category>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[destructuring]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Isaiah Jefferson]]></dc:creator>
            <pubDate>Mon, 04 Jul 2022 20:45:29 GMT</pubDate>
            <atom:updated>2022-07-04T20:57:21.178Z</atom:updated>
            <content:encoded><![CDATA[<p>Phase 2 has been quite a journey and a strong test to my resolve in regards to learning how to code. After facing a medical emergency in my immediate family and dealing with stress with a change of my living situation in relation to that emergency somehow I’m still here, let’s get into it. In the previous blog post I spoke of destructuring in vanilla javascript as a quick refresher, here’s an example of destructuring an object and an array</p><pre><br>const example = {<br>firstName: &quot;Isaiah&quot;,<br>lastName: Jefferson,<br>}</pre><pre>const {firstName, lastName} = example</pre><pre><br>const exampleArr = [&quot;person&quot;, &quot;place&quot;, &quot;thing&quot;]</pre><pre>const [noun1, noun2, noun3] = exampleArr</pre><p>When destructuring an object you can extract the key as local variables and each key will represent it’s corresponding value, for instance the firstName variable will represent the value of a string &#39;Isaiah&#39;. Whereas with arrays we can set local variables in Array by having each variable represent the value of it’s corresponding index, like for instance since personis in index “0” then noun1 will represent the string of person.</p><p>Destructuring helps make React easier to navigate especially when using props, which is short for properties. Modern React allows us to use components that act a functions that isolate a single portion of our webpage. You need a parent component that can tie all the components together.</p><figure><img alt="An example of React component" src="https://cdn-images-1.medium.com/max/1024/1*as_YW76WntofId4JmMbqEQ.png" /><figcaption>An example a React component</figcaption></figure><p>In the example above the parent component which is the BotPage, is importing the child components of YourBotArmy and BotCollection. Since the parent component is holding the data in the form of a fetch it needs to pass down that data to it’s sub-components and fortunately that is done by essentially passing an object down to these components. When we pass props down we are passing a key value pair for example</p><pre>&lt;BotCollection bots={bots}  handleBotEnlist={handleBotEnlist} handleDelete={handleDelete}/&gt;</pre><pre>{<br>bots = bots,  </pre><pre>handleBotEnlist = handleBotEnlist, </pre><pre>handleDelete = handleDelete<br>}</pre><pre>// the above object is being passed to the child component of BotsCollection </pre><pre>}</pre><p>As stated in my previous blog post on destructuring, you can destructure an object and pass it as an argument to a function. Since components are essentially functions themselves we can destructure the object in order to pass the values to the key’s down to the child components</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p7mahKGXg0IAQLgxF5-09Q.png" /><figcaption>Passing a destructured object in the form of props</figcaption></figure><p>In summary, destructuring is a very useful tool when passing down data in React, it allows you to provide a key that is the same name as the data it’s passing down which cut down on an confusion once the data is being utilized in the child component since the reference of the key has the same name.</p><p>That’s pretty much it when it comes to destructuring props and passing it down to child components. Due to it’s convenience of use, it’s become the standard way to have components interact with each other and to dry up the coding process in a legible way. In the next blog post I’ll be writing about Ruby and how it differs from Javascript syntax.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98f7973f8e86" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Technical Code Series Part 1: Destructuring Objects]]></title>
            <link>https://medium.com/@ijandicos90/technical-code-series-part-1-destructuring-objects-dda6f1d2f98a?source=rss-9f31c78dfd0e------2</link>
            <guid isPermaLink="false">https://medium.com/p/dda6f1d2f98a</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[codingbootcamp]]></category>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[objects]]></category>
            <category><![CDATA[destructuring]]></category>
            <dc:creator><![CDATA[Isaiah Jefferson]]></dc:creator>
            <pubDate>Fri, 20 May 2022 03:44:37 GMT</pubDate>
            <atom:updated>2022-05-25T04:12:11.810Z</atom:updated>
            <content:encoded><![CDATA[<p>After passing the prework phase of the Flatiron School coding bootcamp I learned quite a bit about JavaScript topics including arrays/objects and the most important part of arrays and objects was mentioned at the last module just after the Object Ball lab. In my opinion destructuring could’ve came before the lab, because it was a very powerful technique that allowed me to breeze through what would otherwise be a very tedious and difficult lab. This will be my first foray into explaining a technical topic in regards to JavaScript code and I’m writing this to help bring clarity to this technique I incorporated into my Object Ball lab and my API project. Destructuring is an assignment technique that deals with arrays and objects, it was first introduce to JavaScript syntax in the ES6 revision of JavaScript.</p><p>Destructuring allows you to bypass having to use dot notation or bracket notation for objects, take this object for example:</p><pre>const exampleObj = {<br>name: &quot;Jamaal&quot;<br>address: &quot;2450 Thomas Ave&quot;</pre><p>if you wanted to access the name property inside the object you could use traditional syntax and store the property in a variable as below</p><pre>const exampleName = exampleObj.name<br>const objName = exampleObj[&#39;name&#39;]</pre><p>with destructuring you can simply create a variable for each property in the object by referencing the key’s in an object and making them variables.</p><pre>const {name, address} = exampleObj<br>console.log(`Hello, my name is ${name} and I live on ${address}.`<br>// Hello, my name is Jamaal and I live on 2450 Thomas Ave.</pre><p>The power of destructuring objects becomes apparent when dealing with nested objects such as the one I encountered in my Object Ball lab.</p><figure><img alt="object of home and away team stats" src="https://cdn-images-1.medium.com/max/1024/1*REt-AoUzg1p9lIBK5mrH5Q.png" /></figure><p>With the object above, we have a players object of all players and their stats but they are nested in the home and and away objects for each team respectively. In order to access the home player “Alan Anderson” points stats with out destructuring you’d have to use the following syntax.</p><pre>gameObject().home.players[&quot;Alan Anderson&quot;].points</pre><p>With destructuring we can segment out the players subobject for the home object by setting a variable for the players object with destructuring</p><pre>const { home: {players}= gameObject()</pre><pre>players[&quot;Alan Anderson&quot;].points</pre><p>you have to put a {} bracket around players so we can do a nested destructure, but there is an issue here, both the home object and the away object have the same key of players, and since we use const to set the variables with our destructuring technique, it would seemingly lock us out of targeting players object in both the home and away objects. There’s a work around with this, we simply assign a new name for the key of players for both the home and away objects.</p><pre>const { home: { players: homePlayers }, away: { players: awayPlayers } } = gameObject()</pre><p>This method is very convenient when dealing with similar keys of nested objects.</p><p>The is one more technique that is very powerful with destructuring and that’s the ability to use use variable for a destructure within a function. I utilized this technique within my project for fetching API’s. Let’s say you have JSON data, which is an object of data you can utilize to populate a webpage by manipulation of the DOM.</p><pre>fetch(`https://api.polygon.io/v2/snapshot/locale/us/markets/stocks/tickers/${tickerSymb}?apiKey=HRJaobcNSX77koktspcX6RhjjQ1aw4W5`)</pre><pre>.then(response =&gt; response.json())</pre><pre>.then(data =&gt; {</pre><pre>const { ticker: {day}} = data</pre><pre>renderStockTable(tickerSymb,day)</pre><p>We can take the data from the JSON and destructure it so we have easy access to the components therein. The data I’m fetching is stock ticker data and the day object has keys that represent fluctuations in price for the ticker symbol I pass through the submit event for my app. I want to take each of these keys c: for price at market close, h: for price high, l: for price low, o: price at market open, v: for volume of trades, vw for weighted average price and put them in a table as table data. In the renderStockTable function I’m passing the day variable in the function which represents an object</p><pre>&quot;request_id&quot;: &quot;4070d186a2380f9385b5904cec5fd1a6&quot;,<br>  &quot;status&quot;: &quot;DELAYED&quot;,<br>  &quot;ticker&quot;: {<br>    &quot;day&quot;: {<br>      &quot;c&quot;: 137.35,<br>      &quot;h&quot;: 141.66,<br>      &quot;l&quot;: 136.6,<br>      &quot;o&quot;: 139.88,<br>      &quot;v&quot;: 136077468,<br>      &quot;vw&quot;: 138.6621<br>    },<br>    &quot;min&quot;: {<br>      &quot;av&quot;: 136077468,<br>      &quot;c&quot;: 138.3,<br>      &quot;h&quot;: 138.3,<br>      &quot;l&quot;: 138.22,<br>      &quot;o&quot;: 138.22,<br>      &quot;v&quot;: 3481,<br>      &quot;vw&quot;: 138.2578<br>    },<br>    &quot;prevDay&quot;: {<br>      &quot;c&quot;: 140.82,<br>      &quot;h&quot;: 147.3601,<br>      &quot;l&quot;: 139.9,<br>      &quot;o&quot;: 146.85,<br>      &quot;v&quot;: 109742890,<br>      &quot;vw&quot;: 142.6901<br>    },<br>    &quot;ticker&quot;: &quot;AAPL&quot;,<br>    &quot;todaysChange&quot;: -2.52,<br>    &quot;todaysChangePerc&quot;: -1.79,<br>    &quot;updated&quot;: 1653004800000000000<br>  }<br>}</pre><p>I then destructure that object with the renderStockTable function in the global scope and pass each of those variables as arguments. I then assign each of these variables to the textcontent for each of the table data elements I’m creating to add to my table with the ‘stock-table’ ID.</p><pre>function renderStockTable(ticker,{c, h, l, o, v, vw}) {</pre><pre>const table = document.getElementById(&#39;stock-table&#39;)</pre><pre>const tableRow = document.createElement(&quot;tr&quot;)</pre><pre>tableRow.classList.add(&#39;style-new-row&#39;)</pre><pre>const tableHead = document.createElement(&#39;th&#39;)</pre><pre>const tableBody = document.createElement(&#39;tb&#39;)</pre><pre>const closingPrice = document.createElement(&#39;td&#39;)</pre><pre>const priceHigh = document.createElement(&#39;td&#39;)</pre><pre>const priceLow = document.createElement(&#39;td&#39;)</pre><pre>const openPrice = document.createElement(&#39;td&#39;)</pre><pre>const tradingVol = document.createElement(&#39;td&#39;)</pre><pre>const deleteRow = document.createElement(&#39;td&#39;)</pre><pre>const weightAveragePrice = document.createElement(&#39;td&#39;)</pre><pre>const deleteBtn = document.createElement(&#39;button&#39;)</pre><pre>deleteBtn.type = &quot;button&quot;</pre><pre>tableHead.textContent = `${ticker}`</pre><pre>closingPrice.textContent = `${c}`</pre><pre>priceHigh.textContent = `${h}`</pre><pre>priceLow.textContent = `${l}`</pre><pre>openPrice.textContent = `${o}`</pre><pre>tradingVol.textContent = `${v}`</pre><pre>weightAveragePrice.textContent = `${vw}`</pre><pre>tableRow.append(tableHead, closingPrice, priceHigh, priceLow, openPrice, tradingVol, weightAveragePrice, deleteRow)</pre><pre>table.append(tableRow)</pre><pre>deleteRow.append(deleteBtn)</pre><pre>deleteBtn.innerText = &quot;Delete&quot;</pre><pre>deleteBtn.addEventListener(&#39;click&#39;, (e) =&gt; e.target.parentNode.parentNode.remove())</pre><pre>}</pre><p>I’ve read in many parts of the web in my research that destructuring a function argument is very much commonplace in frameworks such as REACT, once I get to the phase where I learn REACT I will take a deep dive into REACT props, that will be part 2 of the series. I hope that I brought some clarity on destructuring objects and it’s many convenient uses and I’ll see you in Part 2.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dda6f1d2f98a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Personality type and coding. A match made in heaven?]]></title>
            <link>https://medium.com/@ijandicos90/my-personality-type-and-coding-a-match-made-in-heaven-6ab9878188d2?source=rss-9f31c78dfd0e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ab9878188d2</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[codingbootcamp]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[flatiron-school]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Isaiah Jefferson]]></dc:creator>
            <pubDate>Fri, 08 Apr 2022 20:52:10 GMT</pubDate>
            <atom:updated>2022-04-08T20:52:10.879Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ll start with an introduction, my name is Isaiah Jefferson and I’m a warehouse worker at Amazon. I’m apart of the Flatiron school cohort of 2022. The first will be my first blog entry documenting my progress and experience with learning how to code and how I overcome some of the challenges there, but first I’ll give a short backstory about myself and why I think coding is a natural fit for me. I was born in Los Angeles, California and raised in Bakersfield. At a young age my parents got an ugly divorce and I grew up in poverty harsh conditions, but the most notable thing about my childhood is was it shaped my personality</p><p>I never was the coolest kid or had the “flyest” clothes to impress my peers, I was in fact a loner or always analyzed the environment around me and tried to figure out how things worked systematically. Naturally I became a huge fan of playing chess, video game and math all these hobbies stimulated my brain due to their puzzle solving nature. As I grew older I got interested in critical thinking and the MBTI personality test, each time I take the test I came up as an INTJ, a personality type known for their intellect, eccentricity and ambition. As such, I would get A’s and B’s but I also struggled with depression as I would get very caught up in my thoughts on society, my life and the world at large relative to my own living situation. One thing about me is that when I get into a bad mental space I’d obsessively do puzzles or play video games as an escape. With INTJ’s we are a minority of the population (2%) and we operate very different, instead of going out to party with friends I rather stay inside and study, instead of going about a task aimlessly we’d rather break it down into parts then systematically plan out handle to handle said task. Since I wasn’t able to connect to my peers at a young age I adapted to knowledge seeking and puzzles.</p><p>Now as an adult after finishing college and breaking out my shell I’ve come to appreciate the harsh upbringing. I’ve come to realize that there isn’t a problem that can’t be solve with willpower and knowledge. When a friend of mine recommended that I attend the Flatiron School seminar, because it would probably be something I’d like, I pursue it, after all I’ve been around video games and computers throughout my life. After 4 week of doing the Flatiron School coding bootcamp I’m already hooked. I wake up looking at code and I go to sleep and dream of code. I put aside all my hobbies just for this course, because I want to master this subject, which is typical of an INTJ, but also I understand that this is another instance of using brainpower to overcome life’s circumstances.</p><p>In the next entries I’ll be covering what I learned and certain methods that I love utilizing in my code. Hopefully this first entry gave a short snapshot of myself and how code entered my life. I’ll continue to let my personality and ambition to carry me and if I can help others along the way then all the better. I was hesitant on writing this blog, because I rather be learning new syntax, looking at coding videos and looking at my old code to see if I could have done them better, but as I write this entry it only reinforces my conviction on learning how to code. All my appreciation goes towards Amazon for paying for the program, my instructors and anyone who is reading this. Now in typical INTJ fashion I’m going to watch and take notes on Colt Steel’s masterclass in Data Structures and Algorithms, not only because it will help me find a job easier, but also because I find the topic fascinating and I’m interested in learning how to make my code run faster. Catch ya in the next entry.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ab9878188d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>