@@ -610,7 +610,7 @@ std::cout << "all topologies complete" << '\n';
 
 ## Task API
 
-Each `tf::Taskflow::Task` object is a lightweight handle for you to create dependencies in its associated graph. 
+Each task object is a lightweight handle for you to create dependencies in its associated graph. 
 The table below summarizes its methods.
 
 | Method         | Argument    | Return | Description |
 
@@ -3,18 +3,24 @@
 This page summarizes a list of frequently asked questions about Cpp-Taskflow.
 If you cannot find a solution here, please post an issue [here][Github issues].
 
++ [General Questions](#General-Questions)
++ [Compilation Issues](#Compilation-Issues)
++ [Programming Questions](#Programming-Questions)
+
+---
+
 ## General Questions
 
-#### Q: How do I use Cpp-Taskflow in my projects?
+### Q: How do I use Cpp-Taskflow in my projects?
 
-**A:** Cpp-Taskflow is a header-only library with zero dependencies. 
+Cpp-Taskflow is a header-only library with zero dependencies. 
 The only thing you need is a [C++17][C++17] compiler.
 To use Cpp-Taskflow, simply drop the folder 
 [taskflow](../taskflow) to your project and include [taskflow.hpp](../taskflow/taskflow.hpp).
 
-#### Q: What is the difference between static tasking and dynamic tasking?
+### Q: What is the difference between static tasking and dynamic tasking?
 
-**A:** Static tasking refers to those tasks created before execution,
+Static tasking refers to those tasks created before execution,
 while dynamic tasking refers to those tasks created during the execution of static tasks
 or dynamic tasks (nested).
 Dynamic tasks created by the same task node are grouped together to a subflow.
@@ -24,37 +30,39 @@ Dynamic tasks created by the same task node are grouped together to a subflow.
 | ![](../image/static_graph.png) | ![](../image/dynamic_graph.png) |
 
 
-#### Q: How many tasks can Cpp-Taskflow handle?
+### Q: How many tasks can Cpp-Taskflow handle?
 
-**A:** Cpp-Taskflow is a very lightweight and efficient tasking library.
+Cpp-Taskflow is a very lightweight and efficient tasking library.
 It has been applied in many academic and industry projects to scale up their existing workload.
 A research project [OpenTimer][OpenTimer] has used Cpp-Taskflow to deal with hundreds of millions of tasks.
 
-#### Q: What are the differences between Cpp-Taskflow and other tasking libraries?
+### Q: What are the differences between Cpp-Taskflow and other tasking libraries?
 
-**A:** From our humble opinion, Cpp-Taskflow is superior in its tasking API, interface, and performance.
+From our humble opinion, Cpp-Taskflow is superior in its tasking API, interface, and performance.
 In most cases, users can quickly master Cpp-Taskflow to create large and complex dependency graphs
 in just a few minutes.
 The performance scales very well and is comparable to hard-coded multi-threading.
 Of course, the judge is always left for users -:)
 
-#### Q: What is the weird hex value, like 0x7fc39d402ab0, in the dumped graph?
+### Q: What is the weird hex value, like 0x7fc39d402ab0, in the dumped graph?
 
-**A:** Each task has a method `name(const std::string&)` for user to assign a human readable string
+Each task has a method `name(const std::string&)` for user to assign a human readable string
 to ease the debugging process. 
 If a task is not assigned a name or is an internal node,
 its address value in the memory is used instead.
 
-## Compile Issues
+---
 
-#### Q: I can't get Cpp-Taskflow compiled in my project!
+## Compilation Issues
 
-**A:** Please make sure your compile supports the latest version of [C++17][C++17]. 
+### Q: I can't get Cpp-Taskflow compiled in my project!
+
+Please make sure your compile supports the latest version of [C++17][C++17]. 
 Make sure your project meets the System Requirements described at [README][README].
 
-#### Q: Clang can't compile due to the use of std::variant.
+### Q: Clang can't compile due to the use of std::variant.
 
-**A:** Cpp-Taskflow uses `std::variant` to enable uniform interface between static and dynamic tasking.
+Cpp-Taskflow uses `std::variant` to enable uniform interface between static and dynamic tasking.
 However it has been reported in 
 [Clang Bug 31852](https://bugs.llvm.org/show_bug.cgi?id=31852) that
 clang-6.0 (and before) does not correctly pick up the friend declaration with auto-deduced return type.
@@ -71,11 +79,13 @@ For clang users, you will need to use this patch in `taskflow.hpp` as follows:
 #endif
 ```
 
+---
+
 ## Programming Questions
 
-#### Q: What is the difference between Cpp-Taskflow threads and workers?
+### Q: What is the difference between Cpp-Taskflow threads and workers?
 
-**A:** The master thread owns the thread pool and can spawn workers to run tasks 
+The master thread owns the thread pool and can spawn workers to run tasks 
 or shutdown the pool. 
 Giving taskflow `N` threads means using `N` threads to do the works, 
 and there is a total of `N+1` threads (including the master threads) in the program.
@@ -86,39 +96,40 @@ tf::Taskflow(N);    // N workers, N+1 threads in the program.
 
 If there is no worker threads in the pool, the master thread will do all the works by itself.
 
-#### Q: Is taskflow thread-safe?
-**A:** No, the taskflow object is not thread-safe. You can't create tasks from multiple threads
+### Q: Is taskflow thread-safe?
+No, the taskflow object is not thread-safe. You can't create tasks from multiple threads
 at the same time.
 
-#### Q: My program hangs and never returns after dispatching a taskflow graph. What's wrong?
+### Q: My program hangs and never returns after dispatching a taskflow graph. What's wrong?
 
-**A:** When the program hangs forever it is very likely your taskflow graph has a cycle.
+When the program hangs forever it is very likely your taskflow graph has a cycle.
 Try the `dump` method to debug the graph before dispatching your taskflow graph.
 If there is no cycle, make sure you are using `future.get()` in the right way, 
 i.e., not blocking your control flow.
 
-#### Q: In the following example where B spawns a joined subflow of two tasks B1 and B2, do they run concurrently with task A?
+### Q: In the following example where B spawns a joined subflow of two tasks B1 and B2, do they run concurrently with task A?
 
 <p>
 <img src="../image/dynamic_graph.png" width="60%">
 </p>
 
-**A:** No. The subflow is spawned during the execution of B, and at this point A must finish
+No. The subflow is spawned during the execution of B, and at this point A must finish
 because A precedes B. This gives rise to the fact B1 and B2 must run after A. 
 This graph may looks strange because B seems to run twice!
 However, Cpp-Taskflow will schedule B only once to create its subflow.
 Whether this subflow joins or detaches from B only affects the future object returned from B.
 
-#### Q: How can I parallelize multiple runs on the same function with different arguments?
+### Q: How can I parallelize multiple runs on the same function with different arguments?
+
+Many people have been asking how to apply Taskflow's `parallel_for` method
+to parallelize a sequential loop over an index sequence.
 
 ```cpp
 for(int i=0; i<N; ++i) {
   func(i);  // each call to func is independent of each other
 }
 ```
 
-**A:** Many people have been asking how to apply Taskflow's `parallel_for` method
-to parallelize a sequential loop over an index sequence.
 This can be done by using the capture property of a C++ lambda.
 
 ```cpp
@@ -131,6 +142,12 @@ for(int i=0; i<N; ++i) {
 tf.wait_for_all();
 ```
 
+### Q: What is a Taskflow::Task?
+
+A `Taskflow::Task` is a lightweight handle associated with an internal graph node
+for users to build task dependencies.
+We do not allow users to explicitly access the internal node but using this wrapper
+to assign different attributes to a graph node.
 
 * * *
 [Github issues]:         https://github.com/cpp-taskflow/cpp-taskflow/issues
 
@@ -1,4 +1,4 @@
-// 2018/09/18 - created by Tsung-Wei Huang
+// 2018/09/19 - created by Tsung-Wei Huang
 //
 // This program is used to benchmark the taskflow under different types 
 // of workloads.
@@ -29,6 +29,57 @@ using tf_privatized_t  = tf::BasicTaskflow<std::function, tf::PrivatizedThreadpo
   std::cout << "Taskflow [privatized  + std::func] elapsed time: "      \
             << F<tf_privatized_t>() << " ms\n";                         \
 
+// ============================================================================
+// Dynamic Stem
+// ============================================================================
+
+// Function: dynamic_stem
+template <typename T>
+auto dynamic_stem() {
+  
+  auto beg = std::chrono::high_resolution_clock::now();
+  
+  const int L = 1024;
+
+  std::atomic<size_t> sum {0};
+
+  T tf;
+
+  std::optional<tf::Task> prev;
+
+  for(int l=0; l<L; ++l) {
+    auto curr = tf.silent_emplace([&, l] (auto& subflow) {
+      sum.fetch_add(1, std::memory_order_relaxed);
+      std::optional<tf::Task> p;
+      for(int k=0; k<L; k++) {
+        auto c = subflow.silent_emplace([&] () {
+          sum.fetch_add(1, std::memory_order_relaxed);
+        });
+        if(p) {
+          p->precede(c);
+        }
+        p = c;
+      }
+      if(l & 1) {
+        subflow.detach();
+      }
+    });
+
+    if(prev) {
+      prev->precede(curr);
+    }
+    prev = curr;
+  }
+
+  tf.wait_for_all();
+
+  assert(sum == L*(L+1));
+
+  auto end = std::chrono::high_resolution_clock::now();
+
+  return std::chrono::duration_cast<std::chrono::milliseconds>(end - beg).count();
+}
+
 // ============================================================================
 // Map-Reduce
 // ============================================================================
@@ -46,7 +97,7 @@ auto map_reduce() {
 
   T tf;
 
-  std::optional<typename T::TaskType> prev;
+  std::optional<typename T::Task> prev;
 
   for(int i=0; i<num_batches; ++i) {
 
@@ -87,7 +138,7 @@ auto level_graph() {
 
   T tf;
 
-  std::vector< std::vector<typename T::TaskType> > tasks;
+  std::vector< std::vector<typename T::Task> > tasks;
 
   tasks.resize(num_levels);
   for(int l=0; l<num_levels; ++l) {
@@ -132,7 +183,7 @@ auto linear_graph() {
 
   T tf;
 
-  std::vector<typename T::TaskType> tasks;
+  std::vector<typename T::Task> tasks;
 
   for(int i=0; i<num_nodes; ++i) {
     tasks.push_back(tf.silent_emplace([&] () { ++sum; }));
@@ -163,9 +214,9 @@ auto binary_tree() {
   T tf;
 
   std::atomic<size_t> sum {0};
-  std::function<void(int, typename T::TaskType)> insert;
+  std::function<void(int, typename T::Task)> insert;
 
-  insert = [&] (int l, typename T::TaskType parent) {
+  insert = [&] (int l, typename T::Task parent) {
 
     if(l < num_levels) {
 
@@ -257,13 +308,14 @@ auto atomic_add() {
 
 // Function: main
 int main(int argc, char* argv[]) {
-  
+
   BENCHMARK("Empty Jobs", empty_jobs);
   BENCHMARK("Atomic Add", atomic_add);
   BENCHMARK("Binary Tree", binary_tree);
   BENCHMARK("Linear Graph", linear_graph);
   BENCHMARK("Level Graph", level_graph);
   BENCHMARK("Map Reduce", map_reduce);
+  BENCHMARK("Dynamic Stem", dynamic_stem);
 
   return 0;
 }