<?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 Nick Gentile on Medium]]></title>
        <description><![CDATA[Stories by Nick Gentile on Medium]]></description>
        <link>https://medium.com/@nickjgentile?source=rss-66fdb9b6369f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dG6WPeJ6oFPOT1JXjBkw-w.png</url>
            <title>Stories by Nick Gentile on Medium</title>
            <link>https://medium.com/@nickjgentile?source=rss-66fdb9b6369f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:59:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nickjgentile/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[No, ChatGPT is Not Going To Replace Software Engineers. Here’s Why:]]></title>
            <link>https://medium.com/@nickjgentile/no-chatgpt-is-not-going-to-replace-software-engineers-heres-why-3dcfad1f1d9?source=rss-66fdb9b6369f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3dcfad1f1d9</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[chatgpt]]></category>
            <dc:creator><![CDATA[Nick Gentile]]></dc:creator>
            <pubDate>Thu, 09 Mar 2023 20:07:48 GMT</pubDate>
            <atom:updated>2023-03-09T20:17:13.263Z</atom:updated>
            <content:encoded><![CDATA[<h4>ChatGPT and other A.I. models are all anyone can talk about currently. It is impressive technology and has many people in different careers fearing for their jobs. Software Engineers should have nothing to worry about in this regard, and I’ll explain some of the reasons why.</h4><p>I’ll start this article off by explaining what almost all software engineers know to be true: Nobody outside of other software engineers have any idea what actually goes into the work that we do. Here are some things that go unseen outside of our department that separate us from A.I.</p><h3>Gathering Requirements</h3><p>Often times the projects that we work on are assigned to us from a client or prioritized by the business to make it more competitive/fill a gap in the market. While your client and or business may have an understanding of what they want it is often up to us to determine what they actually need based on their expressed wants and the possibilities technology has to offer.</p><p>Lets use an extremely relevant example. Lets say your business wants to get on board with this ChatGPT trend that has everyone in the market talking. It can be a great selling point as everyone’s ears perk up when they hear that word right now. The business/client comes to you as an engineer and says ‘We need ChatGPT in our product’. Well, if you give that description to ChatGPT and think you will get a result that is an any facet useful you might be the type to believe Cloud Computing actually takes place in physical clouds.</p><p>Where we come in is to determine <em>how </em>we can utilize ChatGPT. Research it. See how it can fit into our product and what it will take to make that happen. We consider the business itself, what its goals are, how utilizing the new technology could help to accomplish these goals (see <strong>Systems Thinking</strong> below for more on this). There is so much context and work that goes into the points between A) Being asked to do something, and B) Actually determining <em>what</em> needs to be done. And for anyone who knows computers this is <strong>not what computers are good at.</strong> Computers are very good at being told exactly what to do, and executing the actions given to it exactly as they are listed (behind the scenes, that is what ChatGPT is doing after all — and what programming is at its most core description).</p><p>A Software Engineer does not just start writing code the second they are given a task. Getting to that point often requires as much research, prototyping, design and planning as actual coding. This is where we separate ourselves from A.I. and will likely continue to.</p><h3>Systems Thinking</h3><p>One of the most important qualities of a programmer is their ability to consider the system as a whole when creating/adding to it. For example, say you are going to create a new WebAPI that your user interface will interact with. This WebAPI will read and write data from a database that is already being used by several other services. Your A.I. will likely go about creating your new WebAPI in the most optimized way for it to exist on its own, without considering the rest of the system.</p><p>It would likely not consider any other system when writing its code. For example, lets say the existing WebAPI is expecting all records to be encrypted using a specific package when fetching them out of the database. ChatGPT however, has found the latest encryption package that performs sub-milliseconds faster than the other packages on the market and decides it must use this package. All of the sudden database records are being encrypted differently in the new WebAPI it is writing and breaking tests+causing errors in the existing WebAPI. ChatGPT has done its job and created an extremely efficient API, but did so like a wrecking-ball to the system without any awareness of its context.</p><p>How would ChatGPT go about figuring this problem out? What would a non-engineer do? Tell ChatGPT ‘find out why this error is happening’? Even if it were able to get the error log, would it be able to connect the dots and discover the encryption differences between the two systems?</p><p>Adding to a complex system is not something that you do with only optimization and the task at hand in mind. You have to consider everything else that touches the system. You have to know the products and how they will respond to your additions. And this is just another way where we as systems-thinkers differentiate ourselves from A.I.</p><h3>Code Quality</h3><p>If you ever have applied to a job as a Software Engineer you know one of the first things they will try to sniff out is whether you are able to maintain and write quality code. This is why so much emphasis is put on things like The Solid Principles and the 4-Pillars of Object-Oriented Programming.</p><p>You can write the most clever, impressive code imaginable but if it is not readable, extendable, searchable and modular it is useless.</p><p>For example, consider the following two solutions to the same problem: (taken from <a href="https://www.codewars.com/kata/514b92a657cdc65150000006/solutions/javascript">Codewars</a>)</p><blockquote>Finish the solution so that it returns the sum of all the multiples of 3 or 5 below the number passed in. Additionally, if the number is negative, return 0 (for languages that do have them).</blockquote><blockquote>Note: If the number is a multiple of both 3 and 5, only count it <em>once</em>.</blockquote><pre>function solution(number){<br>  return number &lt; 1 ? 0 : [...new Array(number).keys()].filter(n =&gt; n % 3 == 0 || n % 5 == 0).reduce((a, b) =&gt; a + b);<br>}</pre><pre>function solution(number){<br>  var sum = 0;<br>  <br>  for(var i = 1;i&lt; number; i++){<br>    if(i % 3 == 0 || i % 5 == 0){<br>      sum += i<br>    }<br>  }<br>  return sum;<br>} </pre><p>Now, which of these two solutions would you want in your codebase (hopefully the second)? And which of the two solutions do you think ChatGPT would be more likely to produce (probably the first)? I imagine any sane engineer would not want to ever touch the first solution. It is not something you have any chance of fully understanding on first read. You really have to extrapolate its meaning, walk through the steps of what it is doing and the order of its operations to understand. It is an all-around overly-clever solution to the problem.</p><p>The second solution is something that just about any engineer could read and understand after a quick read-over. You would know what to expect of the code when you give it an argument and easily debug or extend it if needed.</p><p>Although <em>clever</em> is a word that often has desired connotations outside of the Software industry, it is something that codebases should try to avoid at all costs. It is much more important to write code in a way that the next person, or computer, to modify the codebase can easily understand.</p><p>This example just covers readability of code, there are so many other areas of quality that each team of Engineers decides to standardize and uphold. How would you tell an A.I. model not to create a god class for example? How would you tell it to ensure no methods within a class serve multiple responsibilities? How are you defining ‘god-class’ and ‘responsibilities’ within your system of standards? Do you think any of these things could be communicated to a computer by a client or project manager? No chance. The A.I. would have to be tuned and maintained by an engineering team that would probably end up being larger than the human-comprised team that could otherwise be creating and maintaining your product with much more quality and understanding of the business/systems it interacts with.</p><p><em>I’d like to note that these are just some of the examples I could think of on my own of where we separate ourselves as Software Engineers from A.I. If you think I missed any or want to add to this list please do so in comments!</em></p><h3>How ChatGPT Will Actually Effect Software Engineers:</h3><p>ChatGPT could have a lot of uses for programmers. For example asking it <strong>‘bootstrap me a React.JS application that uses Redux for state-management, Less for style compilation, Rollout to build into a dist folder, formats using Prettier and lints with ESLint in a way that cooperates with the Prettier config’</strong> (I know create-react-app exists I just think this is a good example that is easily followed) could get you some awesome results. Or imagine the benefit of being able to ask it something like `<strong>create me 100 records with mock-data in JSON format that follows the Schema from “path/to/userModel.js”`</strong>. You would almost certainly have to tweak the results yourself afterwards but the AI could reduce a <em>ton</em> of busywork you would otherwise have to setup on your own and get you right into actual coding.</p><p>In the end AI won’t stand a chance to compete with our understanding of complex systems, code-quality and ability to understand what a client needs based on what they ask for. But it <em>can</em> be an extremely useful tool for Engineers to utilize and help us rather than replace us.</p><p><strong>ChatGPT and other AI technologies are something that you should be excited for as a Software Engineer, not something you should be afraid of.</strong></p><figure><img alt="AI will not Take Er Jerbs" src="https://cdn-images-1.medium.com/max/1024/1*RlZgngCmZPALIC8Rlq4Omw.jpeg" /><figcaption>AI WIll Not TakeEr Jerbs</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3dcfad1f1d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Creating Extendable Web Workers in Vue3 for Offloading Process-Heavy Execution]]></title>
            <link>https://medium.com/@nickjgentile/creating-extendable-web-workers-in-vue3-for-offloading-process-heavy-execution-ce9b4745fbed?source=rss-66fdb9b6369f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce9b4745fbed</guid>
            <category><![CDATA[vuejs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[webworker]]></category>
            <category><![CDATA[multithreading]]></category>
            <dc:creator><![CDATA[Nick Gentile]]></dc:creator>
            <pubDate>Sun, 15 Jan 2023 23:06:02 GMT</pubDate>
            <atom:updated>2023-01-15T23:10:51.454Z</atom:updated>
            <content:encoded><![CDATA[<h4>Web workers allow us to multi-thread in the browser using Javascript. There are many simple examples on how to do this, but I am going to show a way to make your workers very extendable with a common interface in Vue3! These same concepts are easily applicable to Angular, React or any Javascript framework.</h4><p><em>All of the code I will be taking examples from can be forked/downloaded via the link below. Feel free to follow along of even throw a commit in if you think you have a good idea!</em></p><p><a href="https://github.com/nickjgentile/web-worker-sample">GitHub - nickjgentile/web-worker-sample: Sample web worker factory that is extendable and modular for Medium article.</a></p><p>To begin, lets first talk about what a <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers">Web Worker</a> is. Javascript is a single-threaded language, which means any execution that is running on the stack <em>must </em>finish before moving on to the next item.</p><p>This can bog down your applications if you are executing any sort of heavy processing code in the browser. Luckily we have <a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers">Web Worker</a>s which allow us to bypass the language’s inherent single-threaded nature and create a worker thread to handle process-heavy execution. This can free up your main thread to finish up the rest of the stack while your process-heavy code runs off to the side, in its own worker thread.</p><p>Creating a web worker is rather simple. You create a worker file that adheres to the worker interface by having an <strong>onmessage</strong> property:</p><pre>Worker.js<br>###<br><br>onmessage = function(e) {<br>  var results = e.data + 1;<br>// Post message back to whoever implemented the worker.<br>  postMessage(result);<br>}</pre><p>Then you implement the worker by instantiating a new Worker instance with the path to your worker file:</p><pre>App.vue<br>###<br><br>var worker = new Worker(&quot;PATH_TO_YOUR_WORKER_DIR/Worker.js&quot;);<br>// send message to worker<br>worker.postMessage(1);<br>// receive messages back from worker when it needs to communicate back<br>worker.onmessage = function(event) {<br>  // get data from worker&#39;s message <br>  var updatedValueFromWorker = event.data;<br>}</pre><p>The worker and whatever is implementing it communicate back and forth via a <strong>postMessage</strong> and <strong>onmessage </strong>interface.</p><p>The example above is very easy to follow and quick to setup, but it can be limiting in terms of what your worker can do. Having all of your code within your <strong>onmessage </strong>property of your worker can very quickly lead to massive amounts of code that are not properly split-up and hard to read through.</p><p>A more digestable approach for me has been to treat the worker files like more of a class that holds one single responsibility and adheres to an interface that requires it to have an <strong>onmessage</strong> property for external communication. Lets take an example from the Github repository I linked:</p><figure><img alt="countWorker.js" src="https://cdn-images-1.medium.com/max/1024/1*gMupiEzWztwA4mUeG1c-4w.png" /><figcaption>countWorker.js</figcaption></figure><p>Here we have a worker file that counts to different numbers (yes there are simpler ways to do this but suspend disbelief for the example).</p><p>The <strong>onmessage</strong> handler is no longer doing <em>everything </em>for this worker, rather it is just parsing the message, checking to make sure it has a method to call that aligns with the <strong>type </strong>the message is labelled as, executing the method if it finds a match and then posting a response back.</p><p>This allows our worker to be much more flexible and only do exactly what whoever is calling it needs it to do. It also allows us to not have to create 50 worker files to handle the same responsibility (in this case, counting). We can just create one worker, give it a solid, adhered-to responsibility and extend it to fulfill that responsibility in as many ways as we need it to (just be careful not to create a God-worker, split responsibilities into new files when necessary!).</p><p>To implement this worker, it is very simple:</p><figure><img alt="MultiThreadButton.vue" src="https://cdn-images-1.medium.com/max/1024/1*BCqLsd0eRqY1eFiQimjYmg.png" /><figcaption>MultiThreadButton.vue</figcaption></figure><p>Just like in my previous example, I am instantiating a new Worker with the file path to my <strong>countWorker.js</strong> file. I am creating an <strong>onmessage</strong> handler for the worker to communicate back to me, and then I am calling <strong>worker.postMessage</strong> but this time I am specifying what I want the worker to do for me by passing <strong><em>{ type: ‘countToOneHundredThousand’ } </em></strong>in the message data.</p><p>If you want to see the actual effects of the worker, go ahead and pull down the repository and look at the differences between clicking the <strong>Single Threaded Execution</strong> button and <strong>Multi Threaded Execution</strong> button. You’ll notice that the <strong>Multi Threaded Execution</strong> button’s main-thread runtime is hardly anything at all!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce9b4745fbed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Debugging the Accessibility of your Webpages with Chrome Devtools]]></title>
            <link>https://medium.com/@nickjgentile/debugging-the-accessibility-of-your-webpages-with-chrome-devtools-a8e58d00e632?source=rss-66fdb9b6369f------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8e58d00e632</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[html]]></category>
            <dc:creator><![CDATA[Nick Gentile]]></dc:creator>
            <pubDate>Wed, 09 Nov 2022 16:33:53 GMT</pubDate>
            <atom:updated>2022-11-09T16:33:53.234Z</atom:updated>
            <content:encoded><![CDATA[<h4>Making our webpages accessible to all potential users is important when building a website and or application. Chrome devtools has some great interfaces that allow us to debug the accessibility of each HTML node, or view the accessibility DOM tree entirely for testing.</h4><p><em>Edit: These same interfaces exist in Microsoft Edge.</em></p><p>As some of you may already know, when a browser converts markup into a DOM tree it then uses that DOM tree to create an <a href="https://developer.mozilla.org/en-US/docs/Glossary/Accessibility_tree">Accessibility Tree</a> that can be consumed by screen readers.</p><p>What you might not know is that you have access to debug the accessibility rendering of each HTML node on your webpage.</p><h4>Debugging the Accessibility of HTML Nodes</h4><p>To open the accessibility extension within Chrome devtools, select a node you would like to inspect within your <strong>elements</strong> tab, then click the right-chevron icon near the styles listing to see more extension options and select Accessibility.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*GOOs6LEaAN2p1qysioHq5w.gif" /></figure><p>Lets take a close look at what this gives us visibility to, take a look at the screenshot below highlighting the element I was interrogating in the gif above:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vLkH_qKk9CkDlU29tHWKqg.png" /></figure><p>What we can see is that we have a <strong>&lt;button&gt;</strong> node that is the child of a whole bunch of <a href="https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/generic_role">generics</a> (usually generics are just divs when referring to the accessibility tree). What is more valuable than having visibility to the tree here however is being able to <strong>see the computed accessibility properties for the node</strong>, which is what I’ve highlighted in the image above.</p><p>In this example our button node has no aria attributes or title. This is fine because a button node is <a href="https://www.w3schools.com/html/html5_semantic_elements.asp">semantic</a> and the button contains contents (i.e. the text “Publish”) within the node which screen readers will use if available.</p><p>Had this been a generic node, like a <strong>&lt;div&gt;</strong> or <strong>&lt;span&gt;</strong>, these attributes would be necessary to tell screen readers: <em>what is the role of this node</em>, <em>what should I label it as to users</em> and <em>whether the node is focusable/clickable</em>. Being able to view these computed properties allows us to see any accessibility flaws our HTML might have when testing.</p><p><em>Note: It’s generally not good practice to use something like a </em><strong><em>&lt;div&gt;</em></strong><em> with </em><strong><em>role=”button” </em></strong><em>to act like a button, but if you are doing something like this, make sure that you add the appropriate accessibility attributes to the node for screen readers.</em></p><h4>Viewing the Entire Accessibility Tree</h4><p>If you want to view the accessibility tree entirely, you can do so by <strong>enabling the full-page accessibility tree:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*TyXp1uPOcYLhVUVCqYVjjQ.gif" /></figure><p>Once you’ve checked this option on, you can reload dev tools and now <strong>toggle between the DOM and Accessibility DOM by clicking the person-icon in the top right corner of your elements tab</strong>. This can allow you to interrogate the accessibility tree in its entirety!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8e58d00e632" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>