Wrap up getting started docs (#664)

**Pull Request Checklist**
- [x] Fixes #627 (i.e. this is the last PR)
- [x] ~Tests added~ Docs only
- [x] Documentation/examples added
- [x] [Good commit messages](https://cbea.ms/git-commit/) and/or PR
title

---------

Signed-off-by: Elliot Gunton <[email protected]>

Author: elliotgunton

docs/expr.md

@@ -62,7 +62,7 @@ There maybe times that you want to get a struct field whose name conflicts with
 
 Map elements can be accessed used the `[]` syntax.
 
-* `g.var['element']` transpiles to `var.['element']`
+* `g.var['element']` transpiles to `var['element']`
 
 ### Reference
 

docs/getting-started/walk-through/advanced-hera-features.md

@@ -0,0 +1,45 @@
+# Advanced Hera Features
+
+This section is used to publicize Hera's features beyond the essentials covered in the walk through. Note that these
+features do not exist in Argo as they are specific to the `hera` module.
+
+## Pre-Build Hooks
+
+Hera offers a pre-build hook feature through `hera.shared.register_pre_build_hook` with huge flexibility to do pre-build
+processing on any type of `template` or `Workflow`. For example, it can be used to conditionally set the `image` of a
+`Script`, or set which cluster to submit a `Workflow` to.
+
+To use this feature, you can write a function that takes an object of type `template` or `Workflow`, does some
+processing on the object, then returns it.
+
+For a simple example, we'll write a function that adds an annotation with key "hera", value "This workflow was submitted
+through Hera!"
+
+```py
+from hera.shared import register_pre_build_hook
+from hera.workflows import Workflow
+
+@register_pre_build_hook
+def set_workflow_default_labels(workflow: Workflow) -> Workflow:
+    if workflow.annotations is None:
+        workflow.annotations = {}
+
+    workflow.annotations["hera-annotation"] = "This workflow was submitted through Hera!"
+    return workflow
+
+```
+
+Now, any time `build` is called on the Workflow (e.g. to submit it or dump it to yaml), it will add in the annotation!
+
+## Experimental Features
+
+From time to time, Hera will release a new feature under the "experimental feature" flag while we develop the feature
+and ensure stability. Currently this is used for the `RunnerScriptConstructor` seen in the
+[runner script example](../../examples/workflows/callable_script.md).
+
+To enable experimental features you must set the feature by name to `True` in the `global_config.experimental_features`
+dictionary before using the feature:
+
+```py
+global_config.experimental_features["script_runner"] = True
+```

docs/getting-started/walk-through/advanced-template-features.md

@@ -0,0 +1,83 @@
+# Advanced Template Features
+
+This section exemplifies `template` features found in Argo, but are beyond the scope of the Walk Through.
+
+## Secrets
+
+To access secrets stored in your Kubernetes/Argo cluster, you should use the `env` or `env_from` members of
+`TemplateMixin` (i.e. any standard template).
+
+```py
+from hera.workflows import (
+    ConfigMapEnv,
+    ConfigMapEnvFrom,
+    Container,
+    Env,
+    ResourceEnv,
+    SecretEnv,
+    SecretEnvFrom,
+    Workflow,
+)
+
+with Workflow(generate_name="secret-env-from-", entrypoint="whalesay") as w:
+    whalesay = Container(
+        image="docker/whalesay:latest",
+        command=["cowsay"],
+        env_from=[
+            SecretEnvFrom(prefix="abc", name="secret", optional=False),
+            ConfigMapEnvFrom(prefix="abc", name="configmap", optional=False),
+        ],
+        env=[
+            Env(name="test", value="1"),
+            SecretEnv(name="s1", secret_key="s1", secret_name="abc"),
+            ResourceEnv(name="r1", resource="abc"),
+            ConfigMapEnv(name="c1", config_map_key="c1", config_map_name="abc"),
+        ],
+    )
+```
+
+## Retrying and Timeouts
+
+You can easily set retries and timeouts on templates through the `retry_strategy` and `timeout` members of `TemplateMixin`.
+
+See the example below for a combination of these features, which retries with a backoff up to 10 times or until the
+timeout, set at 5 minutes.
+
+```py
+from hera.workflows import (
+    Container,
+    RetryStrategy,
+    Workflow,
+    models as m,
+)
+
+with Workflow(
+    generate_name="retry-backoff-til-timeout-",
+    entrypoint="retry-backoff-til-timeout",
+) as w:
+    retry_backoff_til_timeout = Container(
+        name="retry-backoff-til-timeout",
+        image="python:alpine3.6",
+        command=["python", "-c"],
+        args=["import random; import sys; exit_code = random.choice([0, 0, 0, 1]); sys.exit(exit_code)"],
+        retry_strategy=RetryStrategy(
+            limit=10,
+            backoff=m.Backoff(
+                duration="1",
+                factor="2",
+                max_duration="1m",
+            ),
+        ),
+        timeout="5m",
+    )
+```
+
+## Recursion
+
+Individual Steps and Tasks can specify the `Steps` or `DAG` template that it is a part of, allowing recursive Template
+Invocators. You must ensure there is a break condition, and you should *NOT* make the first `Step` or `Task` the parent
+`Steps` or `DAG` without a condition, otherwise the Argo controller will expand the definition indefinitely until it
+crashes.
+
+See the [recursive coinflip](../../examples/workflows/upstream/coinflip-recursive.md) example for a recursive `Steps`
+template.

docs/getting-started/walk-through/advanced-workflow-features.md

@@ -0,0 +1,51 @@
+# Advanced Workflow Features
+
+This section exemplifies Workflow features found in Argo, but are beyond the scope of the Walk Through.
+
+## Exit Handlers
+
+Exit handlers are templates that always execute (regardless of success or failure) at the end of a workflow.
+
+Some use cases listed from [Argo Workflows](https://argoproj.github.io/argo-workflows/walk-through/exit-handlers/)
+include:
+
+* cleaning up after a workflow runs
+* sending notifications of workflow status (e.g. e-mail/Slack)
+* posting the pass/fail status to a web-hook result (e.g. GitHub build result)
+* resubmitting or submitting another workflow
+
+To use an exit handler on a Workflow in Hera, you can either define the template to use within the workflow, then set
+the `on_exit` member which will take the name from the template itself, or specify the template to use as a string when
+initializing the Workflow object. See both methods below.
+
+```py
+with Workflow(
+    generate_name="exit-handler-workflow-",
+) as w1:
+    cleanup_exit_handler = Container(
+        name="cleanup",
+        image="docker/whalesay",
+        command=["cowsay"],
+        args=["cleanup!"],
+    )
+    w1.on_exit = cleanup_exit_handler
+    ...
+
+with Workflow(
+    generate_name="exit-handler-workflow-",
+    on_exit="cleanup",
+) as w2:
+    cleanup_exit_handler = Container(
+        name="cleanup",
+        image="docker/whalesay",
+        command=["cowsay"],
+        args=["cleanup!"],
+    )
+    ...
+```
+
+## Volume Claim Templates
+
+Volume Claim Templates can be used to copy a large amount data from one step to another in a Workflow.
+
+See the [Empty Volume](../../examples/workflows/upstream/volumes_emptydir.md) example for creating a volume dynamically for the Workflow, or the [Existing Volumes](../../examples/workflows/upstream/volumes_existing.md) example for using an existing volume.

docs/getting-started/walk-through/conditionals.md

@@ -0,0 +1,68 @@
+# Conditionals
+
+Conditional execution of steps and tasks is available through the [basic `when` clause](#basic-when-clauses), along with
+more complex [expressions](#complex-when-clauses) and [`Task` functions](#improved-task-conditionals).
+
+## Basic `when` Clauses
+
+Argo uses [`govaluate`](https://github.com/Knetic/govaluate) in its `when` expressions - Hera is compatible with these
+`when` expression if you write them in literal strings, however, without prior Argo knowledge, you may not know the
+chain of keys to access steps and their parameters.
+
+You can instead use `Parameters` and the special `result` parameter in an f-string to make your code more readable:
+
+```py
+run_script(
+    ...,
+    when=f'{previous_step.get_parameter("some-parameter")} == "some-value"'
+)
+```
+
+is equivalent to
+
+```py
+run_script(
+    ...,
+    when='{{steps.previous-step.outputs.parameter.some-parameter}} == "some-value"'
+)
+```
+
+And
+
+```py
+run_script(
+    ...,
+    when=f'{previous_step.result} == "some-value"'
+)
+```
+
+is equivalent to
+
+```py
+run_script(
+    ...,
+    when='{{steps.previous-step.outputs.result}} == "some-value"'
+)
+```
+
+## Complex `when` Clauses
+
+If you want to use more complex `when` clauses than simple comparisons, involving Argo expression functions such as
+`filter` or `map` or even [sprig functions](http://masterminds.github.io/sprig/), you should check out Hera's
+[`expr` module documentation](../../expr.md).
+
+## Improved Task Conditionals
+
+When using DAGs, there are many convenience functions we can use:
+
+* `on_success`
+* `on_failure`
+* `on_error`
+* `on_other_result`
+* `when_any_succeeded`
+* `when_all_failed`
+* `on_workflow_status`
+
+These functions (except `on_workflow_status`) are essentially aliases to `Task`'s `next` function, with the `on`
+parameter populated with the corrected `TaskResult`, so they can be used to set stricter dependencies than with the
+rshift (`>>`) operator.

docs/getting-started/walk-through/loops.md

@@ -40,8 +40,8 @@ call. First, specify the list of items you want to echo in the `with_items` kwar
         )
 ```
 
-Now, we need to replace the value of the `message` argument. In Argo, you would use the `"{{item}}"` expression syntax,
-which is also what we use in Hera:
+Now, we need to replace the value of the `message` argument. In Argo, you would use the `{{item}}` expression syntax,
+which is also what we use in Hera (within a string):
 
 ```py
         echo(

docs/getting-started/walk-through/pydantic-support.md

@@ -0,0 +1,3 @@
+# Integrated Pydantic Support
+
+<!-- TODO -->

docs/getting-started/walk-through/steps.md

@@ -60,16 +60,14 @@ with Workflow(
 w.create()
 ```
 
-Remember any parallel steps will run indeterminately within the context, so `parallel-1`, `parallel-2` and `parallel-3` could
-run in any order, but `pre-parallel` will always run before the parallel steps and `post-parallel` will run after *all* the
-parallel steps have completed.
-
+Remember any parallel steps will run indeterminately within the context, so `parallel-1`, `parallel-2` and `parallel-3`
+could run in any order, but `pre-parallel` will always run before the parallel steps and `post-parallel` will run after
+*all* the parallel steps have completed.
 
 ## `when` Clauses
 
-Examples of `when` clauses can be found throughout the examples, such as
-[the Argo coinflip example](../../examples/workflows/upstream/coinflip.md). They specify conditions under which the step
-will run.
+A `when` clause specifies the conditions under which the step or task will run. Examples of `when` clauses can be found
+throughout the examples, such as [the Argo coinflip example](../../examples/workflows/upstream/coinflip.md).
 
 If we consider features offered by Hera along with what we've learned about parameters and parallel steps, we
 can form a Workflow with identical behaviour to the upstream coinflip, but using only Python scripts and syntactic sugar
@@ -89,14 +87,25 @@ def flip():
 
 
 @script()
-def it_was(result):
-    print(f"it was {result}")
+def it_was(coin_result):
+    print(f"it was {coin_result}")
 
 
 with Workflow(generate_name="coinflip-", entrypoint="steps") as w:
     with Steps(name="steps") as s:
         f = flip()
         with s.parallel():
-            it_was(name="heads", arguments={"result": "heads"}).on_other_result(f, "heads")
-            it_was(name="tails", arguments={"result": "tails"}).on_other_result(f, "tails")
+            it_was(name="heads", arguments={"coin_result": "heads"}, when=f'{f.result} == "heads"')
+            it_was(name="tails", arguments={"coin_result": "tails"}, when=f'{f.result} == "tails"')
+```
+
+<details><summary>Click to see an example Workflow log</summary>
+
+```console
+coinflip-gfrws-flip-1899249874: heads
+coinflip-gfrws-it-was-2809981541: it was heads
 ```
+
+</details>
+
+For more about `when` clauses, see the [Conditionals](conditionals.md) page!