Follow your heart

Remote Packet Capture for iOS Devices

2013-07-29T15:12:00-07:00

just use the rvictl shell command to build an remote virtual interface and use tcpdump/wireshark to capture what one want

just see here

Remote Packet Capture

here,

Getting a Packet Trace

and here

网络模拟与抓包

The Wisdom Project

2013-07-16T09:56:00-07:00

Nice website, just share it here

The Widsom Prject, "Safeguard significant knowledge for posterity"

Git: 使用手册

2013-07-06T13:10:00-07:00

Git使用手册

TO-DO

Git: 使用手册

Mac: Build MacVim

2013-07-05T20:50:00-07:00

Github源码

  git clone https://github.com/b4winckler/macvim.git

Build

  CC=clang ./configure --with-features=huge \
                       --enable-rubyinterp \
                       --enable-pythoninterp \
                       --enable-perlinterp \
                       --enable-cscope
  make

Install

  cp -a src/MacVim/build/Release/MacVim.app ~/Applications/MacVim.app

Configure:

  git clone https://github.com/amix/vimrc.git

  and have a look at here (https://github.com/amix/vimrc)

Have fun, thanks!

TO-DO

Build MacVim

三个快速且简单的让你的大脑安静下来的方法

2013-07-05T20:35:00-07:00

Hey, you can check it out here

三个快速且简单的让你的大脑安静下来的方法

or here

Quick and Easy Ways to Quiet Your Mind

" 快速冥想 "

" 建立工作节奏 " 类似于番茄钟

" 胡思乱想白日做梦 "

Just have fun, guys!

TO-DO

三个快速且简单的让你的大脑安静下来的方法

无题

2013-07-05T20:25:00-07:00

最早了解到“吸引力法则”，是来自《秘密/Secret》这本书。

何为吸引力？

能够吸引你的事物

生活中的吸引力法则

求职。面对多个offer，我们作出了自己的选择，而实际上是这份工作吸引了我们。。。
恋爱。热恋的男女，是怎么走到一起的呢？彼此吸引
购物。你是怎么去选择自己喜欢的服饰呢？谁更能吸引，就选择谁，不是吗
还有很多很多。。。

正确引导吸引力

被好的事物所吸引/影响

能得到什么启发？

... 也许，可以利用这一点，做一些事情。也许，没有任何意义。，

TO-DO

无题之吸引力

MySQL: 两个实用的时间戳函数

2013-07-05T19:50:00-07:00

时间戳->日期字符串

SELECT FROM_UNIXTIME(1373025189);
日期字符串->时间戳

SELECT UNIX_TIMESTAMP('2013-07-05 12:00:00');

TO-DO

MySQL: 两个实用的时间戳函数

TED: 四旋翼直升机的惊人运动机能

2013-07-04T10:07:00-07:00

NB的四旋翼直升机的惊人运动机能，浏览这里

四旋翼直升机的惊人运动机能

TO-DO

四旋翼直升机的惊人运动机能

tukkk在线小语种学习

2013-07-03T22:47:00-07:00

小语种在线学习资源，很不错的哈\^{_\^}

tukkk小语种在线学习

TO-DO

tukkk在线小语种学习

CoffeeScript学习资源

2013-07-03T19:50:00-07:00

很好的学习资源，收藏，\^{_\^}

Coffee is not a coffee: http://coffee-js.github.io/coffeescript.cn/

TO-DO

CoffeeScript学习资源

Programming is an art

2013-07-03T10:12:00-07:00

just read here, Programming is an art

" I have been thinking why I love programming and the bottom line is that I love creating stuff. I like to imagine how things can be. Using only a computer I can create anything I can imagine and I can easily share my creations with other people. It's not many professions that enable you this "

" Allocate 4 hours pr. week where you can create anything you want. Focus on creating. Don't let anybody interrupt you. Move to a cafe. Lock your office. Don't consume. Don't read Hacker News. Don't consume Twitter. Use the 4 hours to create something! " --- from Amir Salihefendic

I think it's a very best idea.

Just keep creative, and do something, you will get more.

Have fun, guys~!

TO-DO

Programming is an art

Unity3D: 预定义宏定义

2013-07-02T18:53:00-07:00

Unity3D的一些预定义宏定义，仅仅作为备案，以备查阅。

来自Unity3D官方Platform Dependent Compilation

Platform Defines The platform defines that Unity supports for your scripts are:

UNITY_EDITOR	Define for calling Unity Editor scripts from your game code.
UNITY_STANDALONE_OSX	Platform define for compiling/executing code specifically for Mac OS (This includes Universal, PPC and Intel architectures).
UNITY_DASHBOARD_WIDGET	Platform define when creating code for Mac OS dashboard widgets.
UNITY_STANDALONE_WIN	Use this when you want to compile/execute code for Windows stand alone applications.
UNITY_STANDALONE_LINUX	Use this when you want to compile/execute code for Linux stand alone applications.
UNITY_STANDALONE	Use this to compile/execute code for any standalone platform (Mac, Windows or Linux).
UNITY_WEBPLAYER	Platform define for web player content (this includes Windows and Mac Web player executables).
UNITY_WII	Platform define for compiling/executing code for the Wii console.
UNITY_IPHONE	Platform define for compiling/executing code for the iPhone platform.
UNITY_ANDROID	Platform define for the Android platform.
UNITY_PS3	Platform define for running PlayStation 3 code.
UNITY_XBOX360	Platform define for executing Xbox 360 code.
UNITY_NACL	Platform define when compiling code for Google native client (this will be set additionally to UNITY_WEBPLAYER).
UNITY_FLASH	Platform define when compiling code for Adobe Flash.

Also you can compile code selectively depending on the version of the engine you are working on. Currently the supported ones are:

UNITY_2_6	Platform define for the major version of Unity 2.6.
UNITY_2_6_1	Platform define for specific version 1 from the major release 2.6.
UNITY_3_0	Platform define for the major version of Unity 3.0.
UNITY_3_0_0	Platform define for the specific version 0 of Unity 3.0.
UNITY_3_1	Platform define for major version of Unity 3.1.
UNITY_3_2	Platform define for major version of Unity 3.2.
UNITY_3_3	Platform define for major version of Unity 3.3.
UNITY_3_4	Platform define for major version of Unity 3.4.
UNITY_3_5	Platform define for major version of Unity 3.5.
UNITY_4_0	Platform define for major version of Unity 4.0.
UNITY_4_0_1	Platform define for major version of Unity 4.0.1.
UNITY_4_1	Platform define for major version of Unity 4.1.

Note: For versions before 2.6.0 there are no platform defines as this feature was first introduced in that version.

Before I die, I want to ...

2013-07-01T19:27:00-07:00

Before I die, I want to be complete myself!

This topic can be found here Candy Chang: Before I die I want to... and here andy Chang: Before I die I want to... and here Before_I_Die

TO-DO

Before I die, I want to ...

你的时间都浪费在什么地方？

2013-07-01T19:25:00-07:00

TO-DO

你的时间都浪费在什么地方?

Richard St. John's 8 secrets of success

2013-07-01T19:15:00-07:00

Passion
Work
Good
Push
Serve
Ideas
Persist
Focus

and you can see this TED video on Richard St. John's 8 secrets of success

TO-DO

Richard St. John's 8 secrets of success

Jkeyll: 如何写博客

2013-06-30T13:01:00-07:00

基本格式

---
layout: post
title: "title"
date: 2013-06-30 12:00
category: "category"
tags: [tags]
--


xxxxxx
xxxxxx 使用markdown语法写内容
xxxxxx

MARKDOWN语法

参考Mac下Mou编辑器

TO-DO

Jkeyll: 如何写博客

今天，你努力了吗？

2013-06-30T12:56:00-07:00

如题!

TO-DO

今天，你努力了吗？

Golang开发环境: vim+gocode

2013-06-29T18:02:00-07:00

安装Golang

下载Golang编译器，解压到某一目录，可以放在/usr/local或者~/bin目录，或者其他自己喜好的目录；

设置Golang环境，我的配置如下(Mac)：

# Golang settings
export GOROOT=$HOME/Applications/go
export GOPATH=$HOME/go
export GOARCH=amd64
export GOOS=darwin
export GOBIN=$GOROOT/bin
export PATH=.:$GOBIN:$PATH

大家可以参考自己的安装环境做一定的修改。其中， + GOROOT - Golang的安装目录 + GOPATH - Golang第三方库安装位置，用go get xx.xx.xx.xx/xx安装第三方库安装到该目录 + GOARCH - CPU架构，amd64/386/arm/... + GOOS - 当前使用的OS，linux/darwin/...

安装Gocode

参考官方的安装方法

go get -u github.com/nsf/gocode (-u flag for "update")

配置Gocode，命令为gocode set option value

gocode set propose-buildins true
gocode set lib-path ~/Projects/go/pkg/darwin_amd64:~/go/pkg/darwin_amd64

其中,

propose-buildins: 是否自动提示Go的内置函数、类型和常量，默认false，不提示
lib-path: 默认情况下，gocode只会搜索$GOPATH/pkg/$GOOS$GOARCH和$GOROOT/pkg/$GOOS$GOARCH目录下的包，当然这个设置就是可以设置我们额外的lib能访问的路径，代码自动完成时需要设置该选项

配置Vim

复制$GOROOT/misc/vim目录下内容到~/.vim目录

make -p ~/.vim
cp -a $GOROOT/misc/vim ~/.vim

安装gocode的vim脚本

cd $HOME/go/src/github.com/nsf/gocode/vim (gocode的安装目录下)
./update.sh

启用 filetype plugin

filetype plugin on

使用golang的代码自动完成

Ctrl-x Ctrl-o -- 代码编辑时，打开自动完成
Ctrl-p -- 代码提示列表

TO-DO

搭建Golang开发环境

Mac: 安装Jekyll博客系统

2013-06-29T16:56:00-07:00

部署Jekyll时，需要使用Ruby 1.9.x以上，而最新的Mac OSX 10.8.x系统上使用Ruby 1.8.x，需要使用RVM来安装不同的Ruby版本。

也可以使用homebrew安装ruby，有兴趣的朋友可以尝试。

brew install ruby

安装RVM

RVM被用来管理系统中不同的Ruby版本，安装前请对RVM进行了解。

安装稳定版

curl -L https://get.rvm.io | bash -s stable

安装过程中输出的信息，会提示如何启用rvm，如使用

source ~/.rvm/scripts/rvm

即可使用RVM。

安装成功后，在~/.bash_profile中会自动添加

[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"

表示在打开终端时自动加载

为了加快RVM下载源码的速度，可以修改RVM的源码镜像地址，具体请参考RubyGems淘宝镜像

安装Ruby

通过RVM中安装Ruby 2.0.0

rvm install 2.0.0

安装过程中，若下载Ruby 2.0.0源码时较慢或者没有反应，可以手动下载Ruby 2.0.0。然后把Ruby源码放在~/.rvm/archives/目录下，重新执行安装即可。

rvm reinstall 2.0.0

启用Ruby 2.0.0

rvm use 2.0.0

使用Rubygems安装包时，为了加快下载速度，可以改用RubyGems淘宝镜像，具体设置请参考RubyGems淘宝镜像

安装 Jekyll

通过RubyGems安装

gem install jekyll jekyll-tagging

如果不需要用默认的Markdown模版Maruku，想使用RDiscount，则请安装：

gem install rdiscount

TO-DO

github环境搭建
jekyll配置

Refrence

[TO-DO]为什么写Blog

2013-06-29T12:48:00-07:00

这个家伙很懒，什么也没留下

!!!未完待续，to be continued ...!!!

TO-DO

为什么写Blog

Jekyll Quick Start

2013-06-28T22:36:00-07:00

Read Jekyll Quick Start

Complete usage and documentation available at: Jekyll Bootstrap

Update Author Attributes

In _config.yml remember to specify your own data:

title : My Blog =)

author :
  name : Name Lastname
  email : blah@email.test
  github : username
  twitter : username

The theme should reference these variables whenever needed.

Sample Posts

This blog contains sample posts which help stage pages and blog data. When you don't need the samples anymore just delete the _posts/core-samples folder.

$ rm -rf _posts/core-samples

Here's a sample "posts list".

29 Jul 2013 » Remote Packet Capture for iOS Devices
16 Jul 2013 » The Wisdom Project
06 Jul 2013 » Git: 使用手册
05 Jul 2013 » Mac: Build MacVim
05 Jul 2013 » 三个快速且简单的让你的大脑安静下来的方法
05 Jul 2013 » 无题
05 Jul 2013 » MySQL: 两个实用的时间戳函数
04 Jul 2013 » TED: 四旋翼直升机的惊人运动机能
03 Jul 2013 » tukkk在线小语种学习
03 Jul 2013 » CoffeeScript学习资源
03 Jul 2013 » Programming is an art
02 Jul 2013 » Unity3D: 预定义宏定义
01 Jul 2013 » Before I die, I want to ...
01 Jul 2013 » 你的时间都浪费在什么地方？
01 Jul 2013 » Richard St. John's 8 secrets of success
30 Jun 2013 » Jkeyll: 如何写博客
30 Jun 2013 » 今天，你努力了吗？
29 Jun 2013 » Golang开发环境: vim+gocode
29 Jun 2013 » Mac: 安装Jekyll博客系统
29 Jun 2013 » [TO-DO]为什么写Blog
28 Jun 2013 » Jekyll Quick Start
13 May 2013 » 乔布斯: 坚持思考两个问题
04 May 2013 » 鲁迅生活哲理
26 Nov 2012 » Linux: 设置Oracle JDK环境
26 Nov 2012 » Linux: 安装WireShark问题
26 Nov 2012 » Linux: 使用RT-Thread构建嵌入式应用
29 Dec 2011 » Jekyll Introduction

To-Do

This theme is still unfinished. If you'd like to be added as a contributor, please fork! We need to clean up the themes, make theme usage guides with theme-specific markup examples.

乔布斯: 坚持思考两个问题

2013-05-13T20:30:00-07:00

Why doesn't it work?
What should I change to make it work?

TO-Do

乔布斯: 坚持思考两个问题

鲁迅生活哲理

2013-05-04T12:48:00-07:00

鲁迅生活哲理，来自《一种深久的不安》，有声版

所谓生存，不是苟活
所谓温饱，不是奢侈
所谓发展，不是放纵

TO-DO

鲁讯生活哲理

Linux: 设置Oracle JDK环境

2012-11-26T14:54:00-08:00

安装好Oracle JDK环境后（实际上是安装到一个目录中），但Linux系统并不知道，需要进行设置，如下：

$ sudo update-alternatives --install "/usr/bin/java" "java" "/home/sfh/software/jdk1.6.0_37/bin/java" 1  
$ sudo update-alternatives --install "/usr/bin/javac" "javac" "/home/sfh/software/jdk1.6.0_37/bin/javac" 1  
$ sudo update-alternatives --install "/usr/bin/javaws" "javaws" "/home/sfh/software/jdk1.6.0_37/bin/javaws" 1  

$ sudo update-alternatives --config java  
$ sudo update-alternatives --config javac  
$ sudo update-alternatives --config javaws

说明：/home/sfh/software/jdk1.6.0_37是jdk的安装目录

$ java -version

运行后发现java环境设置成功

其次，设置java环境

编辑/etc/profile文件，添加如下：

#set java environment  
export JAVA_HOME=/home/sfh/software/jdk1.6.0_37  
export CLASSPATH=.:$JAVA_HOME/lib:$JAVA_HOME/jre/lib

TO-DO

Linux: 设置Oracle JDK环境

Linux: 安装WireShark问题

2012-11-26T14:39:00-08:00

由于项目需要调试网络数据帧，一个开源的好工具是wireshark。在Debian系统下安装wireshark（具体怎么安装就不介绍了）后，打开wireshark文件发现，没有一个网络接口可供操作的，这是肿么回事？

在linux终端下尝试使用sudo来运行wireshark，这才发现，wireshark需要根用户权限才能使用。但话说回来，每次使用这wireshark工具，都用在终端下敲下

sudo wireshark

着实有些麻烦，本人一向比较懒，直接点击wireshark图标打开文件，岂不快哉？在google大神的帮助下，终于找到解决方案:

参考网址: http://ask.wireshark.org/questions/7976/wireshark-setup-linux-for-nonroot-user

$ sudo dpkg-reconfigure wireshark-common   
$ sudo usermod -a -G wireshark $USER  
$ gnome-session-quit --logout --no-prompt

TO-DO

Linux: 安装Wireshark问题

Linux: 使用RT-Thread构建嵌入式应用

2012-11-26T14:19:00-08:00

本文主要介绍如何在Linux环境使用国人开发的嵌入式实时操作系统RT-Thread构建嵌入式应用。

主要环境配置

主机系统：Debian wheezy 32bit
交叉编译工具：sourcery g++ lite-2012.09
项目构建工具：scons
RT-Thread版本：RT-Thread V1.0.3
开发板：自制STM32F103ZET6开发板
调试器：JLink

工程构建说明

在自制的STM32F103ZET6开发板上，基于RT-Thread自带的BSP—stm32f10x构建一个示例工程test，本工程仅仅是一个示例，意在介绍如何在Linux环境使用RT-Thread以及scons构建工具建立嵌入式应用，开发实际项目进行相应修改及扩展即可。

将RT-Thread源码解压到工程目录test中;

在test工程目录中建立应用程序目录apps，此时test工程目录是:

+ apps
+ bsp
+ componets
+ documents
+ examples
+ include
+ libcpu
+ src
+ tools

在apps目录中建立test.c文件，在其中添加代码（假定是一个流水灯的任务代码）后保存;

RT-Thread使用scons工具来进行项目工程构建，RT-Thread中scons的使用可以参照《RT-Thread中的SCons使用详解》，本文不做介绍。需要在apps目录下建立scons编译脚本文件SConscript（实际上是一段Python程序），告诉scons需要编译哪些文件。示例中apps目录下仅有一个文件test.c，因此SConscript文件内容如下:

Import('RTT_ROOT')
from building import *

src = Split("""
test.c
""")

#The set of source files associated with this SConscript file.
path = [GetCurrentDir()]
group = DefineGroup('Apps', src, depend = [''], CPPPATH = path)
Return('group')

在linux终端中，进入到目录bsp/stm32f10x中，执行scons，完成后发现apps目录中的文件并没有编译;

为了能够编译apps目录下的内容，需要修改bsp/stm32f10x目录中的SConstruct文件，在适当的位置添加如下内容:

#Application
objs = objs + SConscript(RTT_ROOT + '/apps/SConscript', variant_dir='build/apps', duplicate=0)

这句脚本告诉scons，编译apps目录下的代码并添加到二进制目标文件中，且由apps目录下的SConscript指定编译哪些文件;

再次执行scons，这时候可以看到，apps目录的代码已经被编译; 说明：若要查看apps下的代码有没有被编译，可以查看bsp/stm32f10x/build目录下，有没有apps目录，以及该目录有没有相应的.o文件;

代码烧录到开发板中，操作说明请参照《Linux下通过Jlink烧写RT-Thread》

如何使用scons构建工程项目，请参照《RT-Thread中的SCons使用详解》以及scons官方文档。

TO-DO

Linux: 使用RT-Thread构建嵌入式应用

Jekyll Introduction

2011-12-29T00:00:00-08:00

This Jekyll introduction will outline specifically what Jekyll is and why you would want to use it. Directly following the intro we'll learn exactly how Jekyll does what it does.

Overview

What is Jekyll?

Jekyll is a parsing engine bundled as a ruby gem used to build static websites from dynamic components such as templates, partials, liquid code, markdown, etc. Jekyll is known as "a simple, blog aware, static site generator".

Examples

This website is created with Jekyll. Other Jekyll websites.

What does Jekyll Do?

Jekyll is a ruby gem you install on your local system. Once there you can call jekyll --server on a directory and provided that directory is setup in a way jekyll expects, it will do magic stuff like parse markdown/textile files, compute categories, tags, permalinks, and construct your pages from layout templates and partials.

Once parsed, Jekyll stores the result in a self-contained static _site folder. The intention here is that you can serve all contents in this folder statically from a plain static web-server.

You can think of Jekyll as a normalish dynamic blog but rather than parsing content, templates, and tags on each request, Jekyll does this once beforehand and caches the entire website in a folder for serving statically.

Jekyll is Not Blogging Software

Jekyll is a parsing engine.

Jekyll does not come with any content nor does it have any templates or design elements. This is a common source of confusion when getting started. Jekyll does not come with anything you actually use or see on your website - you have to make it.

Why Should I Care?

Jekyll is very minimalistic and very efficient. The most important thing to realize about Jekyll is that it creates a static representation of your website requiring only a static web-server. Traditional dynamic blogs like Wordpress require a database and server-side code. Heavily trafficked dynamic blogs must employ a caching layer that ultimately performs the same job Jekyll sets out to do; serve static content.

Therefore if you like to keep things simple and you prefer the command-line over an admin panel UI then give Jekyll a try.

Developers like Jekyll because we can write content like we write code:

Ability to write content in markdown or textile in your favorite text-editor.
Ability to write and preview your content via localhost.
No internet connection required.
Ability to publish via git.
Ability to host your blog on a static web-server.
Ability to host freely on GitHub Pages.
No database required.

How Jekyll Works

The following is a complete but concise outline of exactly how Jekyll works.

Be aware that core concepts are introduced in rapid succession without code examples. This information is not intended to specifically teach you how to do anything, rather it is intended to give you the full picture relative to what is going on in Jekyll-world.

Learning these core concepts should help you avoid common frustrations and ultimately help you better understand the code examples contained throughout Jekyll-Bootstrap.

Initial Setup

After installing jekyll you'll need to format your website directory in a way jekyll expects. Jekyll-bootstrap conveniently provides the base directory format.

The Jekyll Application Base Format

Jekyll expects your website directory to be laid out like so:

.
|-- _config.yml
|-- _includes
|-- _layouts
|   |-- default.html
|   |-- post.html
|-- _posts
|   |-- 2011-10-25-open-source-is-good.markdown
|   |-- 2011-04-26-hello-world.markdown
|-- _site
|-- index.html
|-- assets
    |-- css
        |-- style.css
    |-- javascripts

_config.yml
Stores configuration data.
_includes
This folder is for partial views.
_layouts
This folder is for the main templates your content will be inserted into. You can have different layouts for different pages or page sections.
_posts
This folder contains your dynamic content/posts. the naming format is required to be @YEAR-MONTH-DATE-title.MARKUP@.
_site
This is where the generated site will be placed once Jekyll is done transforming it.
assets
This folder is not part of the standard jekyll structure. The assets folder represents any generic folder you happen to create in your root directory. Directories and files not properly formatted for jekyll will be left untouched for you to serve normally.

Jekyll Configuration

Jekyll supports various configuration options that are fully outlined here: https://github.com/mojombo/jekyll/wiki/Configuration

Content in Jekyll

Content in Jekyll is either a post or a page. These content "objects" get inserted into one or more templates to build the final output for its respective static-page.

Posts and Pages

Both posts and pages should be written in markdown, textile, or HTML and may also contain Liquid templating syntax. Both posts and pages can have meta-data assigned on a per-page basis such as title, url path, as well as arbitrary custom meta-data.

Working With Posts

Creating a Post
Posts are created by properly formatting a file and placing it the _posts folder.

Formatting
A post must have a valid filename in the form YEAR-MONTH-DATE-title.MARKUP and be placed in the _posts directory. If the data format is invalid Jekyll will not recognize the file as a post. The date and title are automatically parsed from the filename of the post file. Additionally, each file must have YAML Front-Matter prepended to its content. YAML Front-Matter is a valid YAML syntax specifying meta-data for the given file.

Order
Ordering is an important part of Jekyll but it is hard to specify a custom ordering strategy. Only reverse chronological and chronological ordering is supported in Jekyll.

Since the date is hard-coded into the filename format, to change the order, you must change the dates in the filenames.

Tags
Posts can have tags associated with them as part of their meta-data. Tags may be placed on posts by providing them in the post's YAML front matter. You have access to the post-specific tags in the templates. These tags also get added to the sitewide collection.

Categories
Posts may be categorized by providing one or more categories in the YAML front matter. Categories offer more significance over tags in that they can be reflected in the URL path to the given post. Note categories in Jekyll work in a specific way. If you define more than one category you are defining a category hierarchy "set". Example:

---
title :  Hello World
categories : [lessons, beginner]
---

This defines the category hierarchy "lessons/beginner". Note this is one category node in Jekyll. You won't find "lessons" and "beginner" as two separate categories unless you define them elsewhere as singular categories.

Working With Pages

Creating a Page
Pages are created by properly formatting a file and placing it anywhere in the root directory or subdirectories that do not start with an underscore.

Formatting
In order to register as a Jekyll page the file must contain YAML Front-Matter. Registering a page means 1) that Jekyll will process the page and 2) that the page object will be available in the site.pages array for inclusion into your templates.

