Chengxiaobai

This book delineates four levels of reading styles, progressing from the basic reading to inspectional reading, analytical reading, and thematic reading. Each corresponds to distinct methodologies.

While you may have already practiced this approach casually, the author has disassembled, quantified, and standardized the act of reading. This abstraction and synthesis of reading methods can guide and assist many individuals in reshaping their reading behaviors, enhancing reading efficiency, much like the “design patterns” in the programming world.

I encountered this book during my college years in physical form, but it was a hasty library pick that felt somewhat tedious due to its methodological approach. Recently, while browsing on Kindle, I rediscovered it, and halfway through, I regretted not appreciating this remarkable book earlier.

I have now organized my past notes and recent reflections, and I am sharing them with you all.

I have ultimately decided to transition my blog from a dynamic Typecho website to a static Hexo platform 😳.

HTTPS has become the fundamental threshold for internet service access, and the use of port 443 as the default port for HTTPS requests, combined with virtual hosting support, seamlessly complements this.

However, Trojan is somewhat exceptional. Its operational mode necessitates direct interfacing with traffic entry points; otherwise, its protocol cannot be correctly identified by the server. Additionally, for the sake of enhancing service concealment, it’s often configured on port 443. Nevertheless, there’s only one port 443 available. While Trojan offers a “non-standard request” forwarding feature, it’s still relatively new, and channeling all traffic through it presents limitations in terms of stability, performance, flexibility, and, importantly, it doesn’t support TLS forwarding.

In this context, I’ve devised a scheme for sharing port 443 between Trojan and Nginx, with Docker deployment support.

An article delayed due to procrastination 😭.

After macOS released the massive 10.15.1 update, I decided to upgrade my development machine (running 10.14.6) this Saturday. After all, a development machine should always be on the edge of new and stable, right? 🤪

However, my phone had already been upgraded to the latest 13.2, and the most annoying thing was that iOS 13’s “Reminders” is somehow incompatible with Mojave. Apple’s decision was quite perplexing.

Their system versions update quickly, but they couldn’t ensure even basic backward compatibility for such an essential app. It’s almost as if they’re adopting the style of internet companies entirely! 🤷🏻‍♂️

What struck me most at the iOS UI level was the Automatic Dark Mode. While Mojave had Dark Mode, it didn’t switch automatically.

In my opinion, the Light Mode (light color theme) works best during the day, so switching to Dark Mode manually at night felt cumbersome. Why make users switch something that could be automated?

Night Shift, on the other hand, transitions naturally. Fortunately, Catalina finally introduced Automatic Dark Mode. However, I realized there were too few websites adapted to Dark Mode, creating a stark contrast between the system and webpages.

Of course, since Dark Mode is relatively new, it will take time for websites and apps to adapt. Even Apple’s official website hasn’t fully adapted yet. So, I decided to adapt my own blog.

Good things are worth pursuing, right? 🙆🏻‍♂️

Learning Design Patterns?

Just reading this should suffice 😼.

Documenting the entire process of migrating the blog to Docker.

Although the architecture of this blog is straightforward, it cannot withstand my frequent tinkering, including but not limited to data center migrations, plugin development testing, testing new features, and more. Throughout this process, rebuilding the entire system repeatedly, the traditional approach involves pulling code, launching SQL, configuring Nginx…

As someone who adheres to the DRY principle, I cannot tolerate such repetitive and technically unchallenging tasks.

In the early days of programming, the crudest method I employed was configuring the development environment within a virtual machine and then copying the entire virtual machine file to a USB drive for manual migration. Later, I upgraded to Vagrant. Subsequently, I discovered Docker, and since then, all my development-related environments have been based on Docker. However, all production environments still operate in the traditional manner. Coincidentally, the JD.com data center is expiring soon, so I decided to take this opportunity to transition my blog to Docker.

Guzzle is an exceedingly potent and steadfast HTTP client. Unlike common cURL encapsulation components, Guzzle employs a variety of request methods internally to execute HTTP requests. Although cURL is the most frequently utilized method, Guzzle offers formidable asynchronous and concurrent capabilities, rendering the construction of an HTTP request remarkably facile and extensible. Presently, Guzzle has been integrated into the core modules of Drupal, attesting to its unwavering reliability. Guzzle currently adheres to the PSR-7 specification, thereby enhancing its extensibility and compatibility. While it was briefly mentioned in a previous refactoring record, it was not analyzed in depth. This time, we intend to introduce some usage examples and conduct an in-depth examination of its underlying implementation principles. If you have any queries, kindly elucidate in the comments as we collectively progress.

Which subject do you find the most challenging?

Mathematical analysis.

I’ve asked many students who have graduated from our major, and the most useful subject they learned in college or the one they wish they had excelled in the most is mathematical analysis.

Oh?

At a college meeting

First and foremost, I recommend this book; it is not voluminous, and one can immerse oneself and complete it in half a day. The initial section primarily introduces new features, while the latter delves into tools and procedures for testing and deployment. It does not delve into coding techniques but rather expounds on the modernized engineering development, testing, and deployment practices within the realm of PHP. Indeed, this is of paramount importance; PHP necessitates an elegant and effective means of standardizing engineering development.

This book is based on PHP version 5.6; after all, PHP 7 had not been released at that time. However, readers should approach this book with a contemporary perspective, as technology continually advances. From the author’s initial compilation to the publication and even translation, a significant amount of time has elapsed.

From another perspective, the internet is the swiftest means of acquiring knowledge, and proficiency in English is crucial.

While organizing my notes, I will incorporate some PHP7 (up to 7.1) features and aspects not covered in the book but which I have encountered more frequently, indicated as “supplement.”