<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Hassam Uddin | Developer</title>
    <link>https://hassamuddin.com/</link>
    <description>Recent content on Hassam Uddin | Developer</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language><atom:link href="https://hassamuddin.com/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Parallel Programming Syllabus</title>
      <link>https://hassamuddin.com/blog/cuda-syllabus/</link>
      <pubDate>Sun, 28 Jul 2024 16:35:31 -0500</pubDate>
      
      <guid>https://hassamuddin.com/blog/cuda-syllabus/</guid>
      <description>Whenever I am trying to learn something new, I tend to spend about a day (or longer depending on scope) doing research on the best resources to use. I keep these to myself, but I was recently building a syllabus for learning CUDA and some friends recommended I formalize and share it.
Just give me the syllabus If you don&amp;rsquo;t want to read my yapping, this is the syllabus with no added commentary:</description>
    </item>
    
    <item>
      <title>Svelte Authentication</title>
      <link>https://hassamuddin.com/blog/svelte-authentication/</link>
      <pubDate>Mon, 22 Jul 2024 08:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/svelte-authentication/</guid>
      <description>I&amp;rsquo;ve been working on a hobby project in Svelte for the past few weeks and have been struggling to find resources on doing proper authentication when using a backend alongside SvelteKit. Here&amp;rsquo;s the setup:
Svelte Frontend &amp;ndash; Svelte is extremely refreshing to use and makes me genuinely enjoy writing frontend code. The ecosystem is growing, and I think it&amp;rsquo;s a serious contender to React, at least for hobby projects. SvelteKit &amp;ndash; Svelte is significantly stunted without SvelteKit.</description>
    </item>
    
    <item>
      <title>Algorithmically Parsing Gameboy Opcodes</title>
      <link>https://hassamuddin.com/blog/gb-algo/</link>
      <pubDate>Wed, 03 Feb 2021 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/gb-algo/</guid>
      <description>There are a few projects I think everyone should undertake at least once:
A compiler An operating system An emulator I&amp;rsquo;m not really interested in embedded or systems development, but these projects have taught me immensely about the inner workings of the computer and the tools that programmers use. One of my issues with emulator development is that if you want to emulate something more modern, say the Gameboy, you&amp;rsquo;re going to have to implement every single opcode that the CPU handles.</description>
    </item>
    
    <item>
      <title>Extending Euler&#39;s method</title>
      <link>https://hassamuddin.com/blog/extended-euler/</link>
      <pubDate>Thu, 03 Dec 2020 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/extended-euler/</guid>
      <description>Last time, I discussed two of Euler&amp;rsquo;s methods for numerical approximation, explicit and implicit Euler. In this blog post, we&amp;rsquo;re going to extend the idea of Euler&amp;rsquo;s method, and then generalize our extension into something called Runge-Kutta. I apologize for the delay between blog posts, I&amp;rsquo;ve been working on college apps, but I hope to get a bit more active now, especially with the Advent of Code going on.
Extended Euler (or Heun&amp;rsquo;s Method) When we worked with explicit Euler, we stepped forward by \( h \) , but we found the slope only at our given \( (x, y) \) .</description>
    </item>
    
    <item>
      <title>Exploring Euler&#39;s Methods for Solving ODEs</title>
      <link>https://hassamuddin.com/blog/euler/</link>
      <pubDate>Sat, 12 Sep 2020 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/euler/</guid>
      <description>I&amp;rsquo;m currently taking Differential Equations in school and during class Euler&amp;rsquo;s method was a brief topic of discussion. Euler&amp;rsquo;s method is really simple, but it works really well. As my teacher puts it, we &amp;ldquo;dumbass&amp;rdquo; our way to the right answer. There are better methods than it that have faster convergence, less error, or more efficiency, but during my journey of trying to learn about them, I&amp;rsquo;ve found that they&amp;rsquo;re explained with unnecessary complexity.</description>
    </item>
    
    <item>
      <title>Writing an asynchronous MQTT Broker in Rust - Part 3</title>
      <link>https://hassamuddin.com/blog/rust-mqtt/channels/</link>
      <pubDate>Fri, 28 Aug 2020 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/rust-mqtt/channels/</guid>
      <description>When I began this project, many months ago, there were no good resources on Tokio. I procrastinated on writing this blog series, but my intention was for it to be a guide on using Tokio and implementing a real project. A reference of sorts. When I began populating this blog in March, there still weren&amp;rsquo;t any resources. That is no longer the case. I recently discovered that Tokio added a much better tutorial in June.</description>
    </item>
    
    <item>
      <title>Writing an asynchronous MQTT Broker in Rust - Part 2.5</title>
      <link>https://hassamuddin.com/blog/rust-mqtt/codec/</link>
      <pubDate>Sun, 09 Aug 2020 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/rust-mqtt/codec/</guid>
      <description>I was a little annoyed at needing to use an older version of tokio-util in our previous post, so in this short little post, we&amp;rsquo;re going to write our own Codec and transition our code.
