HW311

The Preliminary Eve

Mon, 18 Feb 2019 15:39:42 +0000

Special thanks to my mentor, Zhuoran Shen, for providing this elegant translation.

Today is January 28, 2019, Layue 23, the Year of Earth and Dog, and the Preliminary Eve.

Before saying anything else, I wish you and your family a happy Chinese New Year.

I am not a festival person. However, since I crossed the International Date Line to the other side of the globe, I started wondering when I should celebrate each holiday or birthday. Probably, my obsession for clear-cut decisions and sense of ceremony defeated my tiredness of holidays. Well, the question of when to celebrate is actually quite dull, but every time it gets me for a while. When should I say happy birthday to my friends? When should I post my cherry-picked holiday photos to social media? When should I say happy birthday to myself with my inner speech? It doesn’t feel so right to follow Beijing Time, but it does feel a bit late if I wait for the clock tick in Pacific Time. Luckily, the days in the two time zones do still have several hours of overlap which let me eschew the questions.

I remember in my childhood, the New-Year atmosphere would come with the Preliminary Eve. By then, there would have been snow outside my window. The dirty snow, dry and dead branches, and the gloomy sky were all integral to a New Year in my memory. A dumpling meal would mark the start of the New Year. My parents would be more lenient to me, and I would get the freedom to be excessively childish and playful. Next up would be to purchase New Year’s Goods. I didn’t bother worrying about most of them, but the firework stores did really excite me. My parents would dress me in thick clothes and take me to the temporary tent built on the square before the large shopping mall, where the army green door curtain would be hiding the warmth of the crowd, the unique smell of Red Earths (belts of 50,000 firecrackers each), and the festive holiday atmosphere. I wouldn’t have the chance to decide what courses to serve at the Meal of the New Year Eve. But here, it would be my call. Fricative crackers, collisional crackers, Splashy Cylinders, Flashy Spinning Tops, and Little Bees were all my favorites. In the tent in a frozen city, before shelves full of assortments of fireworks, I would have been starting to look forward to the night with thick smoke, deafening explosions, and the smell of fireworks spread in the air.

The memories are so fresh that I can almost still smell the fireworks. Nonetheless, it’s been long since I last had such an experience. Did I turn numb after getting into middle or high school? Did the ban on fireworks dissolve the holiday atmosphere? Or did my parents become too old to have a proper celebration? …

Having moved to the US, the atmosphere of the traditional holidays started to feel increasingly distant. Currently, more and more Chinese are migrating here. I can even hear the familiar language here and there. However, social and cultural environments are still constantly taking us away from the traditions. I didn’t realize the Preliminary Eve was around the corner until Mom reminded me yesterday during our chat on WeChat. I now feel fortunate that the time zone difference saved me from missing the holiday. I’m actually not sure whether the King of Cookers understands time zones and is willing to accept my excuse for forgetting it. Anyways, the North and the South (of China) once again have a disagreement on when we should celebrate the Preliminary Eve, just as they disagree on the name of Yuanxiao/Tangyuan and whether rice dumplings should be sweet or not. The North celebrates it on the 23rd, while the South on the 24th. I’m not the kind of person that would dwell on this issue. However, it does give me an extra excuse to make up for the celebration today.

Right now, I am having fast dumplings in T-shirts and shorts, in the warm and pleasant weather in California. The dumplings are fulfilling the last bits of the sense of ceremony left in my memory. Well, let’s just make this my Preliminary Eve.

Today is January 28, 2019 and Layue 23, the Year of Earth and Dog, Pacific Standard Time; and January 29, 2019 and Layue 24, the Year of Earth and Dog, Beijing Time. Both are the Preliminary Eve.

Add LaTeX support to your blog

Wed, 23 Jan 2019 02:04:47 +0000

In the last post we briefly introduced how to build a blog with Jekyll. This post and several following posts will dive in a little bit deeper and introduce some methods to extend and improve your blog. I will assume that readers have already become familiar with concepts and features of Jekyll. You can always go back and refer to the last post if needed. In this short post, I will introduce how to add $\LaTeX$ support to this blog using MathJax.

