<?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 Brett Schules on Medium]]></title>
        <description><![CDATA[Stories by Brett Schules on Medium]]></description>
        <link>https://medium.com/@brettschules?source=rss-ebc012b6bea1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*NwSxV2KLIZgo2j7-.</url>
            <title>Stories by Brett Schules on Medium</title>
            <link>https://medium.com/@brettschules?source=rss-ebc012b6bea1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 17:21:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@brettschules/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[JavaScript Symbol]]></title>
            <link>https://medium.com/@brettschules/javascript-symbol-4c4cdc5a4818?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c4cdc5a4818</guid>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Sun, 26 Nov 2017 17:32:40 GMT</pubDate>
            <atom:updated>2019-03-01T23:23:34.243Z</atom:updated>
            <content:encoded><![CDATA[<p>In ES2015 Javascript added an additional primitive data type know as a Symbol.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F11sBLVxNs7v6WA%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F11sBLVxNs7v6WA%2Fgiphy.gif&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2F11sBLVxNs7v6WA%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="196" frameborder="0" scrolling="no"><a href="https://medium.com/media/17e9f2dd491c9e6ce502bc06094b2fb1/href">https://medium.com/media/17e9f2dd491c9e6ce502bc06094b2fb1/href</a></iframe><p>Symbols are a unique and immutable data type which means once created, they reserve a unique place in memory. Just like fingerprints.</p><p>You can create a symbol by using the Symbol Object and pass in your arguments.</p><pre>var fingerprint = Symbol(&quot;a unique fingerprint&quot;)<br>console.log(fingerprint); <br>// Symbol(a unique fingerprint)</pre><p>Note that you cannot declare a symbol using the new keyword.</p><p>Object keys makes a perfect candidate to use symbols due to their uniqueness. This allows our key from being overwritten by someone else who might accidentally use the same key. For example, we can test this out by comparing two symbols to see if they are equal.</p><pre>var sym1 = Symbol(&quot;Hey&quot;);<br>var sym2 = Symbol(&quot;Hey&quot;);</pre><pre>sym1 === sym2 //false</pre><p>Let’s check out how we can bring all of this together to create an object using symbols as properties. First, we will create our dog object. Then, a symbol assigned to our breeds variable containing our description of ‘array of dog breeds’. Finally, we will assign our key an array of dog breeds for our dog object. Note that you must use brackets notation as using dot notation does not refer to our key.</p><pre>var dogs = {}</pre><pre>dogs[breeds] = [&quot;Labrador Retriever&quot;, &quot;German Shepherd&quot;, &quot;Bulldog&quot;, &quot;Beagle&quot;]</pre><pre>console.log(dogs[breeds])<br>//[ &#39;Labrador Retriever&#39;, &#39;German Shepherd&#39;, &#39;Bulldog&#39;, &#39;Beagle&#39; ]</pre><pre>console.log(dogs)<br>//{ [Symbol(array of dog breeds)]: [ &#39;Labrador Retriever&#39;, &#39;German Shepherd&#39;, &#39;Bulldog&#39;, &#39;Beagle&#39; ] }</pre><p>There you have it. I hope you learn as much as I did from this blog!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c4cdc5a4818" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web Sockets]]></title>
            <link>https://medium.com/@brettschules/web-sockets-80ba7dee0e6a?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/80ba7dee0e6a</guid>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Sat, 18 Nov 2017 23:37:47 GMT</pubDate>
            <atom:updated>2017-11-18T23:37:47.652Z</atom:updated>
            <content:encoded><![CDATA[<p>This blog about Web Sockets will be available soon!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80ba7dee0e6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CSS 3 Flexbox]]></title>
            <link>https://medium.com/@brettschules/css-3-flexbox-35fed0af0203?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/35fed0af0203</guid>
            <category><![CDATA[css]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Thu, 09 Nov 2017 00:17:11 GMT</pubDate>
            <atom:updated>2017-11-09T00:17:11.103Z</atom:updated>
            <content:encoded><![CDATA[<p>Can you imagine a world without CSS? Sure, we would still have functioning Web Applications that can complete their tasks, however they would just a skeleton of boring black and white web pages with words. This is where CSS or <strong>Cascading Style Sheets </strong>comes in to create layouts for web pages to create a more memorial experience for it’s users. In today’s world where a website can be view either on a desktop computer, smartphones, or tables; CSS 3 is a very powerful tool that allows us to adapt to user demands. The CSS 3 flexbox allows us to create web pages that are responsive to various devices. Let’s check it out!</p><p>In order to create a flexbox, we first need to give our class “container” the flex property so that it will enable the flex content for it’s child elements.</p><pre>.container {<br>   display: flex;<br>}</pre><p>Then, we can give it a property. For example, the flex-direction property allows you to specify the direction you want you child elements to be displayed in. The row value allows you to align your elements in ascending order that the child elements are created horizontally. Row-reverse aligns the elements in descending order. Column and column-reverse does the same thing as row and row-reverse except vertically.</p><pre>.container {<br>   display: flex;<br>   flex-direction: row | row-reverse | column | column-reverse;<br>} <br>Note: The flex-direction property take in one value at a time. The | is just to show multiple examples.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/1*GmTrf3U-3uhFs7wYw1uzUQ.png" /><figcaption>The layouts are in the following order row, row-reverse, column, column-reverse.</figcaption></figure><p>The justify-content property allows us to dictate how we want to place our elements on a webpage so they are spaced out evenly. Again, this allows our page to be responsive ensuring that it adjusts accordingly to the different screen sizes.</p><pre>.container {   <br>   justify-content: flex-start | flex-end | center | space-between |          <br>   space-around | space-evenly; <br>}</pre><p>Flex-start: elements are arranged toward the start line. Flex-end: elements are arrange toward to end line. Center: elements are centered along the line. Space-between: the first element is arranged to the start line, second element to the center, and third to the end line. Elements are evenly spaced in the line to take up the width of the page. Space-around: elements are evenly distributed in the line with equal space around them. Space-evenly: elements are distributed so that the spacing between any two items as well as the space from the start and end lines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/493/1*2Z86bLnsH7lONhVlV13ZsQ.png" /></figure><p>With the align-content property we can do the same things as the justify-content but vertically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*moagSYu4-M_kZ9Ufu6E54A.png" /></figure><p>There are many more useful properties that comes with the flex-box. Since it is almost midnight, I am not going to list them here and bore you even more. Rather check out this interactive fun game that allows you to play a game while you learn the CSS 3 flex box! <a href="http://flexboxfroggy.com/">http://flexboxfroggy.com/</a>. Also, a big thanks to Chris Coyier and his website for the graphics displaying the flex-box used in this blog. <a href="https://css-tricks.com/snippets/css/a-guide-to-flexbox/">https://css-tricks.com/snippets/css/a-guide-to-flexbox/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35fed0af0203" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScript Bind/Call/Apply]]></title>
            <link>https://medium.com/@brettschules/javascript-bind-call-apply-c180376bf71e?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/c180376bf71e</guid>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Sat, 04 Nov 2017 15:03:28 GMT</pubDate>
            <atom:updated>2017-11-04T15:03:28.906Z</atom:updated>
            <content:encoded><![CDATA[<p>If you ever worked with event listeners in JavaScript, then chances are that you used either bind, call, or apply. Those three methods are very powerful functions that can be used within objects to set the <em>this</em> value explicitly. The three methods are very similar in terms of how they operated with each methods being unique for different cases.</p><p>Here, we have an example of bind being used in the case of an event listener. In the bold text, we add an event listener of click, then pass on the callback function of onSubmit. However, the event is currently pointing to the DOM object which will return an error when the event is being called. This when we can explicitly tell the onSubmit that we want to point this function to our current object when App is initialize.</p><pre>class App {<br>    constructor () {<br>      this.textBox = document.querySelector(&#39;#todo-text&#39;)<br>      this.submitBtn = document.querySelector(&#39;button&#39;)<br><strong><em>      this.submitBtn.addEventListener(&#39;click&#39;, this.onSubmit.bind(this))</em></strong><br>      this.todoList = new TodoList()<br>      this.todoContainer = document.querySelector(&#39;.list&#39;)<br>    }<br>    onSubmit () {<br>      event.preventDefault()<br>      this.todoList.addTodo(this.textBox.value)<br>      this.textBox.value = &#39;&#39;<br>      this.render()<br>    }<br> }</pre><p>If this seems confusing at first, not to worry! Let’s look at a much more simplified example.</p><pre>var obj = {Pennsylvania: &quot;Harrisburg&quot;}</pre><pre>function stateAndCapitals(year, population ) {<br>  console.log(&quot;The capital of Pennsylvania is &quot; +this.Pennsylvania + &quot; which was founded in &quot; + year, &quot;and has a population of &quot;+ population + &quot;.&quot;)<br>}</pre><pre>var test = stateAndCapitals.bind(obj, 1812, 48,904)<br>test()<br>// The capital of Pennsylvania is Harrisburg which was founded in 1812 and has a population of 48,904.</pre><p>We have set the variable obj to an object containing the key and value of “Pennsylvania and Harrisburg. In our stateAndCapitals function, we print out “The capital of Pennsylvania is “ +this.Pennsylvania…etc. Note, this. Pennsylvania. <em>This </em>is pointing to our current object(which will be our obj variable later on) then we call our key from the object which give the value of Pennsylvania. Finally, in our test variable we bind the stateAndCapital to the obj variable so it will know where <em>this </em>is pointing to. Note that we call our test function at the end, this is due to bind not invoking the function immediately. Now what if we wanted it invoke our function at the same time we bound the function? This is where the call method comes in!</p><p>The call method is does the same thing as bind expect for invoking our function right away.</p><pre>stateAndCapitals.call(obj)<br>// The capital of Pennsylvania is Harrisburg which was founded in 1812 and has a population of 48,904.</pre><p>Finally, we have the apply method which just like out call method, however the apply method allows you to pass additional arguments in an array format. For example, passing in an array containing the elements “1812” and “48,904” will give you the same output as our bind and call methods.</p><pre>stateAndCapitals.apply(obj, [&quot;1812&quot;, &quot;48,904&quot;])<br>//// The capital of Pennsylvania is Harrisburg which was founded in 1812 and has a population of 48,904.</pre><p>There we have it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c180376bf71e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScript Async/Await]]></title>
            <link>https://medium.com/@brettschules/javascript-async-await-6a8ce52abb98?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a8ce52abb98</guid>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Sat, 28 Oct 2017 13:37:17 GMT</pubDate>
            <atom:updated>2017-10-28T13:37:17.910Z</atom:updated>
            <content:encoded><![CDATA[<p>For me personally, I think the Async/Await is of the most overlooked and useful function in Javascript. As the web becomes more reliant on making AJAX calls and the use of promises, Javascript has come a long way since the old days of using the messy XML HttpRequests to then function and now async/await. Let’s take a look at how the Async/Await functions work.</p><p>Async is used before a function which allows it to alway return a promise.</p><pre>async function test() {<br>  return &quot;Hello World&quot;;<br>}<br><br>test().then(console.log)</pre><p>Now let’s look at the await operator which makes JavaScript wait until that promise settles and returns its result. Note that the await operator can only be used inside the async function.</p><pre>function getMessage() {<br>  return new Promise((resolve, reject) =&gt; {<br>    setTimeout(() =&gt; resolve(&quot;Hey&quot;), 2000);<br>  });<br>}<br>async function start() {<br>  const message = await getMessage();<br>   console.log(message)<br>   console.log(&quot;Hello&quot;)<br>}</pre><pre>start().then(msg =&gt; msg);</pre><p>In the function getMessage(), it creates a promise with the string of “Hey” (we used the setTimout to stimulate the time it may take to return a list of promises). In the start function, we set a variable called message which will return the promise from the getMessage() function. Finally, we console.log our data of (“Hey”) and “Hello”). This returns the following console logs Hey and Hello in order as if the function was synchronous meaning the code was executed in sequential order.</p><p>Imagine if we did not use the async and await, then the start() function would executed asynchronously meaning the multiple things are running in the background at once. The getMessage() would be fired first however it will not run until two seconds later(stimulated the promise yet to be resolved), the next line of code is executed. The start function would instead console.log “Hello”, then “Hey” when the getMessage function is finally resolved.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a8ce52abb98" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sorting Algorithms]]></title>
            <link>https://medium.com/@brettschules/sorting-algorithms-e4dc01294d77?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4dc01294d77</guid>
            <category><![CDATA[sorting-algorithms]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Sat, 21 Oct 2017 14:46:45 GMT</pubDate>
            <atom:updated>2017-10-21T14:46:45.301Z</atom:updated>
            <content:encoded><![CDATA[<p>For the past few week, I’ve wanted to switch gears from Web Development to learn a more deeper topic which is computer science! One of the topics that I focused on learning are the different sorting algorithms commonly used and the time complexity of each one. In computer science, the <strong>time complexity</strong> of an algorithm quantifies the amount of <strong>time</strong> taken by an algorithm to run, This can be expressed in using the big O notation. We will get into more details later, but first let checkout the different sorting algorithms.</p><h3>Bubble Sort</h3><p>The first algorithm is the bubble sort which works by repeatedly steps through the list to be sorted, compares each pair of adjacent items and <a href="https://en.wikipedia.org/wiki/Swap_(computer_science)">swaps</a> them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FfdFQlt5A45jyw%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FfdFQlt5A45jyw%2Fgiphy.gif&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FfdFQlt5A45jyw%2F200.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="261" frameborder="0" scrolling="no"><a href="https://medium.com/media/1015cf00044a8d9cd7118b14ae10c118/href">https://medium.com/media/1015cf00044a8d9cd7118b14ae10c118/href</a></iframe><p>Let think about how we can implement this in code for if we want to sort an array from smallest to largest numbers. First, we would want to iterate through the array until all of the numbers are sorted. We iterate through the whole array comparing the two numbers together and if the first number is greater than the second number than we can simply swap the two. This will go on until all of the number in the array are sorted.</p><pre>const array = [5,3,40,20,100,33,6,7]<br>function bubbleSort(array) {<br>  let notSorted = true;<br>  <br>  while(notSorted) {<br>    notSorted = false;<br>    for(let i=0; i&lt;array.length; i++) {<br>      if(array[i] &gt;= array[i+1]) {<br>        array[i], array[i+1] = array[i+1], array[i];<br>        notSorted = true;<br>      }<br>    }<br>  }<br>  return array;<br>}</pre><pre>bubbleSort(array);</pre><p>Looking at our JS script algorithm above, we can see that we have two loops (while and for) which will take place as we iterate through the length of the array until it is sorted. As a result, we get a time complexity of O(n²) in the worst case scenario. Bubble Sort is consider to be one of the worst sorting algorithms in terms of performance. I think we can do better than that!</p><h3>Inersation Sort</h3><p>This algorithm is actually quite simple on paper. We simply iterate over the original array to find the current minimum value in the original array, remove it from the array, and insert into a new array. Rinse and repeat until there are no more elements left in the original array.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F26vIe36MKNH7Z8He0%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F26vIe36MKNH7Z8He0%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F26vIe36MKNH7Z8He0%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="248" frameborder="0" scrolling="no"><a href="https://medium.com/media/b15dc55cac8468b81284a9da802c0d1d/href">https://medium.com/media/b15dc55cac8468b81284a9da802c0d1d/href</a></iframe><pre>const array = [5,3,40,20,100,33,6,7];</pre><pre>function insertionSort(array){<br>  let newArray = [];<br>  while (array.length !==0) {<br>    newArray.push(findMinAndRemove(array))<br>  }<br>  return newArray;<br>}</pre><pre>function findMinAndRemove(array){<br>  let minNum = array[0];<br>  let index = 0;</pre><pre>for (var i = 0; i &lt; array.length; i++) {<br>    if(array[i] &lt; minNum) {<br>      minNum = array[i];<br>      index = i;<br>    }<br>  }<br>  array.splice(index, 1)<br>  return minNum;<br>}</pre><pre>insertionSort(array);</pre><p>In the Insertion Sort algorithm, we have two functions that takes in the array as an argument. In the insertionSort function we call the findMinAndRemove function which will allow us to return the minimum value from our original array and add it to the new array. The findMinAndRemove function works by iteration over all of the elements in the original array and comparing each element with the minNum placeholder. If it finds the minimum value of the array, then it reassigns the minNum placeholder with the new value. We return the new minNum variable containg the minimum value of the array after our iteration. The insertionSort will continue to call the findMinAndRemove function until there is nothing left in the original array which in that case we can exit out of the while loop to return our new array with the sorted elements! The time complexity of this is O(n²) in the worst case scenario. Still not quite ideal, lets move on…</p><h3>Merge Sort</h3><p>The merge Sort is one of the tricker algorithm due to it’s recursive call. The merge sort algorithm sorts a list in two main steps. First, it takes an unordered list and continue splitting the list into smaller and smaller subarrays until the subarrays each one element. Second, it couples up the neighboring lists and merge them together. While the merge operation only applies to sorted lists, when the list has only one element in it, it is automatically sorted.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F3ohhwyfwtPffFZHEw8%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F3ohhwyfwtPffFZHEw8%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F3ohhwyfwtPffFZHEw8%2F200.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="261" frameborder="0" scrolling="no"><a href="https://medium.com/media/9985a7e49be457cfdd2c78690c0007d7/href">https://medium.com/media/9985a7e49be457cfdd2c78690c0007d7/href</a></iframe><pre>const array = [5,3,40,20,100,33,6,7];</pre><pre>function mergeSort(array) {<br>  if (array.length &lt;2)<br>    return array;</pre><pre>let middlePoint = array.length/2;<br>  let firstSubarray = array.slice(0, middlePoint);<br>  let secondSubArray = array.slice(middlePoint, array.length);</pre><pre>return merge(mergeSort(firstSubarray), mergeSort(secondSubArray));<br>}</pre><pre>function merge(firstSubarray, secondSubArray) {<br>  let result = [];</pre><pre>while(firstSubarray.length &amp;&amp; secondSubArray.length) {<br>    if (firstSubarray[0] &lt;= secondSubArray[0]) {<br>      result.push(firstSubarray.shift());<br>    } else<br>      result.push(secondSubArray.shift());<br>  }</pre><pre>while (firstSubarray.length) {<br>    result.push(firstSubarray.shift());<br>  }</pre><pre>while (secondSubArray.length) {<br>    result.push(secondSubArray.shift());<br>  }<br>  return result;<br>}</pre><pre>mergeSort(array);</pre><p>Just like our Insertion Sort, this algorithm is split up into two parts. In the mergeSort function, we use recursion to split up our array into sub arrays. This is done by finding the middle point of the array’s length divided by two. The firstSubarray variable is from the starting element up until the middle point. The secondSubArray variable is from the middle point to the end of the array. This recursive call will continue to split our array until there is only one element in our array. At the same time it calls our mergeSort function.</p><p>In the mergeSort function, we compare first elements in the from the FirstSubarray and the secondSubArray to see which value is less than. Then, we can use the shift method to take out that element and use the push method to insert it into our new array. This continues until there is no elements left into the FirstSubarray or secondSubArray.</p><p>Calculating the time complexity for this algorithm is tricky since we have multiple steps. First, looking at mergeSort which splits the our array that has a length of 8, we divide this array by 2 three times(8/2 = 4/2 = 2/2 =1) until we are left with one element. This is a time complexity of log(n). Now factoring in our merge function which finds the smallest elements of our subarrays, this is n. Therefore overall this algorithm is n log(n).</p><p>Compare the big o of Merge Sort with that of Insertion and Bubble Sorts. Remember that Insertion and Bubble Sorts cost us n². Well in this example of sorting an array of eight elements n log n = 24 while n² = 64. Once we arrive at a size where n = 1000 then n² = 1,000,000 while n log n = 9,965. So when is one thousand selection sort takes over a hundred times longer than merge sort. That is significant!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4dc01294d77" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[High Level and Low Level Languages]]></title>
            <link>https://medium.com/@brettschules/high-level-and-low-level-languages-62776d0b89f0?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/62776d0b89f0</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Thu, 12 Oct 2017 22:45:36 GMT</pubDate>
            <atom:updated>2017-10-12T22:45:36.333Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*66CzIufgBdxUo9OcUHZT3w.jpeg" /></figure><p>There are two categories of programming languages, high level and low level. It can be debatable which level goes in which category but the general rule is that it depends on how similar the language is to the only language a computer understands such as machine code (We’ll talk more about machine code later). High level programming languages are ones most developers are familiar with: Java, Ruby, C++, Javascript, etc. A<strong> high level programming language</strong> is a language that allows you to tell a computer to do something, but in a syntax that is easy and intuitive for you to understand. It is a totally different language from what a computer understands.</p><p>Compared to a <strong>low level programming language</strong> is only a slight abstraction from machine code (if any abstraction at all). It’s much less human readable, yet easier and faster for the computer to understand. It also takes much less memory than a high level language due to less abstractions from machine code compared to high level languages. The most common low level languages are assembly languages. Low level languages work by grouping variations of symbols and letters to represent different aspects of the machine code. They use an assembler to convert the assembly language to machine code. You can think of the assembler as a dictionary. In a dictionary, you can look up a word and find the meaning. Just like a dictionary, an assembler can “look up” assembly codes and return the “meaning” or machine code.</p><p>Let’s say machine code is the Mandarin language, and it’s the only language a computer can understand. A high level language is like speaking to the computer in Mandarin, while a low level language is like speaking to it in Pig Latin. It is much easier for the computer to understand low level Pig Latin, which is very similar to English, than it is for it to understand high level Mandarin. Regardless, a computer only understands machine code (or “English”), and needs any language that’s not machine code to be either complied into machine code or interpreted (translated).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*sHrAi0uqCXwrGyuxqSYgPw.png" /></figure><p><strong>Complied vs Interpreted Languages</strong></p><p>While low level assembly languages are understood by converting the language to machine code using an assembler, most high level languages are understood by using either a complier or interpreter. We’ll start with interpreted languages first since they have a different process than complied or assembly languages.</p><p><strong>Interpreted languages</strong> are not converted to machine code. Instead, any program (or source code) written in these languages are directly read line by line by an interpreter. An interpreter is a computer program that executes the actions in the source code in a similar way that a computer can execute machine code. Using an interpreted language allows for faster coding and testing because it can run and give results immediately, unlike compiled languages. What’s also good about these languages is that it can be used on multiple platforms and operating systems since it is not converted to machine code, which is often computer-specific. A disadvantage is that, since it always interprets the code as the code is executed, it can make it much slower than using a compiled language. Python, Perl, and Ruby are popular examples of interpreted languages.</p><p>Then there are compiled languages. <strong>Compiled languages</strong> have to go through a compiler before they are executed. The compiler converts the program into machine code so that it can be understood by the computer. Java, C++, and C# are popular compiled languages. The benefit of compiled languages are that once compiled, they tend to run much faster than interpreted languages. Compiling only has to be done once, then a program can run many times. Interpreted languages on the other hand are consistently being read and can therefore be slower. Another benefit is that, since it is complied, it doesn’t reveal any source code, which means people can’t see or copy your code. A downfall is that they usually don’t work across platforms. A program that runs one way on a Mac doesn’t run the same way on a PC. This is why when you go to download applications on the internet, they have an option to download for Mac OS X or Windows.</p><p><strong>From the Complier, to Machine Code, to the Processor</strong></p><p>After the compiler (or assembler) converts the high level language to machine code, the computer is ready to execute actions. To understand how the processor of the computer (also known as the Central Processing Unit or CPU) reads machine code, you first need to understand what machine code is.</p><p>Machine code is a set of binary instructions consisting of 1’s and 0’s called bits. To the processor, 1 represents an electrical switch being on, while 0 means a switch is off. The 1’s and 0’s are grouped together in different ways, creating 8-bit combinations called bytes. Combinations of these 1’s and 0’s send various electrical signals to the transistors in the CPU. Modern CPU’s have over a billion transistors which contain logic gates. The logic gates are opened and closed based on the bytes of code it receives, and this opening and closing of the gates is what allows your computer to do what you tell it to do.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*Z7sLtmZ6cXxicLc3j84Wnw.png" /></figure><p>To wrap this up, there are many different things to consider when choosing a programming language. The advantages of interpreted languages is no compilation means the time from editing code to testing the app can be diminished. However compiled languages are more efficient on time and space due to not having the overhead of an interpreter. Whatever programming language you may choose is up you!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62776d0b89f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React 16]]></title>
            <link>https://medium.com/@brettschules/react-16-b41745f917cb?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b41745f917cb</guid>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Sat, 07 Oct 2017 16:11:16 GMT</pubDate>
            <atom:updated>2017-10-07T16:11:16.228Z</atom:updated>
            <content:encoded><![CDATA[<p>React 16 was released on September 26, 2017 with exciting changes. For starters React 16 is released under the MIT license which means that developers would no longer have to worry about issue revolving patent grants. This is huge as in the past where companies had no patent protect should they use the React software causing many to reconsider their use of React. This is one less thing to worry about! Let check out some of the amazing feature released with React 16.</p><h3>Error Boundaries</h3><p>In React 16, error boundaries can be used the catch any JavaScript errors in the child component tree, log those errors, and display a fallback UI. This allows you to provide a back up should something go wrong and prevent the entire app from breaking. This can be done with the new life cycle component called componentDidCatch(error, info).</p><pre>class ErrorBoundary extends React.Component {<br>  constructor(props) {<br>    super(props);<br>    this.state = { hasError: false };<br>  }<br><br>  componentDidCatch(error, info) {<br>    // Display fallback UI<br>    this.setState({ hasError: true });<br>    // You can also log the error to an error reporting service<br>    logErrorToMyService(error, info);<br>  }<br><br>  render() {<br>    if (this.state.hasError) {<br>      // You can render any custom fallback UI<br>      return &lt;h1&gt;Something went wrong.&lt;/h1&gt;;<br>    }<br>    return this.props.children;<br>  }<br>}</pre><pre>Then you can use it as a regular component:</pre><pre>&lt;ErrorBoundary&gt;<br>  &lt;MyWidget /&gt;<br>&lt;/ErrorBoundary&gt;</pre><h3>Portals</h3><p>We all know in React that a parent component can render its child component. But what if we want to render a component that is not within the DOM hierachy of the parment component? This is where Portals come in! Portals provide a first-class way to render children into a DOM node that exists outside the DOM hierarchy of the parent component.</p><p>You can do this by adding a second element in the root div.</p><pre>ReactDOM.render(&lt;App /&gt;, document.getElementById(&#39;root&#39;));<br>&lt;body&gt;<br>  &lt;div id=&quot;root&quot;&gt;&lt;/div&gt;<br>  &lt;div id=&quot;my-portal&quot;&gt;&lt;/div&gt;<br>&lt;body&gt;</pre><p>Then, we can use the ReactDOM.createPortal(child, container) to render our component. The function’s first argument child is the content you want to render, and the second argument container is the DOM element where the content is going to render.</p><pre>class Modal extends Component {<br>  render() {<br>    return (<br>      ReactDOM.createPortal(<br>        this.props.children,<br>        document.getElementById(&#39;my-portal&#39;)<br>      )<br>    );<br>  }<br>}</pre><p>Now, since our Modal component returns a portal via createPortal(), we can place this component anywhere in our app.</p><pre>class App extends Component {<br>  render() {<br>    return (<br>      &lt;div&gt;<br>        &lt;header&gt;<br>          &lt;h1&gt;Welcome to my App!&lt;/h1&gt;<br>        &lt;/header&gt;<br>        &lt;Modal /&gt;<br>      &lt;/div&gt;<br>    );<br>  }<br>}</pre><h3>Preventing page rendering with null</h3><p>This has to be one of my favorite feature in React 16 due it’s usefulness in many cases. This feature allows you to control whether the component get updated or not. This is to prevent unnecessary updates which could hind performance. You can do this by simply setting the state to null which will not trigger a re-render to the component. For example, let’s say we want to prevent useless render if we are getting the same state, we can do this by the example below. Here, we check to see if the state is the same as our current state which then set the state to null if it is. If it is not, then we set the state to our new state. This determines whether if our component re-renders.</p><pre>getCourse = course =&gt; {<br>  const newTitle = course.title;<br>  this.setState(state =&gt; {<br>    <strong>if (state.title === newTitle) {<br>      return null;<br>    } else {<br>      return { title: newTitle };<br>    }</strong><br>  });<br>};</pre><h3>Rendering Arrays</h3><p>In React 16, you can render multiple sibling elements without a wrapping element by returning an array.</p><pre>const MyFavoriteFoods = () =&gt; {<br>  return [<br>    &lt;li key=&quot;1&quot;&gt;Pizza&lt;/li&gt;,<br>    &lt;li key=&quot;2&quot;&gt;Tacos&lt;/li&gt;,<br>    &lt;li key=&quot;3&quot;&gt;Bacon&lt;/li&gt;<br>  ];<br>}</pre><p>You can render the then Languages component in a list.</p><pre>const Foods = () =&gt; {<br>  return (<br>    &lt;ul&gt;<br>      &lt;li&gt;Ice Cream&lt;/li&gt;<br>      <strong>&lt;MyFavoriteFoods /&gt;</strong><br>      &lt;li&gt;Apples&lt;/li&gt;<br>      &lt;li&gt;Blueberries&lt;/li&gt;<br>    &lt;/ul&gt;<br>  );<br>}</pre><p>This would display to the HTML as</p><pre>· Ice Cream</pre><pre>· Pizza</pre><pre>· Tacos</pre><pre>· Bacon</pre><pre>· Apples</pre><pre>· Blueberries</pre><p>This blog was to highlight some of the key features of React 16. Please check out the documentation for a comprehensive list of all of the features with React 16 <a href="https://reactjs.org/blog/2017/09/26/react-v16.0.html">https://reactjs.org/blog/2017/09/26/react-v16.0.html</a>. I hope you learn as much as I did from writing this blog!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b41745f917cb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Add_index Rails]]></title>
            <link>https://medium.com/@brettschules/add-index-rails-b68bf2d99d17?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b68bf2d99d17</guid>
            <category><![CDATA[ruby-on-rails]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Thu, 28 Sep 2017 16:56:35 GMT</pubDate>
            <atom:updated>2017-09-28T18:23:00.779Z</atom:updated>
            <content:encoded><![CDATA[<p>This blog is going to be different as instead of talking about Javascript or it’s frameworks, we are going to be talking about Rails. Yes, RAILS! Ah, sure brings back memories as Rails was my first Framework along with Ruby as my first programming language that I learned. I was going over the Rails Tutorial by Michael Hartl for a good refresher when I noticed something I never seen before; the add_index to a table in the database.</p><p>According to the w3schools documentation on SQL, “Indexes are used to retrieve data from the database very fast. The users cannot see the indexes, they are just used to speed up searches/queries.”</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FTPl5N4Ci49ZQY%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FTPl5N4Ci49ZQY%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia4.giphy.com%2Fmedia%2Fv1.Y2lkPTc5MGI3NjExODV1aWw0dm9lZ29hcXl5dDNqMDhpa3ZuYWJudHNwcXIxY2YzOThsMSZlcD12MV9naWZzX2dpZklkJmN0PWc%2FTPl5N4Ci49ZQY%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="326" frameborder="0" scrolling="no"><a href="https://medium.com/media/f877b87d96e262b1fe2072c9a469545a/href">https://medium.com/media/f877b87d96e262b1fe2072c9a469545a/href</a></iframe><h3>The Why</h3><p>Ok, that is not very helpful as to the why and how. Let’s take a further look into this. Basically indexes are used to quickly locate data instead of having to search through every row in the database. One can think of an index like the table of contents in a book. If we wanted to search for a specific piece of information, we would have to search through the entire book, which in the worst case scenario could be on the last page of the book. However to narrow our search down and to cut down our look up time, we can use the table of contents to find the chapters containing the information. Same thing applies to databases as well!</p><h3>The how</h3><p>Let’s take a look some examples of how this would work in rails. Below we have a migration for the Users table that contains the rows of the user’s name, email, and age. Now, if we wanted to find the user by their name, we could do User.find_by(name: “User’s Name”). This allows it do a query through the database to find the row that matches the user’s name and retrieve the data. Since this is something we would be querying quite frequently in our database, it is best to use the add_index to our name data. This allows for faster lookup by only grabbing all of the names in the name column in our database, then comparing it to our search query of the name we are looking for.</p><pre>class CreateUsers &lt; ActiveRecord::Migration[5.1]<br>  def change<br>    create_table :users do |t|<br>      t.string :name<br>      t.string :email      <br>      t.integer :age<br>      t.timestamps<br>     end<br>    add_index :users, :name<br>  end<br>end</pre><p>Adding an index can also be used in the case of a join table. We have a Songs table which is a one to many relationship with the Users table(Users has_many songs and a song belongs to a user). Once again, adding an index to the Songs table allows us to find the user_id by looking up the user_id index and go to the row that we were looking for.</p><pre>class CreateSongs &lt; ActiveRecord::Migration[5.1]<br>  def change<br>    create_table :users do |t|<br>      t.string :name<br>      t.references :user, foreign_key: true  <br>      t.timestamps<br>     end<br>    add_index :songs, :user_id<br>  end<br>end</pre><p>Of course it doesn’t stop there as there are many different custom search queries that can be done with add_index. We can ensure that two or more indexes will be unique in our data base by adding an unique option at the end. Check out the active record documentation for more options for add_index. <a href="https://apidock.com/rails/ActiveRecord/ConnectionAdapters/SchemaStatements/add_index">https://apidock.com/rails/ActiveRecord/ConnectionAdapters/SchemaStatements/add_index</a></p><pre>add_index :relationships, [:follower_id, :followed_id], unique: true</pre><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F3o6Zt9PivJAtA1xXyg%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F3o6Zt9PivJAtA1xXyg%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F3o6Zt9PivJAtA1xXyg%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="244" frameborder="0" scrolling="no"><a href="https://medium.com/media/8f9fec8b3ba1fa0d4b290fbdc426e1cf/href">https://medium.com/media/8f9fec8b3ba1fa0d4b290fbdc426e1cf/href</a></iframe><p>Now you may be thinking why not just add index to everything in our database! Well, unfortunately like many things in life, there is always a catch. There is a performance hit with indexes. In exchange for faster search queries, writing and updating the database is slower as there is an overhead in maintaining the indexes. However, that negative impact only add milliseconds in writing time to the database which is offset by saving seconds(even minutes) on search queries. Now if you forget or is not sure to add an index, don’t worry! Since Rails 3 and above, there is a feature that automatically prints out a warning if the query search takes longer than 0.5 secs. That might mean it would be a good time to use that add_index!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b68bf2d99d17" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Regular Expression in Javascript]]></title>
            <link>https://medium.com/@brettschules/i-heard-of-two-sides-when-it-comes-to-peoples-view-on-regular-expressions-290d06e00800?source=rss-ebc012b6bea1------2</link>
            <guid isPermaLink="false">https://medium.com/p/290d06e00800</guid>
            <category><![CDATA[regex]]></category>
            <category><![CDATA[regular-expressions]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Brett Schules]]></dc:creator>
            <pubDate>Thu, 21 Sep 2017 18:54:13 GMT</pubDate>
            <atom:updated>2017-09-22T12:30:36.533Z</atom:updated>
            <content:encoded><![CDATA[<p>I heard of two sides when it comes to people’s view on Regular Expressions. One is they praise it, or two they repeat this quote by <a href="http://regex.info/blog/2006-09-15/247"><em>Jamie Zawinski</em></a>: “Some people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems.” Well, whatever side you are on, don’t worry as the purpose of this blog is to educate not to start another internet debate!</p><p>According to w3schools, “A regular expression is a sequence of characters that forms a search pattern.” (<a href="https://www.w3schools.com/js/js_regexp.asp">https://www.w3schools.com/js/js_regexp.asp</a>). Regular expression allows you to search data in a text by using the search pattern to describe what you are searching for. A regular expression search can contain anywhere from a single character to many complicated patterns. Regular expressions are objects in Javascript and some of it’s methods include match, search, split that can be used.</p><p>A regular expression can be created in one of two ways. One using the expression literal which is to be used when the regular expression will remain constant. For instance, using in a loop so the regular expression won’t be recompiled. Literal expressions can be written as below…</p><pre>var re = /ab+c/;</pre><p>The second way of creating regular expressions is using the constructor function by initializing the regular expression object. The constructor function is used when you know the regular expression pattern will be changing from a source such as getting input from a user. This can be written as below</p><pre>var re = new RegExp(&#39;\\w+&#39;);</pre><p>Let’s take a look at some of the basic syntax of Regular Expressions or Regex for short. Brackets in Regex are used to find a range of characters between the brackets. For example..</p><p>[abc]</p><p>Find any of the characters between the brackets</p><p>[0–9]</p><p>Find any of the digits between the brackets</p><p>(x|y)</p><p>Find any of the alternatives separated with |</p><p>Regex can be used with Metacharacters that are characters with a special meaning such as…</p><p>\d</p><p>Find a digit</p><p>\s</p><p>Find a whitespace character</p><p>\b</p><p>Find a match at the beginning or at the end of a word</p><p>Regex can be used with flags the performs case insensitive global searches such as</p><p><strong>g</strong></p><p>global match; find all matches rather than stopping after the first match</p><p><strong>i</strong></p><p>ignore case</p><p><strong>m</strong></p><p>multiline; treat beginning and end characters (^ and $) as working over multiple lines (i.e., match the beginning or end of <em>each</em> line (delimited by \n or \r), not only the very beginning or end of the whole input string)</p><p>Let’s take a look at some examples of regular expressions.</p><p>Using the test method allow you to search a string for a pattern and returns true or false if the criteria is meet. For example, in the following code below, we are checking to see if the string “The best things in life are free!” contains the letter e, it will return true, which it does. There we have it! Our first regular expression!</p><pre>/e/.test(“The best things in life are free!”);</pre><p>Next, is the match method which matches a string against a regex and returns an array containing it’s matches. Let’s say if what wanted to search a range of letters in the alphabet. We can do it as shown in the example below. We declare a var made up the string of “Hello World” and we want to check to see if there is a match of the letters in the the range of A to E. Let’s taking this step by step. In the Regex variable, we declare the regular expression by using the literal expression using the backward slashes (/ /). Then, we give the range of alphabet by putting the letters A to E in the brackets (A-E). Finally, we can specific more attaching arguments after the Regex by adding flags. The g flag allows to find all matches rather than stoping after the first match and the i flag allows for case-insensitive matching.</p><pre>var str = ‘Hello World!’;</pre><pre>var regexp = /[A-E]/gi;</pre><pre>var matches_array = str.match(regexp);</pre><pre>console.log(matches_array);</pre><pre>// [‘e’,’d’]</pre><p>Let’s check out some more complex examples with the use of Regex. First, we declare the beginning and ending of the string with the ^ for start and $ for the end. Next, we specify the characters we want to test by declaring acceptable characters [a-z0–9_-] between the brackets. This says any lowercase number between a to z, numbers 0 to 9, underscore and hypen are acceptable. Finally, we have specify a range of characters we are looking for by using delimiters using swirly brackets. In this case, {3,16} means a minimum of three characters up to a maximum of 16 characters are acceptable.</p><pre>var regexp = /^[a-z0–9_-]{3,16}$/;</pre><pre>var str = ‘th1s1-ist00_ok’;</pre><pre>var result = regexp.test(str);</pre><pre>console.log(result);</pre><pre>// true</pre><pre>var str = var str = ‘th1s1-ist00_notok’;<br>console.log(result);</pre><pre>// false</pre><p>Using Regex to check for valid emails is common, however this can get really complicated, as there is many factors that one has to be aware of. Let’s keep it simple though. Don’t let the example below intimidate you! All we are doing is breaking the Regex in three different groups by using parentheses. In the first group, once again we are checking for the string for letters a to z, numbers 0 to 9, underscore, hypen, and period(Used escaped the dot because a non-escaped dot means any character). After the @, we have the Regex for the domain name, then finally we have the country specific TLD’s. Told you it was not so bad!</p><pre>var regexp = /^([a-z0–9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/;</pre><pre>var result = regexp.test(str);</pre><pre>var str = ‘myname@example.com’;</pre><pre>console.log(result);</pre><pre>// true</pre><pre>var str = ‘myname@examplecom’;</pre><pre>console.log(result);</pre><pre>// false</pre><p>The blog was to cover the basics of how regular expression works as the scale of Regular Expression is beyond what I can fit in my blog. The are many great documentations on regular expression that you can look up for much more complex examples. This is a great site to start of. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions</a>. I hope you learned as much about Regular Expression as I did!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=290d06e00800" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>