Categories and Tags
Pages do not compute categories nor tags so defining them will have no effect.

Sub-Directories
If pages are defined in sub-directories, the path to the page will be reflected in the url. Example:

.
|-- people
    |-- bob
        |-- essay.html

This page will be available at http://yourdomain.com/people/bob/essay.html

Recommended Pages

index.html
You will always want to define the root index.html page as this will display on your root URL.
404.html
Create a root 404.html page and GitHub Pages will serve it as your 404 response.
sitemap.html
Generating a sitemap is good practice for SEO.
about.html
A nice about page is easy to do and gives the human perspective to your website.

Templates in Jekyll

Templates are used to contain a page's or post's content. All templates have access to a global site object variable: site as well as a page object variable: page. The site variable holds all accessible content and metadata relative to the site. The page variable holds accessible data for the given page or post being rendered at that point.

Create a Template
Templates are created by properly formatting a file and placing it in the _layouts directory.

Formatting
Templates should be coded in HTML and contain YAML Front Matter. All templates can contain Liquid code to work with your site's data.

Rending Page/Post Content in a Template
There is a special variable in all templates named : content. The content variable holds the page/post content including any sub-template content previously defined. Render the content variable wherever you want your main content to be injected into your template:

...
<body>
  <div id="sidebar"> ... </div>
  <div id="main">