Fun Fact：$\LaTeX$ was originally developed by Leslie Lamport based on $\TeX$¹. The “La” in $\LaTeX$ refers to Lamport. $\TeX$ in turn, was developed by Donald Knuth. Knuth pointed out that $\TeX$ stands for Greek capital letters Τ (Tau), Ε (Epsilon), and Χ (Chi), as the name derives from the Greek: τέχνη (skill, art, technique).² Therefore, the pronunciation should be /tɛx/ or /ˈtɛk/. Similarly, $\LaTeX$ should be pronounced as /ˈlɑːtɛx(k)/ or /ˈleɪtɛx(k)/.¹

As a ~~serious academic~~ blog, we sometimes want to include mathematical equations and formulae in posts. However, the Markdown or HTML language we use does not directly support formula editing. One simple solution is to use external tools to generate images of formulae and insert those images into our posts. This method does not allow us to easily edit the formulae. What if I find something wrong after inserting all the images? The excessive use of images also burdens our website and page loading. We want to render equations locally using Jekyll, for example writing $\LaTeX$ codes directly in Markdown. The answer to this is MathJax.

MathJax

MathJax is an open-source mathematical environment rendering engine in JavaScript, supporting multiple languages such as $\LaTeX$, MathML, and AsciiMath.³ No plugin is required. No installation on the user side is needed. All you need is to include MathJax in your web page, then magic happens. This page was processed by MathJax, you can check the outcome directly here, or check the samples and live demo given by MathJax.

How to use MathJax

It is recommended to use CDN to include MathJax⁴:

<script type="text/javascript" async
  src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML">
</script>

Just put this code snippet into the <head> section. It will load MathJax version 2.7.5, and configure the script with ?config=TeX-MML-AM_CHTML. This configuration says

TeX: recognize and supprot $\TeX$
MML: recognize and supprot MathML
AM: recognize and supprot AsciiMath
CHTML: use CommonHTML to render output

MathJax uses a lot of “combined configuration files”⁵ like this to provide different configurations for us to include. The combined configuration file above is equivalent to the following configuration code⁵:

MathJax.Hub.Config({
  jax: ["input/TeX","input/MathML","input/AsciiMath","output/CommonHTML"],
  extensions: ["tex2jax.js","mml2jax.js","asciimath2jax.js","MathMenu.js","MathZoom.js","AssistiveMML.js", "a11y/accessibility-menu.js"],
  TeX: {
    extensions: ["AMSmath.js","AMSsymbols.js","noErrors.js","noUndefined.js"]
  }
});

The configuration I used for this website is:

<script type="text/x-mathjax-config">
  MathJax.Hub.Config({
    tex2jax: {
      skipTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code'],
      inlineMath: [['$','$'], ['\\(','\\)']],
      processEscapes: true
    },
    TeX: {
      equationNumbers: {
        autoNumber: "AMS"
      }
    }
  });
</script>

<script type="text/javascript" async
  src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS_CHTML">
</script>

Just ignore the configuration code above for now. I used the TeX-AMS_CHTML configuration file, which means I only need to use $\TeX$ and use CommonHTML as the rendering output. You may also find that I used .../latest.js instead of .../MathJax.js mentioned above. This ensures that the latest version is used.⁶ Please refer to the offical docs⁵ to find the right combined configuration file for you.

Configuring MathJax

Now that we have successfully included MathJax, let’s go back and review the MathJax.Hub.Config() function.

MathJax.Hub.Config() receives a configuration parameter in JSON format and provides us with a rich set of configuration options, which can be categorized into 7 groups:⁷

Limited by the length of this post, I will only introduce common options that I used.

skipTags: ['script', 'noscript', 'style', 'textarea', 'pre']: This is an option of the tex2jax preprocessor. It lists HTML tags that we’d like MathJax to ignore. Similar options include ignoreClass and processClass.

inlineMath: [['$','$'], ['\$','\$']]: This is also a tex2jax option. It specifies delimiters used in inserting inline equations. For example $some expression$ or $some expression$.

processEscapes: true: Another tex2jax option. If it is set to true, we can use backslashes to escape the dollar sign. Note that in HTML, \$ is sufficient to output a “\$” symbol. However, if you are writing in Markdown, you need to use \\$ as \ itself is a special character used by Markdown to denote “escaping.”

equationNumbers: { autoNumber: "AMS" }: This is an option for the $\TeX$ input processor. It controls the numbering of equations. "AMS" means using AMSmath style numbering. For example, the environment align:

