<?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 Karis Tobias on Medium]]></title>
        <description><![CDATA[Stories by Karis Tobias on Medium]]></description>
        <link>https://medium.com/@karistobias?source=rss-e515462b1ed0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Rl3UZiByFL0YOFY3</url>
            <title>Stories by Karis Tobias on Medium</title>
            <link>https://medium.com/@karistobias?source=rss-e515462b1ed0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 15:43:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@karistobias/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[What’s Been My Experience of Launch School’s Core Curriculum?]]></title>
            <link>https://karistobias.medium.com/whats-been-my-experience-of-launch-school-s-core-curriculum-a7bf52199987?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7bf52199987</guid>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Wed, 02 Aug 2023 00:24:20 GMT</pubDate>
            <atom:updated>2023-08-02T00:24:20.115Z</atom:updated>
            <content:encoded><![CDATA[<p>While the Core Program had its highs and lows, overall it was an incredibly transformative experience and a program I was glad to have undertaken. Going through a mastery program is such a unique opportunity in that, not only do you walk away with mastered skills, but you get to challenge preconceived ideas about yourself and what you think is possible.</p><p>In the beginning, I wasn’t sure if I was too old or too ‘artistic’ to do Core and transition into a tech career. I worried about my average high school math and science grades and that my previous professions were in design and architecture — careers that I thought would not serve me at all. I feared that I may not have the brains nor the aptitude to become a software engineer.</p><p>These beliefs slowly shifted over time through Core, as each time I was able to complete an exercise I wasn’t able to do before, or write more confidently about a programming fundamental. Doing well in assessments and getting kudos from study buddies were also huge confidence boosts.</p><p>Now, I’m able to speak confidently about concepts like closures or polymorphism and gracefully solve interview-style programming problems. There are also other non-technical benefits I gained simply by working through a mastery-based program. Ones that stand out to me are clearer, more concise communication as well as improved research and problem solving skills. These kinds of soft skills are invaluable and can serve you regardless of your profession.</p><p>I also became less proud and fearful to ask questions in Launch School’s community Slack chat and forums. I learned that it’s better to put yourself out there and face a bit of discomfort, than pretending to know and performing poorly on an assessment. Not reaching out for help or asking questions can breed poor performance, which hinders your progress and can shake the confidence and foundations you’re trying to build as a programmer.</p><p>I also learned I could use my art/architecture background to solve problems more creatively. I fully believe no matter your previous profession, there are many skills that you can transfer to programming and apply in ways you didn’t think were possible. All you have to do is look for them.</p><p>Though I made a few amazing study buddies throughout Core, my personal Core experience was generally more solitary due to timezone differences. As Launch School is based in the US and I live in Australia, I missed out on several events, and meetups were just not possible. Not everyone was willing to accommodate my timezone and study with me, so a lot of my personal challenges through Core may have been exacerbated by not studying with others as much. I believe studying with others can really supercharge your learning as peers can recognise your blind spots and vice versa.</p><p>One of the most challenging parts about Core was managing my own test anxiety. When it came time to prepare for and take assessments it did get progressively better because I knew what to expect, but there were times when it would get the better of me. In the end though, it was never as bad as my imagination painted it to be and I was glad to have risen to the challenge. The other challenging thing was being faced with an exercise or concept I thought I might never be able to comprehend, which can lead to doubt and questioning my resolve to change careers. Fortunately I was able to prove this idea wrong with enough determination to understand the problem or concept in front of me.</p><p>One of the best parts of Core was the satisfaction of finally understanding a programming problem or concept that I had been mulling over for days. This is such a great feeling and made me incredibly grateful for having challenged the limits of my understanding. The other best part was the people of Launch School. I don’t think I’ve ever met so many like-minded, hardworking individuals like the ones within the community.</p><p>And because of the transformation everyone seems to go through at Launch School, they love being able to turn around to the people behind them and pay forward their hard earned lessons. I really respect that kind of generosity. I too continue to pay forward all the amazing things I learned about myself and about programming at Launch School.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7bf52199987" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting stuck in programming — how do I overcome it?]]></title>
            <link>https://karistobias.medium.com/getting-stuck-in-programming-how-do-i-overcome-it-4c048e79ca8c?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c048e79ca8c</guid>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Wed, 26 Jul 2023 08:26:28 GMT</pubDate>
            <atom:updated>2023-08-01T04:23:58.793Z</atom:updated>
            <content:encoded><![CDATA[<h3>Getting stuck while programming? Here’s how I overcame it</h3><blockquote>Below are some of study techniques I used as I was working through <a href="https://launchschool.com/">Launch School’s Prep and Core curriculum courses.</a> I hope you find these reflections helpful, particularly if you are still looking for a study technique that works for you.</blockquote><p>Say you can’t comprehend something, like a concept or an exercise. First thing is that you have to admit to yourself that you don’t know. Something I grappled with from time to time in Prep and Core was my own pride of trying to figure out an exercise without looking at the solution. Once I admitted to myself “I don’t know”, it allowed me to move forward and look at the solution.</p><p>For overcoming struggle with exercises, especially when I was preparing for the 119 interview, whenever I spotted a really good solution — I collected it and saved it for later. Before I knew it, I started collecting good solutions and would break them down in irb (or node) and began to appreciate how each line was strung together and how elegant they were. Problems over time started to appear more familiar to me. I would soon be able to look at a problem and examine it a bit before I realised — “oh this is a ‘recursion’ problem” or “this is an ‘iteration’ problem” etc. Because I collected and broke down so many different types of solutions, I could get creative with solving that problem and might have had two or more different ways to solve it.</p><p>For overcoming the struggle with programming concepts, once I realised I didn’t fully understand what a concept meant, I felt the need to look at it from a different angle. Sometimes when a definition would escape me, I might have looked up documentation or a reputable text book to see someone else’s take on it. Although this may have been overkill, I felt I understood things more deeply and didn’t just know concepts on a surface level.</p><h3>A strategy for mastering programming fundamentals at Launch School</h3><blockquote>Note: Make sure you look at the study guide before you begin preparing for an assessment! Below reflects my own personal way of mastering fundamentals for assessments. While this strategy worked for me, it may not work for everyone. Examples are written in Ruby as my first assessment was in Ruby.</blockquote><p>I used the <strong>chunking strategy</strong> explained in Barbara Oakley’s <a href="https://www.coursera.org/learn/learning-how-to-learn">“Learning how to Learn” course</a> that you’ll come across in Launch School’s prep courses:</p><p>Each chunk represents a programming concept. Launch School’s study guide will help you identify all the concepts you need to know. eg some fundamental examples are:</p><ul><li>truthiness, variables as pointers, pass by reference/pass by value etc.</li></ul><p>For each programming fundamental, locate all the rules for it in the material. eg for truthiness:</p><ul><li>In Ruby, everything is truthy except for false and nil</li></ul><p>For every rule, locate 1–2 code snippets that exemplifies the rule:</p><pre>my_var = nil<br><br>if my_var<br> puts &quot;it&#39;s truthy!&quot;<br>else<br> puts &quot;it&#39;s falsy!&quot;<br>end<br><br># output: it&#39;s falsy!</pre><pre>my_var = 5<br><br>if my_var<br> puts &quot;it&#39;s truthy!&quot;<br>else<br> puts &quot;it&#39;s falsy!&quot;<br>end<br><br># output: it&#39;s truthy!</pre><p>Then you can chunk the fundamental, all of its rules and examples together:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q48CjQw5vKH-AWzQlEliYw.png" /><figcaption>Chunking programming fundamentals</figcaption></figure><ul><li>Use the Launch School study guide to help you summarize and identify the fundamental at play, what the code is doing and how it demonstrates a particular rule in programming</li><li>Also don’t be afraid to pull apart your examples and play with them in irb/node.</li><li>Use a highlighter plugin to help underline text in assignments. Make sure to use different colors to represent different things. eg. for concepts highlight in red, rules in blue, and examples in yellow. It helps speed up note taking when preparing for assessments.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c048e79ca8c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Curse of Knowledge]]></title>
            <link>https://karistobias.medium.com/the-curse-of-knowledge-14a2667eeaed?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/14a2667eeaed</guid>
            <category><![CDATA[teaching-and-learning]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[teaching]]></category>
            <category><![CDATA[launch-school]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Fri, 15 Apr 2022 06:27:02 GMT</pubDate>
            <atom:updated>2022-05-03T10:19:02.475Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QmuaWT9AcfgxXw8q" /><figcaption>Photo by <a href="https://unsplash.com/@matmacq?utm_source=medium&amp;utm_medium=referral">Mathew MacQuarrie</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>As a student and TA of the <a href="https://launchschool.com/course_catalog">Launch School</a> community, the other day I conducted my very first study group. This particular group was a beginner session to reinforce programming fundamentals, and answer any questions they might have.</p><p>While the session went well, there was a moment that stood out to me as an important, often overlooked part of teaching — heck, any kind of communication.</p><p>It began when a student in the session asked me about recursion, and if I could supply a real world example.</p><p>“Recursion?” I wondered. “Why would a student want to know about an advanced topic right at the beginning of their studies?”</p><p>Putting that thought aside, I decided how I could answer.<strong> </strong>Coincidentally, I had <em>just</em> learned that recursion was an excellent way to “walk the list” of a DOM tree in order to modify the data and behaviour of a web application.</p><p>As I was about to deliver this information, I hesitated. “Wait a minute,” I thought. “If this student is attending<strong> </strong>a beginner session, it’s very likely that they will have no idea what I’m talking about!”</p><p>Here lies the dilemma of what many individuals will face as their understanding of a topic<strong> </strong>increases: <em>The Curse of Knowledge</em>.</p><p>The idea here is that you know a concept well, but others outside your level of expertise will not. Your job then is to deliver the information in plain English, and bridge their understanding with one foot in familiar territory, and the other in the unfamiliar.</p><p>The <em>Curse of Knowledge </em>is not a new idea. It belongs to the brilliant minds of brothers and educators Chip and Dan Heath, in their book: <a href="https://heathbrothers.com/books/made-to-stick/"><em>Made to Stick</em></a>.</p><p>In the book, they explain the problem of the Curse of Knowledge through the story of a struggling company trying to prove why they should exist. The brothers were conducting a non-profit seminar to help organisations get clear on their core mission.</p><p>Having a clear core mission helps others care about your organisation and support your cause through volunteering, donations and continued employment.</p><p>One such organisation — The Murray Duo Piano Foundation — had a lot of trouble getting the other attendees to understand their core mission statement, which read:</p><blockquote><strong>We exist to protect, preserve, and promote the music of duo piano.</strong></blockquote><p>This statement doesn’t say much at all — does it? But it made perfect sense to the organisation. Why wouldn’t it? <em>They</em> understood the music of Duo Piano.</p><p>The problem was no one else in the room did.</p><p>It took over 10 minutes of persistent questioning until one attendee finally asked — “Why would the world be a less rich place if Duo Pianos disappeared completely?” The Foundation was shocked by this question, then finally answered:</p><blockquote><strong>The piano is this magnificent instrument. It was created to put the entire range and tonal quality of the whole orchestra under the control of one performer. There is no other instrument that has the same breadth and range. And when you put two of these magnificent instruments in the same room, and the performers can respond to each other and build on each other, it’s like having the sound of the orchestra but the intimacy of chamber music.</strong></blockquote><p>Suddenly it all made sense.</p><p>Everyone at the seminar finally understood why Duo Pianos were so important. But why did it take so long for The Murray Duo Piano Foundation to arrive at an explanation that <em>everyone</em> could understand?</p><p>Because they were affected by <em>the</em> <em>Curse of Knowledge. </em>The<em> </em>Heath Brothers leave us with the insight that:</p><blockquote><strong>If you come to work every day for years, focused on Duo Piano issues, it’s easy to forget that a lot of the world has never heard of the Duo Piano.</strong></blockquote><p>Similarly, a brand new programming student has never heard of “walking the DOM list as a great example of recursion in the real world”. Telling them this would be the Curse of Knowledge at play.</p><p>If I had mentioned this to my study group it would have fallen on deaf ears. Heck, some may have even felt alienated and lost confidence in their ability to grasp other advanced programming concepts.</p><p>I wanted to <em>reduce </em>their uncertainty, not enhance it.</p><p>So, with trepidation I started from a place where they may be able to understand.</p><p>One foot in familiar territory.</p><p>I asked if they knew what an HTML document was, and what it looked like. One or two students nervously raised their hands, as I went on to explain that recursion can be used to extract deeply nested information on a webpage.</p><p>Though simpler than my original answer, I knew this answer was still a bit ambitious. And sure enough, though the student was grateful, the explanation went right over their head.</p><p>Which goes to show how powerful the <em>Curse of Knowledge</em> can be — even if you <em>haven’t </em>spent decades in a field.</p><p>Perhaps I could have led with a metaphor,<strong> </strong>or withheld the information altogether, telling them it would be explained as they progressed through the course.<strong> </strong>But I went with this answer, because I strongly believe in nurturing a students curiosity, especially so early on in the learning journey — it will serve them well for the rest of their career.</p><p>The point I am trying to make here is that <strong>when you gain knowledge in a field that others outside your domain don’t yet possess; you cannot assume they will understand you, nor should you expect them to.</strong></p><p>Instead, why not put yourself in their position and ask “What do they know? What <em>don’t </em>they know? How can I bridge this gap to a place where they understand what I’m saying?” <strong>By asking yourself these questions, you’ll be able to create more opportunities for clarity, understanding and inspiration, instead of easily succumbing to the <em>Curse of Knowledge.</em></strong></p><p>It doesn’t matter if you’re a teacher, a senior student, an employee or an employer. Anyone can do this — even though it may take more time in the long run, I believe it is well worth the effort.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=14a2667eeaed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 1: The JavaScript OLOO Pattern Explained (with pictures)]]></title>
            <link>https://karistobias.medium.com/part-1-the-javascript-oloo-pattern-explained-with-pictures-34be175b7908?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/34be175b7908</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[prototype]]></category>
            <category><![CDATA[launch-school]]></category>
            <category><![CDATA[oop]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Fri, 11 Feb 2022 08:18:15 GMT</pubDate>
            <atom:updated>2022-02-23T09:31:03.430Z</atom:updated>
            <content:encoded><![CDATA[<p>Having listened to a number of students during my software development studies, I observed a lot of confusion surrounding <strong>JavaScript’s Object Creation Patterns</strong>. For beginners it can be especially tricky — and without careful study, can lead to hesitation around using objects. With this in mind, I braced myself for a deep dive into learning JavaScript’s Object Creation patterns for the first time.</p><p>To my relief, my progress was smooth as I learned these patterns at <a href="https://launchschool.com/">Launch School</a> — with little to no confusion. How was this done? Well, I am very happy to share my findings here in two parts:</p><ul><li><a href="https://karistobias.medium.com/part-1-the-javascript-oloo-pattern-explained-with-pictures-34be175b7908"><strong>Part 1</strong></a> covers Prototype Inheritance and delegation in JavaScript with the OLOO pattern</li><li><a href="https://karistobias.medium.com/part-2-the-javascript-pseudo-classical-pattern-explained-with-pictures-70dfda6c6351"><strong>Part 2</strong></a> deals with the Pseudo-classical pattern — a combination of constructor functions and prototypes that create objects in JavaScript</li></ul><p>As there is a plethora of technical information out there on JavaScript Objects, we will attempt to keep technicalities light. We will instead take a top-down, integrated approach to these articles. Before I get stuck into JavaScript prototypes, let us first discuss how other OOP languages create objects using classes.</p><h3>Traditional Class-Based Objects</h3><p>We will be expanding on Software Engineer <a href="https://alistapart.com/article/prototypal-object-oriented-programming-using-javascript/">Mehdi Maujood’s brilliant chair object metaphor:</a></p><p>In a class-based language, such as Ruby: classes are like blueprints. If we wanted to manufacture a chair for example, that has a width and height, we would create a class that serves as the “blueprint” and create (or instantiate) a chair based on that blueprint:</p><pre>class Chair<br>  def initialize(width, height)<br>    @width = width<br>    @height = height<br>  end<br>end</pre><pre>my_chair = Chair.new(50, 45)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*G3ORwU9cAaZ9JuEvvNFHjA.png" /></figure><p>What if we then wanted to create a more specific object, say a desk chair? We must make changes to the blueprint. Desk chairs are typically more complex than a basic chair — their height can be adjusted and they have wheels. To accommodate both chair objects, we must keep our original Chair class (superclass) and create a more specific class DeskChair (subclass), which will set the original properties of our Chair class using the super keyword:</p><pre>class Chair<br>  def initialize(width, min_height)<br>    @width = width<br>    @min_height = min_height<br>  end<br>end</pre><pre>class DeskChair &lt; Chair<br>  def initialize(width, min_height, max_height, wheels)<br>    super(width, min_height)<br>    @max_height = max_height<br>    @wheels = wheels<br>  end<br>end</pre><pre>my_chair = Chair.new(50, 45)<br>my_desk_chair = DeskChair.new(50, 45, 52, 5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*MnTBF4Svq9iwKqg4zQlqxQ.png" /></figure><h3>JavaScript Prototypes</h3><p>Continuing with <a href="https://alistapart.com/article/prototypal-object-oriented-programming-using-javascript/">Mehdi Maujood’s chair metaphor</a> — when it comes to prototypes, we don’t create blueprints or classes, we just create a chair object. Imagine chopping up some wood and building a chair out of it. This is a fully functional chair object and can work as the prototype for future chair objects:</p><pre>let myChair = {<br>  width: 50,<br>  height: 45,<br>};</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*Aagll_2G91c9tqBBKB8ZEA.png" /><figcaption>In JavaScript objects don’t need classes</figcaption></figure><p>Maujood goes on to explain: “In the world of prototypes, you build a chair and simply make ‘duplicates’ of it”. If we want to build our desk chair, we ‘duplicate’ our original chair using Object.create, give our new chair some adjustable height, add some wheels to it and ta-da! We have a desk chair! We didn’t have to create a blueprint for that now did we?</p><pre>let myChair = {<br>  width: 50,<br>  minHeight: 45,<br>};</pre><pre>let myDeskChair = Object.create(myChair);<br>myDeskChair.maxHeight = 52;<br>myDeskChair.wheels = 5;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I5SEPYVn8r-i1-7I-6JwMg.jpeg" /></figure><p>And if we wanted a chair object of <em>any </em>width and height we can simply add an init method to set initial values for a chair of any dimension:</p><pre>let myChair = {<br>  init(width, height) {<br>    this.width = width;<br>    this.height = height;<br>    return this;<br>  }<br>};</pre><pre>let anotherChair = Object.create(myChair).init(40,60);</pre><p>There is a major yet subtle difference between class-based objects and prototypal objects. If we were to compare a Ruby desk chair object to a JavaScript desk chair object, aside from Ruby’s superficial Object id information: #&lt;DeskChair: 0x000055e0cfa1fddc8, we would find an important distinction. Can you spot it in the code below?</p><p>Ruby’s Desk Chair:</p><pre>p my_desk_chair</pre><pre>#&lt;DeskChair:0x000055e0cfa1fdc8 <br>@width=50, @min_height=45, @max_height=52, @wheels=5&gt;</pre><p>JavaScript‘s Desk Chair:</p><pre>console.log(myDeskChair);</pre><pre>{ maxHeight: 52, wheels: 5 }</pre><p>To spot the difference here, we first need to understand JavaScript’s <strong>Prototypal Chain.</strong></p><h3>The Prototypal Chain: Inheritance &amp; Delegation</h3><p>If you looked close enough you might have noticed that the Ruby desk chair contained all its properties: width, min_height, max_height and wheels whereas our new JavaScript desk chair object only contains maxHeight and wheels. That’s strange…didn’t we ‘duplicate’ our original chair? Shouldn’t it have all the properties from our original chair prototype?</p><p>Actually….our new desk chair object <strong><em>does</em></strong> have access to all its properties:</p><pre>console.log(myDeskChair);    // { maxHeight: 52, wheels: 5 }</pre><pre>myDeskChair.width;           // 50<br>myDeskChair.min_height;      // 45</pre><p>Wait…what’s going on?! Those properties don’t exist on myDeskChair yet we still retain access to them — how is this possible?</p><p>As it turns out, myDeskChair starts out as a blank object that we added the maxHeight and wheels properties to. Every object in JavaScript contains a hidden property called [[Prototype]]. This property contains access to an object’s prototype. When we created our desk chair, Object.create sets myDeskChair&#39;s hidden [[Prototype]] property to reference the myChair object as its value.</p><p>To find the “missing” properties on myDeskChair, we can access any properties on our object’s prototype using JavaScript’s <strong>prototype chain.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*19-r-bFrJEEn-SV0yP7VtA.jpeg" /></figure><p>When we attempt to access the width property from myDeskChair, JavaScript will check the myDeskChair object first. The width property is not found so JavaScript will lookup its prototype chain via myDeskChair‘s hidden [[Prototype]] property. It’s prototype is myChair – which JavaScript will search next and find that a width property exists. It will access and return the first width property it sees – enabling prototype properties further up the lookup chain that have the same name to be overridden.</p><p>At the top of the prototype chain lies the <a href="https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Object_prototypes">most basic prototype object</a> called Object.prototype. All objects will have this object as their prototype by default. Object.prototype does not have a prototype of its own and will return null if we attempt to access its prototype:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ieCe8jif6ewRAjityna6dA.jpeg" /></figure><p>This approach is known as <strong>prototypal inheritance</strong> or <strong>delegation</strong>. This is where newly created objects can delegate messages up its prototype chain to one of its prototypes, in order to retrieve the requested property or method. This keeps future objects small and efficient, containing only the necessary properties it needs that make it unique from other linked objects.</p><h3>Conclusion</h3><p>This Object creation pattern is known as <strong>OLOO or “Objects Linking to Other Objects”</strong>, which is at the heart of how objects really work in JavaScript. Historically speaking OLOO was introduced <em>after</em> the Pseudo-classical pattern, in an attempt to return to the true nature of JavaScript objects, prototypes and delegation.</p><p>The Pseudo-classical Object creation pattern however was the original way of creating objects in JavaScript and is a valid pattern in its own right. In Part 2, we will discuss the breakdown of how it works and how objects are secretly working behind the scenes!</p><p><a href="https://karistobias.medium.com/part-2-the-javascript-pseudo-classical-pattern-explained-with-pictures-70dfda6c6351">Continue to Part 2 of our discussion on JS OOP Patterns…</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34be175b7908" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 2: The JavaScript Pseudo-Classical Pattern Explained (with pictures)]]></title>
            <link>https://karistobias.medium.com/part-2-the-javascript-pseudo-classical-pattern-explained-with-pictures-70dfda6c6351?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/70dfda6c6351</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[pseudoclassical]]></category>
            <category><![CDATA[launch-school]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Fri, 11 Feb 2022 08:16:37 GMT</pubDate>
            <atom:updated>2022-02-17T22:25:01.661Z</atom:updated>
            <content:encoded><![CDATA[<p>In <a href="https://karistobias.medium.com/part-1-the-javascript-oloo-pattern-explained-with-pictures-34be175b7908">Part 1</a> we discussed the<strong> OLOO Pattern</strong>: Objects Linking to Other Objects in JavaScript. We learned that objects aren’t created from classes, but rather from other objects called <strong>prototypes</strong>. Prototypes can then receive “requests” from objects at the bottom of the prototype chain in order to store common data and behaviour. Once prototypes are understood, OLOO can be a very simple and dynamic pattern to create objects with.</p><p>The predecessor to OLOO is the <strong>Pseudo-classical pattern</strong>. It is known to be a more complex system, where constructor functions and prototypes work together to create objects.</p><p>Now you might be wondering why a more complex pattern precluded the OLOO pattern. <a href="https://www.youtube.com/watch?v=hQVTIJBZook&amp;t=1511s">Douglas Crockford</a> — an ongoing influencer in the development of JavaScript — explains there were many mixed feelings about JavaScript’s prototypal nature. This was due to the fact that all popular languages featured the “classical approach” — classes creating objects (as demonstrated in our Ruby example in <a href="https://karistobias.medium.com/part-1-the-javascript-oloo-pattern-explained-with-pictures-34be175b7908">Part 1</a>).</p><p>There are a couple of key items that class-based languages often represent:</p><ol><li>Some sort of <strong>constructor function</strong> for creating objects</li><li>A <strong>new keyword</strong> which initializes the creation of a new object</li></ol><p>To keep the syntax familiar, the first release of JavaScript (ES1) used constructor functions and the new keyword to create objects. Under the hood however lies JavaScript’s true nature: a system of objects and prototypes secretly linking up to each other.</p><h3>Constructor Functions, Prototypes and Objects</h3><p>To explain how this all works lets go back to our myChair object we created in <a href="https://karistobias.medium.com/part-1-the-javascript-oloo-pattern-explained-with-pictures-34be175b7908">Part 1</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*Aagll_2G91c9tqBBKB8ZEA.png" /><figcaption>the myChair object</figcaption></figure><p>Firstly, below is an object literal that produces a simple chair like the above:</p><pre>let myChair = {<br>  width: 50,<br>  minHeight: 45,<br>};</pre><p>And here is the pseudo-classical approach to creating the same chair:</p><pre>function Chair(width, minHeight) {<br>  this.width = width;<br>  this.minHeight = minHeight;<br>}</pre><pre>let myChair = new Chair(50, 45);<br>myChair;                           // { width: 50, minHeight: 45 }</pre><p>Based on this code we can come to some conclusions:</p><ul><li>The Chair function is invoked with the new operator, which turns an ordinary function into a ‘constructor function’ (we will explain constructors later). Constructors are typically <strong><em>capitalised </em></strong>to differentiate themselves from normal functions and other variables.</li><li>Within the Chair constructor this sets width and minHeight properties to itself, and assigns passed-in values to these new properties (again this will be explained later).</li><li>An object is returned from the method as indicated on the last line when we reference the object assigned to myChair —it returns the same value as our object literal.</li></ul><p>Okay… this <em>kind of</em> explains what’s happening with a constructor ‘instantiating’ an object, but what about Pseudo-classical <strong>inheritance</strong>? Does our myChair object <em>inherit </em>from anything?</p><p>Actually it <strong>does</strong>! But to explain inheritance we must first understand that…</p><blockquote><strong>All functions are objects — they have properties and methods just like regular objects!</strong></blockquote><p>Functions are actually objects! Now that we know this, we can finally understand how Pseudo-classical inheritance works:</p><p>Our Chair constructor function —actually all functions for that matter — have a special property called the <strong>prototype property</strong> that references...yup you guessed it — <em>a prototype object. It’s called </em><em>Chair.prototype</em>.</p><pre>typeof Chair.prototype;    // &quot;object&quot;</pre><p>This Chair.prototype object <strong>supports prototype-based inheritance in JavaScript</strong>. The myChair object produced from our Chair constructor function will reference this Chair.prototype object in its own hidden [[Prototype]] property:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V3ZQNOabmV6YYwiwxrY-ig.jpeg" /><figcaption>under the hood of a constructor, JavaScript implements prototype-based inheritance</figcaption></figure><p>Now you might be wondering, “why would JavaScript go through all this trouble just to link two objects together using a constructor function?!” It was to make JavaScript <em>feel </em>more approachable to programmers who were more familiar with class-based programming. Hence why this pattern is called <strong><em>Pseudo</em></strong>-classical. <strong>JavaScript <em>is</em> and always has been a <em>prototype-based language.</em></strong> It has no true classes of its own, and can only use objects and prototypes to perform prototype-based inheritance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*TDgBz8ZoosDYPJrC8Eet0A.jpeg" /><figcaption>the myChair prototype chain</figcaption></figure><p>Please note that <strong>a constructor function’s </strong><strong>prototype property and an object’s hidden </strong><strong>[[Prototype]] property are two different things. </strong>In this example however they both reference the same object — Chair.prototype. And as we learned in <a href="https://karistobias.medium.com/part-1-the-javascript-oloo-pattern-explained-with-pictures-34be175b7908">Part 1</a>, all objects by default have Object.prototype — the most basic object — as their prototype.</p><h3>The 5 Steps of JavaScript Constructors</h3><p>Lets now have a closer look at how the constructors work, using our Chair example. If we remember our Pseudo-classical implementation from before:</p><pre>function Chair(width, minHeight) {<br>  this.width = width;<br>  this.minHeight = minHeight;<br>}</pre><pre>let myChair = new Chair(50, 45);</pre><p><strong>When </strong><strong>new Chair(50,45) executes, the following happens:</strong></p><ol><li><strong>Chair becomes a <em>constructor</em> and creates a new blank object:<br></strong>There’s nothing special about this blank object — think of it as a plain old empty object {}.</li><li><strong>The blank object’s hidden</strong><strong>[[Prototype]] property is set to reference the </strong><strong>Chair.Prototype object:<br></strong>As mentioned before, this is so our chair object can now receive <em>prototype-based inheritance.</em></li><li><strong>The execution context (</strong><strong>this) is set from the global object to the blank object:<br></strong>Because the Chair invocation had no explicit caller, by default this references the <em>global object instead of our blank object. </em>Before we can assign properties to our blank object, this must first point to it.</li><li><strong>Execute the function to add properties to the chair object:<br></strong>Our constructor function is finally executed, and all code within the definition runs. In this case, both passed-in arguments width and minHeight are assigned to properties of the same name, and set to our new chair object.</li><li><strong>The new chair object is returned from the </strong><strong>Chair constructor function:<br></strong>By default, constructors will implicitly return the object created in step 1, unless an explicit return is used to return some other object.</li></ol><p>The below animation shows how all 5 steps of constructors work:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*rJT6QxBI7H8-G43YStOC6A.gif" /></figure><h3>Setting Behaviours to Pseudo-classical Objects</h3><p>Now that you understand how constructors really work — congratulations! It is no small task!</p><p>There is just one final part of the Pseudo-classical pattern we have to discuss, and that is where <strong>prototypal inheritance comes into play</strong>.</p><p>Say we wanted to make 2 chair objects: myChair and anotherChair , each with different width and minHeight properties. These properties differ from one chair object to another so it makes sense to keep these differences on each object:</p><pre>function Chair(width, minHeight) {<br>  this.width = width;<br>  this.minHeight = minHeight;<br>}</pre><pre>let myChair = new Chair(50, 45);<br>let anotherChair = new Chair(40, 60);</pre><pre>myChair;                        // { width: 50, minHeight: 45 }<br>anotherChair;                   // { width: 40, minHeight: 60 }</pre><p>But what about <strong>properties that remain the same for all chair objects?</strong></p><p><strong>Behaviours are usually common amongst objects of the same type. </strong>Say for example, all Chair objects had the ability to be folded and put away. We could create a fold method like so:</p><pre>function fold() {<br>  console.log(&#39;chair folded!&#39;);<br>}</pre><p>Great! Now that we have a fold function how do we attach it to all of our chair objects?</p><p>We could pass this function object to the constructor and assign it like the other properties, e.g. this.fold = fold;. However this would cause unnecessary duplication, as each chair object would hold the exact same method. As we learnt in <a href="https://karistobias.medium.com/part-1-the-javascript-oloo-pattern-explained-with-pictures-34be175b7908">Part 1</a>: <strong>objects should keep only what remains unique to them and delegate common data to their prototype.</strong></p><p>So that’s exactly what we will do! We can add our fold function as a method to Chair.prototype — the prototype of all chair objects:</p><pre>Chair.prototype.fold = function() {<br>  console.log(&#39;chair folded!&#39;);<br>}</pre><p>Now if either chair object — or any future chair object for that matter — should invoke their fold method it is found on their prototype chain within the Chair.prototype object. It is accessible via each chair’s hidden [[Prototype]] property:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*JXI918smRQbPLUBZqof0_g.jpeg" /><figcaption>chair objects inherit the fold() method from their prototype</figcaption></figure><h3>Conclusion</h3><p>Phew! There is a lot involved when it comes to the OLOO and Pseudo-classical object creation patterns — so I’m glad you stuck it out to the end!</p><p>Here are some important points to remember about Object creation in JavaScript:</p><ul><li><strong>JavaScript is an object-oriented programming language in the purest sense</strong>: it has no classes of its own, and simple objects can become working prototypes for other objects</li><li><strong>JavaScript supports prototype-based inheritance</strong>: inheritance can only be performed using objects and prototypes. Anything else that claims to look like inheritance is just objects working under the surface</li><li><strong>Objects delegate shared, common properties to their prototypes using a prototype chain</strong>: this way, objects only contain the necessary properties that makes them unique, keeping them small and efficient</li></ul><p>I hope you found this pair of articles insightful and thank you so much for taking the time to read it. Happy studying!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=70dfda6c6351" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScript Closures: A Mental Model]]></title>
            <link>https://karistobias.medium.com/javascript-closures-a-mental-model-66b7a9f02781?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/66b7a9f02781</guid>
            <category><![CDATA[launch-school]]></category>
            <category><![CDATA[closures-functions]]></category>
            <category><![CDATA[how-to-study]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[programming-tips]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Sun, 15 Aug 2021 06:07:02 GMT</pubDate>
            <atom:updated>2021-08-15T06:07:02.148Z</atom:updated>
            <content:encoded><![CDATA[<p>Whilst I’ve been studying JavaScript at <a href="https://launchschool.com/">Launch School</a>, I came across a fantastic mental model the school created on how closures work. Because the metaphor is very visual it inspired me to draw a little comic that illustrates their explanation. Enjoy!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Hr7NK9J-74rv4_TRSTAxag.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66b7a9f02781" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programming Concepts: How to Make Them Stick]]></title>
            <link>https://medium.com/launch-school/programming-concepts-how-to-make-them-stick-f43f6247fd67?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/f43f6247fd67</guid>
            <category><![CDATA[launch-school]]></category>
            <category><![CDATA[how-to-study]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[memorization]]></category>
            <category><![CDATA[ruby]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Sat, 20 Mar 2021 01:17:51 GMT</pubDate>
            <atom:updated>2021-03-20T03:12:29.681Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*Au3ZhKlOFnnFlC38KzcknQ.png" /></figure><p><em>Please note: The following technique is not for everyone. It can be of tremendous help for a visual learner like myself, but it’s not meant to replace any study method that already works for you. If you find however that traditional study methods aren’t really your thing — feel free to read on.</em></p><p>When we’re learning something new — particularly something as abstract as programming — we’re often going to bump up against unfamiliar concepts that are quite difficult to remember. Take for example the Symbol#to_proc method I learned from <a href="https://launchschool.com/course_catalog">Launch School’s Ruby course RB130:</a></p><p>The Symbol#to_proc method is not exactly a straight-forward concept to grasp. Consider the code block below:</p><pre>[1, 2, 3].map(&amp;:to_s)<br>=&gt; [&quot;1&quot;, &quot;2&quot;, &quot;3&quot;]</pre><p>If we were to break down how (&amp;:to_s) works, it would go something like this:</p><ul><li>Ruby first looks to see if the object behind&amp; is a ProcObject.</li><li>If it is a Proc object, &amp; converts the proc into a block. The block can then be passed into the Array#map method as an argument and be executed.</li><li>If the object isn’t a Proc, Ruby tries to call the #to_proc method on the object.</li><li>:to_s is not a Proc — it’s a Symbol, which happens to have it’s own Symbol#to_proc method.</li><li>The Symbol#to_proc method converts the Symbol :to_s into a Proc object for you.</li><li>&amp; can now convert the new Proc object into a block and the method Array#map can finally execute the block.</li></ul><p>Phew! It’s a bit confusing isn’t it? How might we go about remembering all the intricacies of these steps — in that order?</p><p>Well, we <em>could </em>try the brute force approach by applying rote learning techniques — repeating the concept over and over in our heads until one day it sticks. This does work of course — but it’s not necessarily the most <em>effective </em>way of memorizing how our Symbol#to_proc method works. At least not by itself.</p><p><a href="http://www.learning-knowledge.com/Neuroscience.html">According to neuroscientist John Medina</a>, <strong>pictures </strong>can supercharge our ability to recall information:</p><blockquote><em>“Text and oral presentations are not just less efficient than pictures for retaining certain types of information; they are way less efficient. If information is presented orally, people remember about 10 percent, tested 72 hours after exposure. That goes up to </em><strong><em>65 percent</em></strong><em> if you add a picture.”</em></blockquote><p>65 percent?! Can you imagine how this impacts our ability to memorize all kinds of complex programming concepts?</p><p>Medina goes onto explain: “One of the reasons that text is less capable than pictures is that the brain sees words as lots of tiny pictures.”</p><p>This idea of pictures supercharging text is nothing new. It’s why movies, animations and comics are so engaging. It’s why really great storytelling stays with us; because we form pictures in our heads of what’s happening. This is “learning by association” in action<em> </em>— using pictures to associate more complex ideas. Could this be applied to complicated programming concepts too? And if so, how do we do it?</p><p>The answer here lies in <a href="https://www.amazon.com/Unlimited-Memory-Advanced-Strategies-Productive-ebook/dp/B00I3QS1XQ">memory master Kevin Horsley’s book: <em>Unlimited Memory</em></a><em>. </em>Horsley<em> </em>indicates that we can use our <em>creativity and imagination</em> to associate easy-to-remember pictures with abstract concepts.</p><p>Let me show you one way we could do this using our Symbol#to_proc method.</p><p>First, lets think about what’s happening here. How can we tell a story about this sequence of steps?</p><p>Perhaps we could start off by creating some memorable characters that interact with each other. Let’s see… we could have a ruby, A proc object, a block, a symbol, an &amp; and the Symbol#to_proc method:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*wnRIf7fRS0r8pHtlWADm4g.png" /></figure><p>Now “&amp;” is already abstract in nature and therefore less memorable for our brain to hold onto, so I’ve swapped it out for an “ant”. They don’t sound too different from each other and it’ll help make the concept stick better. A method is also pretty abstract, so in my mind a method conjures up the image of a cog in a machine. A proc is also another hard-to-grasp concept so I thought of a fiery rock — a pyro rock (or a proc!). The rest of the characters should be self explanatory.</p><p>Now we can explain how the steps work in the Symbol#to_proc method:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*R5Xegss3BPbiRr-0VarCVQ.png" /></figure><ol><li>Ruby will first look to see if the object behind &amp; (ant) is a Proc object.</li><li>If it is, the &amp; (ant) converts the Proc into…</li><li>…a block!</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*5VHj6j8SZeVDB9aB1jkyzA.png" /></figure><p>4. If the object isn’t a Proc— in this case its a Symbol — Ruby calls the Symbol#to_proc method.</p><p>5. Once called, the Symbol#to_proc method will then convert the Symbol …</p><p>6. …into a Proc object for us!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*R5Xegss3BPbiRr-0VarCVQ.png" /></figure><p>7. The newly created Proc object now sits behind the &amp; (ant).</p><p>8. Now&amp; (ant) can finally convert it into…</p><p>9. …a block, ready to be executed!</p><p>And there we have it! Granted, It’s a completely different way of memorizing that involves a little bit of creativity on our end, but the payoff is huge. When we combine wacky characters with a story-telling component, we form strong, memorable mental pictures of how tricky concepts work.</p><p>I understand not everyone is comfortable with drawing pictures — and that’s perfectly okay. Horsley explains you can use Clipart instead of drawings. You can even write down your stories if you wish. The point here is that <strong>you can make hard-to-grasp concepts 65% more retainable with pictures</strong> than just plain text alone. And for anyone that’s ever wanted to learn something well — this is terrific news.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f43f6247fd67" width="1" height="1" alt=""><hr><p><a href="https://medium.com/launch-school/programming-concepts-how-to-make-them-stick-f43f6247fd67">Programming Concepts: How to Make Them Stick</a> was originally published in <a href="https://medium.com/launch-school">Launch School</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comic: A Very Basic Explanation of How the Internet Works]]></title>
            <link>https://medium.com/launch-school/comic-a-very-basic-explanation-of-how-the-internet-works-db4f67252a14?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/db4f67252a14</guid>
            <category><![CDATA[how-to-study]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Tue, 02 Mar 2021 21:23:14 GMT</pubDate>
            <atom:updated>2021-03-03T22:18:14.790Z</atom:updated>
            <content:encoded><![CDATA[<p>Here’s a comic I put together that covers just the basics of how the internet delivers a webpage to your computer. It attempts to be more fun and memorable than it is technical. For the sake of simplicity I have left out a number of topics (models, TLS etc) that were covered in LS170. Enjoy!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*e-domHWTXS-uvFwGBwgWZw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db4f67252a14" width="1" height="1" alt=""><hr><p><a href="https://medium.com/launch-school/comic-a-very-basic-explanation-of-how-the-internet-works-db4f67252a14">Comic: A Very Basic Explanation of How the Internet Works</a> was originally published in <a href="https://medium.com/launch-school">Launch School</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sailing Through PEDAC: the Left & Right Brain Approach]]></title>
            <link>https://karistobias.medium.com/sailing-through-pedac-the-left-right-brain-approach-66a4a9519b1f?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/66a4a9519b1f</guid>
            <category><![CDATA[neuroscience]]></category>
            <category><![CDATA[pedac]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[launch-school]]></category>
            <category><![CDATA[problem-solving]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Mon, 23 Nov 2020 00:14:44 GMT</pubDate>
            <atom:updated>2021-03-18T00:11:51.151Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DtjwlY_ZcbNN41po" /><figcaption>Photo by <a href="https://unsplash.com/@sonjalangford?utm_source=medium&amp;utm_medium=referral">Sonja Langford</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A long time ago, there were two sailors — one hailed from Europe and the other a native from the isles of Truk. Both were skilled men with the ability to safely sail a small boat through the vast Pacific Ocean, from one island to the next. However, the way each sailor went about this task was completely different.</p><p>Prior to leaving the shore, the European sailor would first chart a course in latitude and longitude, and then estimate his time of arrival at each point in the journey. Once his plan was devised, all that was left was to carry out each step until he arrived at his chosen destination. To make sure he stayed on course, the European would utilise all the tools available to him — such as a map, compass, and sextant to name a few. His movements were extremely precise and he always knew where he was going.</p><figure><img alt="An island" src="https://cdn-images-1.medium.com/max/1024/0*eYUjJtzhgim9JAp8" /><figcaption>Photo by <a href="https://unsplash.com/@marekokon?utm_source=medium&amp;utm_medium=referral">Marek Okon</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>The native Truk however had no need for a plan, and instead began his journey by picturing his destination in relation to the surrounding islands. While sailing, he’d repeatedly adjust his direction based on his current position. Each decision made was in the moment and dependent on the relative positions of the sun, landmarks and wind direction. The Trukese used relativity to navigate the seas from where he began, where he currently was, and where he needed to go next. Although he was sailing without European instruments, his process was both fluid and too complex to be put into words.¹</p><p>Now, you might be wondering how this story relates to Launch School’s PEDAC problem-solving approach. But before I can answer this, I will first need to explain the story’s underlying concept.</p><h3>The Two Brains</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1Vqj-KPnrCspeq-RrN9NWA.jpeg" /><figcaption>Creator: BlueLela | Credit: Getty Images/iStockphoto</figcaption></figure><p>Each sailor represents two kinds of thinking our brain adopts. The European sailor thinks in logical, linear, analytical terms — commonly known as ‘left-brain thinking’. And then there’s the native Trukese, who embraces a more spatial, non-linear, intuitive approach, also known as ‘right-brain thinking’.²</p><p>While there has been <a href="https://www.npr.org/sections/13.7/2013/12/02/248089436/the-truth-about-the-left-brain-right-brain-relationship">much debate about where these two types of thinking are located in the brain</a>; what I’m more interested in is how we can use the two-brain idea to inform our understanding of how to use PEDAC.</p><h3>What is PEDAC again?</h3><p><a href="https://launchschool.com/lessons/85376b6d/assignments/2c1146ee">PEDAC </a>is introduced by Launch School as a problem-solving process that can help programmers code with intention. In particular, it helps to solve more complicated programming problems that cannot be solved at first glance. It is a tool that saves time and counters the ‘hack and slash approach’ — which can often lead to fatigue, frustration and countless hours of trial and error.</p><p>The PEDAC acronym consists of a series of steps which stands for:</p><ul><li>Understanding the <strong>P</strong>roblem</li><li><strong>E</strong>xamples and test cases</li><li><strong>D</strong>ata Structure</li><li><strong>A</strong>lgorithm</li><li><strong>C</strong>ode</li></ul><p>It is worth noting that the first five letters — PEDA — involve the planning stage of the problem-solving process. Whereas the last letter — C — is the only actual step where coding takes place.</p><h3>Left Brain Thinking</h3><p>Returning to our sailor analogy — just like PEDAC, the European’s navigation strategy requires a lot of planning prior to execution. All of his actions are intentional and flow in a linear, analytical, logical sequence with tools assisting him towards the final destination.</p><p>PEDAC stops us getting lost in a sea of confusion, by providing the necessary structure and problem-solving tools to get to the solution. You first understand the problem by gathering inputs, identifying problem domains, examining requirements, asking questions and finally putting together a mental model. This leads to testing examples, structuring your data and eventually writing an algorithm for coding.</p><p>If we were to imagine a mental model of the PEDAC process it would look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/1*2PQpCRTKTTRlZXevBY3bnA.png" /></figure><p>So at this point it would seem that we only need to use our left brains to solve a programming problem with the help of PEDAC. There’s no use for right brain thinking…right?</p><p>Think again.</p><h3>Right Brain Thinking</h3><p>As the story suggests, it is difficult to put into words how the Trukese navigated without the use of instruments. His process was based on improvisation relative to where he was currently situated.</p><p>Right-brain thinking naturally appears more complex because it does not contain the language centres of the brain³. It is without words, yet it understands spatiality, relativity, imagination and unity.⁴</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gMah0VB24CE9A1qE" /><figcaption>Photo by <a href="https://unsplash.com/@ilyapavlov?utm_source=medium&amp;utm_medium=referral">Ilya Pavlov</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Does this even play a part in the PEDAC process? Actually in many ways it does. Think about when you begin writing your code (after writing your algorithm) and when testing for an expected return value, you find a bug. This bug wasn’t part of your plan, so what do you do now?</p><p>You can’t “sail around” this bug — like the Trukese, you’ll need to adapt to the situation, by checking where you are in the code and adjusting your direction accordingly. Debugging utilises right brain-thinking. We look for patterns and differences — something that just doesn’t add up. We look at the parts relative to one another and the sum as a whole.</p><p>Right brain thinking also features in how we use the PEDAC process to solve a programming problem. It’s easy to assume that being an acronym, PEDAC should be used in a linear fashion — where we first complete the P then the E, D, A and finish with C. This is often not the case.</p><p>From my observations of others and my own application of the process, while PEDAC appears to look like a linear structure (left brain), the way we actually utilise it is often non-linear (right brain).</p><p>So if we were to update our mental model of how PEDAC is actually traversed it could look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/1*s6ZAdqtz1THoRA_7orQSuA.png" /></figure><p>PEDAC in this light is not as linear and chronological as we thought. When solving a more difficult problem we might first start with P then move to A, then to E, and back to P again and so on. How then can we rely on a structure that might require a lot of jumping around?</p><h3>PEDAC Problem Solving: a Left &amp; Right Brain Approach</h3><p>Rather than imagining PEDAC as a single word, we might be better off appreciating each letter as a stand alone object, complete with its own logical structure and analytical behaviour. Each letter can then be considered a left brain process.</p><p>There is no guarantee of the final order of PEDAC when problem-solving, as one problem might need to be solved in this way: PPPPEADACAC, whereas another might be more straight forward like this: PAC. This means the way we navigate PEDAC is situational and relative to the problem — which is considered to be more right brain thinking.</p><p>In truth, we need both parts of our brain to make the most of PEDAC. Without the logical structure of each letter, we could be forever recalibrating to find the right path, which could borderline as a hack and slash approach. And without the freedom to rearrange each letter in relation to the problem, PEDAC would become too rigid and unadaptable to more complicated problems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Rxi0EZZUQoAV0s5g" /><figcaption>Photo by <a href="https://unsplash.com/@ferrez?utm_source=medium&amp;utm_medium=referral">Stefano Ferretti</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Although the two sailors in our story never had the chance to amalgamate their left and right brain approaches — we can imagine how effective it would be to merge their two styles together. Fortunately in present day programming, and with a little help from PEDAC, we are able to combine the best of left and right brain thinking, and know what it feels like to truly code with intention.</p><p><strong>References:</strong></p><p><strong>1.</strong> J.A. Paredes and M. J. Hepburn, Vol 17, 1976 . “The Split-Brain and the Culture-Cognition Paradox,” in <em>Current Anthropology. </em>The University of Chicago Press</p><p><strong>2,4.</strong> Edwards, B., 2016. <em>Drawing On The Right Side Of The Brain</em>. London: Souvenir.</p><p><strong>3.</strong> Taylor, J., 2008. <em>My Stroke Of Insight</em>. New York, N.Y.: Penguin Audio.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66a4a9519b1f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When am I ready to take Launch School’s 109 interview?]]></title>
            <link>https://karistobias.medium.com/when-am-i-ready-to-take-launch-schools-109-interview-3ef7e9a6be26?source=rss-e515462b1ed0------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ef7e9a6be26</guid>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[launch-school]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[study]]></category>
            <category><![CDATA[problem-solving]]></category>
            <dc:creator><![CDATA[Karis Tobias]]></dc:creator>
            <pubDate>Sun, 15 Nov 2020 05:51:36 GMT</pubDate>
            <atom:updated>2020-11-15T06:39:49.977Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ddszWD6YT52T3WnK" /><figcaption>Photo by <a href="https://unsplash.com/@bermixstudio?utm_source=medium&amp;utm_medium=referral">Bermix Studio</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>Disclaimer:</strong> What follows below is my own personal journey of preparing for the interview and may not reflect the experience of others. It’s a more brute force, leave-no-stone-unturned approach that might not work for everyone. That being said, if you are someone who errs on the side of caution and/or has a deep desire to master the basics — then read on.</p><p>While I found the interview surprisingly less difficult than I thought it would be, the hours leading up to it and all the study I had put in weeks before were nothing short of hard work. Hindsight is always 20/20, so I decided to gather my thoughts for the next person who’s unsure about the interview.</p><p><strong>So when are you actually ready?</strong> The short answer is — it depends. Are you a beginner? Intermediate? Advanced? Are you naturally confident? Or do you second guess yourself? For a beginner programmer like me with an anxious temperament on a mission for mastery; I knew I’d be studying for an interview like this for quite some time. And although the stress I put myself through in the lead up to it wasn’t worth it, there were some practices that I stand by and will use again for upcoming assessments. And here they are…</p><h3>Study tips for the 109 interview:</h3><ul><li><strong>Practice and re-practice: </strong>When it comes to practice, I finished the<a href="https://launchschool.com/exercises"> small problem exercises</a> that Launch School provides, and then went on to solve other code problems too. There’s a<a href="https://docs.google.com/document/d/1WVxV5LeGCeVdR1n-cMNdl7Rwr-avKanXoihpK9YoYkE/edit?usp=sharing"> big list of questions</a> floating around out there that showcases all kinds of problems you might potentially need to solve. In addition to solving lots of problems, what also prepared me for the interview was finding more than one way to solve a single problem. There was a noticeable breakthrough moment when I found myself able to fly through solutions that once took hours to figure out. This is a great indicator for being ready for the interview.</li><li><strong>Take note of great solutions: </strong>You don’t need to reinvent the wheel, when there are already wheels rolling around out there! Solving problems is necessary and all that, but do not underestimate the power of taking an existing solution and breaking down WHY it works. I did this for a bunch of solutions in<a href="https://www.codewars.com/"> Code Wars</a> (those elegant one-liners you see on the solutions page), and with Launch School exercises. By exposing yourself to all kinds of solutions, you expand your repertoire and have a bigger set of tools at your disposal for problem-solving. Peers can give you examples on how they solve code too, which brings me to my next bullet point…</li><li><strong>Buddy up with students live: </strong>In a <a href="https://medium.com/@karistobias/what-to-expect-from-launch-schools-rb109-written-assessment-e108138d3cee">previous post</a> I mentioned I am not the most social person, especially whilst studying. But this was one of the things that I’d consider MANDATORY. A few kind souls took the trouble to patiently sit behind their computers and watch me sit in silence with no idea how to solve the problem in front of me. Gosh it was painful and embarrassing — but 100% necessary. To know that I had no clue how to solve a problem made me very aware of how much more study I needed. Trust me — you do not want to wait for the interview to face a situation like this. Put out a comment over student chat when you feel ready enough to solve problems in front of others.</li><li><strong>Attend at least 1 study review with a TA: </strong>Attending a session with a TA was great for simulating battle-like conditions. Although I was given easier problems to solve than that of the interview, your solution is still timed and examined by a TA. This was great for tightening up algorithms so they’re all ready to be coded up in your chosen language.</li><li><strong>Think out loud: </strong>Since you will be graded on your verbal communication with the interviewer, I strongly advise to get into the habit of thinking out loud. And I don’t mean just while you’re coding. Think out loud in front of your friends, partner, siblings, parents, peers, pets — whoever! It doesn’t matter. As long as you get comfortable with explaining why you do what you do, you’re going to make it A LOT easier for the person on the other end of the call.</li></ul><blockquote><em>In my interview I accidentally gave a confusing name to a variable. Afterwards, my instructor commented that “had you not clearly explained what you were doing, I would have found your algorithm harder to understand”. Even though I made a mistake, I kept clarifying my code as I was talking, and he was never left behind.</em></blockquote><ul><li><strong>Make friends with PEDAC:</strong> When I was first introduced to PEDAC in RB101 — I didn’t get it. I found it long, repetitive, and all I wanted to do was just dive straight in — write an algorithm and code it up in Ruby. But when I was a bundle or nerves during the interview and all common sense left my body, PEDAC was a shining beacon of light when I was lost in the dark. More than just a framework, PEDAC always kept me on track towards an inevitable solution.</li></ul><blockquote>The interviewer kept up with my thought process with the help of PEDAC. He pointed out that having a mental model and data structure in particular helped clarify my solution towards the problem.</blockquote><p><strong>Whether you set out to do these tasks or not is not important.</strong> <br>What is important is being in touch with how prepared you <strong>actually</strong> are. Since Launch School is an online educational platform, you’re not physically surrounded by teachers and students — you’re on your own. And when you’re on your own, your judgement can get blurred by how you feel. If you feel over-confident you may go in under-prepared. And if you’re under-confident, you may never feel ready enough to take the test. The only way to remedy this — I found — is by connecting with others that can assess you along the way, find your blind spots, and make sure you solve all kinds of problems. That way there are no nasty surprises. Good luck!!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ef7e9a6be26" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>