josehu07 / josehu07.github.io Goto Github PK

View Code? Open in Web Editor NEW

3.0 3.0 1.0 226.16 MB

Guanzhou's personal website

Ruby 0.04% HTML 97.73% SCSS 1.59% Shell 0.64%

josehu07.github.io's Introduction

Hi there 👋, welcome!

Check out my personal homepage at https://josehu.com 😎

josehu07.github.io's People

Contributors

Stargazers

Watchers

Forkers

moomoohorse

josehu07.github.io's Issues

memo/2020/02/10/macos-dev-environment

Personal Dev Environment & Tools Configuration on macOS X | Guanzhou (Jose) Hu

This post summarizes my personal development environment configuration on macOS X. Just for memo. 记录一下我在 macOS X >= 10.14 上的个人开发环境 & 工具配置，以便将来需要时 refer。

https://www.josehu.com/memo/2020/02/10/macos-dev-environment.html

index

Guanzhou (Jose) Hu | Guanzhou’s personal storage for lecture notes, blog posts, & good mood.

Guanzhou’s personal storage for lecture notes, blog posts, & good mood.

https://www.josehu.com/

technical/2020/05/23/consistency-models

Consistency Models for Distributed Replicated State Machines | Guanzhou (Jose) Hu

Replicated state machine is a common distributed system design to achieve fault-tolerance against fail-stops. Consistency among distributed replicas thus arise as a crucial problem. People have defined different levels of consistency models throughout distributed systems research. Some of them are strong and easier to reason about and program with, while others weaken the constraints to pursue higher performance.

https://www.josehu.com/technical/2020/05/23/consistency-models.html

memo/2021/01/02/linux-kernel-build-debug

Building a Custom Linux Kernel & Debugging via QEMU + GDB | Guanzhou (Jose) Hu

When doing systems research, we sometimes need to modify/add new stuff into the Linux kernel. This post lists a successful workflow of building and installing a custom Linux kernel under a Ubuntu 18.04/20.04 environment (deb), along with steps to debug the Linux kernel by running it over the QEMU emulator and attaching to GDB.

https://www.josehu.com/memo/2021/01/02/linux-kernel-build-debug.html

technical/2020/06/13/write-buffering-lsm-tree

Write Buffering, LSM Tree, & Journaling Summarized | Guanzhou (Jose) Hu

In file system & database design, write buffering (write grouping or coalescing) is a commonly-used technology to avoid in-place updates and only expose sequential writes to disks. Log-Structured Merge Tree (LSM tree) is a modern practical solution which sacrifices a little bit of read performance to enable efficient write buffering. Journaling (write-ahead logging) is another file system terminology which is sometimes confused with write buffering. In short, write buffering is for write performance and journaling is for crash recovery - they are different, but can be combined.

https://www.josehu.com/technical/2020/06/13/write-buffering-lsm-tree.html

technical/2019/09/03/rust-lang

About the Design of the Rust Language and Its Pros & Cons | Guanzhou (Jose) Hu

Rust 作为一门新兴的 system programming 语言，其设计参考了各 system programming 语言的优劣势，以安全、同时快速为目标，开创了 compile-time 实现几乎一切安全检查的新颖的编程语言模式。可以说，Rust 承载了作者 Graydon Hoare 和新互联网时代逐渐关注起安全的众多开发者们的理想，也吸引了如 M 校前沿系统研究者们的关注（参考 PDOS 博士生 Jon Gjenset)。

https://www.josehu.com/technical/2019/09/03/rust-lang.html

technical/2020/06/10/cpu-side-channel

CPU Cache Side-Channel Attacks: Meltdown & Spectre | Guanzhou (Jose) Hu

One of the most dangerous kinds of security attacks is side-channel attacks since they are not part of the designed threat model. Meltdown & Spectre, the most recent side-channel vulnerabilities found on modern microprocessors, are good demonstration of the sneakiness and danger of side-channel attacks. These attacks combine CPU speculative execution + cache timing side-channel.

https://www.josehu.com/technical/2020/06/10/cpu-side-channel.html

personal/2020/06/17/pc-building

【游戏+工作站】M-ATX 装机记录 2020 | Guanzhou (Jose) Hu

在美国勉强算是安顿下来了。这个小公寓可能一呆就是 5 年，故干脆狠下心配了一套 2020 年中高配的【游戏+工作站】的 PC，作为自己 5 年学习生涯的小家。在此将自己第一次亲力亲为的装机过程，尽可能详细地记录下来。

https://www.josehu.com/personal/2020/06/17/pc-building.html

technical/2021/05/31/locking-techniques

Multicore Locking Design & A Partial List of Lock Implementations | Guanzhou (Jose) Hu

Concurrency plays a significant role in modern multi-core operating systems. We want a locking mechanism that is efficient (low latency), scalable (increasing the number of threads does not degrade performance too badly), and fair (considers the order of acquirement and does not make any one thread wait too long). This post summarizes a bit on hardware atomic instructions which modern locks are built upon, a comparison between spinning and blocking locks, and a partial list of representative lock implementations.

https://www.josehu.com/technical/2021/05/31/locking-techniques.html