$$
\begin{align}
  \nabla\times\vec{\mathbf{B}}-\frac{1}{c}\frac{\partial\vec{\mathbf{E}}}{\partial t} &= \frac{4\pi}{c}\vec{\mathbf{j}} \\
  \nabla\cdot\vec{\mathbf{E}} &= 4\pi\rho \\
  \nabla\times\vec{\mathbf{E}}+\frac{1}{c}\frac{\partial\vec{\mathbf{B}}}{\partial t} &= \vec{\mathbf{0}} \\
  \nabla\cdot\vec{\mathbf{B}} &= 0
\end{align}
$$

will be rendered as

\[\begin{align} \nabla\times\vec{\mathbf{B}}-\frac{1}{c}\frac{\partial\vec{\mathbf{E}}}{\partial t} &= \frac{4\pi}{c}\vec{\mathbf{j}} \\ \nabla\cdot\vec{\mathbf{E}} &= 4\pi\rho \\ \nabla\times\vec{\mathbf{E}}+\frac{1}{c}\frac{\partial\vec{\mathbf{B}}}{\partial t} &= \vec{\mathbf{0}} \\ \nabla\cdot\vec{\mathbf{B}} &= 0 \end{align}\]

Note that the equations are automatically numbered. While the align* environment:

$$
\begin{align*}
  \dot{x} &= \sigma(y - x) \\
  \dot{y} &= \rho x - y - xz \\
  \dot{z} &= -\beta z + xy
\end{align*}
$$

will be rendered as

\[\begin{align*} \dot{x} &= \sigma(y - x) \\ \dot{y} &= \rho x - y - xz \\ \dot{z} &= -\beta z + xy \end{align*}\]

Note the equations are not numbered.

More examples

$$
\frac{1}{\Bigl(\sqrt{\phi \sqrt{5}}-\phi\Bigr) e^{\frac25 \pi}} \equiv 1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}} {1+\frac{e^{-8\pi}} {1+\cdots} } } }
$$

\[\frac{1}{\Bigl(\sqrt{\phi \sqrt{5}}-\phi\Bigr) e^{\frac25 \pi}} \equiv 1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}} {1+\frac{e^{-8\pi}} {1+\cdots} } } }\]

$$
\left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right)
$$

\[\left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right)\]

$$
\Gamma\ \Delta\ \Theta\ \Lambda\ \Xi\ \Pi\ \Sigma\ \Upsilon\ \Phi\ \Psi\ \Omega
$$

\[\Gamma\ \Delta\ \Theta\ \Lambda\ \Xi\ \Pi\ \Sigma\ \Upsilon\ \Phi\ \Psi\ \Omega\]

$$
\omicron\ \pi\ \rho\ \sigma\ \tau\ \upsilon\ \phi\ \chi\ \psi\ \omega\ \varepsilon\ \vartheta\ \varpi\ \varrho\ \varsigma\ \varphi
$$

\[\omicron\ \pi\ \rho\ \sigma\ \tau\ \upsilon\ \phi\ \chi\ \psi\ \omega\ \varepsilon\ \vartheta\ \varpi\ \varrho\ \varsigma\ \varphi\]

$$
\alpha\ \beta\ \gamma\ \delta\ \epsilon\ \zeta\ \eta\ \theta\ \iota\ \kappa\ \lambda\ \mu\ \nu\ \xi
$$

\[\alpha\ \beta\ \gamma\ \delta\ \epsilon\ \zeta\ \eta\ \theta\ \iota\ \kappa\ \lambda\ \mu\ \nu\ \xi\]

$$
\gets\ \to\ \leftarrow\ \rightarrow\ \uparrow\ \Uparrow\ \downarrow\ \Downarrow\ \updownarrow\ \Updownarrow
$$

\[\gets\ \to\ \leftarrow\ \rightarrow\ \uparrow\ \Uparrow\ \downarrow\ \Downarrow\ \updownarrow\ \Updownarrow\]

$$
\Leftarrow\ \Rightarrow\ \leftrightarrow\ \Leftrightarrow\ \mapsto\ \hookleftarrow
$$

\[\Leftarrow\ \Rightarrow\ \leftrightarrow\ \Leftrightarrow\ \mapsto\ \hookleftarrow\]

