<?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 Kyle on Medium]]></title>
        <description><![CDATA[Stories by Kyle on Medium]]></description>
        <link>https://medium.com/@kyle_77228?source=rss-1b9e2a8fe076------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1IyfSgU4VKq_Sv8Yy2kbUA.png</url>
            <title>Stories by Kyle on Medium</title>
            <link>https://medium.com/@kyle_77228?source=rss-1b9e2a8fe076------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 14:25:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kyle_77228/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[Kanban: Process Policies in 3 Minutes]]></title>
            <link>https://itnext.io/kanban-process-policies-in-3-minutes-e1a370817a49?source=rss-1b9e2a8fe076------2</link>
            <guid isPermaLink="false">https://medium.com/p/e1a370817a49</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[kanban]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[process]]></category>
            <dc:creator><![CDATA[Kyle]]></dc:creator>
            <pubDate>Mon, 23 Dec 2019 13:02:03 GMT</pubDate>
            <atom:updated>2019-12-23T13:25:34.377Z</atom:updated>
            <content:encoded><![CDATA[<h4>The goal of using Kanban is to create a stable workflow, but to establish stability there needs to be a consistent implementation of policies.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*myC4xZznQVoWxWXHlPWwpQ.jpeg" /><figcaption>Basic kanban board</figcaption></figure><p>If you are running a Kanban team, you will need to define some policies around how your team works. These policies help make your team become much more fluid, this is an essential tool for a successful kanban team. Setting these policies helps you and your team understand the setup of the kanban methodologies.</p><p>Many people think of policies as strict rules or large employee handbooks. That is not the case here, the idea is for your team to come up with policies that work for the team.</p><p>The reason we need these policies in the kanban framework is that kanban does not define the different stages of your processes; it allows the team to decide on what the most effective way of working is. Most importantly, you want to make all of your process policies visible and explicit.</p><h4>Kanban process policy examples</h4><p>Here are some examples that I have implemented in the past and have worked efficiently. This is not a complete list but serves as an idea of how policies are formed. Have regular meetings with your team after specific milestones to revisit your policies so that you can add and remove them.</p><ul><li><strong>Visualize the workflow (and policies)</strong><br>For this example, you want your team and your stakeholders to know exactly where you are in terms of work. This can be achieved with a physical board, but electronic boards work extremely well as well — such as <a href="https://trello.com/">trello</a> or <a href="https://clubhouse.io/">clubhouse</a>.</li><li><strong>Limit WIP<br></strong>We limit work in progress in certain kanban columns, like In Progress or In Review. Limiting tickets in a specific column encourages higher quality and greater performance.</li><li><strong>Handling critical requests<br></strong>The nature of kanban allows your team and stakeholders to bring in new work quite regularly. This can be disruptive, so the idea of this policy is to define what happens when a new critical request comes in. Are people dying? Then stop what you’re doing and attend to it. If it is not that urgent, complete what you are working on and attend to it after.</li><li><strong>Combing</strong> <strong>your backlog</strong><br>Decide on a time when you want to go through your backlog of tickets with your team, information is not always shared especially when small bugs or small requests are logged. Set a maximum limit on your requests, say 10 tickets, and once your request column hits that limit set up a grooming meeting with your team. Prioritize, delete and action.</li><li><strong>Have regular showcases of your work with stakeholders<br></strong>Having showcases with your stakeholders is extremely important to show the progress of your work, especially if you are working on very large projects. This will help if you have missed any piece of work from the brief or specification you were given, as well as bring closure to your team.</li><li><strong>Last minute features<br></strong>Do not allow last-minute nice to have features during design reviews, or launch readiness testing. If you had gone through your specification properly and thoroughly you would not have missed any essential features.</li></ul><p>Kanban is an extremely powerful framework, it is open and doesn’t have any explicit rules of its own. However, to achieve success, you will need to define explicit policies with your team.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1a370817a49" width="1" height="1" alt=""><hr><p><a href="https://itnext.io/kanban-process-policies-in-3-minutes-e1a370817a49">Kanban: Process Policies in 3 Minutes</a> was originally published in <a href="https://itnext.io/">ITNEXT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[High level Micro-ui Architecture]]></title>
            <link>https://itnext.io/high-level-micro-ui-architecture-a033bc8e87a8?source=rss-1b9e2a8fe076------2</link>
            <guid isPermaLink="false">https://medium.com/p/a033bc8e87a8</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[micro-frontends]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Kyle]]></dc:creator>
            <pubDate>Thu, 05 Dec 2019 12:13:13 GMT</pubDate>
            <atom:updated>2019-12-08T15:38:48.018Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>“Good frontend development is hard. Scaling frontend development so that many teams can work simultaneously on a large and complex product is even harder.” — <strong>Cam Jackson</strong></blockquote><h3>Is this just another fad?</h3><p>The current trend in the tech community is to build feature rich and powerful SPA’s which are usually powered by micro service architecture. What we have seen happen is that overtime the frontend layer becomes massive, bloated and duplicated. Often different features are maintained by different teams.</p><p>One code base, several teams working on it requires a lot of coordination and can cripple a team with blockers, bureaucracy and dozens of meetings around tech team wide standards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WXTsaqXwg9rMqNYPgCwtAQ.jpeg" /><figcaption>High level approaches to overall application structuring</figcaption></figure><p>There are several benefits of autonomous teams which have seen across different industries, in our specific industry, we have seen that autonomy leads to out of the box thinking, trivial solutions to complex problems and better job satisfaction — if pulled off right that is.</p><p>The micro-ui or micro frontend approach strives to give autonomy back to the teams in a way that lets them have complete control over their features or products without having to align on specific detail that could rather be decided in each team or squad.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9tzceopxrIpG4LtGsBcUTA.jpeg" /><figcaption>High level micro-ui structure</figcaption></figure><h3>Core ideas behind Micro-UI</h3><p><strong>Be technology agnostic</strong></p><p>Each team should be able to choose and upgrade their stack without having to coordinate with other teams. This allows tech teams to scale faster with a tech agnostic approach. <a href="https://developer.mozilla.org/en-US/docs/Web/Web_Components">Web Components</a> are a great way in providing a neutral interface to others</p><p><em>For example</em></p><pre>&lt;notification-bell&gt;{notificationCount}&lt;/notification-bell&gt;</pre><p><em>vs</em></p><pre>&lt;div class=”notification-bell”&gt;{notificationCount}&lt;/div&gt;</pre><p><strong>Isolate team code</strong></p><p>If all teams share the same tech stack, standards and so on do not share the same runtime. Build apps that are independent and that are self contained, do not rely on specific shared state or global variables, however there are exceptions which I mention later.</p><p><strong>Build a Resilient Site</strong></p><p>Not all browsers are equal, they each consume JavaScript differently and many features aren’t supported by all browsers. Try your best to use API’s that are in all browsers otherwise use a polyfill to implement those API’s on browsers that do not support them.</p><p>Use a <a href="https://github.com/brillout/awesome-universal-rendering">Universal Rendering technique</a> (SSR/SSG/Pre-rendering) and <a href="https://www.webfx.com/blog/web-design/progressive-enhancement/">Progressive Enhancement</a> (emphasize core webpage content first) to improve perceived performance. I will discuss several performance improvement strategies further down the article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UEfgg_iJLIGSPEdupIjQ7Q.jpeg" /><figcaption>Autonomous teams</figcaption></figure><h3>What does this look like?</h3><p>From a development perspective, we see separate applications that run and build independently, they may have different tech stacks but the end result is a web application or website that works on your browser and behaves as it was defined.</p><p>From a users perspective they see one web application that links or navigates different micro-ui’s — however they do not see or notice this (or, shouldn’t).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*77BjGLt8wpP5nqLAo0z9EA.jpeg" /><figcaption>End-to-End delivery of micro-ui’s</figcaption></figure><p>Each micro-ui has its own source code, contained in a repo somewhere (ideally). Each of these projects are built and tested in their own pipeline and once that is done they are deployed to a place somewhere on the web. Finally we start to tie all of these products or features into one application. We can achieve this by using different routing methods either with route 53, nginx, ingress etc.</p><h3>Common Source &amp; Logic</h3><p>The most common thing we would want to share across these different applications is going to be styling and maybe several helper functions which are commonly used in your applications (eg. parsing bearer tokens).</p><p>The technique commonly used is to create separate NPM libraries and pull those into each of your micro-ui’s. These should be designed so that they client (the micro-ui) could extend on these shared components, so that if different theming, padding, etc. is needed it easy to do so.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TwK0j-Q_NKidZK9FriRl1Q.jpeg" /><figcaption>Common shared libraries</figcaption></figure><p>In many cases micro-ui’s will need to authentication state, the simple way to do this will be by storing your authentication tokens in a LocalStorage which works across a domain this is used if you are going with a pre-rendered progressive enhancement approach. We all have the cookie method which will be the one you need to use if you are going with a server-side-rendered (SSR) approach.</p><p>Sharing authentication state is only one example, you could share several bits of state, but please use caution here as this could potentially expose sensitive information.</p><h3>Performance Techniques</h3><p>The biggest issue that you may experience is loading large bundles of compiled code. There are several ways to improve performance when loading multiple bundles and I will address some of them.</p><p><strong>Use a content delivery network for static assets</strong></p><p>Using a CDN will allow all of your assets to be loaded faster, as most CDN’s will know where the user is requesting the content from. Other than performance, this will reduce your bandwidth and infrastructure costs.</p><p><strong>“Prebrowsing”</strong></p><p>What if your browser anticipated the requests the user was going to need? Well you can definitely instruct it to do so. In a nutshell prebrowsing will tell the browser to fetch and cache a resource in your users browser while they are browsing. There are several <a href="https://css-tricks.com/prefetching-preloading-prebrowsing/">prebrowsing</a> API’s, I’ll discuss two that are most relevant to our problem.</p><ul><li><strong>Preconnect</strong><br>We want specific content to be loaded as early as possible, before an HTTP request is actually sent to the server. Preconnect resolves the DNS as well as make the TCP handshake, and if TLS is required it would do the negotiation as well. Preconnect can reduce request latency by a few hundred milliseconds, sometimes even thousands. <br>&lt;link rel=&quot;preconnect&quot; href=&quot;(url)&quot;&gt;</li><li><strong>Prefetch<br></strong>We know that we will be loading certain micro ui’s in the future so we can ask the browser to fetch that resource in the meanwhile and store it in the cache for later use. For example, you could load an image with prefetch, you could load any asset that is cacheable by your browser.<br>&lt;link rel=&quot;preconnect&quot; href=&quot;(url)&quot;&gt;</li></ul><h3>The Migration Approach</h3><p>If you want to start moving your frontend monolith into more maintainable and separate micro-ui applications you can start immediately. To get started I encourage you to define which parts of your application should be separated, an example would be your auth or login module. This way you can start migrating modules in isolation, while they are still being used on the monolith.</p><p>For each new feature you need to build into your application I would suggest immediately create micro-ui’s for those, an example would be a new blog.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g41GNM5FRyiiWXRgFiF3-Q.jpeg" /><figcaption>Migrating your monolith into micro-ui’s</figcaption></figure><p>Once all modules are migrated using this approach, you will essentially have a routing application at its core.</p><h3>TLDR;</h3><p>In conclusion, by using a micro-ui driven architectural approach you will receive several benefits. These include true team or squad autonomy, less points of failure — if a critical bug is introduced your entire application may not fall over which gives us an isolated environment similar to what we have seen in the microservice architecture. This is just the tip of the iceberg when it comes to micro-ui or micro-frontend architecture, be sure to ask questions or leave thoughts in the comment section!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a033bc8e87a8" width="1" height="1" alt=""><hr><p><a href="https://itnext.io/high-level-micro-ui-architecture-a033bc8e87a8">High level Micro-ui Architecture</a> was originally published in <a href="https://itnext.io/">ITNEXT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Firebase + Algolia Searching]]></title>
            <link>https://itnext.io/firebase-algolia-6c58fba930b7?source=rss-1b9e2a8fe076------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c58fba930b7</guid>
            <category><![CDATA[algolia]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[firebase]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Kyle]]></dc:creator>
            <pubDate>Tue, 23 Apr 2019 13:17:38 GMT</pubDate>
            <atom:updated>2019-04-25T09:19:59.750Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iLz5a4UAm7IDnnIWel_DVg.jpeg" /><figcaption>Search your firestore database with exceptional speed and indexing</figcaption></figure><p>I set out to create an app to help others learn the basic <a href="https://polish-verbs.firebaseapp.com/">Polish conjugations</a>. I wanted the application to have an exceptional search ability because we all learn language differently and we may remember parts of words, or even the sounds of them.</p><p>Algolia allowed me to index my database very quickly, it is extremely powerful. Elasticsearch is an alternative, but I wanted to develop a true “configless/serverless” experience with this application.</p><p>I created a firebase function that is executed via a url, this function will index my firestore collection/s. I then used the algolia client API to search on these indexes, again not having to obfuscate any important API or admin keys as no one is able to write to the algolia indexes without the admin key.</p><p>Let’s get started.</p><p><strong>Step 1: Setup </strong><a href="https://firebase.google.com/docs/functions/get-started"><strong>firebase</strong></a></p><pre>$ npm install -g firebase-tool</pre><pre>$ firebase login</pre><pre>$ mkdir firebase-functions &amp;&amp; cd firebase-functions</pre><pre>$ firebase init functions</pre><p>Follow the rest of the CLI process and get your firebase functions project set up.</p><p><strong>Step 2: Setup your project</strong></p><p>In the firebase-functions project, install and save algoliasearch.</p><pre>$ npm i algoliasearch --save</pre><p><strong>Step 3: Write your function</strong></p><blockquote>Note: You will need to upgrade from the spark plan to use functions that use external API’s.</blockquote><p>Make sure that you have setup <a href="https://www.algolia.com/doc/">Algolia</a>.</p><pre>// functions/index.js</pre><pre>const functions = require(&#39;firebase-functions&#39;);<br>const admin = require(&#39;firebase-admin&#39;);<br>const algoliasearch = require(&#39;algoliasearch&#39;);<br><br>const ALGOLIA_APP_ID = &#39;XXXXXXXX&#39;;<br>const ALGOLIA_ADMIN_KEY = &#39;XXXXXXXX&#39;;<br>const ALOGOLIA_INDEX_NAME = &#39;XXXXXXXX&#39;;<br><br>admin.initializeApp(functions.config().firebase);<br><br>exports.firestoreToAlgolia = functions.https.onRequest((req, res) =&gt; {<br>    const arr = [];<br>    admin.firestore().collection(&#39;COLLECTION_NAME&#39;).get().then(docs =&gt; {<br>        docs.forEach(doc =&gt; {<br>            const verb = doc.data();<br>            verb.objectID = doc.id;<br>            arr.push(verb);<br>        });<br><br>        const client = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_ADMIN_KEY);<br>        const index =  client.initIndex(ALOGOLIA_INDEX_NAME);<br>        <br>        index.saveObjects(arr, (err, content) =&gt; {<br>            if (err) res.status(500);<br>            <br>            res.status(200).send(content);<br>        });<br>    });<br>});</pre><p><strong>Step 4: Deploy &amp; execute the function</strong></p><p>Now that you have written your firebase function it’s time to deploy and execute.</p><pre>$ firebase deploy --only functions</pre><p>Once you have successfully deployed your function, you will see a message similar to this:</p><pre>Function URL (firestoreToAlgolia): <a href="https://us-central1-my_project.cloudfunctions.net/addMessage">https://us-central1-MY_PROJECT.cloudfunctions.net/</a>firestoreToAlgolia</pre><p>Alternatively you can find the url it in your firebase project, under the functions link.</p><p>Copy and paste that URL into your browser and after a few seconds your data will have been indexed by algolia search.</p><p><strong>Step 5: Configure the client</strong></p><p>I created a Algolia “class” in my react project, and you can do this in another way if you wish.</p><pre>// utils/algolia.js</pre><pre>import algoliasearch from &#39;algoliasearch&#39;;<br><br>const ALGOLIA_APP_ID = &#39;XXXXXXXX&#39;;<br>const ALGOLIA_API_KEY = &#39;XXXXXXXX&#39;;<br><br>const client = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_API_KEY, {<br>  protocol: &#39;https:&#39;<br>});<br>const index = client.initIndex(&#39;COLLECTION_NAME&#39;);<br><br>export default index;</pre><p>I then use it in my React “Verbs” container</p><pre>// containers/verb/index.js</pre><pre>import React, { useState } from &#39;react&#39;;<br>import algolia from &#39;utils/algolia&#39;;</pre><pre>const getVerbs = (verbs, setVerbs, query) =&gt;<br>  algolia.search({ query, hitsPerPage: 50 }).then(res =&gt; setVerbs(res.hits));</pre><pre>const Verbs = ({ history }) =&gt; {<br>  const [loading, setLoading] = useState(true);<br>  const [verbs, setVerbs] = useState([]);<br>  const [query, updateQuery] = useState(&#39;&#39;);<br>  const [fetching, updateFetch] = useState(true);<br><br>  if (fetching)<br>    getVerbs(verbs, setVerbs, query).then(() =&gt; {<br>      setLoading(false);<br>      updateFetch(false);<br>    });<br><br>  return (<br>    &lt;&gt;<br>      &lt;SearchBar updateQuery={updateQuery} updateFetch={updateFetch} /&gt;<br>    &lt;/&gt;<br>  );<br>};</pre><pre>...</pre><p>And that is it, you now have an extremely powerful search component in your application, indexed when new data is added by only executing a URL.</p><p>Please leave a comment and share your experience! I would love to hear what you thought of the article and if you have any tips to share with me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c58fba930b7" width="1" height="1" alt=""><hr><p><a href="https://itnext.io/firebase-algolia-6c58fba930b7">Firebase + Algolia Searching</a> was originally published in <a href="https://itnext.io/">ITNEXT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Micro frontends — migrating legacy systems]]></title>
            <link>https://medium.com/@kyle_77228/micro-frontends-migrating-legacy-systems-8a6a9d10d4d4?source=rss-1b9e2a8fe076------2</link>
            <guid isPermaLink="false">https://medium.com/p/8a6a9d10d4d4</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[micro-frontends]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[frontend]]></category>
            <dc:creator><![CDATA[Kyle]]></dc:creator>
            <pubDate>Tue, 19 Dec 2017 08:15:23 GMT</pubDate>
            <atom:updated>2017-12-19T08:15:23.327Z</atom:updated>
            <content:encoded><![CDATA[<h4>A modular approach to replacing legacy code</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NJEhCxhaxQV5Q2wQKP129Q.png" /></figure><p>One of the biggest issues we face today is dealing with legacy web systems that were written before we had the knowledge we have today. This is my approach to dealing with the migration.</p><p><strong>Micro frontends</strong> are the new kids on the block. It is an elusive concept that is often misconstrued. The benefit of this concept is that it provides freedom to explore and growth to the frontend developer who engages in it. As opposed to being shoved onto a monolith system to support or burn out on features. If you aren’t familiar with the micro frontend topic have a look at <a href="https://medium.com/@tomsoderlund/micro-frontends-a-microservice-approach-to-front-end-web-development-f325ebdadc16">Tom’s post</a>.</p><p>I first implemented micro frontends in practice when we needed a new module in our customer support admin system, which was no longer maintainable — at least in my mind. I spun up a <a href="https://vuex.vuejs.org/">Vue</a> application using the <a href="https://github.com/vuejs/vue-cli">Vue-cli</a>, with routing, and state management. In addition I included a couple of helpers like LESS and a library with prebuilt Vue components — <a href="http://element.eleme.io/#/en-US">Element</a>.</p><p>I decided to use Vue because of its size, incredible scalability, ease of use for non FE devs and the freedom that allows choice of preferred tools. I hosted the new module on the same domain as the bigger admin app, which allowed the sharing of cookies for authentication, and if the user wasn’t authenticated I simply redirected them to the main application which has the authentication module.</p><p>That alone made this transition extremely easy, and that’s all there is to this in its core. The biggest issue when it comes to using a whole new framework is sharing state, or in this case it was authentication. Having your authentication token stored in a cookie which is stored on the same domain allowed for this behaviour, if you aren’t keeping track of authentication in that manner there are many others ways to solve this.</p><p>I will refrain from tackling the finer things with this post such as having a shared style library as there is already a considerable amount of literature covering this topic . However if you are interested <a href="https://www.smashingmagazine.com/2016/12/styling-web-components-using-a-shared-style-sheet/">this article</a> can get you up to speed. This is quite important for this to work efficiently, it will improve the life of your application in the end as well.</p><p>How will this help migrate the legacy systems to fresher and better systems built around past experiences? <strong>We can start migrating modules in isolation</strong>, while they are still being used. This is where a good framework becomes important, a framework that can support reusable parts your legacy system, your API calls that were written with axios or superagent, your component specific pre-processed styling and your translation module.</p><p>Once all modules are migrated, one essentially has a routing application at its core. At this point if all the modules are using the same framework one can convert your application back into the monolith you once had, which will be a simple task to do. If one avoids confining all modules to the same framework then one can enjoy the freedom of having isolated modules that are independent of one another.</p><p>Share your experiences of using the micro frontend approach with me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a6a9d10d4d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>