“Ninety percent of success in life is just showing up.” ― Woody Allen

For a long time I was troubled by insomnia.

I always tried to find a state called sleep. If not, I probably go check my phone or something, put myself in another state.

Last night was basically the same except I remind my good old childhood days, which I may not fell asleep but who cares, you are not allowed to wake, just be there.

And guess what, I slept just well, woke up at 6am.

I think that’s the answer, maybe I just go too hard on myself. Just be there, for sleep, learn and all other daily jobs, just be there.

GitHub已成为全球开发者协作的标准平台。无论你是程序员、设计师还是内容创作者，掌握Git和GitHub的基础知识都能显著提升你的团队协作效率。本文将为Git新手提供一份实用指南，从环境设置到日常协作流程。

什么是Git和GitHub？

• Git：一个分布式版本控制系统，追踪文件变化，允许多人协作开发
• GitHub：基于Git的云托管平台，提供图形界面和额外协作功能

第一步：环境设置

安装Git

1. 访问Git官网下载适合你操作系统的版本
2. 安装时保持默认选项即可
3. 安装完成后，打开终端/命令行，输入git --version确认安装成功

创建GitHub账号

1. 访问GitHub
2. 点击”Sign up”并按提示完成注册
3. 验证邮箱地址

接受协作邀请

如果项目负责人已将你添加为协作者，你会收到一封邮件邀请。

1. 点击邮件中的邀请链接或访问通知中心
2. 接受邀请后，项目负责人会告知你需要克隆和操作的具体仓库
3. 按照指示克隆指定仓库并进行后续操作

设置SSH密钥

SSH密钥让你能安全地连接GitHub，无需每次操作都输入用户名密码。从2021年8月13日起，GitHub已不再支持密码验证，必须使用SSH密钥或个人访问令牌(PAT)进行身份验证。

生成SSH密钥

1. 打开终端/命令行（Windows上使用PowerShell）
2. 输入以下命令：

   ssh-keygen -t ed25519
   

   说明： -t ed25519 指定使用Ed25519算法，这是GitHub目前推荐的更安全、更现代的密钥类型。

   兼容性提示： 如果你使用的是较旧的系统不支持Ed25519，可以使用RSA：ssh-keygen -t rsa -b 4096

3. 当提示”Enter a file in which to save the key”时，直接按Enter接受默认位置
4. 可以设置密码短语，也可以直接按Enter跳过

添加公钥到GitHub

1. 复制SSH公钥内容：

   # Windows (PowerShell)
   Get-Content ~/.ssh/id_ed25519.pub | Set-Clipboard
      
   # macOS/Linux
   cat ~/.ssh/id_ed25519.pub
   # 然后手动复制输出内容
   

2. 登录GitHub，点击右上角头像 → Settings → SSH and GPG keys
3. 点击”New SSH key”
4. 输入标题（如”我的电脑”）
5. 粘贴公钥内容到”Key”框
6. 点击”Add SSH key”

测试连接

ssh -T git@github.com

看到”Hi username! You’ve successfully authenticated…“表示成功。

⚠️ 大陆用户注意：由于网络环境限制，连接GitHub可能不稳定。可以考虑使用代理工具，具体方法请根据个人情况自行解决，本文不提供详细教程。

Git基础操作

配置用户信息

git config --global user.name "你的名字"
git config --global user.email "你的邮箱"

克隆仓库

git clone git@github.com:用户名/仓库名.git

基本工作流程

1. 拉取最新代码：

   git pull
   

2. 创建分支（可选）：

   git checkout -b feature-name
   

   提示： 对于小型项目或个人项目，可以直接在主分支上工作

3. 做出修改并提交：

   git add .
   git commit -m "描述你的修改"
   

4. 推送到远程：

   git push origin feature-name
   

   提示： 如果已经设置了当前分支跟踪远程分支，可以直接使用 git push

5. 创建Pull Request：
   • 访问GitHub仓库页面
   • 点击”Compare & pull request”
   • 填写PR描述
   • 点击”Create pull request”

协作最佳实践

分支管理

• main/master分支：稳定代码，通常受保护
• feature分支：新功能开发
• bugfix分支：修复问题
• release分支：准备发布版本

有效的提交信息

好的提交信息格式：

类型: 简短描述（50字符以内）

详细描述（可选，72字符换行）

类型可以是：feat（新功能）、fix（修复）、docs（文档）、style（格式）、refactor（重构）、test（测试）等。

解决冲突

当多人修改同一文件时可能发生冲突：

1. git pull获取最新代码
2. Git会标记冲突位置：

   <<<<<<< HEAD
   你的修改
   =======
   别人的修改
   >>>>>>> branch-name
   

3. 手动编辑文件解决冲突
4. git add标记为已解决
5. git commit完成合并

代码审查

• 提交PR后请求团队成员审查
• 审查者应关注代码质量、逻辑和潜在问题
• 保持建设性和尊重的沟通

高效LaTeX工作流配置

在使用Git进行协作时，合理的编辑器配置能大幅提升工作效率。以下是推荐的VSCode LaTeX Workshop配置，特别适合需要处理学术论文的团队：

{
    "latex-workshop.latex.tools": [
        {
            "name": "xelatex",
            "command": "xelatex",
            "args": [
                "-synctex=1",
                "-interaction=nonstopmode",
                "-file-line-error",
                "%DOC%"
            ]
        },
        {
            "name": "bibtex",
            "command": "bibtex",
            "args": [
                "%DOCFILE%"
            ]
        }
    ],
    "latex-workshop.latex.recipes": [
        {
        "name": "xe->bib->xe->xe",
        "tools": [
            "xelatex",
            "bibtex",
            "xelatex",
            "xelatex"
            ]
        }
    ],
    "latex-workshop.latex.recipe.default": "xe->bib->xe->xe",
    "latex-workshop.latex.autoBuild.run": "never",
    "git.enableSmartCommit": true,
    "git.autofetch": true
}