&#123;{content}&#125;


  </div>
</body>
...

Sub-Templates

Sub-templates are exactly templates with the only difference being they define another "root" layout/template within their YAML Front Matter. This essentially means a template will render inside of another template.

Includes

In Jekyll you can define include files by placing them in the _includes folder. Includes are NOT templates, rather they are just code snippets that get included into templates. In this way, you can treat the code inside includes as if it was native to the parent template.

Any valid template code may be used in includes.

Using Liquid for Templating

Templating is perhaps the most confusing and frustrating part of Jekyll. This is mainly due to the fact that Jekyll templates must use the Liquid Templating Language.

What is Liquid?

Liquid is a secure templating language developed by Shopify. Liquid is designed for end-users to be able to execute logic within template files without imposing any security risk on the hosting server.

Jekyll uses Liquid to generate the post content within the final page layout structure and as the primary interface for working with your site and post/page data.

Why Do We Have to Use Liquid?

GitHub uses Jekyll to power GitHub Pages. GitHub cannot afford to run arbitrary code on their servers so they lock developers down via Liquid.

Liquid is Not Programmer-Friendly.

The short story is liquid is not real code and its not intended to execute real code. The point being you can't do jackshit in liquid that hasn't been allowed explicitly by the implementation. What's more you can only access data-structures that have been explicitly passed to the template.

