<?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 Alex Njoroge on Medium]]></title>
        <description><![CDATA[Stories by Alex Njoroge on Medium]]></description>
        <link>https://medium.com/@njorogealex?source=rss-5f9e4b0d438c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*yodkiQk4z2DSBAKvCIfl5A.jpeg</url>
            <title>Stories by Alex Njoroge on Medium</title>
            <link>https://medium.com/@njorogealex?source=rss-5f9e4b0d438c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 11:08:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@njorogealex/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[Pointers (A Computer Architecture Point of View)]]></title>
            <link>https://medium.com/@njorogealex/pointers-a-computer-architecture-point-of-view-cfe88e17119e?source=rss-5f9e4b0d438c------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfe88e17119e</guid>
            <dc:creator><![CDATA[Alex Njoroge]]></dc:creator>
            <pubDate>Mon, 22 Sep 2025 09:09:54 GMT</pubDate>
            <atom:updated>2025-09-22T09:09:54.809Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/317/1*DH0v3zPZJaDiT6IaSxvp2Q.png" /></figure><h3>Pointers</h3><h4>The basics of Pointers</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5622700550798193954a70715389b469/href">https://medium.com/media/5622700550798193954a70715389b469/href</a></iframe><p><em>The asterisk defines to the C system that the variable int_pointer is of type pointer. </em><strong><em>More precisely, the combination int *specifies that the variable is of type “pointer to int,” meaning that it will be used in the program to indirectly access the value of one or more integer variables.</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bfa05485ba941e06dcd44b2c37dd9a36/href">https://medium.com/media/bfa05485ba941e06dcd44b2c37dd9a36/href</a></iframe><p><strong><em>&amp;</em></strong><em>: This </em><strong><em>unary operator</em></strong><em>, known as the </em><strong><em>address operator</em></strong><em>, is used to make a pointer to an object in C. So if </em><strong><em>x</em></strong><em> is a variable of a particular type, then the expression &amp;x is a pointer to that variable. </em><strong><em>The expression &amp;x can be assigned to any pointer variable, if desired, that has been declared to be a pointer to the same type as x.</em></strong></p><p><em>The address operator sets up the indirect reference between int_pointer and count. </em><strong><em>The address operator has the effect of assigning to the variable int_pointer not the value of count-but a pointer to the variable count.</em></strong></p><p><em>In order to reference the contents of count through the pointer variable int_pointer, we use the indirection operator, which is the asterisk *.So if x were defined to be of type int, then the statement</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c01da8ba573e8439be38ce506a257270/href">https://medium.com/media/c01da8ba573e8439be38ce506a257270/href</a></iframe><p><em>would assign the value that is indirectly referenced through int_pointer to the variable x. Since int_pointer was previously set pointing to count, this statement would have the effect of assigning the value contained in the variable count-which is 10 to the variable x.</em></p><p>Here is the complete program with comments:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bd157a866384b576b31061bdb1d217b/href">https://medium.com/media/5bd157a866384b576b31061bdb1d217b/href</a></iframe><h4>Interesting properties of Pointers</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1d0fc1256e02bbabbdcdb6c57cd5efad/href">https://medium.com/media/1d0fc1256e02bbabbdcdb6c57cd5efad/href</a></iframe><p>This section of the article assumes basic knowledge in c-programming and MIMPS.</p><p>Translate the following MIPS code to C. Assume that the variables f, g, h, i and j are assigned to registers $s0, $s1, $s2, $s3 and $s4, respectively. Assume that the base address of the arrays A and B are in registers $s6 and $s7, respectively:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2f39e82f076d787346e8191b8d03ad78/href">https://medium.com/media/2f39e82f076d787346e8191b8d03ad78/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfe88e17119e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Whats Wrong with Offset Pagination?]]></title>
            <link>https://medium.com/@njorogealex/whats-wrong-with-offset-pagination-fab87612e787?source=rss-5f9e4b0d438c------2</link>
            <guid isPermaLink="false">https://medium.com/p/fab87612e787</guid>
            <category><![CDATA[pagination]]></category>
            <category><![CDATA[pagination-in-django]]></category>
            <dc:creator><![CDATA[Alex Njoroge]]></dc:creator>
            <pubDate>Wed, 28 Dec 2022 11:33:13 GMT</pubDate>
            <atom:updated>2022-12-28T11:33:13.796Z</atom:updated>
            <content:encoded><![CDATA[<p>There are two main ways to implement pagination for your list data in an application:<br>1. Offset pagination<br>2. Cursor pagination</p><p>In this article, I will be discussing the offset pagination and particularly trying to articulate as simply as possible, what is wrong with it.</p><h4>Implementation</h4><p>Offset pagination leverages a SQL query containing an OFFSET value</p><pre>SELECT * from tablename   <br>ORDER BY timestamp        /* unique, sequential column e.g. timestamp */<br>OFFSET 10                 /* offset is page_number * item_per_page */<br>LIMIT 5                   /* limit is item_per_page */</pre><p>The<strong><em> </em></strong>ORDER BYkeyword is used to sort the results-set in an ascending or descending order. It is important to ensure the same order every time we request the results. The default order is ascending.</p><p>The OFFSET keyword dictates the number of rows to skip from the beginning of the returned results-set before presenting the results.</p><p>The LIMIT is used in a query to return up to a specific number of rows in the results-set.</p><h4>So Whats wrong?</h4><p>Duplicate data may be returned</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8F91XPLJV6Be4fD-ChGwDA.png" /></figure><p>Sometimes data may be skipped</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fQXJ2pWbl1RxfKphQC1wHQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fab87612e787" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prototype Design Pattern]]></title>
            <link>https://medium.com/@njorogealex/prototype-design-pattern-acf51adcf323?source=rss-5f9e4b0d438c------2</link>
            <guid isPermaLink="false">https://medium.com/p/acf51adcf323</guid>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[prototype-design]]></category>
            <category><![CDATA[good-software-design]]></category>
            <category><![CDATA[prototype-design-pattern]]></category>
            <dc:creator><![CDATA[Alex Njoroge]]></dc:creator>
            <pubDate>Sun, 05 Jan 2020 17:08:21 GMT</pubDate>
            <atom:updated>2020-01-05T17:08:21.593Z</atom:updated>
            <content:encoded><![CDATA[<p>This is an obvious one. Just like the name suggests, this creational design pattern allows you to copy (deep copy) existing objects without making your code dependent on their classes (i.e. sub-classing them).</p><p>A good example would be in an UI that allows you to copy and paste an element. I assume that behind the scenes the object you are copying would be cloned to a new object that you can paste to another location.</p><p>The problem this pattern fixes is having to manually create an instance of the object’s class and then having to enter the exact same values for all its properties. Imagine how hectic this would for composite objects.</p><p>With the prototype design pattern, you should be careful when cloning complex/composite object to avoid <a href="https://stackoverflow.com/questions/184710/what-is-the-difference-between-a-deep-copy-and-a-shallow-copy">shallow copying</a>.</p><p>Here is a good code example in python from the <a href="https://refactoring.guru/">refactoring guru</a>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a308c57efb08cd8ceff55ec72e7212ec/href">https://medium.com/media/a308c57efb08cd8ceff55ec72e7212ec/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=acf51adcf323" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Builder Design Pattern]]></title>
            <link>https://medium.com/@njorogealex/builder-design-pattern-429ec3f30dc6?source=rss-5f9e4b0d438c------2</link>
            <guid isPermaLink="false">https://medium.com/p/429ec3f30dc6</guid>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[builder-design-pattern]]></category>
            <dc:creator><![CDATA[Alex Njoroge]]></dc:creator>
            <pubDate>Sun, 05 Jan 2020 15:21:20 GMT</pubDate>
            <atom:updated>2020-01-05T15:21:20.278Z</atom:updated>
            <content:encoded><![CDATA[<p>The builder design pattern allows you to flexibly construct different representation of a complex objects. It does so by separating the object representation from its construction. Constructing an object using a class constructor is inflexible because the object representation is coupled with the construction logic.</p><p>Here is a practical example; imagine you want to create a house object from a house class. Problem is, it could be a palace, a castle, a house with a swimming pool, a glass house, a cottage, a townhouse etc etc. These are all different representation of the same house class. Imagine if the house class has a property, swimming pool, but mind you only 1 in 50 houses have a swimming pool, therefore that would be a pretty useless property most in most cases.</p><p>It would be impossible to subclass the house since there are a billion ways someone could choose to build their house. Even if you subclass successfully at some point you will end up with the same problem, inflexibility.</p><p>Now imagine this, you separate all the components of a house i.e. wall, floor, swimming pool, roofing, windows, balcony e.t.c. Now you can choose whether to add a component to the house or not. You can now flexibly build a house with a swimming, a house without a swimming pool, a house with a balcony and glass walls etc etc, these are all different representations of the house.</p><p>Code example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/708048ad7d3b09917a5c971c914af86e/href">https://medium.com/media/708048ad7d3b09917a5c971c914af86e/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=429ec3f30dc6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Factory Method Design Pattern]]></title>
            <link>https://medium.com/@njorogealex/factory-method-design-pattern-421568270506?source=rss-5f9e4b0d438c------2</link>
            <guid isPermaLink="false">https://medium.com/p/421568270506</guid>
            <category><![CDATA[factory-design-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[fog]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Alex Njoroge]]></dc:creator>
            <pubDate>Sun, 05 Jan 2020 12:46:26 GMT</pubDate>
            <atom:updated>2020-01-05T15:43:08.040Z</atom:updated>
            <content:encoded><![CDATA[<p>The factory method design pattern provides a way for sub-classes to alter the type of objects created by an interface.</p><p>In my experience this design pattern occurs naturally especially when you’re trying to reuse code. I have implemented it in Java a lot, but I have not found much use for this pattern in Python.</p><p>Here is a very basic examples of this pattern:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AXKwjcrIPyF_KKWWvWKpbQ.png" /></figure><p>In the example the abstract methods in the <strong>PizzaStore</strong> class are implemented concretely on the different stores. The abstract method <strong><em>createPizza()</em></strong> method in the<strong> PizzaStore</strong> superclass returns an abstract Pizza. Note that, In the <strong><em>createPizza()</em></strong> method returns different types of Pizza in the different subclass <strong>ChicagoStore</strong> and <strong>SeattleStore</strong>. In this example <strong>the factory method is <em>createPizza()</em></strong></p><p>code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2ca2ca5454bce7ea7d369a9538105f62/href">https://medium.com/media/2ca2ca5454bce7ea7d369a9538105f62/href</a></iframe><p>Another example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/643/1*iXMeId-4heGw2gn6uyU-SQ.png" /></figure><p>In this example <strong>the factory method is <em>createTransport()</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=421568270506" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Abstract Factory Design Pattern]]></title>
            <link>https://medium.com/@njorogealex/abstract-factory-design-pattern-1b11f8d9c197?source=rss-5f9e4b0d438c------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b11f8d9c197</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[creational-design-pattern]]></category>
            <category><![CDATA[creational-patterns]]></category>
            <dc:creator><![CDATA[Alex Njoroge]]></dc:creator>
            <pubDate>Sat, 04 Jan 2020 15:47:16 GMT</pubDate>
            <atom:updated>2020-01-04T16:24:16.012Z</atom:updated>
            <content:encoded><![CDATA[<p>As the name suggests abstract factory design pattern is for creating different abstract products/ (polymorphic objects).</p><p>Imagine you are tasked to build a software for a furniture shop. Within your nice software, you have a class that creates chairs. The problem is, these chairs could be either Victorian, Modern or Art Deco. In a well designed program a class should be responsible for only one thing. In your case the class will be responsible for three things; creating modern chairs, creating Victorian chairs and creating art-deco chairs. Your class is also pretty nasty, its riddled with conditionals that keep switching the behavior. Well, you could choose to separate the three classes. In that case, you would have to expose all of them to the client, you cannot just smoothly abstract them away. The client would also need to know which of the classes to call beforehand. In the future, when you add other variant of chairs, you would need to expose them to the client too? There is a chance you will have a lot of repeated code and your code base may be very hard to extend. Remember, you’re not just creating variants of chairs, you’re also creating the same variants for tables, sofas, stools and other furniture. Is there an elegant way to design your code?</p><p>An elegant solution would be the use of an abstract factory design pattern. You would just need a factory interface that creates abstract chairs for your clients, and then nicely hide away the concrete classes that implement the abstract factory for all the variants of your chairs.</p><p>Here is an simple example in code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ea89cda9b9f3b3536897378959807721/href">https://medium.com/media/ea89cda9b9f3b3536897378959807721/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b11f8d9c197" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementing A* Algorithm for Path Planning]]></title>
            <link>https://medium.com/@njorogealex/implementing-a-algorithm-for-path-planning-7362193354d0?source=rss-5f9e4b0d438c------2</link>
            <guid isPermaLink="false">https://medium.com/p/7362193354d0</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[path-planning]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[robotics]]></category>
            <dc:creator><![CDATA[Alex Njoroge]]></dc:creator>
            <pubDate>Thu, 25 Oct 2018 23:54:29 GMT</pubDate>
            <atom:updated>2018-10-29T21:21:28.580Z</atom:updated>
            <content:encoded><![CDATA[<p>I guess I just can’t keep my mouth shut after learning something new. So I participated on Google Kickstart round G and the last and presumably the hardest question was a path planning problem. I learnt about path planning in my Robotics and Algorithms classes about a year ago. Problem is, I had since forgotten everything. After the competition , I decided to jog my memory on path finding, I kept going deeper and deeper, and this article is the upshot of that.</p><h3><strong>Path Planning</strong></h3><p>Sometimes in robotics and gaming we may want to find the optimal path from point A to point B. This most optimal path could be the shortest path, the path that takes the least amount of time to traverse, or the path that needs the least amount of energy to traverse. The process of finding that optimal path is referred to as <strong>Path Planning</strong>.</p><p>Other interesting, direct and indirect applications of path finding are:</p><ol><li><strong>Arbitrage opportunity</strong> -Imagine that you could convert 100,000 Kenyan Shillings to 4,800 Ghanaian Cedis and then the 4,800 Ghanaian Cedis to $1008 which you convert back to 102,020 Kenyan Shillings. Just by converting from currency to currency you make 2,020 Kenya Shillings=$20. This could apply to any asset.</li><li><strong>Word Ladder Puzzles</strong> -Imagine you have the word “cat” and you need to change it to “dog”. However, you can only change one letter at a time. And you can only change from one valid word to another— “cat”, “bat”, “bag”, “bog”, “dog”.</li><li><strong>Shortest Path Between Cities</strong> -You want to go on a road trip from Nairobi to Accra. You have the list of cities in between Nairobi and Accra and the different highways connecting them. Each highway connecting two cities has a cost and scenic beauty value. How would you find the cheapest route between Nairobi and Accra or the most scenic route?</li><li><strong>Computer Networks</strong> -Given a network of computers (eg, a peer-to-peer application), how would you find the shortest path from machine A to machine B.</li><li><strong>Social Network</strong>-You can find the shortest distance between two people in a social media graph. This is often referred to as <em>Degree of Separation</em>. Social media apps like Facebook may use this to recommend you new friends.</li><li><strong>Optimization by Column Generation</strong>-Shortest path problems form the foundation of an entire class of optimization problems that can be solved by a technique called <em>column generation</em>. Examples include vehicle routing problem and survivable network design problem.</li></ol><h3>Path Planning Algorithms</h3><p>By now you have a good mental model of what path planning is and its application. Here are examples of Algorithms that can be used for path planning and their distinctions:</p><ol><li><strong>Wavefront Algorithm</strong> -Given a map, this algorithm explores equally in all possible directions.</li><li><strong>Dijkstra&#39;s Algorithm</strong> -This algorithm favors paths that require lower cost to explore.</li><li><strong>A* Algorithm</strong> -This is a best-first-search algorithm because it searches the most promising directions first i.e. the directions that are closest to the goal.</li></ol><h3><strong>A* Algorithm</strong></h3><p>We are going to implement A* algorithm for a robot that needs to move from point A to point B.</p><h4>The map(grid)</h4><p>Our grid map looks as shown in the image below. The robot needs to find the shortest path between point A(start) and point B(stop).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*dgIuzoWbCI6cXvdiCuHuTg.png" /></figure><p>This can be translated into code as follows. All traversible cells have 0 and all obstacle cells have 1. The cost of traversing from one cell to any of its neighbors is 1.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b26b988b50d68c2d799e0bece5012428/href">https://medium.com/media/b26b988b50d68c2d799e0bece5012428/href</a></iframe><h4>Get Neighbors</h4><p>There are two ways to get the neighbors of a cell as illustrated below:</p><p><strong>4-Point Connectivity</strong></p><p>In this approach only 4 cells (right, left, top, bottom) are considered as neighbors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/254/1*zzelnsv1RKjuJvQlkzhK0A.png" /></figure><p><strong>8-Point Connectivity</strong></p><p>In this approach all 8 cells neighboring a cell are considered as neighbors. This is the approach we will use in this case. The python code implements the illustration below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/265/1*aCR_WaPZZRT1jdtLiO3qnA.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee811ec7b09748cb94d964b8a738c09a/href">https://medium.com/media/ee811ec7b09748cb94d964b8a738c09a/href</a></iframe><h4>Cost of Traversal</h4><p><strong>Heuristic Search</strong></p><p>We will use the estimated distance from <em>each neighbor</em> to the <em>goal</em> for the priority queue ordering. The <em>neighbor </em>closest to the goal will be explored first.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7397772ab8b9e2e79078df7a2126292a/href">https://medium.com/media/7397772ab8b9e2e79078df7a2126292a/href</a></iframe><p><strong>Cost of moving from current cell to a neighbor</strong></p><p>If a neighbor has 0 it means that it is traversible and therefore the cost of moving from the current cell to the neighbor is 1.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/40d175dd2f5b4b90b58e67465261c090/href">https://medium.com/media/40d175dd2f5b4b90b58e67465261c090/href</a></iframe><h4>A* Algorithm</h4><p>A* uses a priority list to determine the order of traversal of each cell.</p><blockquote>priority = heuristics + cost</blockquote><p>Here are the steps:</p><ol><li>Put the start cell into the priority list with a priority of 0.</li><li>While the priority list is not empty, get the cell with the lowest priority from the queue. If cell = goal, break.</li><li>Get the neighbors of the cell.</li><li>For each neighbor calculate its priority (heuristics + cost), and add it into the priority list.</li><li>Store the predecessor of each node in a map.</li><li>Return the predecessors map.</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/262b843b13f11d027d1800bc65048cff/href">https://medium.com/media/262b843b13f11d027d1800bc65048cff/href</a></iframe><h4>Build the Optimal Path</h4><p>Given the predecessors map from the A* algorithm above, you should now develop the optimal path.</p><p>Steps: Starting from the goal, continuously get the predecessor of each cell until you arrive at the start cell. This is know as <strong><em>back tracking</em></strong>. Below is the python code for that.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/436b32c78bc7ca63bac905ff985907ae/href">https://medium.com/media/436b32c78bc7ca63bac905ff985907ae/href</a></iframe><p>Bring it all together nicely:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/60f901d1edbdbd1606aa407bea426338/href">https://medium.com/media/60f901d1edbdbd1606aa407bea426338/href</a></iframe><p>Here is the complete code for this example</p><p><a href="https://github.com/alexwaweru/Astar-algorithm">alexwaweru/Astar-algorithm</a></p><p>Thanks for Reading through !!!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7362193354d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>