<?xml version="1.0" encoding="utf-8"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Maxnilz🌴</title>
    <link>https://maxnilz.com</link>
    <description>Maxnilz🌴</description>
    <language>en-us</language>
    <lastBuildDate>Wed, 15 Apr 2026 11:28:39 &#43;0800</lastBuildDate>
    <atom:link href="https://maxnilz.com/" rel="self" type="application/rss+xml" /><item>
      <title>Building RocksDB-like storage: Merging Iterator and Range Deletions</title>
      <link>https://maxnilz.com/posts/035-cckv-merging-iterator/</link>
      <guid>https://maxnilz.com/posts/035-cckv-merging-iterator/</guid>
      <pubDate>Tue, 27 Jan 2026 00:00:00 &#43;0000</pubDate>
      <description>The implementation details for the Merging Iterator in cckv.  This is the second post in a series documenting the development of cckv, a RocksDB-like KV storage engine written in C&#43;&#43;20 for my experimental database sboxdb.
 First post: Building RocksDB-like KV: Range Tombstones and MVCC Point Lookups </description>
    </item><item>
      <title>Understanding MinIO Erasure Coding: Erasure Sets, Quorums, Degraded States, and Recovery at Scale</title>
      <link>https://maxnilz.com/posts/034-minio-ec/</link>
      <guid>https://maxnilz.com/posts/034-minio-ec/</guid>
      <pubDate>Thu, 22 Jan 2026 00:00:00 &#43;0000</pubDate>
      <description>This post explains how MinIO implements erasure coding (EC) in practice—covering erasure sets, shard layout, read/write quorums, disk-full behavior, degraded operation, recovery (rebalance &#43; heal), and how MinIO can safely scan very large object namespaces without collapsing under load.  Summarized by ChatGPT from the Q/As in ChatGPT.
</description>
    </item><item>
      <title>Building RocksDB-like storage, part1: Range Tombstones and Point Lookups</title>
      <link>https://maxnilz.com/posts/033-cckv-range-tombstone/</link>
      <guid>https://maxnilz.com/posts/033-cckv-range-tombstone/</guid>
      <pubDate>Tue, 13 Jan 2026 00:00:00 &#43;0000</pubDate>
      <description>The implementation details for Range Tombstones and Point Lookups in cckv.  This is the first post in a series documenting the development of cckv, a RocksDB-like KV store written in C&#43;&#43;20 for my experimental database sboxdb.
</description>
    </item><item>
      <title>Understand special member function generation</title>
      <link>https://maxnilz.com/docs/005-lang/moderncpp/007-special-members/</link>
      <guid>https://maxnilz.com/docs/005-lang/moderncpp/007-special-members/</guid>
      <pubDate>Sat, 29 Nov 2025 11:01:13 &#43;0800</pubDate>
      <description>In modern C&#43;&#43;, there are six special member functions for a class:
 Default Constructor, a.k.a, ctor, T() Copy Constructor, a.k.a, copy ctor, T(const T&amp;amp;) Copy Assignment, a.k.a, copy assign, T&amp;amp; operator=(const T&amp;amp;) Move Constructor, a.k.a, move ctor, T(T&amp;amp;&amp;amp;) Move Assignment, a.k.a, move assign, T&amp;amp; operator=(T&amp;amp;&amp;amp;) Destructor, a.k.a, dtor, ~T()  The compiler generated version #     Special member Implicitly declared when… Implicitly deleted when…     Default ctor No user-declared constructor(Copy ctor is also called ctor) A base/member is not default-constructible   Destructor If not user-declared A base/member destructor is deleted   Copy ctor No user-declared copy ctor A base/member is not copy-constructible   Copy assign No user-declared copy assignment A base/member is not copy-assignable   Move ctor No copy/move ctor/assign and no user-declared destructor A base/member is not move-constructible   Move assign Same as move ctor A base/member is not move-assignable    Deleted means the function is declared (either implicitly or explicitly) but marked unusable.</description>
    </item><item>
      <title>A memo for Linux I/O and Filesystem</title>
      <link>https://maxnilz.com/posts/031-file-api-rev1/</link>
      <guid>https://maxnilz.com/posts/031-file-api-rev1/</guid>
      <pubDate>Thu, 27 Nov 2025 00:00:00 &#43;0000</pubDate>
      <description>A memo for Linux I/O and Filesystem, collected from AI chat threads  This memo is an extended memo for this post, consolidates knowledge about:
 VFS &amp;amp; Filesystem Delegation File descriptors &amp;amp; open file table stdio / unbuffered / direct I/O Page Cache, Writeback fsync vs fdatasync (accurate across ext4, XFS, Btrfs, ZFS) open flags Pipes, dup2 fork, clone, exec splice / zero-copy design  Designed as a reference entry for systems and storage engine development.
</description>
    </item><item>
      <title>Struct vs. Class</title>
      <link>https://maxnilz.com/docs/005-lang/moderncpp/008-struct-class/</link>
      <guid>https://maxnilz.com/docs/005-lang/moderncpp/008-struct-class/</guid>
      <pubDate>Mon, 17 Nov 2025 11:50:08 &#43;0800</pubDate>
      <description>The content is gathered from chatgpt  Struct vs. Class #  struct and class are interchangeable except for defaults:
 struct members and base classes are public by default. class members and base classes are private by default. Otherwise they behave identically (constructors, inheritance, virtuals, templates, etc.). Style: prefer struct for plain-data / public interfaces and class for encapsulation.  The snippet shows the default member and inheritance access differences and how to make them explicit.</description>
    </item><item>
      <title>Memory Consistency models</title>
      <link>https://maxnilz.com/docs/006-arch/007-mem-consistency/</link>
      <guid>https://maxnilz.com/docs/006-arch/007-mem-consistency/</guid>
      <pubDate>Mon, 03 Nov 2025 17:33:10 &#43;0800</pubDate>
      <description>Memory Consistency models #  A learning note for CMU 15-418/618 Lecture 13.  Memory coherence vs. memory consistency #  Memory coherence defines the requirements for the observed behavior of reads and writes to the same memory location:
 All processors must agree on the order of reads/writes to X In other words: It is possible to put operations involving X on a timeline such that the observations of all processors are consistent with that timeline The goal of cache/memory coherence is to ensure that the memory systme in a parallel computer behaves as if the caches were not there, i.</description>
    </item><item>
      <title>Memory Layout of C&#43;&#43; Object in Different Scenarios</title>
      <link>https://maxnilz.com/docs/005-lang/moderncpp/006-class-layout/</link>
      <guid>https://maxnilz.com/docs/005-lang/moderncpp/006-class-layout/</guid>
      <pubDate>Sun, 26 Oct 2025 18:23:28 &#43;0800</pubDate>
      <description>Memory Layout of C&#43;&#43; Object in Different Scenarios #  The content is copied from this post  In this article, we will see the memory layout of different C&#43;&#43; Object. And how different storage &amp;amp; access specifiers affect this memory footprint. I am not going to discuss compiler augmented code, name mangling &amp;amp; working of any C&#43;&#43; mechanism related to memory as it is compiler &amp;amp; architecture-dependent. To keep this further simple, I have considered the standard stack growth direction i.</description>
    </item><item>
      <title>A Collection papers that accelerate DBMS with LLMs</title>
      <link>https://maxnilz.com/posts/030-db-with-llm/</link>
      <guid>https://maxnilz.com/posts/030-db-with-llm/</guid>
      <pubDate>Fri, 23 May 2025 00:00:00 &#43;0000</pubDate>
      <description>Growing interest and potential in applying generative AI and LLMs to various aspects of DBMS development </description>
    </item><item>
      <title>Rust type categories</title>
      <link>https://maxnilz.com/posts/029-rust-types/</link>
      <guid>https://maxnilz.com/posts/029-rust-types/</guid>
      <pubDate>Tue, 17 Dec 2024 00:00:00 &#43;0000</pubDate>
      <description>Notes for the rust type categories  For rust fundamental types, the serde crate serializer and deserializer provide a reasonable type categories for grouping the complex types when serializing or deserializing a type.
</description>
    </item><item>
      <title>Hardware speeds are shifting</title>
      <link>https://maxnilz.com/posts/028-hd/</link>
      <guid>https://maxnilz.com/posts/028-hd/</guid>
      <pubDate>Thu, 30 May 2024 00:00:00 &#43;0000</pubDate>
      <description>The dominant speeds of hardware components are shifting.
</description>
    </item><item>
      <title>Reference in Rust vs. C&#43;&#43;</title>
      <link>https://maxnilz.com/posts/027-rust-rer/</link>
      <guid>https://maxnilz.com/posts/027-rust-rer/</guid>
      <pubDate>Wed, 20 Mar 2024 00:00:00 &#43;0000</pubDate>
      <description>Notes for the reference in rust  Switching to Rust from C&#43;&#43; would encounter this question: does the reference sematics in rust is same as the C&#43;&#43;?, Let&amp;rsquo;s describe it with an example.
</description>
    </item><item>
      <title>Durability: Linux File APIs</title>
      <link>https://maxnilz.com/posts/025-file-api-durability/</link>
      <guid>https://maxnilz.com/posts/025-file-api-durability/</guid>
      <pubDate>Wed, 29 Nov 2023 00:00:00 &#43;0000</pubDate>
      <description>The content is COPIED from this awesome post as reference to myself.  As part of investigating the durability provided by cloud systems, I wanted to make sure I understood the basics.
</description>
    </item><item>
      <title>Replicating Database Changes to a Message Queue is Tricky</title>
      <link>https://maxnilz.com/posts/024-db-replication/</link>
      <guid>https://maxnilz.com/posts/024-db-replication/</guid>
      <pubDate>Mon, 27 Nov 2023 00:00:00 &#43;0000</pubDate>
      <description>Let&amp;rsquo;s imagine we have an program that stores its state in a database, and we want other programs to do things when changes occur.
</description>
    </item><item>
      <title>DFS in 2 Ways</title>
      <link>https://maxnilz.com/docs/001-ds/graph/001-deep-first-search/</link>
      <guid>https://maxnilz.com/docs/001-ds/graph/001-deep-first-search/</guid>
      <pubDate>Fri, 27 Oct 2023 16:58:48 &#43;0800</pubDate>
      <description>Depth First Search (DFS) – Iterative and Recursive Implementation #  Depth–first search (DFS) is an algorithm for traversing or searching tree or graph data structures. One starts at the root (selecting some arbitrary node as the root for a graph) and explore as far as possible along each branch before backtracking.  Introduction #  The following graph shows the order in which the nodes are discovered in DFS:</description>
    </item><item>
      <title>Detect cycle in 3 Ways</title>
      <link>https://maxnilz.com/docs/001-ds/graph/003-detect-cycle/</link>
      <guid>https://maxnilz.com/docs/001-ds/graph/003-detect-cycle/</guid>
      <pubDate>Fri, 27 Oct 2023 11:24:15 &#43;0800</pubDate>
      <description>Check if a graph contains a cycle in 3 ways #  Cycle detection is an application that is widely used in deadlock detection, wait-for graph, or dependencies analysis, this post is implementing cycle detection in 3 ways.  Introduction #  Given a connected undirected graph, check if it contains any cycle or not.
For example, the following graph contains a cycle 2-5-10-6-2:
1. Using BFS #  When we do a Breadth–first search (BFS) from any vertex v in an undirected graph, we may encounter a cross-edge that points to a previously discovered vertex that is neither an ancestor nor a descendant of the current vertex.</description>
    </item><item>
      <title>Distributed system concepts</title>
      <link>https://maxnilz.com/docs/006-arch/008-dist-sys-concepts/</link>
      <guid>https://maxnilz.com/docs/006-arch/008-dist-sys-concepts/</guid>
      <pubDate>Thu, 19 Oct 2023 12:23:51 &#43;0800</pubDate>
      <description>Distributed system concepts #  A learning notes extracted from MIT 6.824 Lecture 3 and Lecture 8.  The contradictory loop #  Often the starting point for people designing big distributed system or big storage system is that they want to get huge aggregated performance and harness the resources of hundreds of machines in order to get a huge amount of work done.
So, the natural next thought is to split the data over a huge number of servers in order to read/write many servers in parallel, this split process is called sharding or partitioning.</description>
    </item><item>
      <title>Data Alignment in Memory</title>
      <link>https://maxnilz.com/docs/006-arch/006-mem-alignment/</link>
      <guid>https://maxnilz.com/docs/006-arch/006-mem-alignment/</guid>
      <pubDate>Mon, 16 Oct 2023 16:02:15 &#43;0800</pubDate>
      <description>Structure Member Alignment, Padding and Data Packing #  Tthe content is copied from this post with some modification.  In languages like C/C&#43;&#43;, Go, the structures are used as data packs. They don’t provide any data encapsulation or data hiding features.
In this article, we will discuss the property of structure padding in C along with data alignment and structure packing, the same could apply to Go as well.</description>
    </item><item>
      <title>Modern Multi-Core Processor Basics</title>
      <link>https://maxnilz.com/docs/006-arch/001-cpu-basics/</link>
      <guid>https://maxnilz.com/docs/006-arch/001-cpu-basics/</guid>
      <pubDate>Mon, 16 Oct 2023 15:19:19 &#43;0800</pubDate>
      <description>Modern Multi-Core Processor Basics #  A learning note for CMU 15-418/618 Lecture 1 and Lecture 2.  Introduction #  Nowdays, single-thread-of-control(single-instruction-stream-control) performance is improving very slowly, to run programs significantly faster, programs must utilize multiple processing elements, which means we need to know how to write parallel code. Writing parallel programs can be challenging, it requires problem partitioning, communication, and synchronization. The knowledge of machine characteristics is essential.</description>
    </item><item>
      <title>Database Storage Models</title>
      <link>https://maxnilz.com/docs/003-database/005-database-storage-model/</link>
      <guid>https://maxnilz.com/docs/003-database/005-database-storage-model/</guid>
      <pubDate>Mon, 16 Oct 2023 10:29:03 &#43;0800</pubDate>
      <description>Database Storage Models #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  Overview #  A DBMS&amp;rsquo;s storage model specifies how it physically organizes tuples on disk and in memory
Different DBMS workloads would benefit from different storage models.
 Choice #1: N-ary Storage Model (NSM) Choice #2: Decomposition Storage Model (DSM) Choice #3: Hybrid Storage Model (PAX)  Basically, What data &amp;ldquo;looks&amp;rdquo; like determins almost a DBMS&amp;rsquo;s entire system architecture like</description>
    </item><item>
      <title>Scheduling In Go: Part 3 - Go Scheduler</title>
      <link>https://maxnilz.com/docs/005-lang/golang/004-gosch-3/</link>
      <guid>https://maxnilz.com/docs/005-lang/golang/004-gosch-3/</guid>
      <pubDate>Mon, 28 Aug 2023 11:07:15 &#43;0800</pubDate>
      <description>Scheduling In Go: Part 3 - Go Scheduler #  Most of the content is copied from this post
This is the third post in a three part series that will provide an understanding of the mechanics and semantics behind the scheduler in Go. This post focuses on the Go scheduler.
Index of the three part series:
 Scheduling In Go: Part 1 - Overview Scheduling In Go: Part 2 - Go Scheduler Scheduling In Go: Part 3 - Concurrency   Introduction #  In the previous part of this scheduling series, I explained aspects of the operating-system scheduler that I believe are important in understanding and appreciating the semantics of the Go scheduler.</description>
    </item><item>
      <title>Scheduling In Go: Part 2 - OS Scheduler</title>
      <link>https://maxnilz.com/docs/005-lang/golang/003-gosch-2/</link>
      <guid>https://maxnilz.com/docs/005-lang/golang/003-gosch-2/</guid>
      <pubDate>Mon, 28 Aug 2023 11:00:30 &#43;0800</pubDate>
      <description>Scheduling In Go: Part 2 - OS Scheduler #  Most of the content is copied from this post
This is the second post in a three part series that will provide an understanding of the mechanics and semantics behind the scheduler in Go. This post focuses on the operating system scheduler.
Index of the three part series:
 Scheduling In Go: Part 1 - Overview Scheduling In Go: Part 2 - Go Scheduler Scheduling In Go: Part 3 - Concurrency   Introduction #  The design and behavior of the Go scheduler allows your multithreaded Go programs to be more efficient and performant.</description>
    </item><item>
      <title>Timestamp Ordering Concurrency Control</title>
      <link>https://maxnilz.com/docs/003-database/017-timestampordering/</link>
      <guid>https://maxnilz.com/docs/003-database/017-timestampordering/</guid>
      <pubDate>Fri, 14 Jul 2023 09:50:33 &#43;0800</pubDate>
      <description>Timestamp Ordering Concurrency Control #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  2PL determine the serializability order of conflicting operations at runtime while transactions execute, and it is known as a Pessimistic concurrency control protocol, meaning DBMS assume that there are going to be conflicts in transactions, therefore, the DBMS will require the transactions to acquire the locks before they can do whatever it is that the transactions want to do and then DBMS can use the Two-Phase locking protocol to decide that is the transaction allowed acquire lock or not.</description>
    </item><item>
      <title>Multi-Version Concurrency Control</title>
      <link>https://maxnilz.com/docs/003-database/018-multiversioning/</link>
      <guid>https://maxnilz.com/docs/003-database/018-multiversioning/</guid>
      <pubDate>Tue, 04 Jul 2023 09:52:55 &#43;0800</pubDate>
      <description>Multi-Version Concurrency Control #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  Multi-Version Concurrency Control (MVCC) is a larger concept than just a concurrency control protocol.It involves all aspects of the DBMS’s design and implementation. MVCC is the most widely used scheme in DBMSs. It is now used in almost every new DBMS implemented in last 10 years.</description>
    </item><item>
      <title>Pointers, References and Memory Allocation</title>
      <link>https://maxnilz.com/docs/005-lang/moderncpp/004-pointer-ref/</link>
      <guid>https://maxnilz.com/docs/005-lang/moderncpp/004-pointer-ref/</guid>
      <pubDate>Fri, 02 Jun 2023 11:18:46 &#43;0800</pubDate>
      <description>Pointers, References and Dynamic Memory Allocation #  Pointers, References and Dynamic Memory Allocation are the most powerful features in C/C&#43;&#43; language, which allows programmers to directly manipulate memory to efficiently manage the memory - the most critical and scarce resource in computer - for best performance. However, &amp;ldquo;pointer&amp;rdquo; is also the most complex and difficult feature in C/C&#43;&#43; language.
Pointers are extremely powerful because they allows you to access addresses and manipulate their contents.</description>
    </item><item>
      <title>Scheduling In Go: Part 1 - Overview</title>
      <link>https://maxnilz.com/docs/005-lang/golang/002-gosch-1/</link>
      <guid>https://maxnilz.com/docs/005-lang/golang/002-gosch-1/</guid>
      <pubDate>Wed, 31 May 2023 17:54:42 &#43;0800</pubDate>
      <description>Scheduling In Go: Part 1 - Overview #  Most of the content is copied from this quora answer
This is the first post in a three part series that will provide an understanding of the mechanics and semantics behind the scheduler in Go. This post focuses on the high level overview of N:M scheduling.
Index of the three part series:
 Scheduling In Go: Part 1 - Overview Scheduling In Go: Part 2 - Go Scheduler Scheduling In Go: Part 3 - Concurrency   Goroutine #  What goroutine bring us is in fact a version of N:M scheduling, where there are N goroutines which are backed by M OS threads.</description>
    </item><item>
      <title>Kubernetes LoadBalancer Service with MetalLB</title>
      <link>https://maxnilz.com/posts/022-kube-lb/</link>
      <guid>https://maxnilz.com/posts/022-kube-lb/</guid>
      <pubDate>Wed, 24 May 2023 00:00:00 &#43;0000</pubDate>
      <description>In kubernetes, LoadBalancer is the most common way of exposing backend applications to the outside world. Its API is very similar to NodePort with the only exception being the spec.type: LoadBalancer. At the very least, a user is expected to define which ports to expose and a label selector to match backend Pods:
</description>
    </item><item>
      <title>Leak debugging with LeakSanitizer</title>
      <link>https://maxnilz.com/posts/021-santitizer/</link>
      <guid>https://maxnilz.com/posts/021-santitizer/</guid>
      <pubDate>Mon, 22 May 2023 00:00:00 &#43;0000</pubDate>
      <description>LeakSanitizer internally uses ptrace, probably to suspend all threads such that it can scan for leaks without false positives (see issue 9). Only one application can use ptrace, so if we run application under gdb or strace, then LeakSanitizer won&amp;rsquo;t be able to attach via ptrace. if we are using clion, it probably end up with a error message like &amp;ldquo;LeakSanitizer does not work under ptrace (strace, gdb, etc)&amp;rdquo;
</description>
    </item><item>
      <title>big-endian vs. little-endian</title>
      <link>https://maxnilz.com/posts/020-endingness/</link>
      <guid>https://maxnilz.com/posts/020-endingness/</guid>
      <pubDate>Tue, 16 May 2023 00:00:00 &#43;0000</pubDate>
      <description>Big-endian and little-endian are two byte ordering schemes used to store multibyte data types (such as integers and floating-point numbers) in computer memory.
</description>
    </item><item>
      <title>TCP Connection States</title>
      <link>https://maxnilz.com/docs/004-network/003-tcp-connection-state/</link>
      <guid>https://maxnilz.com/docs/004-network/003-tcp-connection-state/</guid>
      <pubDate>Sun, 14 May 2023 12:42:59 &#43;0800</pubDate>
      <description>TCP Connection States #  A connection progresses through a series of states during its lifetime. The states are: LISTEN, SYN-SENT, SYN-RECEIVED, ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT, CLOSING, LAST-ACK, TIME-WAIT, and the fictional state CLOSED. CLOSED is fictional because it represents the state when there is no TCB, and therefore, no connection.
Transmission Control Block #  Transmission Control Block(TCB), a kernel object for stroing the variables such as the local and remote socket numbers, the security and precedence of the connection, pointers to the user&amp;rsquo;s send and receive buffers, pointers to the retransmit queue and to the current segment</description>
    </item><item>
      <title>Linux Networking Stack tutorial: Sending Data</title>
      <link>https://maxnilz.com/docs/004-network/007-linux-tx/</link>
      <guid>https://maxnilz.com/docs/004-network/007-linux-tx/</guid>
      <pubDate>Sun, 14 May 2023 08:56:00 &#43;0800</pubDate>
      <description>Linux Networking Stack tutorial: Sending Data #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  TL;DR #  This post tries to help readers to conceptualize a high-level overview of how the Linux Network Stack send data to the network.
Consider the following code:
int main(){  fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);   bind(fd, ...);  listen(fd, .</description>
    </item><item>
      <title>TCP Connection Closing</title>
      <link>https://maxnilz.com/docs/004-network/002-tcp-connection-close/</link>
      <guid>https://maxnilz.com/docs/004-network/002-tcp-connection-close/</guid>
      <pubDate>Sun, 14 May 2023 08:17:01 &#43;0800</pubDate>
      <description>TCP Connection Closing #  Introduction #  When a TCP connection is being set-up, the client and server perform a three-way handshake to ensure the connection is a valid one. The connection is established when sequence numbers have been exchanged and synchronized in both directions. CLOSE is an operation meaning &amp;ldquo;I have no more data to send.&amp;rdquo;
The notion of closing a full-duplex connection is subject to ambiguous interpretation, of course, since it may not be obvious how to treat the receiving side of the connection.</description>
    </item><item>
      <title>Linux Networking Stack tutorial: Receiving Data</title>
      <link>https://maxnilz.com/docs/004-network/006-linux-rx/</link>
      <guid>https://maxnilz.com/docs/004-network/006-linux-rx/</guid>
      <pubDate>Sun, 14 May 2023 08:11:47 &#43;0800</pubDate>
      <description>Linux Networking Stack tutorial: Receiving Data #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  TL;DR #  This post tries to help readers to conceptualize a high-level overview of how the Linux Network Stack receives data from the network.
Consider the following UDP code:
int main(){  int serverSocketFd = socket(AF_INET, SOCK_DGRAM, 0);  bind(serverSocketFd, ...);   char buff[BUFFSIZE];  int readCount = recvfrom(serverSocketFd, buff, BUFFSIZE, 0, .</description>
    </item><item>
      <title>Programming paradigms</title>
      <link>https://maxnilz.com/docs/006-arch/002-programming-paradigms/</link>
      <guid>https://maxnilz.com/docs/006-arch/002-programming-paradigms/</guid>
      <pubDate>Sat, 13 May 2023 18:25:47 &#43;0800</pubDate>
      <description>Programming paradigms #  A censorship circumvention tool may be required to open the links in this post from mainland of china.
A learning note for Clean Architecture Part II.
 Introduction #  Paradigms are ways of programming, relatively unrelated to languages. A paradigm tells you which programming structures to use, and when to use them. To date, there have been three such paradigms, and it&amp;rsquo;s unlikely to be any other.</description>
    </item><item>
      <title>What is Service Mesh</title>
      <link>https://maxnilz.com/docs/006-arch/005-service-mesh/</link>
      <guid>https://maxnilz.com/docs/006-arch/005-service-mesh/</guid>
      <pubDate>Mon, 08 May 2023 12:16:01 &#43;0800</pubDate>
      <description>What is Service Mesh #  Introduction #  Istio is a popular solution in service mesh for microservices, which naturally leads to the question: what is a service mesh? To answer this, let&amp;rsquo;s take a step back and examine the architectural challenges of operating either a microservice architecture or what we used to call a service-oriented architecture.
What we tend to find is that we&amp;rsquo;re really dealing with a collection of different services, such as a front-end login portal and the ability to check the balance of a bank account, wire transfers, and bill payments.</description>
    </item><item>
      <title>Case-(in)sensitive, collation and quote in different DBMSs.</title>
      <link>https://maxnilz.com/posts/018-sql-quote-faq/</link>
      <guid>https://maxnilz.com/posts/018-sql-quote-faq/</guid>
      <pubDate>Fri, 21 Apr 2023 00:00:00 &#43;0000</pubDate>
      <description>Case-(in)sensitive, collation and quote in different DBMSs.
In Oracle Database, you can use double quotes (&amp;quot;) to quote SQL identifiers such as table names, column names, and aliases. By enclosing an identifier in double quotes, you can use mixed case, special characters, or reserved words as identifiers.
</description>
    </item><item>
      <title>Oracle Usage FAQ</title>
      <link>https://maxnilz.com/posts/017-oracle-faq/</link>
      <guid>https://maxnilz.com/posts/017-oracle-faq/</guid>
      <pubDate>Fri, 21 Apr 2023 00:00:00 &#43;0000</pubDate>
      <description>Unlike other databases like MySQL, PostgreSQL, etc., Oracle database have some dialect and different concepts, for example, create database command won&amp;rsquo;t work in Oracle, instead, it uses user as the isolate mechanisim instead of database.
Here Oracle Database basic usages FAQs record:
 Oracle create user/database via sqlplus Oracle JDBC driver oci8 vs. thin? Oracle sqlplus show non-system users Oracle sqlplus show tables and views </description>
    </item><item>
      <title>Distributed OLAP Databases</title>
      <link>https://maxnilz.com/docs/003-database/023-distributed-olap/</link>
      <guid>https://maxnilz.com/docs/003-database/023-distributed-olap/</guid>
      <pubDate>Thu, 20 Apr 2023 11:05:23 &#43;0800</pubDate>
      <description>Distributed OLAP Databases #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  For a read-only OLAP database, it is common to have a bifurcated environment, where there are multiple instances of OLTP databases that ingest information from the outside world which is then fed into the backend OLAP database, sometimes called a data warehouse. There is an intermediate step called ETL(Extract Transform, and Load) or ELT in a modern system, which combines the OLTP databases into a universal schema for the data warehouse.</description>
    </item><item>
      <title>Connecting Clickhouse to pupular OLTP DBMSs</title>
      <link>https://maxnilz.com/posts/016-clickhouse/</link>
      <guid>https://maxnilz.com/posts/016-clickhouse/</guid>
      <pubDate>Thu, 20 Apr 2023 00:00:00 &#43;0000</pubDate>
      <description>How to Connect Clickhouse to PostgreSQL, MySQL, Oracle, SQL-Server, MongoDB.
This post shows a step-by-step tutorial for connecting ClickHouse to PostgreSQL, MySQL and MongoDB via the ClickHouse storage engine and connecting Oracle and SQL-Server via the JDBC-bridge(the official JDBC-bridge has some limitations, check this fork as a workaround)
</description>
    </item><item>
      <title>Distributed OLTP Databases</title>
      <link>https://maxnilz.com/docs/003-database/022-distributed-oltp/</link>
      <guid>https://maxnilz.com/docs/003-database/022-distributed-oltp/</guid>
      <pubDate>Wed, 12 Apr 2023 22:51:58 &#43;0800</pubDate>
      <description>Distributed OLTP Databases #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  What we&amp;rsquo;ve discussed so far in terms of the distributed database are:
 The DBMS system architecture: Shared-Memory, Shared-Disk, Shared-Nothing systems Partitioning/Sharding: e.g., Hash, Range, Round Robin Transaction coordination: Centralized vs. Decentralized  This class and the next class will talk about the distributed database in the context of OLAP and OLAP, so this class will focus on the OLTP system</description>
    </item><item>
      <title>Introduction to Distributed Databases</title>
      <link>https://maxnilz.com/docs/003-database/021-distributed/</link>
      <guid>https://maxnilz.com/docs/003-database/021-distributed/</guid>
      <pubDate>Wed, 12 Apr 2023 09:36:07 &#43;0800</pubDate>
      <description>Introduction to Distributed Databases #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Indroduction #  Distributed DBMS (Database Management System) aims to solve several problems that arise in scenarios where a centralized DBMS may not be sufficient or efficient. The primary problems that a distributed DBMS tries to address include:
  Scalability: As the volume of data and the number of users grow, a centralized DBMS may struggle to provide adequate performance.</description>
    </item><item>
      <title>Database Crash Recovery</title>
      <link>https://maxnilz.com/docs/003-database/020-recovery/</link>
      <guid>https://maxnilz.com/docs/003-database/020-recovery/</guid>
      <pubDate>Sat, 08 Apr 2023 00:42:12 &#43;0800</pubDate>
      <description>Database Crash Recovery #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Indroduction #  The DBMS relies on its recovery algorithms to ensure database consistency, transaction atomicity, and durability despite failures. Each recovery algorithm is comprised of two parts:
 Actions during normal transaction processing to ensure that the DBMS can recover from a failure(discussed in Logging Schemes) Actions after a failure to recover the database to a state that ensures the atomicity, consistency, and durability of transactions(discuss in the following).</description>
    </item><item>
      <title>Logging Schemes</title>
      <link>https://maxnilz.com/docs/003-database/019-logging/</link>
      <guid>https://maxnilz.com/docs/003-database/019-logging/</guid>
      <pubDate>Fri, 07 Apr 2023 16:35:55 &#43;0800</pubDate>
      <description>Logging Schemes #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  The logging protocol is a machanism to make sure if the application write bunch of changes of the database, and application commit a transaction, the database system tells the application that the transaction is committed, how does the DBMS make sure that there is a crash or something happens, the application come back and the changes still there.</description>
    </item><item>
      <title>Useful shell commands</title>
      <link>https://maxnilz.com/posts/015-shell-cmds/</link>
      <guid>https://maxnilz.com/posts/015-shell-cmds/</guid>
      <pubDate>Thu, 06 Apr 2023 00:00:00 &#43;0000</pubDate>
      <description>xargs #  xargs is a versatile command in Unix-like operating systems, which is used to read items from standard input separated by lines, spaces, or other delimiters, and then execute a command using those items as arguments. Here are some of the most commonly used options for xargs:
 -I: This option allows you to specify a placeholder that will be replaced with the input item in the command line.</description>
    </item><item>
      <title>Two-Phase Locking</title>
      <link>https://maxnilz.com/docs/003-database/016-twophaselocking/</link>
      <guid>https://maxnilz.com/docs/003-database/016-twophaselocking/</guid>
      <pubDate>Mon, 27 Mar 2023 14:02:51 &#43;0800</pubDate>
      <description>Two-Phase Locking #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  A DBMS uses locks to dynamically generate an execution schedule for transactions that is serializable without knowing each transaction’s read/write set ahead of time. These locks protect database objects during concurrent access when there are multiple readers and writes. The DBMS contains a centralized lock manager that decides whether a transaction can acquire a lock or not.</description>
    </item><item>
      <title>Concurrency Control Theory</title>
      <link>https://maxnilz.com/docs/003-database/015-concurrency-control/</link>
      <guid>https://maxnilz.com/docs/003-database/015-concurrency-control/</guid>
      <pubDate>Wed, 15 Mar 2023 09:55:20 &#43;0800</pubDate>
      <description>Concurrency Control Theory #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  A DBMS&amp;rsquo;s concurrency control and recovery components permeate throughout the design of its entire architecture.
        Concurrency control and recovery components    To get us motivated on talking about concurrency control, Here are two basic scenarios,</description>
    </item><item>
      <title>Database Memory management</title>
      <link>https://maxnilz.com/docs/003-database/006-memory-management/</link>
      <guid>https://maxnilz.com/docs/003-database/006-memory-management/</guid>
      <pubDate>Fri, 24 Feb 2023 15:18:35 &#43;0800</pubDate>
      <description>Database Memory management #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  1. Introduction #  The DBMS is responsible for managing its memory and moving data back-and-forth from the disk. Since, for the most part, data cannot be directly operated on in the disk, any database must be able to efficiently move data represented as files on its disk into memory so that it can be used.</description>
    </item><item>
      <title>Welcome back to C&#43;&#43; - Modern C&#43;&#43;</title>
      <link>https://maxnilz.com/docs/005-lang/moderncpp/001-moderncpp/</link>
      <guid>https://maxnilz.com/docs/005-lang/moderncpp/001-moderncpp/</guid>
      <pubDate>Wed, 22 Feb 2023 13:15:08 &#43;0800</pubDate>
      <description>Welcome back to C&#43;&#43; - Modern C&#43;&#43; #  Since its creation, C&#43;&#43; has become one of the most widely used programming languages in the world. Well-written C&#43;&#43; programs are fast and efficient. The language is more flexible than other languages: It can work at the highest levels of abstraction, and down at the level of the silicon. C&#43;&#43; supplies highly optimized standard libraries. It enables access to low-level hardware features, to maximize speed and minimize memory requirements.</description>
    </item><item>
      <title>Database Storage Part 1</title>
      <link>https://maxnilz.com/docs/003-database/003-database-storage-1/</link>
      <guid>https://maxnilz.com/docs/003-database/003-database-storage-1/</guid>
      <pubDate>Thu, 16 Feb 2023 12:17:08 &#43;0800</pubDate>
      <description>Database Storage Part 1 #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  Overview #  In general the database management system is build by different layers
        DBMS layers    The Disk manager(a.k.a Storage manager) is responsible for how we actually represent a database on disk, what it means to get a page from disk, what&amp;rsquo;s inside of it, and so forth, these will affect how we architect the rest of the system.</description>
    </item><item>
      <title>Database Storage Part 2</title>
      <link>https://maxnilz.com/docs/003-database/004-database-storage-2/</link>
      <guid>https://maxnilz.com/docs/003-database/004-database-storage-2/</guid>
      <pubDate>Thu, 16 Feb 2023 12:11:07 &#43;0800</pubDate>
      <description>Database Storage Part 2 #  A censorship circumvention tool may be required to open the links in this post from mainland of china.  Overview #  The DBMS assumes that the primary storage location of the database is on non-volatile disk and the DBMS&amp;rsquo;s components manage the momvent of data between non-volatile and volatile storage.
The Disk manager(a.k.a Storage manager) is responsible for how we actually represent a database on disk, what it means to get a page from disk, what&amp;rsquo;s inside of it, and so forth, these will affect how we architect the rest of the system.</description>
    </item>
  </channel>
</rss>