In Jekyll's case it is not possible to alter what is passed to Liquid without hacking the gem or running custom plugins. Both of which cannot be supported by GitHub Pages.

As a programmer - this is very frustrating.

But rather than look a gift horse in the mouth we are going to suck it up and view it as an opportunity to work around limitations and adopt client-side solutions when possible.

Aside
My personal stance is to not invest time trying to hack liquid. It's really unnecessary from a programmer's perspective. That is to say if you have the ability to run custom plugins (i.e. run arbitrary ruby code) you are better off sticking with ruby. Toward that end I've built Mustache-with-Jekyll

Static Assets

Static assets are any file in the root or non-underscored subfolders that are not pages. That is they have no valid YAML Front Matter and are thus not treated as Jekyll Pages.

Static assets should be used for images, css, and javascript files.

How Jekyll Parses Files

Remember Jekyll is a processing engine. There are two main types of parsing in Jekyll.

Content parsing.
This is done with textile or markdown.
Template parsing.
This is done with the liquid templating language.

And thus there are two main types of file formats needed for this parsing.

Post and Page files.
All content in Jekyll is either a post or a page so valid posts and pages are parsed with markdown or textile.
Template files.
These files go in _layouts folder and contain your blogs templates. They should be made in HTML with the help of Liquid syntax. Since include files are simply injected into templates they are essentially parsed as if they were native to the template.