$$
\leftharpoonup\ \leftharpoondown\ \rightleftharpoons\ \longleftarrow\ \Longleftarrow\ \longrightarrow
$$

\[\leftharpoonup\ \leftharpoondown\ \rightleftharpoons\ \longleftarrow\ \Longleftarrow\ \longrightarrow\]

$$
\Longrightarrow\ \longleftrightarrow\ \Longleftrightarrow\ \longmapsto\ \hookrightarrow\ \rightharpoonup
$$

\[\Longrightarrow\ \longleftrightarrow\ \Longleftrightarrow\ \longmapsto\ \hookrightarrow\ \rightharpoonup\]

$$
\rightharpoondown\ \leadsto\ \nearrow\ \searrow\ \swarrow\ \nwarrow
$$

\[\rightharpoondown\ \leadsto\ \nearrow\ \searrow\ \swarrow\ \nwarrow\]

$$
\bigtriangledown\ \dagger\ \diamond\ \star\ \triangleleft\ \triangleright\ \angle\ \infty\ \prime\ \triangle
$$

\[\bigtriangledown\ \dagger\ \diamond\ \star\ \triangleleft\ \triangleright\ \angle\ \infty\ \prime\ \triangle\]

$$
f(x) = \int_{-\infty}^\infty \hat f(\xi)\,e^{2 \pi i \xi x}
$$

\[f(x) = \int_{-\infty}^\infty \hat f(\xi)\,e^{2 \pi i \xi x}\]

$$
\mathbf{V}_1 \times \mathbf{V}_2 =
\begin{vmatrix}
  \mathbf{i} & \mathbf{j} & \mathbf{k} \\
  \frac{\partial X}{\partial u} & \frac{\partial Y}{\partial u} & 0 \\
  \frac{\partial X}{\partial v} & \frac{\partial Y}{\partial v} & 0
\end{vmatrix}
$$

\[\mathbf{V}_1 \times \mathbf{V}_2 = \begin{vmatrix} \mathbf{i} & \mathbf{j} & \mathbf{k} \\ \frac{\partial X}{\partial u} & \frac{\partial Y}{\partial u} & 0 \\ \frac{\partial X}{\partial v} & \frac{\partial Y}{\partial v} & 0 \end{vmatrix}\]

Afterword

Though I adopted MathJax to render formulae, it is only one of many similar JavaScript math rendering engines. For example, KaTeX is faster than MathJax, but limited in command sets and rendering effect. You may find a live demo⁸ that compares the two.

References

Build a Blog with Jekyll and GitHub Pages

Mon, 21 Jan 2019 21:20:39 +0000

As a computer science student, I often want to record my learning notes and experiences in blog posts for sharing, as well as for my own reference. However, all of my previous countless attempts to build a blog ended up in failure. I just couldn’t persist in maintaining them mainly for two reasons: either I used free blog platforms such as CSDN and Zhihu, and their limits and poor UI designs deterred me from writing posts frequently. Or I tried to build a blog space from scratch with a rented server and got distracted by cumbersome coding in HTML/CSS and JavaScript.

A few days ago, one of my friends started writing a GitBook, which intrigued my interest in writing blog posts again. Having learned from previous failures, I came up with a list of requirements for the blog platform to be used this time:

Minimum cost. Avoid dedicated servers;
Maximum freedom. Allow me to customize UI and functionalities;
Minimum details. Avoid complicated site management so that I can concentrate on creating contents.

After some research, I found that the combination of Jekyll and GitHub Pages perfectly suits my needs.

GitHub Pages

GitHub Pages is a static-site hosting service provided by GitHub, intending to help projects and organizations on GitHub build doc sites.¹ It is very simple to use GitHub Pages to build a website. All you need to do is to create a repository named as <username>.github.io (where <username> is your GitHub username), and the files in this repo will be automatically published on https://<username>.github.io by GitHub.²

For example, let’s create a file index.html：

<!-- index.html -->
<!DOCTYPE html>
<html>
  <head>
    <title>Hello GitHub Pages!</title>
  </head>
  <body>
    <h1>Hello GitHub Pages!</h1>
    <p>This page is hosted on GitHub Pages.</p>
  </body>
</html>

And push to the <username>.github.io repo that we just created. Now access https://<username>.github.io in your web browser and we can see the web page immediately:

As you can see, GitHub Pages manages all the trivial details of website servers. We can rest ourselves and write frontend web pages to build a static website. The use of this service does come with several limits. For example the size of the website cannot exceed 1 GB; there is a soft bandwidth limit of 100 GB per month etc.³ Of course illegal uses and contents prohibited by the terms of service are not allowed. It is also mentioned that GitHub Pages is not intended for or allowed to run business or other commercial websites etc. However, it is good enough for our purpose of building a personal blog.

In summary, GitHub Pages provides us with free hosting space for a static website and a free domain name. We can use git to manage our contents and publish the website easily with a push to the GitHub repo. If wanted, we can also use custom domain names.⁴ However, despite all the benefits, we still need to implement the whole frontend by ourselves. It will be a massive amount of work if we want a beautiful user interface (been there, tried that, gave up :smiley:). Furthermore, every post must be written as a complete web page using HTML, which violates our intention to separate content creation and website management. To this end, we need Jekyll to our rescue.

Jekyll

Jekyll is a static-site generator with templates and support for markup languages. This is a typical structure for a Jekyll project:

├── 404.html                          # Custom 404 page
├── _config.yml                       # Jekyll configuration file
├── _data                             # Data files
├── _includes                         # Include files
├── index.html                        # Index page
├── _layouts                          # Layout templates
│   ├── default.html                  # Default template
│   └── post.html                     # Post page template
├── _drafts                           # Drafts
│   └── blog-jekyll-github-pages.md   # Unpublished draft
└── _posts                            # Posts
    └── 2019-01-19-hello-world.md     # Published post

We can think of Jekyll as a “compiler” that takes in contents written in markup languages (Markdown, HTML, etc), and outputs a static website. It converts our posts (for example _posts/2019-01-19-hello-world.md) into corresponding web pages according to predefined layouts. Then all pages are organized in the website structure. This makes our life much simpler because Markdown is easier to write than HTML. If you don’t know Markdown, it is definitely worth learning.⁵ The use of page layout templates also nicely isolates contents from formats by reusing codes. We only need to write templates in HTML/CSS once, and focus on writing posts that adopt those templates later. The following is an example of a layout template:

<!-- _layouts/default.html -->
<!DOCTYPE html>
<html>
  <head>
    <title>{{ page.title }}</title>
  </head>
  <body>
    <div class="page-content">
      {{ content }}
    </div>
  </body>
</html>

This simple layout file describes an HTML page. The double braces {{ }} in the layout file is the Liquid template language used by Jekyll (for more info please refer to the official docs⁶). Now if we write another file hello-jekyll.md that uses this layout:

---
layout: default
title: 'Hello Jekyll!'
---

## Hello Jekyll!

This page uses the default layout.

Then Jekyll will generate a corresponding HTML file:

<!-- hello-jekyll.html -->
<!DOCTYPE html>
<html>
  <head>
    <title>Hello Jekyll!</title>
  </head>
  <body>
    <div class="page-content">
      <h2 id="hello-jekyll">Hello Jekyll!</h2>
      <p>This page uses the default layout.</p>
    </div>
  </body>
</html>

The README file of Jekyll introduces its philosophy, which I think is very close to our requirements mentioned above:

Jekyll does what you tell it to do – no more, no less. It doesn’t try to outsmart users by making bold assumptions, nor does it burden them with needless complexity and configuration. Put simply, Jekyll gets out of your way and allows you to concentrate on what truly matters: your content.

To make things even better, GitHub Pages uses Jekyll as its pre-process engine. Every file we upload to the GitHub Pages repo will be automatically processed by Jekyll before it is published. ⁷ One thing to note, the Jekyll used by GitHub Pages does not behave exactly the same as the ones installed locally on our computers. For example, custom plugins are not allowed on GitHub Pages for security reasons. ⁸ There is a list of allowd plugins that you can use though.⁹

Install Jekyll locally

When developing the website or writing posts, we may want to check live results on our local machines. This section briefly introduces how to use Jekyll locally (using Ubuntu).

First of all, Jekyll is written in Ruby, therefore we need to install the runtime for Ruby and the package manager, RubyGem:

 sudo apt update
 sudo apt install ruby-full
 sudo apt install gem
 sudo gem update --system

