<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Blogs on Muhammed Uluyol</title>
    <link>https://uluyol.xyz/blog/</link>
    <description>Recent content in Blogs on Muhammed Uluyol</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Fri, 28 Oct 2022 10:47:42 -0700</lastBuildDate><atom:link href="https://uluyol.xyz/blog/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Testing With Fewer Mocks</title>
      <link>https://uluyol.xyz/blog/testing-with-fewer-mocks/</link>
      <pubDate>Fri, 28 Oct 2022 10:47:42 -0700</pubDate>
      
      <guid>https://uluyol.xyz/blog/testing-with-fewer-mocks/</guid>
      <description>While I was working on HEYP, I implemented a monte carlo simulator to study the behavior of a particular component. As part of this, I wrote a loop that looked something like this (written in C++1):
ProcessResult ProcessFunc(Scenario* scenario) { ProcessResult res; for (int i = 0; i &amp;lt; kMaxIters; i++) { auto stats = scenario-&amp;gt;RunOneIter(); res.all_stats.push_back(stats); bool stopEarly = // look at the values in stats and see if we should terminate early if (stopEarly) { // process more stats and set some fields in res break; } else { // other processing in res } } return res; } This sort of code is difficult to test as is.</description>
    </item>
    
    <item>
      <title>Graduate Student Instructor Award</title>
      <link>https://uluyol.xyz/blog/gsi-award/</link>
      <pubDate>Wed, 11 Aug 2021 12:07:51 -0400</pubDate>
      
      <guid>https://uluyol.xyz/blog/gsi-award/</guid>
      <description>I&amp;rsquo;m honored to receive this award for outstanding GSIs. The fact that I received the award is mainly a testament to the amount of time Harsha puts into each class and the curriculum as a whole. I should also acknowledge that EECS 491 is based on distributed systems offerings at other universities, and so it has had the benefit of being refined multiple times.
I will be a GSI for EECS 491 this Fall, so hopefully I can live up to this standard.</description>
    </item>
    
    <item>
      <title>Hashicorp on &#34;Why Multi-Cloud?&#34;</title>
      <link>https://uluyol.xyz/blog/hashicorp-on-why-multi-cloud/</link>
      <pubDate>Sun, 04 Nov 2018 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/hashicorp-on-why-multi-cloud/</guid>
      <description>Mitchell Hashimoto (Hashicorp Founder and CTO) commented on Reddit on why certain corporations care about Multi-Cloud deployments. I have copied the original post below:
This is something I can provide very broad real world insight into. I routinely talk with dozens of users and paying customers that are multi-cloud (biased towards the Global 2000 size) and can share the real reasons why folks are doing this.
First, if you&amp;rsquo;re a small company, you probably don&amp;rsquo;t want to think about multi-cloud.</description>
    </item>
    
    <item>
      <title>Raymond Chen&#39;s PowerPC 600 Series</title>
      <link>https://uluyol.xyz/blog/raymond-chens-powerpc/</link>
      <pubDate>Sun, 26 Aug 2018 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/raymond-chens-powerpc/</guid>
      <description>Following his other architecture series, here is an architecture series on the PowerPC 600 by Raymond Chen:
Part 1: Introduction Part 2: Condition registers and the integer exception register Part 3: Arithmetic Part 4: Bitwise operations and constants Part 5: Rotates and shifts Part 6: Memory access Part 7: Atomic memory access and cache coherency Part 8: Control transfer Part 9: The table of contents Part 10: Passing parameters, function prologues and epilogues Part 11: Glue routines Part 12: leaf functions Part 13: Common patterns Part 14: Code walkthrough </description>
    </item>
    
    <item>
      <title>Chaining RPCs</title>
      <link>https://uluyol.xyz/blog/chaining-rpcs/</link>
      <pubDate>Sat, 28 Jul 2018 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/chaining-rpcs/</guid>
      <description>Remote Procedure Calls (RPCs) are a widely used primitive for communication in distributed applications. In short, they allow a client the ability to invoke a function on a remote server. gRPC, REST, Apache Thrift, and Cap&amp;rsquo;n Proto are just some of the ways that RPCs are used today. However, RPCs only allow for client-server communication patterns. RPC Chains from Microsoft Research are meant to address that.
Execution Flow of regular RPCs (left) vs RPC Chains (right)</description>
    </item>
    
    <item>
      <title>Raymond Chen&#39;s MIPS R4000 Series</title>
      <link>https://uluyol.xyz/blog/raymond-chens-mips-r4000/</link>
      <pubDate>Fri, 20 Apr 2018 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/raymond-chens-mips-r4000/</guid>
      <description>Following his series on the Itanium architecture and Alpha AXP, here is yet another architecture series by Raymond Chen:
Part 1: Introduction Part 2: 32-bit Integer Calculations Part 3: Multiplication, Division, and the Temperamental HI and LO Registers Part 4: Constants Part 5: Memory Access (Aligned) Part 6: Memory Access (Unaligned) Part 7: Memory Access (Atomic) Part 8: Control Transfer Part 9: Stupid Branch Delay Slot Tricks Part 10: Trampolines and Stubs Part 11: More on Branch Delay Slots Part 12: Calling Convention Part 13: Function Prologues and Epilogues Part 14: Common patterns Part 15: Code Walkthrough </description>
    </item>
    
    <item>
      <title>Fast Data Migration</title>
      <link>https://uluyol.xyz/blog/fast-data-migration/</link>
      <pubDate>Tue, 21 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/fast-data-migration/</guid>
      <description>An SOSP&#39;17 paper from the University of Utah used an interesting approach to speed up data migration. As usual, none of the techniques themselves are new, but the way they are applied is. This paper aims to improve the performance of data migration in an in-memory key-value store. The main goals are to migrate data without any loss in availability, minimal disruption to latency, and to complete the migration as quickly as possible.</description>
    </item>
    
    <item>
      <title>Verifying Little Bits of Big Data</title>
      <link>https://uluyol.xyz/blog/verifying-little-bits-of-data/</link>
      <pubDate>Wed, 08 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/verifying-little-bits-of-data/</guid>
      <description>Most data is small. Filesystems store executables, text files, configuration files, and a few large files. Databases are enormous tables of small rows. Version control systems are chains of directory trees made up of small bits of code. Because of the volume of data, efficiently managing this becomes difficult. In this post, we&amp;rsquo;re going to look at how to verify that data hasn&amp;rsquo;t been corrupted or tampered with.
To start, we will assume that most data has not been corrupted.</description>
    </item>
    
    <item>
      <title>Container-Based Hosting</title>
      <link>https://uluyol.xyz/blog/container-based-hosting/</link>
      <pubDate>Thu, 28 Sep 2017 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/container-based-hosting/</guid>
      <description>I recently switched hosting providers. In the process, I decided to switch to running all my services inside of containers.
Why? Let&amp;rsquo;s take a look at my previous server environment: I had
Some version of nginx serving static files and acting as a reverse proxy for gogs and ghost Let&amp;rsquo;s Encrypt client running periodically and copying certificates for nginx Init or cron would run this, maybe both? Some version of Ghost running under some version of node.</description>
    </item>
    
    <item>
      <title>Raymond Chen&#39;s Alpha AXP Series</title>
      <link>https://uluyol.xyz/blog/raymond-chens-alpha-axp-series/</link>
      <pubDate>Tue, 05 Sep 2017 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/raymond-chens-alpha-axp-series/</guid>
      <description>Raymond Chen previously wrote an excellent series of posts on the Itanium archicture, and now he&amp;rsquo;s followed that up with a series on the Alpha AXP. Below are links to the whole series:
Part 1: Initial plunge Part 2: Integer calculations Part 3: Integer constants Part 4: Bit 15. Ugh. Bit 15. Part 5: Conditional operations and control flow Part 6: Memory access, basics Part 7: Memory access, loading unaligned data Part 8: Memory access, storing bytes and words and unaligned data Part 9: The memory model and atomic memory operations Part 10: Atomic updates to byte and word memory units Part 11: Processor faults Part 12: How you detect carry on a processor with no carry?</description>
    </item>
    
    <item>
      <title>This Blog – Brought to You by Vultr</title>
      <link>https://uluyol.xyz/blog/this-blog-brought-to-you-by-vultr/</link>
      <pubDate>Thu, 10 Aug 2017 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/this-blog-brought-to-you-by-vultr/</guid>
      <description>As I recently switched hosting providers, I thought I&amp;rsquo;d offer a quick comparison between them. I am not receiving any commission for this post.
This site used to be hosted on one of Scaleway&amp;rsquo;s C1 machines. As someone who lives in the US, Europe-based hosting has annoyingly high latency. I recently found out about Vultr and am now using their smallest offering. Below is a quick spec comparison:
Scaleway C1Vultr CPU4-Core ARMv7Single-Core 2.</description>
    </item>
    
    <item>
      <title>Raymond Chen&#39;s Itanium Series</title>
      <link>https://uluyol.xyz/blog/raymond-chen-itanium/</link>
      <pubDate>Sun, 27 Dec 2015 00:00:00 +0000</pubDate>
      
      <guid>https://uluyol.xyz/blog/raymond-chen-itanium/</guid>
      <description>Raymond Chen wrote a very interesting introduction to the Itanium architecture and how it is used in Windows. I have collected links for the series of posts below:
Part 1: Warming up Part 2: Instruction encoding, templates, and stops Part 3: The Windows calling convention, how parameters are passed Part 3b: How does spilling actually work? Part 4: The Windows calling convention, leaf functions Part 5: The GP register, calling functions, and function pointers Part 6: Calculating conditionals Part 7: Speculative loads Part 8: Advanced loads Part 9: Counted loops and loop pipelining Part 10: Register rotation </description>
    </item>
    
  </channel>
</rss>