这个配置主要解决了以下问题：

1. 编译流程自动化：设置了完整的XeLaTeX+BibTeX编译链，确保参考文献正确渲染
2. 禁用自动构建：防止编辑大型文档时频繁触发编译
3. Git集成优化：启用智能提交和自动获取更新，简化协作流程

将此配置添加到团队的.vscode/settings.json文件中并提交到仓库，可确保所有协作者使用一致的工作环境，减少因环境差异导致的问题。

总结

Git和GitHub的学习曲线可能较陡，但掌握这些基础知识后，你将能够更高效地与团队协作。记住，熟能生巧——多实践是提高Git技能的最佳方式。

随着你的技能提升，可以探索更多高级功能，如GitHub Actions自动化工作流、GitHub Pages网站托管等。祝你协作愉快！

Factorio is an automation game born in 2013 as a passion project by Prague-based Wube Software. The game places players on an alien planet where they must build and maintain factories while defending them from hostile native creatures.

Byrne Hobart describes this as a meditative game

I find the process of building and optimizing factory systems in Factorio to be strangely calming. Despite the complexity of managing resources, production lines, and logistics networks, there’s something deeply satisfying about watching a well-designed factory operate efficiently. The game rewards systematic thinking and encourages players to continuously improve their designs—skills that translate well to real-world problem-solving.

The Factorio Mindset in Daily Life

What fascinates me most about Factorio is how perfectly it mirrors real-life productivity challenges. When you start a new game, you’re forced to build suboptimal systems because:

1. You don’t yet have access to better tools
2. You don’t fully understand what you’ll need in the future
3. You’re still learning the relationships between different systems

This mirrors our daily lives in profound ways. Think about any skill you’ve developed or system you’ve built:

• When you first learn to code, you write messy, inefficient programs
• When you start a research project, your initial methodology will need refinement
• When you organize a workspace, your first layout rarely survives contact with actual use

The key insight from Factorio that applies to life is this: you cannot build the optimal solution from the start because you don’t yet know what you want or need.

Instead, the process follows a natural evolution:

1. Build something basic that works (even if imperfectly)
2. Use that system to gain resources and knowledge
3. Identify bottlenecks and inefficiencies
4. Refine your tools and processes
5. Expand capabilities with your improved system
6. Repeat the cycle

The beauty of this approach—both in Factorio and in life—is that it embraces continuous improvement rather than expecting perfection from the start. This mindset reduces the paralysis that comes from trying to design the perfect system before taking any action.

In today’s digital landscape, the line between education and entertainment continues to blur. Andrej Karpathy, former Tesla AI Director and OpenAI founding member, offers a thought-provoking perspective on this phenomenon:

This observation resonates with my own experience navigating online learning resources. The most engaging content isn’t always the most educational, and true learning often requires effort that entertainment-focused content deliberately avoids.

If you’ve ever loaded a Jekyll site and noticed a brief flicker where unstyled HTML content appears before your CSS kicks in, you’ve experienced what web developers call a “Flash of Unstyled Content” or FOUC. This jarring visual glitch happens when your browser renders HTML content before the associated stylesheets have finished loading.

For Jekyll sites, this issue is particularly common because of how the platform processes and serves content. The browser starts rendering the HTML document as soon as it receives it, but external stylesheets might take a bit longer to download and parse.

A Simple but Effective Solution

After experiencing this issue on my own Jekyll site, I implemented a minimal fix that completely eliminates the FOUC. The solution involves just a few lines of CSS and JavaScript and works by:

1. Initially hiding the entire page content
2. Revealing the content only after all resources (including CSS) have loaded

Here’s how I did it:

Step 1: Modify custom-head.html

First, I added the following code to my _includes/custom-head.html file:

<!-- Fix for Flash of Unstyled Content (FOUC) -->
<style>
  .no-fouc {
    visibility: hidden;
  }
</style>
<script>
  document.documentElement.className = 'no-fouc';
  window.addEventListener('load', function() {
    document.documentElement.className = '';
  });
</script>

This creates a CSS class that hides elements and sets up a JavaScript event listener that will remove this class once everything has loaded.

Step 2: Apply the class to the HTML element

Then, I updated my _layouts/base.html file to add the class to the root HTML element:

<!DOCTYPE html>
<html lang="en" class="no-fouc">

How It Works

The solution works through these key mechanisms:

1. The .no-fouc CSS class sets visibility: hidden on any element it’s applied to
2. We apply this class to the root <html> element through JavaScript immediately
3. The load event listener waits until all page resources (HTML, CSS, JS, images, etc.) have finished loading
4. Once everything is loaded, we remove the class, making the page visible

Benefits of This Approach

This solution has several advantages:

• Minimal code: Just a few lines of CSS and JavaScript
• No dependencies: Doesn’t require jQuery or other libraries
• Preserves page structure: Unlike some solutions that completely hide the body, this approach maintains the document flow, preventing layout shifts
• Works with Jekyll’s default setup: No need to modify your build process

Testing Your Fix

To confirm the fix works:

1. Open your site in a browser with the network throttled (in Chrome DevTools, use the Network tab to simulate a slow connection)
2. Refresh the page
3. You should see the page appear fully styled, with no interim unstyled content

This simple solution provides a much better user experience by ensuring visitors only see your site when it’s fully styled and ready for presentation.