QUIC is a new transport protocol meant to be the replacement of the TCP + TLS, which is on top of UDP. Other the security mechanisms provided by TLS, QUIC itself has offered an extension for an endpoint to do an identity verification to the remote endpoint, to prevent from traffic amplification attack. It’s called address validation, and it would be done along side with initial handshakes between client and server. This post will briefly talked about how this is done within QUIC.

QPACK is a header field compression format for HTTP/3 that makes HTTP/2’s HPACK header compression format compatible with the QUIC protocol.

In HTTP/3, the way the sender’s encoder and the receiver’s decoder reach agreement on the the state of the dynamic table for compression would be very different compared to HTTP/2. In this post, I would like to talk some of understanding I gained while I was reading the RFC and implementing QPACK.

Apart from the linked list, there is another handful structure offered by Pintos kernel library - Hash Table.

Abstract No matter for what kind of many screenplays, the most common topics among those watcher or fans are probably: Which xxx is the best? Which xxx do you recommend? Do you think what’s the best xxx of 2021? xxx here can be substituted by any type of screenplays, i.e. movies, TV series, TV show and etc. This rule applies to one type of screenplays as well - TV anime. In this post, I would present my analysis on what’s most welcomed TV animes in different period of time and what are the potential features make them become popular among viewers, with the help the data from anime community in Reddit and anime record data.

This post is about an important data structure, embedded linked list, which is used massively in the pintos project amd offers a different idea how to create dynamic list in C. But its design usually made it easy to confuse the people at first, so it’s very interesting to look into its implementation.

This post is about part A of Lab3 of MIT 6.824, Distributed Systems. For previous two parts, please refer to the posts about the Lab 1 and 2 under the tag Distributed System. In this post, we are to build a fault tolerant key-value services on top of Raft.

This post is about part C of Lab2 of MIT 6.824, Distributed Systems. For previous two parts, please refer to Part A and B. In this one we are focusing on Persist in Raft. The implementation would mostly follow the figure 2 in the paper as well.

This post is about part A and B of Lab2 of MIT 6.824, Distributed Systems. It is about the implementation of Raft. Here in these two part, we only discuss the section up to the end of section 5 in the paper.

This is the first lab of MIT 6.824, Distributed Systems. It is about the implementation of MapReduce, a framework introduced by Google that can process huge volume of data parallelly by splitting a single task to multiple small ones and assigning them to a cluster of “cheap” machines. And by using this framework, also as mentioned in the paper, this lets programmer make use of distributed system without the need of experience of it.

A very classic use case of this framework is counting words in a large file, which is also what we are to implement.

After doing a handshake using X3DH, Both users can authenticate each other and agree on a shared master secret.

So what’s next?