Purpose When I began this project, many months ago, there were no good resources on Tokio. I procrastinated on writing this blog series, but my intention was for it to be a guide on using Tokio and implementing a real project.</description>
    </item>
    
    <item>
      <title>A Quick Introduction to Register Allocation</title>
      <link>https://hassamuddin.com/blog/reg-alloc/</link>
      <pubDate>Sun, 26 Jul 2020 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/reg-alloc/</guid>
      <description>Most overviews of register allocation are ridiculously complex and not at all practical. I hope, that by the end of this reading, you will gain a deeper understanding of the vocabulary and concepts that are often employed when discussing register allocation. Near the end, I&amp;rsquo;ll have a full-blown linear scan register allocator written in OCaml. If you want to follow along, you can find the code here.
What is Register Allocation?</description>
    </item>
    
    <item>
      <title>Writing an asynchronous MQTT Broker in Rust - Part 2</title>
      <link>https://hassamuddin.com/blog/rust-mqtt/ping-pong/</link>
      <pubDate>Tue, 14 Jul 2020 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/blog/rust-mqtt/ping-pong/</guid>
      <description>In the last section, we went over the MQTT protocol and our proposed architecture. By the end of this tutorial, we&amp;rsquo;ll have a tiny little broker that will accept clients and play ping-pong, and we&amp;rsquo;ll also have learned a bit about Tokio and how to use it. So let&amp;rsquo;s get started. Now, my Rust isn&amp;rsquo;t the greatest, some of you probably know way more than I do. If you&amp;rsquo;ve got any criticisms, I encourage you to send them to me.</description>
    </item>
    
    <item>
      <title>Kosaraju&#39;s Algorithm for finding Strongly Connected Components</title>
      <link>https://hassamuddin.com/blog/kosaraju/</link>
      <pubDate>Fri, 03 Jul 2020 14:12:27 -0500</pubDate>
      
      <guid>https://hassamuddin.com/blog/kosaraju/</guid>
      <description>Recently I&amp;rsquo;ve been retaking some classes that I had taken a few years ago, now with much more experience and a better mindset to learn. Specifically, I&amp;rsquo;m retaking Stanford&amp;rsquo;s Algorithms: Design and Analysis class on Coursera.
In doing so, I&amp;rsquo;ve gained a significant amount of appreciation for the elegant techniques and methods that algorithm developers have found. Most recently, I learned about Kosaraju&amp;rsquo;s algorithm for finding strongly connected components (SCCs) in a directed graph, and I thought it was ridiculously elegant and clean.</description>
    </item>
    
    <item>
      <title>Writing an asynchronous MQTT Broker in Rust - Part 1</title>
      <link>https://hassamuddin.com/blog/rust-mqtt/overview/</link>
      <pubDate>Sun, 28 Jun 2020 00:54:12 -0500</pubDate>
      
      <guid>https://hassamuddin.com/blog/rust-mqtt/overview/</guid>
      <description>The amount of resources and tutorials available for complex asynchronous programming in Rust and Tokio is abysmal. When I was developing this project, I was very frustrated with the lack of good examples and I promised myself that I would create my own tutorial. That&amp;rsquo;s what you are reading right now.
There&amp;rsquo;s going to be very little code in this first section; I like to understand what I&amp;rsquo;m dealing with and how I&amp;rsquo;m going to approach it before I write any code.</description>
    </item>
    
    <item>
      <title>Projects</title>
      <link>https://hassamuddin.com/projects/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://hassamuddin.com/projects/</guid>
      <description>todo</description>
    </item>
    
  </channel>
</rss>