Then install Jekyll and Bundler via RubyGem:

 sudo gem install jekyll bundler

After successful installation, we can use Jekyll to create a new blog:

 jekyll new myblog

This command will initialize a basic Jekyll project under ./myblog/:

├── 404.html
├── about.md
├── _config.yml
├── Gemfile
├── Gemfile.lock
├── index.md
└── _posts
    └── 2019-01-21-welcome-to-jekyll.markdown

We can build and host the website with Jekyll in ./myblog/. Run

 cd myblog
 bundle exec jekyll serve

and access localhost:4000 in your web browser, then you should be able to see the website.

If you are new to Jekyll, you can read the official docs¹⁰ and try some of the features in this basic project. You may push the project to the GitHub Pages repo created earlier to publish the website.

Use existing themes

If you don’t even bother writing the templates and styles on your own, you can always find many high-quality open-source themes online. For example on JekyllThemes.org or JekyllThemes.io. This blog you are currently viewing is modified from a great theme Centrarium. Since I have made many modifications and added some other functionalities, I also published my theme on GitHub: Jekyll-Theme-HW311. If you like this theme or want to use it, you are welcomed to fork and star it. The main features include (including original features from Centrarium):

In-site searching
Basic support for multilanguage without plugins (GitHub Pages friendly)
Easily customizable fonts and colors
Cover images for your homepage and blog posts
Archiving of posts by categories
Syntax highlighting for code snippets
Disqus integration for post comments
Lightbox for viewing full-screen photos and albums
Google Analytics with custom page name tracking
Social media integration (Twitter, Facebook, LinkedIn, GitHub, and more)

To use this theme, fork it on GitHub and rename it to <username>.github.io (substitute <username> with your GitHub username).

Before using this theme, you also need to edit _config.yml to configure the blog to your settings. Entries that needs configuring are:

title: '<website title>'
subtitle: '<website subtitle>'
email: '<your email>'
name: '<your name>'
description: '<website description>'
url: '<website url>'                  # e.g. https://<username>.github.io
cover: '<path to cover image>'
logo: '<path to logo>'
disqus_shortname: '<disqus shortname>'
ga_tracking_id: '<ga tracking id>'
social:
  - ...                               # Social networks and sharing settings
protocols:
  ...                                 # OS protocol settings

After configuring these settings and pushing to GitHub, you can now view your own blog on <username>.github.io! :tada:

To write posts, create YYYY-MM-DD-<post-title>.md files under en/_posts or zh/_posts. You may find some examples to start with there.

Data files such as multilanguage settings, translations, and post categories etc can by found under _data/.

Please refer to Jekyll’s official docs¹⁰ for usage of Jekyll’s features. If you have specific questions about this theme, please leave comments below or in the GitHub repo.

Use a custom domain name

If you don’t like the github.io domain name provided by GitHub, you can purchase your own domain name and use it for your GitHub Page. Please check the tutorial provided by GitHub. ⁴

First, configure the custom domain name in your GitHub Pages repo. You can add a domain name record via either Settings -> GitHub Pages -> Custom domain; or directly create a CNAME file containing your domain name (without protocol name, for example hw311.me, but not https://hw311.me) under the project root directory.

Then configure A records with your DNS provider. Set the IP addresses to the following:¹¹

185.199.108.153
185.199.109.153
185.199.110.153
185.199.111.153

These IP addresses were obtained from the GitHub Pages official docs¹¹ at the time this post was written. Please check again when configuring.

Afterword

By now, we have built a personal blog using Jekyll and GitHub. This solution may have some shortages, for example we can only build static websites; plugins are limited by GitHub Pages etc., it fits our requirements nevertheless. If you want to focus on writing posts, you can start right away using templates and layouts. If you are also interested in tweaking the website and developing new features like me, hopefully this post and its references may come to your help.

And hopefully I can keep on going this time. (laugh)

References

Hello World

Sat, 19 Jan 2019 01:31:14 +0000

This site is dedicated to HW311, a computer lab in Haking Wong Building HKU, and my companions there. In my four years of university, I spent most of the time learning, coding, and living in HW311. In there I’ve also met many friends and mentors, who guided me through my ups and downs. I dare not except that I have left my own impression upon HW311 or the great minds there, but the wisdom of them has always been enlightening me.

It was my honour.