Arbitrary files and folders.
Files that are not valid pages are treated as static content and pass through Jekyll untouched and reside on your blog in the exact structure and format they originally existed in.

Formatting Files for Parsing.

We've outlined the need for valid formatting using YAML Front Matter. Templates, posts, and pages all need to provide valid YAML Front Matter even if the Matter is empty. This is the only way Jekyll knows you want the file processed.

YAML Front Matter must be prepended to the top of template/post/page files:

---
layout: post
category : pages
tags : [how-to, jekyll]
---

... contents ...

Three hyphens on a new line start the Front-Matter block and three hyphens on a new line end the block. The data inside the block must be valid YAML.

Configuration parameters for YAML Front-Matter is outlined here: A comprehensive explanation of YAML Front Matter

Defining Layouts for Posts and Templates Parsing.

The layout parameter in the YAML Front Matter defines the template file for which the given post or template should be injected into. If a template file specifies its own layout, it is effectively being used as a sub-template. That is to say loading a post file into a template file that refers to another template file with work in the way you'd expect; as a nested sub-template.

How Jekyll Generates the Final Static Files.

Ultimately, Jekyll's job is to generate a static representation of your website. The following is an outline of how that's done:

Jekyll collects data.
Jekyll scans the posts directory and collects all posts files as post objects. It then scans the layout assets and collects those and finally scans other directories in search of pages.
Jekyll computes data.
Jekyll takes these objects, computes metadata (permalinks, tags, categories, titles, dates) from them and constructs one big site object that holds all the posts, pages, layouts, and respective metadata. At this stage your site is one big computed ruby object.
Jekyll liquifies posts and templates.
Next jekyll loops through each post file and converts (through markdown or textile) and liquifies the post inside of its respective layout(s). Once the post is parsed and liquified inside the the proper layout structure, the layout itself is "liquified".
Liquification is defined as follows: Jekyll initiates a Liquid template, and passes a simpler hash representation of the ruby site object as well as a simpler hash representation of the ruby post object. These simplified data structures are what you have access to in the templates.
Jekyll generates output.
Finally the liquid templates are "rendered", thereby processing any liquid syntax provided in the templates and saving the final, static representation of the file.

Notes.
Because Jekyll computes the entire site in one fell swoop, each template is given access to a global site hash that contains useful data. It is this data that you'll iterate through and format using the Liquid tags and filters in order to render it onto a given page.

Remember, in Jekyll you are an end-user. Your API has only two components:

The manner in which you setup your directory.
The liquid syntax and variables passed into the liquid templates.

All the data objects available to you in the templates via Liquid are outlined in the API Section of Jekyll-Bootstrap. You can also read the original documentation here: https://github.com/mojombo/jekyll/wiki/Template-Data

Conclusion

I hope this paints a clearer picture of what Jekyll is doing and why it works the way it does. As noted, our main programming constraint is the fact that our API is limited to what is accessible via Liquid and Liquid only.

Jekyll-bootstrap is intended to provide helper methods and strategies aimed at making it more intuitive and easier to work with Jekyll =)

Thank you for reading this far.

Next Steps

Please take a look at or jump right into Usage if you'd like.