From 6a581d0a6421a90c36c0c25b79770edb676a9e33 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Thu, 8 Sep 2022 14:56:58 +0300
Subject: [PATCH 01/31] learning content for introduction module

---
 .../learning-content/go/content-info.yaml     |  22 +++
 .../basic-concepts/description.md             | 106 ++++++++++
 .../basic-concepts/example/main.go            |  48 +++++
 .../basic-concepts/unit-info.yaml             |  22 +++
 .../from-memory/description.md                |  54 ++++++
 .../from-memory/example/pardoExample.go       |  49 +++++
 .../from-memory/unit-info.yaml                |  22 +++
 .../creating-collections/group-info.yaml      |  27 +++
 .../reading-from-csv/description.md           |  21 ++
 .../reading-from-csv/example/csvExample.go    |  84 ++++++++
 .../reading-from-csv/unit-info.yaml           |  22 +++
 .../reading-from-text/description.md          | 181 ++++++++++++++++++
 .../reading-from-text/example/textIo.go       |  92 +++++++++
 .../reading-from-text/unit-info.yaml          |  22 +++
 .../introduction-concepts/group-info.yaml     |  26 +++
 .../introduction-guide/description.md         |  23 +++
 .../introduction-guide/unit-info.yaml         |  21 ++
 .../introduction-terms/description.md         |  38 ++++
 .../introduction-terms/unit-info.yaml         |  21 ++
 .../go/introduction/module-info.yaml          |  27 +++
 .../learning-content/java/content-info.yaml   |  22 +++
 .../basic-concepts/description.md             | 134 +++++++++++++
 .../basic-concepts/example/Task.java          |  69 +++++++
 .../basic-concepts/unit-info.yaml             |  22 +++
 .../from-memory/description.md                |  59 ++++++
 .../from-memory/example/ParDoExample.java     |  82 ++++++++
 .../from-memory/unit-info.yaml                |  22 +++
 .../creating-collections/group-info.yaml      |  27 +++
 .../reading-from-csv/description.md           |  21 ++
 .../reading-from-csv/example/CSVExample.java  | 104 ++++++++++
 .../reading-from-csv/unit-info.yaml           |  22 +++
 .../reading-from-text/description.md          |  38 ++++
 .../example/TextIOExample.java                |  96 ++++++++++
 .../reading-from-text/unit-info.yaml          |  22 +++
 .../introduction-concepts/group-info.yaml     |  26 +++
 .../introduction-guide/description.md         |  23 +++
 .../introduction-guide/unit-info.yaml         |  22 +++
 .../introduction-terms/description.md         |  38 ++++
 .../introduction-terms/unit-info.yaml         |  22 +++
 .../java/introduction/module-info.yaml        |  26 +++
 .../learning-content/python/content-info.yaml |  22 +++
 .../basic-concepts/description.md             | 117 +++++++++++
 .../basic-concepts/example/task.py            |  38 ++++
 .../basic-concepts/unit-info.yaml             |  22 +++
 .../from-memory/description.md                |  51 +++++
 .../from-memory/example/pardoExample.py       |  47 +++++
 .../from-memory/unit-info.yaml                |  22 +++
 .../creating-collections/group-info.yaml      |  27 +++
 .../reading-from-csv/description.md           |  20 ++
 .../reading-from-csv/example/csvExample.py    |  63 ++++++
 .../reading-from-csv/unit-info.yaml           |  22 +++
 .../reading-from-text/description.md          |  33 ++++
 .../reading-from-text/example/textIo.py       |  58 ++++++
 .../reading-from-text/unit-info.yaml          |  22 +++
 .../introduction-concepts/group-info.yaml     |  26 +++
 .../introduction-guide/description.md         |  23 +++
 .../introduction-guide/unit-info.yaml         |  22 +++
 .../introduction-terms/description.md         |  38 ++++
 .../introduction-terms/unit-info.yaml         |  22 +++
 .../python/introduction/module-info.yaml      |  27 +++
 60 files changed, 2547 insertions(+)
 create mode 100644 learning/tour-of-beam/learning-content/go/content-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/example/main.go
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-guide/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-terms/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/module-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/content-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/example/Task.java
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-guide/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-terms/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/module-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/content-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/example/task.py
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-guide/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-terms/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/module-info.yaml

diff --git a/learning/tour-of-beam/learning-content/go/content-info.yaml b/learning/tour-of-beam/learning-content/go/content-info.yaml
new file mode 100644
index 000000000000..8b75fa8771d2
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/content-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+sdk: Go
+content:
+  - introduction
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/description.md
new file mode 100644
index 000000000000..19c852591246
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/description.md
@@ -0,0 +1,106 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
+
+For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
+
+### Overview
+
+To use Beam, you first need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs. It also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
+
+&#8594; `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
+
+&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+&#8594; Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
+
+&#8594; Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+
+&#8594; Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
+
+### Creating a pipeline
+
+The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then using that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
+
+To use Beam, your driver program must first create an instance of the Beam SDK class Pipeline (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the Pipeline object when you create the object.
+
+```
+// beam.Init() is an initialization hook that must be called
+// near the beginning of main(), before creating a pipeline.
+beam.Init()
+
+// Create the Pipeline object and root scope.
+pipeline, scope := beam.NewPipelineWithRoot()
+```
+
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+### Setting PipelineOptions from command-line arguments
+
+Use Go flags to parse command line arguments to configure your pipeline. Flags must be parsed before `beam.Init()` is called.
+
+```
+// If beamx or Go flags are used, flags must be parsed first,
+// before beam.Init() is called.
+flag.Parse()
+```
+
+This interprets command-line arguments this follow the format:
+
+```
+--<option>=<value>
+```
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+// Use standard Go flags to define pipeline options.
+var (
+	input  = flag.String("input", "", "")
+	output = flag.String("output", "", "")
+)
+```
+
+You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+
+```
+var (
+	input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
+	output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
+)
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/example/main.go
new file mode 100644
index 000000000000..5ecddfda5dc5
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/example/main.go
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// beam-playground:
+//   name: HelloBeam
+//   description: Hello Beam example.
+//   multifile: false
+//   context_line: 34
+
+package main
+
+import (
+  "context"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/debug"
+)
+
+
+
+func main() {
+  p, s := beam.NewPipelineWithRoot()
+
+  hello := helloBeam(s)
+  debug.Print(s, hello)
+
+  err := beamx.Run(context.Background(), p)
+  if err != nil {
+    log.Exitf(context.Background(), "Failed to execute job: %v", err)
+  }
+}
+
+func helloBeam(s beam.Scope) beam.PCollection {
+  return beam.Create(s, "Hello Beam")
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/unit-info.yaml
new file mode 100644
index 000000000000..d22fdb3080e8
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: basic
+name: Basic Concepts
+taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
new file mode 100644
index 000000000000..4eb762bd4d03
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -0,0 +1,54 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating PCollection
+
+Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
+
+There are several options on how to do that:
+
+&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+
+&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+
+Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
+
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
+
+### Creating a PCollection from in-memory data
+
+You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Go Collection. You can apply Create transform directly to your Pipeline object itself.
+
+The following example code shows how to do this:
+
+```
+func main() {
+	ctx := context.Background()
+    
+    // First create pipline
+	p, s := beam.NewPipelineWithRoot()
+
+    //Now create the PCollection using list of strings
+	numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+    
+    //Create a numerical PCollection
+	numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+   
+}
+```
+
+You can find the complete code of this example in the playground window you can run and experiment with.
+
+One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
new file mode 100644
index 000000000000..60739ad6f2e5
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// beam-playground:
+//   name: ParDo
+//   description: ParDo example.
+//   multifile: false
+//   context_line: 32
+
+package main
+
+import (
+  "context"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+  "fmt"
+)
+
+func main() {
+  p, s := beam.NewPipelineWithRoot()
+
+  elements := beam.Create(s, "Hello", "world", "it`s", "Beam")
+
+  output(s, words)
+
+  err := beamx.Run(context.Background(), p)
+  if err != nil {
+    log.Exitf(context.Background(), "Failed to execute job: %v", err)
+  }
+}
+
+func output(s beam.Scope, input beam.PCollection) {
+	 beam.ParDo0(s, func(element interface{}) {
+			fmt.Println(element)
+		}, input)
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
new file mode 100644
index 000000000000..d26548d6cda3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-memory
+name: Creating in-memory PCollections
+taskName: ParDo
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
new file mode 100644
index 000000000000..f291d762b04e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-collections
+name: Creating Collections
+content:
+- from-memory
+- reading-from-text
+- reading-from-csv
+
+
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
new file mode 100644
index 000000000000..dfadb43fdcee
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -0,0 +1,21 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+### Read from csv file
+
+Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+
+Loading data from csv file requires some processing and consists of two main part:
+* Loading text lines using `TextIO.Read` transform
+* Parsing lines of text into tabular format 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
new file mode 100644
index 000000000000..1f1f0a61dbfd
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: CSV
+//   description: CSV example.
+//   multifile: false
+//   context_line: 44
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+	"strconv"
+	"strings"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/top"
+
+)
+
+func less(a, b float64) bool{
+    return a>b
+}
+
+func main() {
+	p, s := beam.NewPipelineWithRoot()
+
+	file := Read(s, "gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv")
+
+	cost := applyTransform(s, file)
+
+	fixedSizeElements := top.Largest(s,cost,10,less)
+
+	output(s, "Total cost: ", fixedSizeElements)
+
+	err := beamx.Run(context.Background(), p)
+	if err != nil {
+		log.Exitf(context.Background(), "Failed to execute job: %v", err)
+	}
+}
+
+// Read reads from fiename(s) specified by a glob string and a returns a PCollection<string>.
+func Read(s beam.Scope, glob string) beam.PCollection {
+	return textio.Read(s, glob)
+}
+
+// ApplyTransform converts to uppercase all elements in a PCollection<string>.
+func applyTransform(s beam.Scope, input beam.PCollection) beam.PCollection {
+	return beam.ParDo(s, func(line string) float64 {
+		taxi := strings.Split(strings.TrimSpace(line), ",")
+		if len(taxi) > 16 {
+			cost, _ := strconv.ParseFloat(taxi[16],64)
+			return cost
+		}
+		return 0.0
+	}, input)
+}
+
+func output(s beam.Scope, prefix string, input beam.PCollection) {
+	beam.ParDo0(s, func(elements []float64) {
+        for _, element := range elements {
+        fmt.Println(prefix,element)
+        }
+	}, input)
+}
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
new file mode 100644
index 000000000000..3d12a4dc6532
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-csv
+name: Creating PCollections from csv files
+taskName: CSV
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
new file mode 100644
index 000000000000..127e3996ef1a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -0,0 +1,181 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
+
+For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
+
+### Overview
+
+To use Beam, you first need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs. It also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
+
+&#8594; `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
+
+&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+&#8594; Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
+
+&#8594; Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+
+&#8594; Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
+
+### Creating a pipeline
+
+The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then using that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
+
+To use Beam, your driver program must first create an instance of the Beam SDK class Pipeline (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the Pipeline object when you create the object.
+
+```
+// beam.Init() is an initialization hook that must be called
+// near the beginning of main(), before creating a pipeline.
+beam.Init()
+
+// Create the Pipeline object and root scope.
+pipeline, scope := beam.NewPipelineWithRoot()
+```
+
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+### Setting PipelineOptions from command-line arguments
+
+Use Go flags to parse command line arguments to configure your pipeline. Flags must be parsed before `beam.Init()` is called.
+
+```
+// If beamx or Go flags are used, flags must be parsed first,
+// before beam.Init() is called.
+flag.Parse()
+```
+
+This interprets command-line arguments this follow the format:
+
+```
+--<option>=<value>
+```
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+// Use standard Go flags to define pipeline options.
+var (
+	input  = flag.String("input", "", "")
+	output = flag.String("output", "", "")
+)
+```
+
+You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+
+```
+var (
+	input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
+	output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
+)
+```
+
+### Creating PCollection
+
+Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
+
+There are several options on how to do that:
+
+&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+
+&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+
+Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
+
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
+
+### Creating a PCollection from in-memory data
+
+You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Go Collection. You can apply Create transform directly to your Pipeline object itself.
+
+The following example code shows how to do this:
+
+```
+func main() {
+	ctx := context.Background()
+    
+    // First create pipline
+	p, s := beam.NewPipelineWithRoot()
+
+    //Now create the PCollection using list of strings
+	numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+    
+    //Create a numerical PCollection
+	numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+   
+}
+```
+
+You can find the complete code of this example in the playground window you can run and experiment with.
+
+One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
+
+### Reading from text file
+
+You use one of the Beam-provided I/O adapters to read from an external source. The adapters vary in their exact usage, but all of them read from some external data source and return a `PCollection` whose elements represent the data records in that source.
+
+Each data source adapter has a Read transform; to read, you must apply that transform to the Pipeline object itself.
+
+`TextIO.Read` , for example, reads from an external text file and returns a `PCollection` whose elements are of type String. Each String represents one line from the text file. Here’s how you would apply `TextIO.Read` to your Pipeline to create a `PCollection`:
+
+```
+func main() {
+	ctx := context.Background()
+    
+    // First create pipline
+	p, s := beam.NewPipelineWithRoot()
+
+    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file 
+    lines :=  textio.Read(scope, 'gs://some/inputData.txt')
+    
+}
+```
+
+In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
+
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+
+### Read from csv file
+
+Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+
+Loading data from csv file requires some processing and consists of two main part:
+* Loading text lines using `TextIO.Read` transform
+* Parsing lines of text into tabular format 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
new file mode 100644
index 000000000000..93439d206ac8
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+/*
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+// beam-playground:
+//   name: TextIO
+//   description: TextIO example.
+//   multifile: false
+//   context_line: 46
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/filter"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+	"regexp"
+	"github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/top"
+)
+
+var (
+	wordRE = regexp.MustCompile(`[a-zA-Z]+('[a-z])?`)
+)
+
+func less(a, b string) bool{
+    return len(a)>len(b)
+}
+
+func main() {
+	p, s := beam.NewPipelineWithRoot()
+
+	file := Read(s, "gs://apache-beam-samples/shakespeare/kinglear.txt")
+
+	lines := getLines(s, file)
+	fixedSizeLines := top.Largest(s,lines,10,less)
+	output(s, "Lines: ", fixedSizeLines)
+
+	words := getWords(s,lines)
+	fixedSizeWords := top.Largest(s,words,10,less)
+	output(s, "Words: ", fixedSizeWords)
+
+	err := beamx.Run(context.Background(), p)
+	if err != nil {
+		log.Exitf(context.Background(), "Failed to execute job: %v", err)
+	}
+}
+
+// Read reads from fiename(s) specified by a glob string and a returns a PCollection<string>.
+func Read(s beam.Scope, glob string) beam.PCollection {
+	return textio.Read(s, glob)
+}
+
+// Read text file content line by line. resulting PCollection contains elements, where each element contains a single line of text from the input file.
+func getLines(s beam.Scope, input beam.PCollection) beam.PCollection {
+	return filter.Include(s, input, func(element string) bool {
+		return element != ""
+	})
+}
+
+// getWords read text lines and split into PCollection of words.
+func getWords(s beam.Scope, input beam.PCollection) beam.PCollection {
+	return beam.ParDo(s, func(line string, emit func(string)) {
+		for _, word := range wordRE.FindAllString(line, -1) {
+			emit(word)
+		}
+	}, input)
+}
+
+func output(s beam.Scope, prefix string, input beam.PCollection) {
+	beam.ParDo0(s, func(elements []string) {
+        for _, element := range elements {
+        fmt.Println(prefix,element)
+        }
+	}, input)
+}
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
new file mode 100644
index 000000000000..396a0190f74a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-text
+name: Creating PCollections from text files
+taskName: TextIO
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
new file mode 100644
index 000000000000..7046fb6da854
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
@@ -0,0 +1,26 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: concepts
+name: Beam Concepts
+content:
+- basic-concepts
+- creating-collections
+
+
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
new file mode 100644
index 000000000000..dc99a15f33a3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -0,0 +1,23 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the Apache Beam.
+The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
+You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
+The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
+Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
+Now let’s start the tour with learning core Beam principles.
+ 
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/unit-info.yaml
new file mode 100644
index 000000000000..76be8c5825fd
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: guide
+name: Tour of Beam Guide
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
new file mode 100644
index 000000000000..c74e22bc383f
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
@@ -0,0 +1,38 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+**Pipeline** - A pipeline is a user-constructed graph of transformations that defines the desired data processing operations.
+
+**PCollection** - A PCollection is a data set or data stream. The data that a pipeline processes is part of a PCollection.
+
+**PTransform** - A PTransform (or transform) represents a data processing operation, or a step, in your pipeline. A transform is applied to zero or more PCollection objects, and produces zero or more PCollection objects.
+
+**Aggregation** - Aggregation is computing a value from multiple (1 or more) input elements.
+
+**User-defined function (UDF)** - Some Beam operations allow you to run user-defined code as a way to configure the transform.
+
+**Schema** - A schema is a language-independent type definition for a PCollection. The schema for a PCollection defines elements of that PCollection as an ordered list of named fields.
+
+**SDK** - A language-specific library that lets pipeline authors build transforms, construct their pipelines, and submit them to a runner.
+
+**Runner** - A runner runs a Beam pipeline using the capabilities of your chosen data processing engine.
+
+**Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
+
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in time order, or to always arrive at predictable intervals.
+
+**Trigger** - A trigger determines when to aggregate the results of each window.
+
+**State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
+
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/unit-info.yaml
new file mode 100644
index 000000000000..747bcb75e743
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: terms
+name: List of Beam Terms
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/module-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/module-info.yaml
new file mode 100644
index 000000000000..78c6ae713bda
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/module-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: introduction
+name: Introduction
+complexity: BASIC
+content:
+- introduction-guide
+- introduction-concepts
+- introduction-terms
+
diff --git a/learning/tour-of-beam/learning-content/java/content-info.yaml b/learning/tour-of-beam/learning-content/java/content-info.yaml
new file mode 100644
index 000000000000..7406bb513e32
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/content-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+sdk: Java
+content:
+  - introduction
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
new file mode 100644
index 000000000000..efc7c150f135
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
@@ -0,0 +1,134 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
+
+For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
+
+### Overview
+
+To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+
+&#8594; `Scope`: The Go SDK has an explicit scope variable used to build a Pipeline. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is passed to PTransform functions to place them in the Pipeline that owns the Scope.
+
+&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+&#8594; Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+
+&#8594; Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+
+&#8594; Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
+
+### Creating a pipeline
+
+The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a `Pipeline` object, and then using that object as the basis for creating the pipeline’s data sets as `PCollection`s and its operations as `Transforms`.
+
+To use Beam, your driver program must first create an instance of the Beam SDK class `Pipeline` (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the `Pipeline` object when you create the object.
+
+```
+// Start by defining the options for the pipeline.
+PipelineOptions options = PipelineOptionsFactory.create();
+
+// Then create the pipeline.
+Pipeline p = Pipeline.create(options);
+```
+
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+When you run the pipeline on a runner of your choice, a copy of the PipelineOptions will be available to your code. For example, if you add a PipelineOptions parameter to a DoFn’s `@ProcessElement` method, it will be populated by the system.
+
+### Setting PipelineOptions from command-line arguments
+
+While you can configure your pipeline by creating a PipelineOptions object and setting the fields directly, the Beam SDKs include a command-line parser that you can use to set fields in PipelineOptions using command-line arguments.
+
+To read options from the command-line, construct your PipelineOptions object as demonstrated in the following example code:
+
+```
+PipelineOptions options =
+    PipelineOptionsFactory.fromArgs(args).withValidation().create();
+```
+
+This interprets command-line arguments that follow the format:
+
+```
+--<option>=<value>
+```
+
+> Appending the method .withValidation will check for required command-line arguments and validate argument values.
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+To add your own options, define an interface with getter and setter methods for each option.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+public interface MyOptions extends PipelineOptions {
+    String getInput();
+    void setInput(String input);
+
+    String getOutput();
+    void setOutput(String output);
+}
+```
+
+You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+
+You set the description and default value using annotations, as follows:
+
+```
+public interface MyOptions extends PipelineOptions {
+    @Description("Input for the pipeline")
+    @Default.String("gs://my-bucket/input")
+    String getInput();
+    void setInput(String input);
+
+    @Description("Output for the pipeline")
+    @Default.String("gs://my-bucket/output")
+    String getOutput();
+    void setOutput(String output);
+}
+```
+
+It’s recommended that you register your interface with `PipelineOptionsFactory` and then pass the interface when creating the `PipelineOptions` object. When you register your interface with `PipelineOptionsFactory`, the `--help` can find your custom options interface and add it to the output of the --help command. `PipelineOptionsFactory` will also validate that your custom options are compatible with all other registered options.
+
+The following example code shows how to register your custom options interface with `PipelineOptionsFactory`:
+
+```
+PipelineOptionsFactory.register(MyOptions.class);
+MyOptions options = PipelineOptionsFactory.fromArgs(args)
+                                                .withValidation()
+                                                .as(MyOptions.class);
+```
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/example/Task.java
new file mode 100644
index 000000000000..16247c48eb44
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/example/Task.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: HelloBeam
+//   description: Hello Beam example.
+//   multifile: false
+//   context_line: 32
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.transforms.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+
+    public static void main(String[] args) {
+        PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+        Pipeline pipeline = Pipeline.create(options);
+
+        PCollection<String> output = setupPipeline(pipeline);
+
+        output.apply("Log", ParDo.of(new LogOutput<String>()));
+
+        pipeline.run();
+    }
+
+    static PCollection<String> setupPipeline(Pipeline pipeline) {
+        return pipeline.apply(Create.of("Hello Beam"));
+    }
+
+    static class LogOutput<T> extends DoFn<T, T> {
+        private String prefix;
+
+        LogOutput() {
+            this.prefix = "Processing element";
+        }
+
+        LogOutput(String prefix) {
+            this.prefix = prefix;
+        }
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info(prefix + ": {}", c.element());
+        }
+    }
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/unit-info.yaml
new file mode 100644
index 000000000000..d22fdb3080e8
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: basic
+name: Basic Concepts
+taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
new file mode 100644
index 000000000000..ceb5b4abfc70
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -0,0 +1,59 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating PCollection
+
+Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
+
+There are several options on how to do that:
+
+&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+
+&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+
+Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
+
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.  
+
+### Creating a PCollection from in-memory data
+
+You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Java Collection. You can apply Create transform directly to your Pipeline object itself.
+
+The following example code shows how to do this:
+
+```
+public static void main(String[] args) {
+    // First create the pipeline 
+    PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+    Pipeline pipeline = Pipeline.create(options);
+    
+    // Now create the PCollection using list of strings
+    PCollection<String> words =
+        pipeline.apply(
+            Create.of("To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+        );
+ 
+    // Create a numerical PCollection
+    PCollection<Integer> numbers =
+        pipeline.apply(
+            Create.of(1,2,3,4,5,6,7,8,9,10)
+        );
+}
+```
+
+You can find the complete code of this example in the playground window you can run and experiment with.
+
+One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
+
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java
new file mode 100644
index 000000000000..957efc99f40d
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+/*
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: ParDo
+//   description: ParDo example.
+//   multifile: false
+//   context_line: 36
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Create;
+import org.apache.beam.sdk.transforms.Min;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.ParDo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+    public static void main(String[] args) {
+
+        LOG.info("Running Task");
+
+        PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+        Pipeline pipeline = Pipeline.create(options);
+
+        PCollection<String> words =
+                pipeline.apply(
+                        Create.of("To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+                );
+
+        PCollection<Integer> numbers =
+                pipeline.apply(
+                        Create.of(1,2,3,4,5,6,7,8,9,10)
+                );
+
+        words.apply("Log words", ParDo.of(new LogStrings()));
+        numbers.apply("Log numbers", ParDo.of(new LogIntegers()));
+
+
+        pipeline.run();
+    }
+
+
+    public static class LogStrings extends DoFn<String, String> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Processing word: {}", c.element());
+            c.output(c.element());
+        }
+    }
+
+    public static class LogIntegers extends DoFn<Integer, Integer> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Processing number: {}", c.element());
+            c.output(c.element());
+        }
+    }
+}
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
new file mode 100644
index 000000000000..d26548d6cda3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-memory
+name: Creating in-memory PCollections
+taskName: ParDo
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/group-info.yaml
new file mode 100644
index 000000000000..f291d762b04e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/group-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-collections
+name: Creating Collections
+content:
+- from-memory
+- reading-from-text
+- reading-from-csv
+
+
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
new file mode 100644
index 000000000000..dfadb43fdcee
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -0,0 +1,21 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+### Read from csv file
+
+Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+
+Loading data from csv file requires some processing and consists of two main part:
+* Loading text lines using `TextIO.Read` transform
+* Parsing lines of text into tabular format 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
new file mode 100644
index 000000000000..6da0e6257a0f
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: CSV
+//   description: CSV example.
+//   multifile: false
+//   context_line: 50
+
+package org.apache.beam.examples;
+
+import java.util.Arrays;
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Count;
+import org.apache.beam.sdk.transforms.Filter;
+import org.apache.beam.sdk.transforms.FlatMapElements;
+import org.apache.beam.sdk.transforms.MapElements;
+import org.apache.beam.sdk.transforms.PTransform;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.TypeDescriptors;
+import org.apache.beam.sdk.transforms.Flatten;
+import org.apache.beam.sdk.transforms.Sample;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.ParDo;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(DataFromFile.class);
+
+
+    public static void main(String[] args) {
+
+        PipelineOptions options = PipelineOptionsFactory.create();
+
+        // Create the Pipeline object with the options we defined above
+        Pipeline p = Pipeline.create(options);
+        PCollection<String> rides = p.apply(TextIO.read().from("gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv"));
+
+        PCollection<Double> rideTolalAmounts = rides.apply(ParDo.of(new ExtractTaxiRideCostFn()));
+        final PTransform<PCollection<Double>, PCollection<Iterable<Double>>> sample = Sample.fixedSizeGlobally(10);
+        PCollection<Double> rideAmounts = rideTolalAmounts.apply(sample)
+                .apply(Flatten.iterables())
+                .apply("Log amounts", ParDo.of(new LogDouble()));
+
+        p.run().waitUntilFinish();
+
+    }
+
+    private static Double tryParseTaxiRideCost(String[] inputItems) {
+        try {
+            return Double.parseDouble(tryParseString(inputItems, 16));
+        } catch (NumberFormatException | NullPointerException e) {
+            return 0.0;
+        }
+    }
+
+
+    private static String tryParseString(String[] inputItems, int index) {
+        return inputItems.length > index ? inputItems[index] : null;
+    }
+
+    static class ExtractTaxiRideCostFn extends DoFn<String, Double> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) {
+            String[] items = c.element().split(",");
+            Double totalAmount = tryParseTaxiRideCost(items);
+            c.output(totalAmount);
+        }
+    }
+
+    public static class LogDouble extends DoFn<Double, Double> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Total Amount: {}", c.element());
+            c.output(c.element());
+        }
+    }
+}
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
new file mode 100644
index 000000000000..3d12a4dc6532
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-csv
+name: Creating PCollections from csv files
+taskName: CSV
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
new file mode 100644
index 000000000000..17a0700b33c9
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -0,0 +1,38 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Reading from text file
+
+You use one of the Beam-provided I/O adapters to read from an external source. The adapters vary in their exact usage, but all of them read from some external data source and return a `PCollection` whose elements represent the data records in that source.
+
+Each data source adapter has a Read transform; to read, you must apply that transform to the Pipeline object itself.
+
+`TextIO.Read` , for example, reads from an external text file and returns a `PCollection` whose elements are of type String. Each String represents one line from the text file. Here’s how you would apply `TextIO.Read` to your Pipeline to create a `PCollection`:
+
+```
+public static void main(String[] args) {
+    // First create the pipeline 
+    PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+    Pipeline pipeline = Pipeline.create(options);
+    
+    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file 
+    PCollection<String> lines =
+        pipeline.apply(“King Lear”,TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt")
+);
+ 
+}
+```
+
+In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
+
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
new file mode 100644
index 000000000000..2d52ffe80376
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
@@ -0,0 +1,96 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+/*
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// beam-playground:
+//   name: TextIO
+//   description: TextIO example.
+//   multifile: false
+//   context_line: 36
+
+package org.apache.beam.examples;
+
+import java.util.Arrays;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Count;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.Filter;
+import org.apache.beam.sdk.transforms.Flatten;
+import org.apache.beam.sdk.transforms.FlatMapElements;
+import org.apache.beam.sdk.transforms.MapElements;
+import org.apache.beam.sdk.transforms.ParDo;
+import org.apache.beam.sdk.transforms.PTransform;
+import org.apache.beam.sdk.transforms.Sample;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.TypeDescriptors;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+
+    public static void main(String[] args) {
+
+        PipelineOptions options = PipelineOptionsFactory.create();
+
+        // Create the Pipeline object with the options we defined above
+        Pipeline p = Pipeline.create(options);
+
+        // Concept #1. Read text file content line by line. resulting PCollection contains elements, where each element
+        // contains a single line of text from the input file.
+        PCollection<String> lines = p.apply(TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt"))
+                .apply(Filter.by((String line) -> !line.isEmpty()));
+
+        // Concept #2. Output first 10 elements PCollection to the console.
+        final PTransform<PCollection<String>, PCollection<Iterable<String>>> sample = Sample.fixedSizeGlobally(10);
+
+        PCollection<String> sampleLines = lines.apply(sample)
+                .apply(Flatten.iterables())
+                .apply("Log lines", ParDo.of(new LogStrings()));
+
+
+        //Concept #3. Read text file and split into PCollection of words.
+        PCollection<String> words = p.apply(TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt"))
+                .apply(FlatMapElements.into(TypeDescriptors.strings()).via((String line) -> Arrays.asList(line.split("[^\\p{L}]+"))))
+                .apply(Filter.by((String word) -> !word.isEmpty()));
+
+        PCollection<String> sampleWords = words.apply(sample)
+                .apply(Flatten.iterables())
+                .apply("Log words", ParDo.of(new LogStrings()));
+
+        // Concept #4. Write PCollection to text file.
+        sampleWords.apply(TextIO.write().to("sample-words"));
+        p.run().waitUntilFinish();
+    }
+
+    public static class LogStrings extends DoFn<String, String> {
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info("Processing element: {}", c.element());
+            c.output(c.element());
+        }
+    }
+
+}
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
new file mode 100644
index 000000000000..396a0190f74a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-text
+name: Creating PCollections from text files
+taskName: TextIO
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
new file mode 100644
index 000000000000..7046fb6da854
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
@@ -0,0 +1,26 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: concepts
+name: Beam Concepts
+content:
+- basic-concepts
+- creating-collections
+
+
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
new file mode 100644
index 000000000000..dc99a15f33a3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
@@ -0,0 +1,23 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the Apache Beam.
+The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
+You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
+The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
+Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
+Now let’s start the tour with learning core Beam principles.
+ 
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/unit-info.yaml
new file mode 100644
index 000000000000..814ca3cefbfe
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: guide
+name: Tour of Beam Guide
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
new file mode 100644
index 000000000000..c74e22bc383f
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
@@ -0,0 +1,38 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+**Pipeline** - A pipeline is a user-constructed graph of transformations that defines the desired data processing operations.
+
+**PCollection** - A PCollection is a data set or data stream. The data that a pipeline processes is part of a PCollection.
+
+**PTransform** - A PTransform (or transform) represents a data processing operation, or a step, in your pipeline. A transform is applied to zero or more PCollection objects, and produces zero or more PCollection objects.
+
+**Aggregation** - Aggregation is computing a value from multiple (1 or more) input elements.
+
+**User-defined function (UDF)** - Some Beam operations allow you to run user-defined code as a way to configure the transform.
+
+**Schema** - A schema is a language-independent type definition for a PCollection. The schema for a PCollection defines elements of that PCollection as an ordered list of named fields.
+
+**SDK** - A language-specific library that lets pipeline authors build transforms, construct their pipelines, and submit them to a runner.
+
+**Runner** - A runner runs a Beam pipeline using the capabilities of your chosen data processing engine.
+
+**Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
+
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in time order, or to always arrive at predictable intervals.
+
+**Trigger** - A trigger determines when to aggregate the results of each window.
+
+**State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
+
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/unit-info.yaml
new file mode 100644
index 000000000000..d18dd26929e1
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: terms
+name: List of Beam Terms
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/module-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/module-info.yaml
new file mode 100644
index 000000000000..242874ea71d6
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/module-info.yaml
@@ -0,0 +1,26 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+id: introduction
+name: Introduction
+complexity: BASIC
+content:
+- introduction-guide
+- introduction-concepts
+- introduction-terms
+
diff --git a/learning/tour-of-beam/learning-content/python/content-info.yaml b/learning/tour-of-beam/learning-content/python/content-info.yaml
new file mode 100644
index 000000000000..ed48f6ecfb7a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/content-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+sdk: Python
+content:
+  - introduction
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/description.md
new file mode 100644
index 000000000000..d1e0c0bd6594
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/description.md
@@ -0,0 +1,117 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
+
+For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
+
+### Overview
+
+To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program then defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+
+&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+&#8594; Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+
+&#8594; **Apply** PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+
+&#8594; Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects that you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
+
+### Creating a pipeline
+
+The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then use that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
+
+To use Beam, your driver program must first create an instance of the Beam SDK class Pipeline (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the Pipeline object when you create the object.
+
+```
+import apache_beam as beam
+
+with beam.Pipeline() as pipeline:
+  pass  # build your pipeline here
+```
+
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+### Setting PipelineOptions from command-line arguments
+
+While you can configure your pipeline by creating a `PipelineOptions` object and setting the fields directly, the Beam SDKs include a command-line parser that you can also use to set fields in `PipelineOptions` using command-line arguments.
+
+To read options from the command-line, construct your `PipelineOptions` object as demonstrated in the following example code:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+beam_options = PipelineOptions()
+```
+
+This interprets command-line arguments that follow this format:
+
+```
+--<option>=<value>
+```
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+class MyOptions(PipelineOptions):
+  @classmethod
+  def _add_argparse_args(cls, parser):
+    parser.add_argument('--input')
+    parser.add_argument('--output')
+```
+
+You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+
+You set the description and default value using annotations, as follows:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+class MyOptions(PipelineOptions):
+  @classmethod
+  def _add_argparse_args(cls, parser):
+    parser.add_argument(
+        '--input',
+        default='gs://dataflow-samples/shakespeare/kinglear.txt',
+        help='The file path for the input text to process.')
+    parser.add_argument(
+        '--output', required=True, help='The path prefix for output files.')
+```
+
+For Python, you can also simply parse your custom options with argparse; there is no need to create a separate PipelineOptions subclass.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/example/task.py
new file mode 100644
index 000000000000..c07a2eaafa90
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/example/task.py
@@ -0,0 +1,38 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: HelloBeam
+#   description: Hello Beam example.
+#   multifile: false
+#   context_line: 35
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+
+        def process(self, element):
+            print(element)
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn())
+
+with beam.Pipeline() as p:
+  (p | beam.Create(['Hello Beam'])
+   | Output())
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/unit-info.yaml
new file mode 100644
index 000000000000..d22fdb3080e8
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: basic
+name: Basic Concepts
+taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
new file mode 100644
index 000000000000..0773e9104f63
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -0,0 +1,51 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Creating PCollection
+
+Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
+
+There are several options on how to do that:
+
+&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+
+&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+
+Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
+
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
+
+### Creating a PCollection from in-memory data
+
+You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Python Collection. You can apply Create transform directly to your Pipeline object itself.
+
+The following example code shows how to do this:
+
+```
+# First create pipline
+with beam.Pipeline() as p:
+
+    # Create a numerical PCollection
+    (p | beam.Create(range(1, 11)))
+     
+     # Now create the PCollection using list of strings
+    (p | beam.Create(['To', 'be', 'or', 'not', 'to', 'be', 'that', 'is', 'the', 'question']))
+
+```
+
+You can find the complete code of this example in the playground window you can run and experiment with.
+
+One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py
new file mode 100644
index 000000000000..f3eff62faee4
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py
@@ -0,0 +1,47 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: pardo-example
+#   description: ParDo example.
+#   multifile: false
+#   context_line: 48
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+        def __init__(self, prefix=''):
+            super().__init__()
+            self.prefix = prefix
+
+        def process(self, element):
+            print(self.prefix+str(element))
+
+    def __init__(self, label=None,prefix=''):
+        super().__init__(label)
+        self.prefix = prefix
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn(self.prefix))
+
+with beam.Pipeline() as p:
+  (p | beam.Create(['Hello Beam','It`s introdction'])
+     | 'Log words' >> Output())
+
+  (p | beam.Create(range(1, 11))
+   | 'Log numbers' >> Output())
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
new file mode 100644
index 000000000000..d26548d6cda3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-memory
+name: Creating in-memory PCollections
+taskName: ParDo
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/group-info.yaml
new file mode 100644
index 000000000000..f291d762b04e
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/group-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-collections
+name: Creating Collections
+content:
+- from-memory
+- reading-from-text
+- reading-from-csv
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
new file mode 100644
index 000000000000..1e20a163e6b8
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -0,0 +1,20 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Read from csv file
+
+Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+
+Loading data from csv file requires some processing and consists of two main part:
+* Loading text lines using `TextIO.Read` transform
+* Parsing lines of text into tabular format 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
new file mode 100644
index 000000000000..544a383c3952
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
@@ -0,0 +1,63 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: csv-example
+#   description: Csv file example.
+#   multifile: false
+#   context_line: 43
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+        def __init__(self, prefix=''):
+            super().__init__()
+            self.prefix = prefix
+
+        def process(self, element):
+            print(self.prefix+str(element))
+
+    def __init__(self, label=None,prefix=''):
+        super().__init__(label)
+        self.prefix = prefix
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn(self.prefix))
+
+class ExtractTaxiRideCostFn(beam.DoFn):
+
+    def process(self, element):
+        line = element.split(',')
+        return tryParseTaxiRideCost(line,16)
+
+
+def tryParseTaxiRideCost(line,index):
+    if(len(line) > index):
+        yield line[index]
+    else:
+        yield 0.0
+
+with beam.Pipeline() as p:
+    lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv') \
+            | beam.ParDo(ExtractTaxiRideCostFn()) \
+            | beam.combiners.Sample.FixedSizeGlobally(10) \
+            | beam.FlatMap(lambda cost: cost) \
+            | Output(prefix = 'Taxi cost: ')
+
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
new file mode 100644
index 000000000000..3d12a4dc6532
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-csv
+name: Creating PCollections from csv files
+taskName: CSV
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
new file mode 100644
index 000000000000..c48a99ebda9a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -0,0 +1,33 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Reading from text file
+
+You use one of the Beam-provided I/O adapters to read from an external source. The adapters vary in their exact usage, but all of them read from some external data source and return a `PCollection` whose elements represent the data records in that source.
+
+Each data source adapter has a Read transform; to read, you must apply that transform to the Pipeline object itself.
+
+`TextIO.Read` , for example, reads from an external text file and returns a `PCollection` whose elements are of type String. Each String represents one line from the text file. Here’s how you would apply `TextIO.Read` to your Pipeline to create a `PCollection`:
+
+```
+# First create pipline
+with beam.Pipeline() as p:
+
+    # Now create the PCollection by reading text files. Separate elements will be added for each line in the input file 
+    (p | beam.io.ReadFromText('gs://some/inputData.txt'))
+     
+```
+
+In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
+
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
new file mode 100644
index 000000000000..83691202b280
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
@@ -0,0 +1,58 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: textIO-example
+#   description: TextIO example.
+#   multifile: false
+#   context_line: 43
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+        def __init__(self, prefix=''):
+            super().__init__()
+            self.prefix = prefix
+
+        def process(self, element):
+            print(self.prefix+str(element))
+
+    def __init__(self, label=None,prefix=''):
+        super().__init__(label)
+        self.prefix = prefix
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn(self.prefix))
+
+
+with beam.Pipeline() as p:
+    lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
+            | beam.Filter(lambda line: line != "")
+
+    lines | 'Log fixed lines' >> beam.combiners.Sample.FixedSizeGlobally(10) \
+    | beam.FlatMap(lambda sentence: sentence) \
+    | Output(prefix = 'Fixed first 10 lines: ')
+
+    words = p | 'Log words' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
+            | beam.FlatMap(lambda sentence: sentence.split()) \
+            | beam.Filter(lambda word: not word.isspace() or word.isalnum()) \
+            | beam.combiners.Sample.FixedSizeGlobally(10) \
+            | beam.FlatMap(lambda word: word) \
+            | 'Log output words' >> Output(prefix = 'Word: ')
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
new file mode 100644
index 000000000000..396a0190f74a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: from-text
+name: Creating PCollections from text files
+taskName: TextIO
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
new file mode 100644
index 000000000000..7046fb6da854
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
@@ -0,0 +1,26 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: concepts
+name: Beam Concepts
+content:
+- basic-concepts
+- creating-collections
+
+
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
new file mode 100644
index 000000000000..dc99a15f33a3
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
@@ -0,0 +1,23 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+# Tour of Beam Programming Guide
+
+Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the Apache Beam.
+The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
+You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
+The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
+Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
+Now let’s start the tour with learning core Beam principles.
+ 
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/unit-info.yaml
new file mode 100644
index 000000000000..814ca3cefbfe
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: guide
+name: Tour of Beam Guide
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
new file mode 100644
index 000000000000..c74e22bc383f
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
@@ -0,0 +1,38 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+**Pipeline** - A pipeline is a user-constructed graph of transformations that defines the desired data processing operations.
+
+**PCollection** - A PCollection is a data set or data stream. The data that a pipeline processes is part of a PCollection.
+
+**PTransform** - A PTransform (or transform) represents a data processing operation, or a step, in your pipeline. A transform is applied to zero or more PCollection objects, and produces zero or more PCollection objects.
+
+**Aggregation** - Aggregation is computing a value from multiple (1 or more) input elements.
+
+**User-defined function (UDF)** - Some Beam operations allow you to run user-defined code as a way to configure the transform.
+
+**Schema** - A schema is a language-independent type definition for a PCollection. The schema for a PCollection defines elements of that PCollection as an ordered list of named fields.
+
+**SDK** - A language-specific library that lets pipeline authors build transforms, construct their pipelines, and submit them to a runner.
+
+**Runner** - A runner runs a Beam pipeline using the capabilities of your chosen data processing engine.
+
+**Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
+
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in time order, or to always arrive at predictable intervals.
+
+**Trigger** - A trigger determines when to aggregate the results of each window.
+
+**State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
+
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/unit-info.yaml
new file mode 100644
index 000000000000..d18dd26929e1
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: terms
+name: List of Beam Terms
+complexity: BASIC
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/module-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/module-info.yaml
new file mode 100644
index 000000000000..78c6ae713bda
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/module-info.yaml
@@ -0,0 +1,27 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: introduction
+name: Introduction
+complexity: BASIC
+content:
+- introduction-guide
+- introduction-concepts
+- introduction-terms
+

From 4cabcb7e165cff394c032d394651fc2606462944 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Thu, 8 Sep 2022 15:13:11 +0300
Subject: [PATCH 02/31] removing white spaces from md files

---
 .../go/introduction/introduction-guide/description.md       | 3 +--
 .../creating-collections/reading-from-text/description.md   | 6 +++---
 .../java/introduction/introduction-guide/description.md     | 3 +--
 3 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
index dc99a15f33a3..91eb996d19b3 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -19,5 +19,4 @@ You can access list of modules by clicking ‘<<’ button on the left . For eac
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
 The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
-Now let’s start the tour with learning core Beam principles.
- 
\ No newline at end of file
+Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index 17a0700b33c9..6f9dd2674522 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -21,15 +21,15 @@ Each data source adapter has a Read transform; to read, you must apply that tran
 
 ```
 public static void main(String[] args) {
-    // First create the pipeline 
+    // First create the pipeline
     PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
     Pipeline pipeline = Pipeline.create(options);
-    
+
     // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file 
     PCollection<String> lines =
         pipeline.apply(“King Lear”,TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt")
 );
- 
+
 }
 ```
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
index dc99a15f33a3..91eb996d19b3 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
@@ -19,5 +19,4 @@ You can access list of modules by clicking ‘<<’ button on the left . For eac
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
 The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
-Now let’s start the tour with learning core Beam principles.
- 
\ No newline at end of file
+Now let’s start the tour with learning core Beam principles.
\ No newline at end of file

From 0aa2e28c654cdcc419754464b2905d8debaf3818 Mon Sep 17 00:00:00 2001
From: Abzal Tuganbay <abzal.tugan@gmail.com>
Date: Thu, 8 Sep 2022 18:39:55 +0600
Subject: [PATCH 03/31] delete whitespaces

---
 .../from-memory/description.md                     |  6 +++---
 .../reading-from-csv/description.md                |  2 +-
 .../reading-from-text/description.md               | 14 +++++++-------
 .../introduction/introduction-guide/description.md |  3 +--
 .../introduction/introduction-terms/description.md |  2 +-
 .../basic-concepts/description.md                  |  2 +-
 .../from-memory/description.md                     |  9 ++++-----
 7 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 4eb762bd4d03..2c24e2900b55 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -34,16 +34,16 @@ The following example code shows how to do this:
 ```
 func main() {
 	ctx := context.Background()
-    
+
     // First create pipline
 	p, s := beam.NewPipelineWithRoot()
 
     //Now create the PCollection using list of strings
 	numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
-    
+
     //Create a numerical PCollection
 	numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-   
+
 }
 ```
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index dfadb43fdcee..5f1441d34132 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -18,4 +18,4 @@ Data processing pipelines often work with tabular data. In many examples and cha
 
 Loading data from csv file requires some processing and consists of two main part:
 * Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format 
+* Parsing lines of text into tabular format
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index 127e3996ef1a..7fdc74f4669f 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -128,16 +128,16 @@ The following example code shows how to do this:
 ```
 func main() {
 	ctx := context.Background()
-    
+
     // First create pipline
 	p, s := beam.NewPipelineWithRoot()
 
     //Now create the PCollection using list of strings
 	numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
-    
+
     //Create a numerical PCollection
 	numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-   
+
 }
 ```
 
@@ -158,13 +158,13 @@ Each data source adapter has a Read transform; to read, you must apply that tran
 ```
 func main() {
 	ctx := context.Background()
-    
+
     // First create pipline
 	p, s := beam.NewPipelineWithRoot()
 
-    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file 
+    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file
     lines :=  textio.Read(scope, 'gs://some/inputData.txt')
-    
+
 }
 ```
 
@@ -178,4 +178,4 @@ Data processing pipelines often work with tabular data. In many examples and cha
 
 Loading data from csv file requires some processing and consists of two main part:
 * Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format 
+* Parsing lines of text into tabular format
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
index dc99a15f33a3..91eb996d19b3 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -19,5 +19,4 @@ You can access list of modules by clicking ‘<<’ button on the left . For eac
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
 The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
-Now let’s start the tour with learning core Beam principles.
- 
\ No newline at end of file
+Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
index c74e22bc383f..3af132c4c04d 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
@@ -35,4 +35,4 @@ limitations under the License.
 
 **State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
 
-**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
index efc7c150f135..2839d238707a 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
@@ -131,4 +131,4 @@ PipelineOptionsFactory.register(MyOptions.class);
 MyOptions options = PipelineOptionsFactory.fromArgs(args)
                                                 .withValidation()
                                                 .as(MyOptions.class);
-```
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
index ceb5b4abfc70..4d08910a5381 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -33,16 +33,16 @@ The following example code shows how to do this:
 
 ```
 public static void main(String[] args) {
-    // First create the pipeline 
+    // First create the pipeline
     PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
     Pipeline pipeline = Pipeline.create(options);
-    
+
     // Now create the PCollection using list of strings
     PCollection<String> words =
         pipeline.apply(
             Create.of("To", "be", "or", "not", "to", "be","that", "is", "the", "question")
         );
- 
+
     // Create a numerical PCollection
     PCollection<Integer> numbers =
         pipeline.apply(
@@ -55,5 +55,4 @@ You can find the complete code of this example in the playground window you can
 
 One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
 
-Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
-
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file

From e081553b3edc74e7d74bb97b40ec5b629f66242d Mon Sep 17 00:00:00 2001
From: Abzal Tuganbay <abzal.tugan@gmail.com>
Date: Thu, 8 Sep 2022 18:46:33 +0600
Subject: [PATCH 04/31] delete whitespaces in python

---
 .../creating-collections/reading-from-csv/description.md    | 2 +-
 .../creating-collections/reading-from-text/description.md   | 2 +-
 .../java/introduction/introduction-terms/description.md     | 2 +-
 .../creating-collections/from-memory/description.md         | 5 ++---
 .../creating-collections/reading-from-csv/description.md    | 2 +-
 .../creating-collections/reading-from-text/description.md   | 6 +++---
 .../python/introduction/introduction-guide/description.md   | 3 +--
 .../python/introduction/introduction-terms/description.md   | 2 +-
 8 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index dfadb43fdcee..5f1441d34132 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -18,4 +18,4 @@ Data processing pipelines often work with tabular data. In many examples and cha
 
 Loading data from csv file requires some processing and consists of two main part:
 * Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format 
+* Parsing lines of text into tabular format
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index 6f9dd2674522..e8c088529331 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -25,7 +25,7 @@ public static void main(String[] args) {
     PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
     Pipeline pipeline = Pipeline.create(options);
 
-    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file 
+    // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file
     PCollection<String> lines =
         pipeline.apply(“King Lear”,TextIO.read().from("gs://apache-beam-samples/shakespeare/kinglear.txt")
 );
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
index c74e22bc383f..3af132c4c04d 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
@@ -35,4 +35,4 @@ limitations under the License.
 
 **State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
 
-**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 0773e9104f63..2f194c554580 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -37,7 +37,7 @@ with beam.Pipeline() as p:
 
     # Create a numerical PCollection
     (p | beam.Create(range(1, 11)))
-     
+
      # Now create the PCollection using list of strings
     (p | beam.Create(['To', 'be', 'or', 'not', 'to', 'be', 'that', 'is', 'the', 'question']))
 
@@ -47,5 +47,4 @@ You can find the complete code of this example in the playground window you can
 
 One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
 
-Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
-
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index 1e20a163e6b8..bdd8a04d1a20 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -17,4 +17,4 @@ Data processing pipelines often work with tabular data. In many examples and cha
 
 Loading data from csv file requires some processing and consists of two main part:
 * Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format 
+* Parsing lines of text into tabular format
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index c48a99ebda9a..548debdd8b28 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -23,11 +23,11 @@ Each data source adapter has a Read transform; to read, you must apply that tran
 # First create pipline
 with beam.Pipeline() as p:
 
-    # Now create the PCollection by reading text files. Separate elements will be added for each line in the input file 
+    # Now create the PCollection by reading text files. Separate elements will be added for each line in the input file
     (p | beam.io.ReadFromText('gs://some/inputData.txt'))
-     
+
 ```
 
 In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
 
-One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
index dc99a15f33a3..91eb996d19b3 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
@@ -19,5 +19,4 @@ You can access list of modules by clicking ‘<<’ button on the left . For eac
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
 The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
-Now let’s start the tour with learning core Beam principles.
- 
\ No newline at end of file
+Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
index c74e22bc383f..3af132c4c04d 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
@@ -35,4 +35,4 @@ limitations under the License.
 
 **State and timers** - Per-key state and timer callbacks are lower level primitives that give you full control over aggregating input collections that grow over time.
 
-**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
+**Splittable DoFn** - Splittable DoFns let you process elements in a non-monolithic way. You can checkpoint the processing of an element, and the runner can split the remaining work to yield additional parallelism.
\ No newline at end of file

From 2d40ee7857c7588edd3b9063d6839f2cc56b8700 Mon Sep 17 00:00:00 2001
From: Abzal Tuganbay <abzal.tugan@gmail.com>
Date: Thu, 8 Sep 2022 18:53:05 +0600
Subject: [PATCH 05/31] delete whitespace #2

---
 .../creating-collections/from-memory/description.md             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 4d08910a5381..9a86f59de850 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -23,7 +23,7 @@ There are several options on how to do that:
 
 Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
 
-We encourage you to take a look, explore these data sets and use them while learning Apache Beam.  
+We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
 
 ### Creating a PCollection from in-memory data
 

From 7a07f51decc3198376a24cf7d549061dca4f3b39 Mon Sep 17 00:00:00 2001
From: Abzal Tuganbay <abzal.tugan@gmail.com>
Date: Fri, 9 Sep 2022 14:59:31 +0600
Subject: [PATCH 06/31] divide pipeline concepts

---
 .../creating-collections/group-info.yaml      |  4 +-
 .../introduction-concepts/group-info.yaml     |  2 +-
 .../creating-pipeline}/description.md         | 48 -----------
 .../creating-pipeline}/example/main.go        |  0
 .../creating-pipeline/unit-info.yaml          | 22 +++++
 .../pipeline-concepts/group-info.yaml         | 24 ++++++
 .../setting-pipeline/description.md           | 55 ++++++++++++
 .../setting-pipeline/example/main.go          | 48 +++++++++++
 .../setting-pipeline}/unit-info.yaml          |  4 +-
 .../introduction-concepts/group-info.yaml     |  2 +-
 .../creating-pipeline}/description.md         | 78 -----------------
 .../creating-pipeline}/example/Task.java      |  0
 .../creating-pipeline/unit-info.yaml          | 22 +++++
 .../pipeline-concepts/group-info.yaml         | 24 ++++++
 .../setting-pipeline/description.md           | 84 +++++++++++++++++++
 .../setting-pipeline/example/Task.java        | 69 +++++++++++++++
 .../setting-pipeline}/unit-info.yaml          |  4 +-
 .../introduction-concepts/group-info.yaml     |  2 +-
 .../creating-pipeline}/description.md         | 66 +--------------
 .../creating-pipeline}/example/task.py        |  0
 .../creating-pipeline/unit-info.yaml          | 22 +++++
 .../pipeline-concepts/group-info.yaml         | 24 ++++++
 .../setting-pipeline/description.md           | 70 ++++++++++++++++
 .../setting-pipeline/example/task.py          | 38 +++++++++
 .../setting-pipeline}/unit-info.yaml          |  4 +-
 25 files changed, 513 insertions(+), 203 deletions(-)
 rename learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/{basic-concepts => pipeline-concepts/creating-pipeline}/description.md (72%)
 rename learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/{basic-concepts => pipeline-concepts/creating-pipeline}/example/main.go (100%)
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
 rename learning/tour-of-beam/learning-content/{python/introduction/introduction-concepts/basic-concepts => go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline}/unit-info.yaml (93%)
 rename learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/{basic-concepts => pipeline-concepts/creating-pipeline}/description.md (58%)
 rename learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/{basic-concepts => pipeline-concepts/creating-pipeline}/example/Task.java (100%)
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
 rename learning/tour-of-beam/learning-content/{go/introduction/introduction-concepts/basic-concepts => java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline}/unit-info.yaml (93%)
 rename learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/{basic-concepts => pipeline-concepts/creating-pipeline}/description.md (63%)
 rename learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/{basic-concepts => pipeline-concepts/creating-pipeline}/example/task.py (100%)
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
 rename learning/tour-of-beam/learning-content/{java/introduction/introduction-concepts/basic-concepts => python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline}/unit-info.yaml (93%)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
index f291d762b04e..418ed516f2b0 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/group-info.yaml
@@ -22,6 +22,4 @@ name: Creating Collections
 content:
 - from-memory
 - reading-from-text
-- reading-from-csv
-
-
+- reading-from-csv
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
index 7046fb6da854..ca568acb6ab6 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
@@ -20,7 +20,7 @@
 id: concepts
 name: Beam Concepts
 content:
-- basic-concepts
+- pipeline-concepts
 - creating-collections
 
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
similarity index 72%
rename from learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/description.md
rename to learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index 19c852591246..a2190d9faa56 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -11,11 +11,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-# Tour of Beam Programming Guide
-
-The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
-
-For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
 
 ### Overview
 
@@ -60,47 +55,4 @@ beam.Init()
 
 // Create the Pipeline object and root scope.
 pipeline, scope := beam.NewPipelineWithRoot()
-```
-
-### Configuring pipeline options
-
-Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
-
-### Setting PipelineOptions from command-line arguments
-
-Use Go flags to parse command line arguments to configure your pipeline. Flags must be parsed before `beam.Init()` is called.
-
-```
-// If beamx or Go flags are used, flags must be parsed first,
-// before beam.Init() is called.
-flag.Parse()
-```
-
-This interprets command-line arguments this follow the format:
-
-```
---<option>=<value>
-```
-
-### Creating custom options
-
-You can add your own custom options in addition to the standard `PipelineOptions`.
-
-The following example shows how to add `input` and `output` custom options:
-
-```
-// Use standard Go flags to define pipeline options.
-var (
-	input  = flag.String("input", "", "")
-	output = flag.String("output", "", "")
-)
-```
-
-You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
-
-```
-var (
-	input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
-	output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
-)
 ```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
similarity index 100%
rename from learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/example/main.go
rename to learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..4c5ca25d4bfa
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-pipeline
+name: Pipeline creating concepts
+taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
new file mode 100644
index 000000000000..29d0afece5ae
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -0,0 +1,24 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: pipeline-concepts
+name: Pipeline concepts
+content:
+- creating-pipeline
+- setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
new file mode 100644
index 000000000000..7f4797b933bb
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -0,0 +1,55 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+### Setting PipelineOptions from command-line arguments
+
+Use Go flags to parse command line arguments to configure your pipeline. Flags must be parsed before `beam.Init()` is called.
+
+```
+// If beamx or Go flags are used, flags must be parsed first,
+// before beam.Init() is called.
+flag.Parse()
+```
+
+This interprets command-line arguments this follow the format:
+
+```
+--<option>=<value>
+```
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+// Use standard Go flags to define pipeline options.
+var (
+	input  = flag.String("input", "", "")
+	output = flag.String("output", "", "")
+)
+```
+
+You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+
+```
+var (
+	input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
+	output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
+)
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
new file mode 100644
index 000000000000..5ecddfda5dc5
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// beam-playground:
+//   name: HelloBeam
+//   description: Hello Beam example.
+//   multifile: false
+//   context_line: 34
+
+package main
+
+import (
+  "context"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/debug"
+)
+
+
+
+func main() {
+  p, s := beam.NewPipelineWithRoot()
+
+  hello := helloBeam(s)
+  debug.Print(s, hello)
+
+  err := beamx.Run(context.Background(), p)
+  if err != nil {
+    log.Exitf(context.Background(), "Failed to execute job: %v", err)
+  }
+}
+
+func helloBeam(s beam.Scope) beam.PCollection {
+  return beam.Create(s, "Hello Beam")
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
similarity index 93%
rename from learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/unit-info.yaml
rename to learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index d22fdb3080e8..83b42a7167b7 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -17,6 +17,6 @@
 # under the License.
 #
 
-id: basic
-name: Basic Concepts
+id: setting-pipeline
+name: Pipeline setting concepts
 taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
index 7046fb6da854..ca568acb6ab6 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
@@ -20,7 +20,7 @@
 id: concepts
 name: Beam Concepts
 content:
-- basic-concepts
+- pipeline-concepts
 - creating-collections
 
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
similarity index 58%
rename from learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
rename to learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index 2839d238707a..ef8f1be51f0c 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -11,12 +11,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-# Tour of Beam Programming Guide
-
-The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
-
-For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
-
 ### Overview
 
 To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
@@ -59,76 +53,4 @@ PipelineOptions options = PipelineOptionsFactory.create();
 
 // Then create the pipeline.
 Pipeline p = Pipeline.create(options);
-```
-
-### Configuring pipeline options
-
-Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
-
-When you run the pipeline on a runner of your choice, a copy of the PipelineOptions will be available to your code. For example, if you add a PipelineOptions parameter to a DoFn’s `@ProcessElement` method, it will be populated by the system.
-
-### Setting PipelineOptions from command-line arguments
-
-While you can configure your pipeline by creating a PipelineOptions object and setting the fields directly, the Beam SDKs include a command-line parser that you can use to set fields in PipelineOptions using command-line arguments.
-
-To read options from the command-line, construct your PipelineOptions object as demonstrated in the following example code:
-
-```
-PipelineOptions options =
-    PipelineOptionsFactory.fromArgs(args).withValidation().create();
-```
-
-This interprets command-line arguments that follow the format:
-
-```
---<option>=<value>
-```
-
-> Appending the method .withValidation will check for required command-line arguments and validate argument values.
-
-### Creating custom options
-
-You can add your own custom options in addition to the standard `PipelineOptions`.
-
-To add your own options, define an interface with getter and setter methods for each option.
-
-The following example shows how to add `input` and `output` custom options:
-
-```
-public interface MyOptions extends PipelineOptions {
-    String getInput();
-    void setInput(String input);
-
-    String getOutput();
-    void setOutput(String output);
-}
-```
-
-You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
-
-You set the description and default value using annotations, as follows:
-
-```
-public interface MyOptions extends PipelineOptions {
-    @Description("Input for the pipeline")
-    @Default.String("gs://my-bucket/input")
-    String getInput();
-    void setInput(String input);
-
-    @Description("Output for the pipeline")
-    @Default.String("gs://my-bucket/output")
-    String getOutput();
-    void setOutput(String output);
-}
-```
-
-It’s recommended that you register your interface with `PipelineOptionsFactory` and then pass the interface when creating the `PipelineOptions` object. When you register your interface with `PipelineOptionsFactory`, the `--help` can find your custom options interface and add it to the output of the --help command. `PipelineOptionsFactory` will also validate that your custom options are compatible with all other registered options.
-
-The following example code shows how to register your custom options interface with `PipelineOptionsFactory`:
-
-```
-PipelineOptionsFactory.register(MyOptions.class);
-MyOptions options = PipelineOptionsFactory.fromArgs(args)
-                                                .withValidation()
-                                                .as(MyOptions.class);
 ```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
similarity index 100%
rename from learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/example/Task.java
rename to learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..4c5ca25d4bfa
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-pipeline
+name: Pipeline creating concepts
+taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
new file mode 100644
index 000000000000..29d0afece5ae
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -0,0 +1,24 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: pipeline-concepts
+name: Pipeline concepts
+content:
+- creating-pipeline
+- setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
new file mode 100644
index 000000000000..32f8d9fe3468
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -0,0 +1,84 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+When you run the pipeline on a runner of your choice, a copy of the PipelineOptions will be available to your code. For example, if you add a PipelineOptions parameter to a DoFn’s `@ProcessElement` method, it will be populated by the system.
+
+### Setting PipelineOptions from command-line arguments
+
+While you can configure your pipeline by creating a PipelineOptions object and setting the fields directly, the Beam SDKs include a command-line parser that you can use to set fields in PipelineOptions using command-line arguments.
+
+To read options from the command-line, construct your PipelineOptions object as demonstrated in the following example code:
+
+```
+PipelineOptions options =
+    PipelineOptionsFactory.fromArgs(args).withValidation().create();
+```
+
+This interprets command-line arguments that follow the format:
+
+```
+--<option>=<value>
+```
+
+> Appending the method .withValidation will check for required command-line arguments and validate argument values.
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+To add your own options, define an interface with getter and setter methods for each option.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+public interface MyOptions extends PipelineOptions {
+    String getInput();
+    void setInput(String input);
+
+    String getOutput();
+    void setOutput(String output);
+}
+```
+
+You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+
+You set the description and default value using annotations, as follows:
+
+```
+public interface MyOptions extends PipelineOptions {
+    @Description("Input for the pipeline")
+    @Default.String("gs://my-bucket/input")
+    String getInput();
+    void setInput(String input);
+
+    @Description("Output for the pipeline")
+    @Default.String("gs://my-bucket/output")
+    String getOutput();
+    void setOutput(String output);
+}
+```
+
+It’s recommended that you register your interface with `PipelineOptionsFactory` and then pass the interface when creating the `PipelineOptions` object. When you register your interface with `PipelineOptionsFactory`, the `--help` can find your custom options interface and add it to the output of the --help command. `PipelineOptionsFactory` will also validate that your custom options are compatible with all other registered options.
+
+The following example code shows how to register your custom options interface with `PipelineOptionsFactory`:
+
+```
+PipelineOptionsFactory.register(MyOptions.class);
+MyOptions options = PipelineOptionsFactory.fromArgs(args)
+                                                .withValidation()
+                                                .as(MyOptions.class);
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
new file mode 100644
index 000000000000..16247c48eb44
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// beam-playground:
+//   name: HelloBeam
+//   description: Hello Beam example.
+//   multifile: false
+//   context_line: 32
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.transforms.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Task {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
+
+
+    public static void main(String[] args) {
+        PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
+        Pipeline pipeline = Pipeline.create(options);
+
+        PCollection<String> output = setupPipeline(pipeline);
+
+        output.apply("Log", ParDo.of(new LogOutput<String>()));
+
+        pipeline.run();
+    }
+
+    static PCollection<String> setupPipeline(Pipeline pipeline) {
+        return pipeline.apply(Create.of("Hello Beam"));
+    }
+
+    static class LogOutput<T> extends DoFn<T, T> {
+        private String prefix;
+
+        LogOutput() {
+            this.prefix = "Processing element";
+        }
+
+        LogOutput(String prefix) {
+            this.prefix = prefix;
+        }
+
+        @ProcessElement
+        public void processElement(ProcessContext c) throws Exception {
+            LOG.info(prefix + ": {}", c.element());
+        }
+    }
+}
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
similarity index 93%
rename from learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/unit-info.yaml
rename to learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index d22fdb3080e8..83b42a7167b7 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/basic-concepts/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -17,6 +17,6 @@
 # under the License.
 #
 
-id: basic
-name: Basic Concepts
+id: setting-pipeline
+name: Pipeline setting concepts
 taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
index 7046fb6da854..ca568acb6ab6 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
@@ -20,7 +20,7 @@
 id: concepts
 name: Beam Concepts
 content:
-- basic-concepts
+- pipeline-concepts
 - creating-collections
 
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
similarity index 63%
rename from learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/description.md
rename to learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index d1e0c0bd6594..e1de290dd676 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -11,12 +11,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-# Tour of Beam Programming Guide
-
-The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
-
-For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
-
 ### Overview
 
 To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program then defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
@@ -56,62 +50,4 @@ import apache_beam as beam
 
 with beam.Pipeline() as pipeline:
   pass  # build your pipeline here
-```
-
-### Configuring pipeline options
-
-Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
-
-### Setting PipelineOptions from command-line arguments
-
-While you can configure your pipeline by creating a `PipelineOptions` object and setting the fields directly, the Beam SDKs include a command-line parser that you can also use to set fields in `PipelineOptions` using command-line arguments.
-
-To read options from the command-line, construct your `PipelineOptions` object as demonstrated in the following example code:
-
-```
-from apache_beam.options.pipeline_options import PipelineOptions
-
-beam_options = PipelineOptions()
-```
-
-This interprets command-line arguments that follow this format:
-
-```
---<option>=<value>
-```
-
-### Creating custom options
-
-You can add your own custom options in addition to the standard `PipelineOptions`.
-
-The following example shows how to add `input` and `output` custom options:
-
-```
-from apache_beam.options.pipeline_options import PipelineOptions
-
-class MyOptions(PipelineOptions):
-  @classmethod
-  def _add_argparse_args(cls, parser):
-    parser.add_argument('--input')
-    parser.add_argument('--output')
-```
-
-You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
-
-You set the description and default value using annotations, as follows:
-
-```
-from apache_beam.options.pipeline_options import PipelineOptions
-
-class MyOptions(PipelineOptions):
-  @classmethod
-  def _add_argparse_args(cls, parser):
-    parser.add_argument(
-        '--input',
-        default='gs://dataflow-samples/shakespeare/kinglear.txt',
-        help='The file path for the input text to process.')
-    parser.add_argument(
-        '--output', required=True, help='The path prefix for output files.')
-```
-
-For Python, you can also simply parse your custom options with argparse; there is no need to create a separate PipelineOptions subclass.
\ No newline at end of file
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
similarity index 100%
rename from learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/basic-concepts/example/task.py
rename to learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..4c5ca25d4bfa
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -0,0 +1,22 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: creating-pipeline
+name: Pipeline creating concepts
+taskName: HelloBeam
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
new file mode 100644
index 000000000000..29d0afece5ae
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -0,0 +1,24 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: pipeline-concepts
+name: Pipeline concepts
+content:
+- creating-pipeline
+- setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
new file mode 100644
index 000000000000..95e14a5c1700
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -0,0 +1,70 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Configuring pipeline options
+
+Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
+
+### Setting PipelineOptions from command-line arguments
+
+While you can configure your pipeline by creating a `PipelineOptions` object and setting the fields directly, the Beam SDKs include a command-line parser that you can also use to set fields in `PipelineOptions` using command-line arguments.
+
+To read options from the command-line, construct your `PipelineOptions` object as demonstrated in the following example code:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+beam_options = PipelineOptions()
+```
+
+This interprets command-line arguments that follow this format:
+
+```
+--<option>=<value>
+```
+
+### Creating custom options
+
+You can add your own custom options in addition to the standard `PipelineOptions`.
+
+The following example shows how to add `input` and `output` custom options:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+class MyOptions(PipelineOptions):
+  @classmethod
+  def _add_argparse_args(cls, parser):
+    parser.add_argument('--input')
+    parser.add_argument('--output')
+```
+
+You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+
+You set the description and default value using annotations, as follows:
+
+```
+from apache_beam.options.pipeline_options import PipelineOptions
+
+class MyOptions(PipelineOptions):
+  @classmethod
+  def _add_argparse_args(cls, parser):
+    parser.add_argument(
+        '--input',
+        default='gs://dataflow-samples/shakespeare/kinglear.txt',
+        help='The file path for the input text to process.')
+    parser.add_argument(
+        '--output', required=True, help='The path prefix for output files.')
+```
+
+For Python, you can also simply parse your custom options with argparse; there is no need to create a separate PipelineOptions subclass.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
new file mode 100644
index 000000000000..c07a2eaafa90
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -0,0 +1,38 @@
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# beam-playground:
+#   name: HelloBeam
+#   description: Hello Beam example.
+#   multifile: false
+#   context_line: 35
+
+import apache_beam as beam
+
+# Output PCollection
+class Output(beam.PTransform):
+    class _OutputFn(beam.DoFn):
+
+        def process(self, element):
+            print(element)
+
+    def expand(self, input):
+        input | beam.ParDo(self._OutputFn())
+
+with beam.Pipeline() as p:
+  (p | beam.Create(['Hello Beam'])
+   | Output())
+
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
similarity index 93%
rename from learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/unit-info.yaml
rename to learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index d22fdb3080e8..83b42a7167b7 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/basic-concepts/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -17,6 +17,6 @@
 # under the License.
 #
 
-id: basic
-name: Basic Concepts
+id: setting-pipeline
+name: Pipeline setting concepts
 taskName: HelloBeam
\ No newline at end of file

From 4fd5735909bef34e86bb4f6593905239e60620fe Mon Sep 17 00:00:00 2001
From: Abzal Tuganbay <abzal.tugan@gmail.com>
Date: Fri, 9 Sep 2022 17:22:12 +0600
Subject: [PATCH 07/31] add pipeline example concepts

---
 .../creating-pipeline/example/main.go         |  4 +-
 .../creating-pipeline/unit-info.yaml          |  2 +-
 .../setting-pipeline/example/main.go          | 41 ++++++++++++------
 .../setting-pipeline/unit-info.yaml           |  2 +-
 .../creating-pipeline/example/Task.java       |  6 +--
 .../creating-pipeline/unit-info.yaml          |  2 +-
 .../setting-pipeline/example/Task.java        | 42 +++++++++++++------
 .../setting-pipeline/unit-info.yaml           |  2 +-
 8 files changed, 67 insertions(+), 34 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
index 5ecddfda5dc5..f3184c99ba0d 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
@@ -14,8 +14,8 @@
 // limitations under the License.
 
 // beam-playground:
-//   name: HelloBeam
-//   description: Hello Beam example.
+//   name: creating-pipeline
+//   description: Creating pipeline example.
 //   multifile: false
 //   context_line: 34
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
index 4c5ca25d4bfa..dc58d75e3af2 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -19,4 +19,4 @@
 
 id: creating-pipeline
 name: Pipeline creating concepts
-taskName: HelloBeam
\ No newline at end of file
+taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index 5ecddfda5dc5..01e14825b995 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -14,8 +14,8 @@
 // limitations under the License.
 
 // beam-playground:
-//   name: HelloBeam
-//   description: Hello Beam example.
+//   name: setting-pipeline
+//   description: Setting pipeline example.
 //   multifile: false
 //   context_line: 34
 
@@ -23,26 +23,43 @@ package main
 
 import (
   "context"
+  "flag"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
   "github.com/apache/beam/sdks/v2/go/pkg/beam"
   "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
   "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
   "github.com/apache/beam/sdks/v2/go/pkg/beam/x/debug"
 )
 
+var (
+  // By default, this example reads from a public dataset containing the text of
+  // King Lear. Set this option to choose a different input file or glob.
+  input = flag.String("input", "gs://apache-beam-samples/shakespeare/kinglear.txt", "File(s) to read.")
 
+  // Set this required option to specify where to write the output.
+  output = flag.String("output", "", "Output file (required).")
+)
 
 func main() {
-  p, s := beam.NewPipelineWithRoot()
+  // If beamx or Go flags are used, flags must be parsed first.
+  flag.Parse()
 
-  hello := helloBeam(s)
-  debug.Print(s, hello)
 
-  err := beamx.Run(context.Background(), p)
-  if err != nil {
-    log.Exitf(context.Background(), "Failed to execute job: %v", err)
+  // Input validation is done as usual. Note that it must be after Init().
+  if *output == "" {
+    log.Fatal("No output provided")
   }
-}
 
-func helloBeam(s beam.Scope) beam.PCollection {
-  return beam.Create(s, "Hello Beam")
-}
\ No newline at end of file
+  p := beam.NewPipeline()
+  s := p.Root()
+
+  // Read from option input file
+  lines := textio.Read(s, *input)
+
+  // Write to option output file
+  textio.Write(s, *output, formatted)
+
+  if err := beamx.Run(context.Background(), p); err != nil {
+    log.Fatalf("Failed to execute job: %v", err)
+  }
+}
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index 83b42a7167b7..8c9c0dcb82f7 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -19,4 +19,4 @@
 
 id: setting-pipeline
 name: Pipeline setting concepts
-taskName: HelloBeam
\ No newline at end of file
+taskName: setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
index 16247c48eb44..1b940cecd6f0 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
@@ -17,10 +17,10 @@
  */
 
 // beam-playground:
-//   name: HelloBeam
-//   description: Hello Beam example.
+//   name: creating-pipeline
+//   description: Creating pipeline example.
 //   multifile: false
-//   context_line: 32
+//   context_line: 33
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.options.PipelineOptions;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
index 4c5ca25d4bfa..dc58d75e3af2 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -19,4 +19,4 @@
 
 id: creating-pipeline
 name: Pipeline creating concepts
-taskName: HelloBeam
\ No newline at end of file
+taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
index 16247c48eb44..313b4654b68f 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
@@ -17,14 +17,14 @@
  */
 
 // beam-playground:
-//   name: HelloBeam
-//   description: Hello Beam example.
+//   name: setting-pipeline
+//   description: Setting pipeline example.
 //   multifile: false
-//   context_line: 32
+//   context_line: 33
 
 import org.apache.beam.sdk.Pipeline;
-import org.apache.beam.sdk.options.PipelineOptions;
-import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.io.TextIO;
+import org.apache.beam.sdk.options.*;
 import org.apache.beam.sdk.values.PCollection;
 import org.apache.beam.sdk.transforms.*;
 import org.slf4j.Logger;
@@ -34,20 +34,36 @@ public class Task {
 
     private static final Logger LOG = LoggerFactory.getLogger(Task.class);
 
+    public interface MyOptions extends PipelineOptions {
+        // Default value if [--output] equal null
+        @Description("Path of the file to read from")
+        @Default.String("gs://apache-beam-samples/shakespeare/kinglear.txt")
+        String getInputFile();
 
-    public static void main(String[] args) {
-        PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
-        Pipeline pipeline = Pipeline.create(options);
+        void setInputFile(String value);
 
-        PCollection<String> output = setupPipeline(pipeline);
 
-        output.apply("Log", ParDo.of(new LogOutput<String>()));
+        // Set this required option to specify where to write the output.
+        @Description("Path of the file to write to")
+        @Validation.Required
+        String getOutput();
+
+        void setOutput(String value);
+    }
 
-        pipeline.run();
+    public static void main(String[] args) {
+        MyOptions options = PipelineOptionsFactory.fromArgs(args).withValidation().as(MyOptions.class);
+
+        readLines(options);
     }
 
-    static PCollection<String> setupPipeline(Pipeline pipeline) {
-        return pipeline.apply(Create.of("Hello Beam"));
+    static void readLines(MyOptions options) {
+        Pipeline pipeline = Pipeline.create(options);
+        PCollection<String> output = pipeline.apply("ReadLines", TextIO.read().from(options.getInputFile()))
+                .apply(Filter.by((String line) -> !line.isEmpty()));
+
+        output.apply("Log", ParDo.of(new LogOutput<String>()));
+        pipeline.run().waitUntilFinish();
     }
 
     static class LogOutput<T> extends DoFn<T, T> {
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index 83b42a7167b7..8c9c0dcb82f7 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -19,4 +19,4 @@
 
 id: setting-pipeline
 name: Pipeline setting concepts
-taskName: HelloBeam
\ No newline at end of file
+taskName: setting-pipeline
\ No newline at end of file

From 7ad04d6e8d59ab5cb0e058817dd10583ac853167 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Fri, 9 Sep 2022 13:31:39 +0200
Subject: [PATCH 08/31] adding category tag to python examples

---
 .../creating-collections/from-memory/example/pardoExample.py    | 2 ++
 .../creating-collections/reading-from-csv/example/csvExample.py | 2 ++
 .../creating-collections/reading-from-text/example/textIo.py    | 2 ++
 .../pipeline-concepts/creating-pipeline/example/task.py         | 2 ++
 .../pipeline-concepts/setting-pipeline/example/task.py          | 2 ++
 5 files changed, 10 insertions(+)

diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py
index f3eff62faee4..99ef70df3b96 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py
@@ -19,6 +19,8 @@
 #   description: ParDo example.
 #   multifile: false
 #   context_line: 48
+#   categories:
+#     - Quickstart
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
index 544a383c3952..c8ce9323682d 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
@@ -19,6 +19,8 @@
 #   description: Csv file example.
 #   multifile: false
 #   context_line: 43
+#   categories:
+#     - Quickstart
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
index 83691202b280..82379ab15542 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
@@ -19,6 +19,8 @@
 #   description: TextIO example.
 #   multifile: false
 #   context_line: 43
+#   categories:
+#     - Quickstart
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
index c07a2eaafa90..88ba56d792c5 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
@@ -19,6 +19,8 @@
 #   description: Hello Beam example.
 #   multifile: false
 #   context_line: 35
+#   categories:
+#     - Quickstart
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
index c07a2eaafa90..88ba56d792c5 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -19,6 +19,8 @@
 #   description: Hello Beam example.
 #   multifile: false
 #   context_line: 35
+#   categories:
+#     - Quickstart
 
 import apache_beam as beam
 

From f7eb966191478768d454360dbd48add93643b31d Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Fri, 9 Sep 2022 13:33:58 +0200
Subject: [PATCH 09/31] adding category to java examples

---
 .../creating-collections/from-memory/example/ParDoExample.java  | 2 ++
 .../reading-from-csv/example/CSVExample.java                    | 2 ++
 .../reading-from-text/example/TextIOExample.java                | 2 ++
 .../pipeline-concepts/creating-pipeline/example/Task.java       | 2 ++
 .../pipeline-concepts/setting-pipeline/example/Task.java        | 2 ++
 5 files changed, 10 insertions(+)

diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java
index 957efc99f40d..590bdd5000ba 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java
@@ -21,6 +21,8 @@
 //   description: ParDo example.
 //   multifile: false
 //   context_line: 36
+//   categories:
+//     - Quickstart
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.options.PipelineOptions;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
index 6da0e6257a0f..7bf88495c5c8 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
@@ -21,6 +21,8 @@
 //   description: CSV example.
 //   multifile: false
 //   context_line: 50
+//   categories:
+//     - Quickstart
 
 package org.apache.beam.examples;
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
index 2d52ffe80376..38fbf1d8fdfa 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
@@ -20,6 +20,8 @@
 //   description: TextIO example.
 //   multifile: false
 //   context_line: 36
+//   categories:
+//     - Quickstart
 
 package org.apache.beam.examples;
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
index 1b940cecd6f0..5c17b30fb9d9 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
@@ -21,6 +21,8 @@
 //   description: Creating pipeline example.
 //   multifile: false
 //   context_line: 33
+//   categories:
+//     - Quickstart
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.options.PipelineOptions;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
index 313b4654b68f..f92a789d6cef 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
@@ -21,6 +21,8 @@
 //   description: Setting pipeline example.
 //   multifile: false
 //   context_line: 33
+//   categories:
+//     - Quickstart
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.io.TextIO;

From 9204431cb8dbacb0a7ab379e9277284aa029b58d Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Fri, 9 Sep 2022 13:35:14 +0200
Subject: [PATCH 10/31] adding category to go examples

---
 .../creating-collections/from-memory/example/pardoExample.go    | 2 ++
 .../creating-collections/reading-from-csv/example/csvExample.go | 2 ++
 .../creating-collections/reading-from-text/example/textIo.go    | 2 ++
 .../pipeline-concepts/creating-pipeline/example/main.go         | 2 ++
 .../pipeline-concepts/setting-pipeline/example/main.go          | 2 ++
 5 files changed, 10 insertions(+)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
index 60739ad6f2e5..4b992bc8f4dd 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
@@ -18,6 +18,8 @@
 //   description: ParDo example.
 //   multifile: false
 //   context_line: 32
+//   categories:
+//     - Quickstart
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
index 1f1f0a61dbfd..58ef024804cd 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
@@ -21,6 +21,8 @@
 //   description: CSV example.
 //   multifile: false
 //   context_line: 44
+//   categories:
+//     - Quickstart
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
index 93439d206ac8..1ab414ac6fc1 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
@@ -20,6 +20,8 @@
 //   description: TextIO example.
 //   multifile: false
 //   context_line: 46
+//   categories:
+//     - Quickstart
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
index f3184c99ba0d..06cae5d7386f 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
@@ -18,6 +18,8 @@
 //   description: Creating pipeline example.
 //   multifile: false
 //   context_line: 34
+//   categories:
+//     - Quickstart
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index 01e14825b995..79353a0de06b 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -18,6 +18,8 @@
 //   description: Setting pipeline example.
 //   multifile: false
 //   context_line: 34
+//   categories:
+//     - Quickstart
 
 package main
 

From af66a8a8826ccf8653e7321f13c84f6c5cc2f22b Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Fri, 9 Sep 2022 13:44:23 +0200
Subject: [PATCH 11/31] fixed go example

---
 .../creating-collections/from-memory/example/pardoExample.go    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
index 4b992bc8f4dd..9b23282956e6 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
@@ -34,7 +34,7 @@ import (
 func main() {
   p, s := beam.NewPipelineWithRoot()
 
-  elements := beam.Create(s, "Hello", "world", "it`s", "Beam")
+  words := beam.Create(s, "Hello", "world", "it`s", "Beam")
 
   output(s, words)
 

From 5322fe11d7adc5b85aa7d56d8c2aa3a58e6607ac Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Fri, 9 Sep 2022 13:54:44 +0200
Subject: [PATCH 12/31] fixed go example compilation

---
 .../pipeline-concepts/setting-pipeline/example/main.go      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index 79353a0de06b..d21cf62e6a44 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -18,6 +18,7 @@
 //   description: Setting pipeline example.
 //   multifile: false
 //   context_line: 34
+//   pipeline_options: --output output.txt
 //   categories:
 //     - Quickstart
 
@@ -26,11 +27,10 @@ package main
 import (
   "context"
   "flag"
+  "log"
   "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
   "github.com/apache/beam/sdks/v2/go/pkg/beam"
-  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
   "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
-  "github.com/apache/beam/sdks/v2/go/pkg/beam/x/debug"
 )
 
 var (
@@ -59,7 +59,7 @@ func main() {
   lines := textio.Read(s, *input)
 
   // Write to option output file
-  textio.Write(s, *output, formatted)
+  textio.Write(s, *output, lines)
 
   if err := beamx.Run(context.Background(), p); err != nil {
     log.Fatalf("Failed to execute job: %v", err)

From 11e2cf8c5d84e1d450b683f4fdd337b93438aec3 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Fri, 9 Sep 2022 14:34:42 +0200
Subject: [PATCH 13/31] fixing python duplicate example names

---
 .../pipeline-concepts/creating-pipeline/example/task.py         | 2 +-
 .../pipeline-concepts/setting-pipeline/example/task.py          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
index 88ba56d792c5..9040f0741ef6 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
@@ -15,7 +15,7 @@
 #   limitations under the License.
 
 # beam-playground:
-#   name: HelloBeam
+#   name: creating-pipeline
 #   description: Hello Beam example.
 #   multifile: false
 #   context_line: 35
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
index 88ba56d792c5..8bee427ccfd4 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -15,7 +15,7 @@
 #   limitations under the License.
 
 # beam-playground:
-#   name: HelloBeam
+#   name: setting-pipeline
 #   description: Hello Beam example.
 #   multifile: false
 #   context_line: 35

From dde4bf4b33c577af5dd88f836dffcea8ffeafdf2 Mon Sep 17 00:00:00 2001
From: Abzal Tuganbay <abzal.tugan@gmail.com>
Date: Fri, 9 Sep 2022 18:44:54 +0600
Subject: [PATCH 14/31] add runner concepts

---
 .../introduction-concepts/group-info.yaml     |  5 +-
 .../setting-pipeline/example/main.go          | 11 ++--
 .../runner-concepts/description.md            | 13 +++++
 .../runner-concepts/unit-info.yaml            | 21 +++++++
 .../introduction-concepts/group-info.yaml     |  1 +
 .../runner-concepts/description.md            | 34 ++++++++++++
 .../runner-concepts/unit-info.yaml            | 21 +++++++
 .../introduction-concepts/group-info.yaml     |  1 +
 .../creating-pipeline/example/task.py         |  4 +-
 .../creating-pipeline/unit-info.yaml          |  2 +-
 .../setting-pipeline/example/task.py          | 55 +++++++++++++++++--
 .../setting-pipeline/unit-info.yaml           |  2 +-
 .../runner-concepts/description.md            | 13 +++++
 .../runner-concepts/unit-info.yaml            | 21 +++++++
 14 files changed, 187 insertions(+), 17 deletions(-)
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/unit-info.yaml

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
index ca568acb6ab6..19ef8ae2fd5b 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/group-info.yaml
@@ -20,7 +20,6 @@
 id: concepts
 name: Beam Concepts
 content:
+- runner-concepts
 - pipeline-concepts
-- creating-collections
-
-
+- creating-collections
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index d21cf62e6a44..62f7502e018f 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -46,10 +46,11 @@ func main() {
   // If beamx or Go flags are used, flags must be parsed first.
   flag.Parse()
 
+  ctx := context.Background()
 
   // Input validation is done as usual. Note that it must be after Init().
   if *output == "" {
-    log.Fatal("No output provided")
+    log.Exitf(ctx,"No output provided")
   }
 
   p := beam.NewPipeline()
@@ -61,7 +62,9 @@ func main() {
   // Write to option output file
   textio.Write(s, *output, lines)
 
-  if err := beamx.Run(context.Background(), p); err != nil {
-    log.Fatalf("Failed to execute job: %v", err)
-  }
+  err := beamx.Run(ctx, p)
+
+  if err != nil {
+  		log.Exitf(ctx, "Failed to execute job: %v", err)
+  	}
 }
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
new file mode 100644
index 000000000000..f428cbe9cc3a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
@@ -0,0 +1,13 @@
+### Overview
+
+Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
+
+### Direct runner
+The Direct Runner executes pipelines on your machine and is designed to validate that pipelines adhere to the Apache Beam model as closely as possible. Instead of focusing on efficient pipeline execution, the Direct Runner performs additional checks to ensure that users do not rely on semantics that are not guaranteed by the model. Some of these checks include:
+
+* enforcing immutability of elements
+* enforcing encodability of elements
+* elements are processed in an arbitrary order at all points
+* serialization of user functions (DoFn, CombineFn, etc.)
+
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/unit-info.yaml
new file mode 100644
index 000000000000..c1637f5fb6b7
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: runner-concepts
+name: Runners
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
index ca568acb6ab6..95f5868d570b 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/group-info.yaml
@@ -20,6 +20,7 @@
 id: concepts
 name: Beam Concepts
 content:
+- runner-concepts
 - pipeline-concepts
 - creating-collections
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
new file mode 100644
index 000000000000..8d908079feba
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
@@ -0,0 +1,34 @@
+### Overview
+
+Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
+
+### Direct runner
+The Direct Runner executes pipelines on your machine and is designed to validate that pipelines adhere to the Apache Beam model as closely as possible. Instead of focusing on efficient pipeline execution, the Direct Runner performs additional checks to ensure that users do not rely on semantics that are not guaranteed by the model. Some of these checks include:
+
+* enforcing immutability of elements
+* enforcing encodability of elements
+* elements are processed in an arbitrary order at all points
+* serialization of user functions (DoFn, CombineFn, etc.)
+
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
+
+### Specify your dependency
+
+When using Java, you must specify your dependency on the Direct Runner in your pom.xml.
+
+```
+<dependency>
+   <groupId>org.apache.beam</groupId>
+   <artifactId>beam-runners-direct-java</artifactId>
+   <version>2.41.0</version>
+   <scope>runtime</scope>
+</dependency>
+```
+
+### Set runner
+
+In java, you need to set runner to `args` when you start the program.
+
+```
+--runner=DirectRunner
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/unit-info.yaml
new file mode 100644
index 000000000000..c1637f5fb6b7
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: runner-concepts
+name: Runners
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
index ca568acb6ab6..95f5868d570b 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/group-info.yaml
@@ -20,6 +20,7 @@
 id: concepts
 name: Beam Concepts
 content:
+- runner-concepts
 - pipeline-concepts
 - creating-collections
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
index 88ba56d792c5..c56320f3a249 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
@@ -15,8 +15,8 @@
 #   limitations under the License.
 
 # beam-playground:
-#   name: HelloBeam
-#   description: Hello Beam example.
+#   name: creating-pipeline
+#   description: Creating pipeline example.
 #   multifile: false
 #   context_line: 35
 #   categories:
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
index 4c5ca25d4bfa..dc58d75e3af2 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -19,4 +19,4 @@
 
 id: creating-pipeline
 name: Pipeline creating concepts
-taskName: HelloBeam
\ No newline at end of file
+taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
index 88ba56d792c5..03a446ac3f91 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -15,15 +15,24 @@
 #   limitations under the License.
 
 # beam-playground:
-#   name: HelloBeam
-#   description: Hello Beam example.
+#   name: setting-pipeline
+#   description: Setting pipeline example.
 #   multifile: false
-#   context_line: 35
 #   categories:
 #     - Quickstart
+#   context_line: 47
+
+import argparse
+import logging
+import re
 
 import apache_beam as beam
 
+from apache_beam.io import ReadFromText
+from apache_beam.io import WriteToText
+from apache_beam.options.pipeline_options import PipelineOptions
+from apache_beam.options.pipeline_options import SetupOptions
+
 # Output PCollection
 class Output(beam.PTransform):
     class _OutputFn(beam.DoFn):
@@ -34,7 +43,41 @@ def process(self, element):
     def expand(self, input):
         input | beam.ParDo(self._OutputFn())
 
-with beam.Pipeline() as p:
-  (p | beam.Create(['Hello Beam'])
-   | Output())
+def main(argv=None, save_main_session=True):
+    """Main entry point; defines and runs the wordcount pipeline."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--input',
+        dest='input',
+        default='gs://dataflow-samples/shakespeare/kinglear.txt',
+        help='Input file to process.')
+    parser.add_argument(
+        '--output',
+        dest='output',
+        required=True,
+        help='Output file to write results to.')
+    known_args, pipeline_args = parser.parse_known_args(argv)
+
+    # We use the save_main_session option because one or more DoFn's in this
+    # workflow rely on global context (e.g., a module imported at module level).
+    pipeline_options = PipelineOptions(pipeline_args)
+    pipeline_options.view_as(SetupOptions).save_main_session = save_main_session
+
+    with beam.Pipeline(options=pipeline_options) as p:
+
+    # Read the text file[pattern] into a PCollection.
+    lines = p | 'Read' >> ReadFromText(known_args.input) \
+            | beam.Filter(lambda line: line != "")
+
+    # Write the output using a "Write" transform that has side effects.
+    # pylint: disable=expression-not-assigned
+    output = lines | 'Write' >> WriteToText(known_args.output)
+
+
+    result = p.run()
+    result.wait_until_finish()
+
 
+if __name__ == '__main__':
+    logging.getLogger().setLevel(logging.INFO)
+    main()
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index 83b42a7167b7..8c9c0dcb82f7 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -19,4 +19,4 @@
 
 id: setting-pipeline
 name: Pipeline setting concepts
-taskName: HelloBeam
\ No newline at end of file
+taskName: setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
new file mode 100644
index 000000000000..f428cbe9cc3a
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
@@ -0,0 +1,13 @@
+### Overview
+
+Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
+
+### Direct runner
+The Direct Runner executes pipelines on your machine and is designed to validate that pipelines adhere to the Apache Beam model as closely as possible. Instead of focusing on efficient pipeline execution, the Direct Runner performs additional checks to ensure that users do not rely on semantics that are not guaranteed by the model. Some of these checks include:
+
+* enforcing immutability of elements
+* enforcing encodability of elements
+* elements are processed in an arbitrary order at all points
+* serialization of user functions (DoFn, CombineFn, etc.)
+
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/unit-info.yaml
new file mode 100644
index 000000000000..c1637f5fb6b7
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: runner-concepts
+name: Runners
\ No newline at end of file

From 12fe2f329e641214d9f3af575f8d3d2ac19f418e Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Fri, 9 Sep 2022 14:53:03 +0200
Subject: [PATCH 15/31] fixing java examples

---
 .../reading-from-csv/example/CSVExample.java                  | 4 +---
 .../pipeline-concepts/setting-pipeline/example/Task.java      | 1 +
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
index 7bf88495c5c8..3337dff7050e 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
@@ -24,8 +24,6 @@
 //   categories:
 //     - Quickstart
 
-package org.apache.beam.examples;
-
 import java.util.Arrays;
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.io.TextIO;
@@ -51,7 +49,7 @@
 
 public class Task {
 
-    private static final Logger LOG = LoggerFactory.getLogger(DataFromFile.class);
+    private static final Logger LOG = LoggerFactory.getLogger(Task.class);
 
 
     public static void main(String[] args) {
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
index f92a789d6cef..a5a824e1a54f 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
@@ -20,6 +20,7 @@
 //   name: setting-pipeline
 //   description: Setting pipeline example.
 //   multifile: false
+//   pipeline_options: --output output.txt
 //   context_line: 33
 //   categories:
 //     - Quickstart

From 89f74ad55fa3e6da0a9fb1e81925f3fa9b0fd8c7 Mon Sep 17 00:00:00 2001
From: Abzal Tuganbay <abzal.tugan@gmail.com>
Date: Mon, 12 Sep 2022 18:36:57 +0600
Subject: [PATCH 16/31] add licence for runner unit

---
 .../runner-concepts/description.md                | 15 ++++++++++++++-
 .../runner-concepts/description.md                | 13 +++++++++++++
 .../runner-concepts/description.md                | 15 ++++++++++++++-
 3 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
index f428cbe9cc3a..051a13c116c2 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
@@ -1,3 +1,16 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
 ### Overview
 
 Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
@@ -10,4 +23,4 @@ The Direct Runner executes pipelines on your machine and is designed to validate
 * elements are processed in an arbitrary order at all points
 * serialization of user functions (DoFn, CombineFn, etc.)
 
-Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
index 8d908079feba..bbb875bdc30f 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
@@ -1,3 +1,16 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
 ### Overview
 
 Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
index f428cbe9cc3a..051a13c116c2 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
@@ -1,3 +1,16 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
 ### Overview
 
 Apache Beam provides a portable API layer for building sophisticated data-parallel processing `pipelines` that may be executed across a diversity of execution engines, or `runners`. The core concepts of this layer are based upon the Beam Model (formerly referred to as the Dataflow Model), and implemented to varying degrees in each Beam `runner`.
@@ -10,4 +23,4 @@ The Direct Runner executes pipelines on your machine and is designed to validate
 * elements are processed in an arbitrary order at all points
 * serialization of user functions (DoFn, CombineFn, etc.)
 
-Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
\ No newline at end of file

From 53d6cec9e893a8a3163f9affedc3b3d2d0a3fae4 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Tue, 13 Sep 2022 13:44:37 +0200
Subject: [PATCH 17/31] some minor fixes for unit names

---
 .../pipeline-concepts/creating-pipeline/unit-info.yaml          | 2 +-
 .../go/introduction/introduction-guide/description.md           | 2 +-
 .../pipeline-concepts/creating-pipeline/unit-info.yaml          | 2 +-
 .../java/introduction/introduction-guide/description.md         | 2 +-
 .../pipeline-concepts/creating-pipeline/description.md          | 2 +-
 .../pipeline-concepts/creating-pipeline/unit-info.yaml          | 2 +-
 .../python/introduction/introduction-guide/description.md       | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
index dc58d75e3af2..f3c47a5fe1ed 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -18,5 +18,5 @@
 #
 
 id: creating-pipeline
-name: Pipeline creating concepts
+name: Creating pipelines
 taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
index 91eb996d19b3..23cd0aa7a4cd 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -17,6 +17,6 @@ Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
-The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
+Learning units are accompanied by examples that you can review in the right pane, and run by clicking ‘Run’ button to see the output.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
 Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
index dc58d75e3af2..f3c47a5fe1ed 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -18,5 +18,5 @@
 #
 
 id: creating-pipeline
-name: Pipeline creating concepts
+name: Creating pipelines
 taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
index 91eb996d19b3..23cd0aa7a4cd 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
@@ -17,6 +17,6 @@ Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
-The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
+Learning units are accompanied by examples that you can review in the right pane, and run by clicking ‘Run’ button to see the output.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
 Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index e1de290dd676..42e8a22c5b2c 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -31,7 +31,7 @@ A typical Beam driver program works as follows:
 
 &#8594; Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
 
-&#8594; **Apply** PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+&#8594; Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
 
 &#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
index dc58d75e3af2..f3c47a5fe1ed 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/unit-info.yaml
@@ -18,5 +18,5 @@
 #
 
 id: creating-pipeline
-name: Pipeline creating concepts
+name: Creating pipelines
 taskName: creating-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
index 91eb996d19b3..23cd0aa7a4cd 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
@@ -17,6 +17,6 @@ Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
-The tour is Beam Introduction learning module contains an example that you can review in the right pane, run and see the output by clicking ‘Run’.
+Learning units are accompanied by examples that you can review in the right pane, and run by clicking ‘Run’ button to see the output.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
 Now let’s start the tour with learning core Beam principles.
\ No newline at end of file

From 0cef6f598882fb5920d6007f1857ce27682dc247 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Tue, 13 Sep 2022 15:58:38 +0200
Subject: [PATCH 18/31] fixed unit name

---
 .../pipeline-concepts/setting-pipeline/unit-info.yaml           | 2 +-
 .../pipeline-concepts/setting-pipeline/unit-info.yaml           | 2 +-
 .../pipeline-concepts/setting-pipeline/unit-info.yaml           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index 8c9c0dcb82f7..1e5073ce8dd6 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -18,5 +18,5 @@
 #
 
 id: setting-pipeline
-name: Pipeline setting concepts
+name: Configuring pipeline options
 taskName: setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index 8c9c0dcb82f7..1e5073ce8dd6 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -18,5 +18,5 @@
 #
 
 id: setting-pipeline
-name: Pipeline setting concepts
+name: Configuring pipeline options
 taskName: setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
index 8c9c0dcb82f7..1e5073ce8dd6 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/unit-info.yaml
@@ -18,5 +18,5 @@
 #
 
 id: setting-pipeline
-name: Pipeline setting concepts
+name: Configuring pipeline options
 taskName: setting-pipeline
\ No newline at end of file

From 0e411cff4355bd20d85ce879f6a25db4dd7cbcea Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Wed, 14 Sep 2022 17:20:31 +0300
Subject: [PATCH 19/31] resolving CR comments

---
 .../example/{pardoExample.go => from_memory.go}        |  0
 .../reading-from-csv/description.md                    | 10 +++++++++-
 .../go/introduction/introduction-guide/description.md  |  2 +-
 .../example/{ParDoExample.java => from_memory.java}    |  0
 .../reading-from-csv/description.md                    | 10 +++++++++-
 .../introduction/introduction-guide/description.md     |  2 +-
 .../example/{pardoExample.py => from_memory.py}        |  0
 .../reading-from-csv/description.md                    |  9 ++++++++-
 .../introduction/introduction-guide/description.md     |  2 +-
 9 files changed, 29 insertions(+), 6 deletions(-)
 rename learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/{pardoExample.go => from_memory.go} (100%)
 rename learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/{ParDoExample.java => from_memory.java} (100%)
 rename learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/{pardoExample.py => from_memory.py} (100%)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
similarity index 100%
rename from learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.go
rename to learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index 5f1441d34132..eaac324596f3 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -18,4 +18,12 @@ Data processing pipelines often work with tabular data. In many examples and cha
 
 Loading data from csv file requires some processing and consists of two main part:
 * Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format
\ No newline at end of file
+* Parsing lines of text into tabular format
+
+Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
+
+Here is a list of fields and a sample record from this dataset:
+
+`VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
+
+`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
index 23cd0aa7a4cd..392c78347302 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -13,7 +13,7 @@ limitations under the License.
 -->
 # Tour of Beam Programming Guide
 
-Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the Apache Beam.
+Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
similarity index 100%
rename from learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/ParDoExample.java
rename to learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index 5f1441d34132..eaac324596f3 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -18,4 +18,12 @@ Data processing pipelines often work with tabular data. In many examples and cha
 
 Loading data from csv file requires some processing and consists of two main part:
 * Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format
\ No newline at end of file
+* Parsing lines of text into tabular format
+
+Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
+
+Here is a list of fields and a sample record from this dataset:
+
+`VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
+
+`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
index 23cd0aa7a4cd..392c78347302 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
@@ -13,7 +13,7 @@ limitations under the License.
 -->
 # Tour of Beam Programming Guide
 
-Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the Apache Beam.
+Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
similarity index 100%
rename from learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/pardoExample.py
rename to learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index bdd8a04d1a20..3adc3105bf2a 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -17,4 +17,11 @@ Data processing pipelines often work with tabular data. In many examples and cha
 
 Loading data from csv file requires some processing and consists of two main part:
 * Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format
\ No newline at end of file
+* Parsing lines of text into tabular format
+
+Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
+Here is a list of fields and a sample record from this dataset:
+
+`VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
+
+`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
index 23cd0aa7a4cd..392c78347302 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
@@ -13,7 +13,7 @@ limitations under the License.
 -->
 # Tour of Beam Programming Guide
 
-Welcome to a Tour Of Beam, a learning guide you can use to get familiar with the Apache Beam.
+Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.

From a94cc398e0b7eccd46abdbbf75a366b12019af2e Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Tue, 27 Sep 2022 17:15:13 +0300
Subject: [PATCH 20/31] adding complexity to examples

---
 .../creating-collections/from-memory/example/from_memory.go      | 1 +
 .../creating-collections/reading-from-csv/example/csvExample.go  | 1 +
 .../creating-collections/reading-from-text/example/textIo.go     | 1 +
 .../pipeline-concepts/creating-pipeline/example/main.go          | 1 +
 .../pipeline-concepts/setting-pipeline/example/main.go           | 1 +
 .../creating-collections/from-memory/example/from_memory.java    | 1 +
 .../reading-from-csv/example/CSVExample.java                     | 1 +
 .../reading-from-text/example/TextIOExample.java                 | 1 +
 .../pipeline-concepts/creating-pipeline/example/Task.java        | 1 +
 .../pipeline-concepts/setting-pipeline/example/Task.java         | 1 +
 .../creating-collections/from-memory/example/from_memory.py      | 1 +
 .../creating-collections/reading-from-csv/example/csvExample.py  | 1 +
 .../creating-collections/reading-from-text/example/textIo.py     | 1 +
 .../pipeline-concepts/creating-pipeline/example/task.py          | 1 +
 .../pipeline-concepts/setting-pipeline/example/task.py           | 1 +
 15 files changed, 15 insertions(+)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
index 9b23282956e6..7e9bbb9af058 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
@@ -20,6 +20,7 @@
 //   context_line: 32
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
index 58ef024804cd..c363c47afef6 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
@@ -23,6 +23,7 @@
 //   context_line: 44
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
index 1ab414ac6fc1..a5ccd0573870 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
@@ -22,6 +22,7 @@
 //   context_line: 46
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
index 06cae5d7386f..5fae34a5c51e 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
@@ -20,6 +20,7 @@
 //   context_line: 34
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index 62f7502e018f..52b2448410ff 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -21,6 +21,7 @@
 //   pipeline_options: --output output.txt
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
index 590bdd5000ba..8d162b66889c 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
@@ -23,6 +23,7 @@
 //   context_line: 36
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.options.PipelineOptions;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
index 3337dff7050e..e79578c6b655 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
@@ -23,6 +23,7 @@
 //   context_line: 50
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 import java.util.Arrays;
 import org.apache.beam.sdk.Pipeline;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
index 38fbf1d8fdfa..d55d86757d5a 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
@@ -22,6 +22,7 @@
 //   context_line: 36
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 package org.apache.beam.examples;
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
index 5c17b30fb9d9..f1948460b9c6 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
@@ -23,6 +23,7 @@
 //   context_line: 33
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.options.PipelineOptions;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
index a5a824e1a54f..066ba1ed6a43 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
@@ -24,6 +24,7 @@
 //   context_line: 33
 //   categories:
 //     - Quickstart
+//   complexity: BASIC
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.io.TextIO;
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
index 99ef70df3b96..656a2e3631a8 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
@@ -21,6 +21,7 @@
 #   context_line: 48
 #   categories:
 #     - Quickstart
+#   complexity: BASIC
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
index c8ce9323682d..67a5ec737602 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
@@ -21,6 +21,7 @@
 #   context_line: 43
 #   categories:
 #     - Quickstart
+#   complexity: BASIC
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
index 82379ab15542..e11ae202256c 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
@@ -21,6 +21,7 @@
 #   context_line: 43
 #   categories:
 #     - Quickstart
+#   complexity: BASIC
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
index c56320f3a249..52761c072633 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
@@ -21,6 +21,7 @@
 #   context_line: 35
 #   categories:
 #     - Quickstart
+#   complexity: BASIC
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
index 151a8e86e7c5..a2c71e4b9e86 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -22,6 +22,7 @@
 #   categories:
 #     - Quickstart
 #   context_line: 47
+#   complexity: BASIC
 
 import argparse
 import logging

From 5554db4b280bae4f35ff785b03c15aabee039cb2 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Tue, 27 Sep 2022 17:19:49 +0300
Subject: [PATCH 21/31] adding tags

---
 .../creating-collections/from-memory/example/from_memory.go     | 2 ++
 .../creating-collections/reading-from-csv/example/csvExample.go | 2 ++
 .../creating-collections/reading-from-text/example/textIo.go    | 2 ++
 .../pipeline-concepts/creating-pipeline/example/main.go         | 2 ++
 .../pipeline-concepts/setting-pipeline/example/main.go          | 2 ++
 .../creating-collections/from-memory/example/from_memory.java   | 2 ++
 .../reading-from-csv/example/CSVExample.java                    | 2 ++
 .../reading-from-text/example/TextIOExample.java                | 2 ++
 .../pipeline-concepts/creating-pipeline/example/Task.java       | 2 ++
 .../pipeline-concepts/setting-pipeline/example/Task.java        | 2 ++
 .../creating-collections/from-memory/example/from_memory.py     | 2 ++
 .../creating-collections/reading-from-csv/example/csvExample.py | 2 ++
 .../creating-collections/reading-from-text/example/textIo.py    | 2 ++
 .../pipeline-concepts/creating-pipeline/example/task.py         | 2 ++
 .../pipeline-concepts/setting-pipeline/example/task.py          | 2 ++
 15 files changed, 30 insertions(+)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
index 7e9bbb9af058..0ac897d93120 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
@@ -21,6 +21,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
index c363c47afef6..74902477ba93 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
@@ -24,6 +24,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
index a5ccd0573870..c68440511037 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
@@ -23,6 +23,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
index 5fae34a5c51e..05e8e0af767b 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/main.go
@@ -21,6 +21,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index 52b2448410ff..576674b5671c 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -22,6 +22,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 package main
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
index 8d162b66889c..9ee6ea7d8e1f 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.java
@@ -24,6 +24,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.options.PipelineOptions;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
index e79578c6b655..ed2e44f8ebc1 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/example/CSVExample.java
@@ -24,6 +24,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 import java.util.Arrays;
 import org.apache.beam.sdk.Pipeline;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
index d55d86757d5a..9e64b27339bf 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/example/TextIOExample.java
@@ -23,6 +23,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 package org.apache.beam.examples;
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
index f1948460b9c6..ae7872e46463 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
@@ -24,6 +24,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.options.PipelineOptions;
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
index 066ba1ed6a43..585d53b0b80b 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/Task.java
@@ -25,6 +25,8 @@
 //   categories:
 //     - Quickstart
 //   complexity: BASIC
+//   tags:
+//     - hellobeam
 
 import org.apache.beam.sdk.Pipeline;
 import org.apache.beam.sdk.io.TextIO;
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
index 656a2e3631a8..bf5fa2a4138e 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
@@ -22,6 +22,8 @@
 #   categories:
 #     - Quickstart
 #   complexity: BASIC
+#   tags:
+#     - hellobeam
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
index 67a5ec737602..74383b46219b 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
@@ -22,6 +22,8 @@
 #   categories:
 #     - Quickstart
 #   complexity: BASIC
+#   tags:
+#     - hellobeam
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
index e11ae202256c..c7826695fc2e 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
@@ -22,6 +22,8 @@
 #   categories:
 #     - Quickstart
 #   complexity: BASIC
+#   tags:
+#     - hellobeam
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
index 52761c072633..f090fc8968c0 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/task.py
@@ -22,6 +22,8 @@
 #   categories:
 #     - Quickstart
 #   complexity: BASIC
+#   tags:
+#     - hellobeam
 
 import apache_beam as beam
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
index a2c71e4b9e86..51d1ea0a65a6 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -23,6 +23,8 @@
 #     - Quickstart
 #   context_line: 47
 #   complexity: BASIC
+#   tags:
+#     - hellobeam
 
 import argparse
 import logging

From 6e1f374a6a9d9b5704e816f89db33d4808e77675 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Wed, 28 Sep 2022 12:02:48 +0300
Subject: [PATCH 22/31] fixed go example compilation

---
 .../pipeline-concepts/setting-pipeline/example/main.go          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index 576674b5671c..1682149f707d 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -30,9 +30,9 @@ package main
 import (
   "context"
   "flag"
-  "log"
   "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
   "github.com/apache/beam/sdks/v2/go/pkg/beam"
+  "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
   "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
 )
 

From 5ff346a53685659d1b20b87f690bbbefe837e9a6 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Wed, 28 Sep 2022 12:59:05 +0300
Subject: [PATCH 23/31] fixed python example with duplicate transform

---
 .../from-memory/example/from_memory.py                   | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
index bf5fa2a4138e..89867d312499 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
@@ -44,9 +44,10 @@ def __init__(self, label=None,prefix=''):
     def expand(self, input):
         input | beam.ParDo(self._OutputFn(self.prefix))
 
-with beam.Pipeline() as p:
-  (p | beam.Create(['Hello Beam','It`s introdction'])
+with beam.Pipeline() as p1:
+  (p1 | beam.Create(['Hello Beam','It`s introduction'])
      | 'Log words' >> Output())
-
-  (p | beam.Create(range(1, 11))
+     
+with beam.Pipeline() as p2:
+  (p2 | beam.Create(range(1, 11))
    | 'Log numbers' >> Output())
\ No newline at end of file

From 4478c7ae841adff3b4be400e3664823c2a51a867 Mon Sep 17 00:00:00 2001
From: abzal <abzal.tugan@gmail.com>
Date: Wed, 28 Sep 2022 16:14:53 +0600
Subject: [PATCH 24/31] change indent python

---
 .../reading-from-csv/example/csvExample.py                  | 2 +-
 .../reading-from-text/example/textIo.py                     | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
index 74383b46219b..39588138b360 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
@@ -58,7 +58,7 @@ def tryParseTaxiRideCost(line,index):
         yield 0.0
 
 with beam.Pipeline() as p:
-    lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv') \
+  lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv') \
             | beam.ParDo(ExtractTaxiRideCostFn()) \
             | beam.combiners.Sample.FixedSizeGlobally(10) \
             | beam.FlatMap(lambda cost: cost) \
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
index c7826695fc2e..6be2fc806892 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
@@ -46,14 +46,14 @@ def expand(self, input):
 
 
 with beam.Pipeline() as p:
-    lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
+  lines = p | 'Log lines' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
             | beam.Filter(lambda line: line != "")
 
-    lines | 'Log fixed lines' >> beam.combiners.Sample.FixedSizeGlobally(10) \
+  lines | 'Log fixed lines' >> beam.combiners.Sample.FixedSizeGlobally(10) \
     | beam.FlatMap(lambda sentence: sentence) \
     | Output(prefix = 'Fixed first 10 lines: ')
 
-    words = p | 'Log words' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
+  words = p | 'Log words' >> beam.io.ReadFromText('gs://apache-beam-samples/shakespeare/kinglear.txt') \
             | beam.FlatMap(lambda sentence: sentence.split()) \
             | beam.Filter(lambda word: not word.isspace() or word.isalnum()) \
             | beam.combiners.Sample.FixedSizeGlobally(10) \

From 6debbed212031a5575e91694b63824511d93081e Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Wed, 28 Sep 2022 13:49:55 +0300
Subject: [PATCH 25/31] fixing missing pipeline options

---
 .../pipeline-concepts/setting-pipeline/example/task.py           | 1 +
 1 file changed, 1 insertion(+)

diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
index 51d1ea0a65a6..a54067976263 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -19,6 +19,7 @@
 #   description: Setting pipeline example.
 #   multifile: false
 #   context_line: 35
+#   pipeline_options: --output output.txt
 #   categories:
 #     - Quickstart
 #   context_line: 47

From 7e929cf509a2398e2e8d91a42ff66f3ec4b15435 Mon Sep 17 00:00:00 2001
From: sirenbyte <abzal.tugan@gmail.com>
Date: Mon, 17 Oct 2022 15:48:43 +0600
Subject: [PATCH 26/31] change arrow symbol

---
 .../from-memory/description.md                |  4 ++--
 .../reading-from-text/description.md          | 24 +++++++++----------
 .../creating-pipeline/description.md          | 20 ++++++++--------
 .../from-memory/description.md                |  4 ++--
 .../creating-pipeline/description.md          | 20 ++++++++--------
 .../from-memory/description.md                |  4 ++--
 .../creating-pipeline/description.md          | 18 +++++++-------
 7 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 2c24e2900b55..398c3f8b3afa 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -17,9 +17,9 @@ Now that you know how to create a Beam pipeline and pass parameters into it, it
 
 There are several options on how to do that:
 
-&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
 
-&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
 
 Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index 7fdc74f4669f..ee6f89ce1996 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -23,27 +23,27 @@ To use Beam, you first need to first create a driver program using the classes i
 
 The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
 
-&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
 
-&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
 
-&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
 
-&#8594; `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
+→ `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
 
-&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
 
 A typical Beam driver program works as follows:
 
-&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
 
-&#8594; Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
+→ Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
 
-&#8594; Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+→ Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
 
-&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
 
-&#8594; Run the pipeline using the designated Pipeline Runner.
+→ Run the pipeline using the designated Pipeline Runner.
 
 When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
 
@@ -111,9 +111,9 @@ Now that you know how to create a Beam pipeline and pass parameters into it, it
 
 There are several options on how to do that:
 
-&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
 
-&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
 
 Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
 
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index a2190d9faa56..9d04a2f88f47 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -18,27 +18,27 @@ To use Beam, you first need to first create a driver program using the classes i
 
 The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
 
-&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
 
-&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
 
-&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
 
-&#8594; `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
+→ `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
 
-&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
 
 A typical Beam driver program works as follows:
 
-&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
 
-&#8594; Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
+→ Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
 
-&#8594; Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+→ Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
 
-&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
 
-&#8594; Run the pipeline using the designated Pipeline Runner.
+→ Run the pipeline using the designated Pipeline Runner.
 
 When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 9a86f59de850..0e672b84e395 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -17,9 +17,9 @@ Now that you know how to create a Beam pipeline and pass parameters into it, it
 
 There are several options on how to do that:
 
-&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
 
-&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
 
 Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index ef8f1be51f0c..cc7945726206 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -17,27 +17,27 @@ To use Beam, you need to first create a driver program using the classes in one
 
 The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
 
-&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
 
-&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
 
-&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
 
-&#8594; `Scope`: The Go SDK has an explicit scope variable used to build a Pipeline. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is passed to PTransform functions to place them in the Pipeline that owns the Scope.
+→ `Scope`: The Go SDK has an explicit scope variable used to build a Pipeline. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is passed to PTransform functions to place them in the Pipeline that owns the Scope.
 
-&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
 
 A typical Beam driver program works as follows:
 
-&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
 
-&#8594; Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
 
-&#8594; Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
 
-&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
 
-&#8594; Run the pipeline using the designated Pipeline Runner.
+→ Run the pipeline using the designated Pipeline Runner.
 
 When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 2f194c554580..aa192b723126 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -17,9 +17,9 @@ Now that you know how to create a Beam pipeline and pass parameters into it, it
 
 There are several options on how to do that:
 
-&#8594; You can create a PCollection of data stored in an in-memory collection class in your driver program.
+→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
 
-&#8594; You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
 
 Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index 42e8a22c5b2c..66e36477409d 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -17,25 +17,25 @@ To use Beam, you need to first create a driver program using the classes in one
 
 The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
 
-&#8594; `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
 
-&#8594; `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
 
-&#8594; `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
 
-&#8594; `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
 
 A typical Beam driver program works as follows:
 
-&#8594; Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
 
-&#8594; Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
 
-&#8594; Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
 
-&#8594; Use IOs to write the final, transformed PCollection(s) to an external source.
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
 
-&#8594; Run the pipeline using the designated Pipeline Runner.
+→ Run the pipeline using the designated Pipeline Runner.
 
 When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects that you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
 

From 934b2051248fdd67d9d8555a3720b4c5cb39199b Mon Sep 17 00:00:00 2001
From: sirenbyte <abzal.tugan@gmail.com>
Date: Mon, 24 Oct 2022 21:44:16 +0600
Subject: [PATCH 27/31] delete example prefix

---
 .../creating-collections/from-memory/example/from_memory.py     | 2 +-
 .../creating-collections/reading-from-csv/example/csvExample.py | 2 +-
 .../creating-collections/reading-from-text/example/textIo.py    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
index 89867d312499..626a765ba2ea 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.py
@@ -15,7 +15,7 @@
 #   limitations under the License.
 
 # beam-playground:
-#   name: pardo-example
+#   name: ParDo
 #   description: ParDo example.
 #   multifile: false
 #   context_line: 48
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
index 39588138b360..936215b21e89 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.py
@@ -15,7 +15,7 @@
 #   limitations under the License.
 
 # beam-playground:
-#   name: csv-example
+#   name: CSV
 #   description: Csv file example.
 #   multifile: false
 #   context_line: 43
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
index 6be2fc806892..555c1193a0bb 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.py
@@ -15,7 +15,7 @@
 #   limitations under the License.
 
 # beam-playground:
-#   name: textIO-example
+#   name: TextIO
 #   description: TextIO example.
 #   multifile: false
 #   context_line: 43

From f8e9e038eecabd1527ba1da73a9e4771f061d6c6 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Wed, 26 Oct 2022 00:15:29 +0300
Subject: [PATCH 28/31] minor formatting and readability fixes

---
 .../from-memory/description.md                |   8 +-
 .../from-memory/example/from_memory.go        |   6 +-
 .../reading-from-csv/example/csvExample.go    |  54 +++----
 .../reading-from-text/description.md          | 140 +-----------------
 .../reading-from-text/example/textIo.go       |  66 ++++-----
 .../creating-pipeline/description.md          |  31 ----
 .../pipeline-concepts/group-info.yaml         |   1 +
 .../overview-pipeline/description.md          |  43 ++++++
 .../overview-pipeline/unit-info.yaml          |  21 +++
 .../setting-pipeline/description.md           |   8 +-
 .../setting-pipeline/example/main.go          |   4 +-
 .../creating-pipeline/description.md          |  30 ----
 .../pipeline-concepts/group-info.yaml         |   1 +
 .../overview-pipeline/description.md          |  42 ++++++
 .../overview-pipeline/unit-info.yaml          |  21 +++
 .../creating-pipeline/description.md          |  28 ----
 .../pipeline-concepts/group-info.yaml         |   1 +
 .../overview-pipeline/description.md          |  40 +++++
 .../overview-pipeline/unit-info.yaml          |  21 +++
 19 files changed, 266 insertions(+), 300 deletions(-)
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
 create mode 100644 learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
 create mode 100644 learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
 create mode 100644 learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 398c3f8b3afa..f4ca299d3e75 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -33,16 +33,16 @@ The following example code shows how to do this:
 
 ```
 func main() {
-	ctx := context.Background()
+    ctx := context.Background()
 
     // First create pipline
-	p, s := beam.NewPipelineWithRoot()
+    p, s := beam.NewPipelineWithRoot()
 
     //Now create the PCollection using list of strings
-	numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+    numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
 
     //Create a numerical PCollection
-	numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+    numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 
 }
 ```
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
index 0ac897d93120..ef8cccb3bc19 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/example/from_memory.go
@@ -48,7 +48,7 @@ func main() {
 }
 
 func output(s beam.Scope, input beam.PCollection) {
-	 beam.ParDo0(s, func(element interface{}) {
-			fmt.Println(element)
-		}, input)
+  beam.ParDo0(s, func(element interface{}) {
+    fmt.Println(element)
+    }, input)
 }
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
index 74902477ba93..eeaedbb1ec51 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/example/csvExample.go
@@ -30,14 +30,14 @@
 package main
 
 import (
-	"context"
-	"fmt"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/log"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
-	"strconv"
-	"strings"
+    "context"
+    "fmt"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+    "strconv"
+    "strings"
     "github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/top"
 
 )
@@ -47,43 +47,43 @@ func less(a, b float64) bool{
 }
 
 func main() {
-	p, s := beam.NewPipelineWithRoot()
+    p, s := beam.NewPipelineWithRoot()
 
-	file := Read(s, "gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv")
+    file := Read(s, "gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv")
 
-	cost := applyTransform(s, file)
+    cost := applyTransform(s, file)
 
-	fixedSizeElements := top.Largest(s,cost,10,less)
+    fixedSizeElements := top.Largest(s,cost,10,less)
 
-	output(s, "Total cost: ", fixedSizeElements)
+    output(s, "Total cost: ", fixedSizeElements)
 
-	err := beamx.Run(context.Background(), p)
-	if err != nil {
-		log.Exitf(context.Background(), "Failed to execute job: %v", err)
+    err := beamx.Run(context.Background(), p)
+    if err != nil {
+        log.Exitf(context.Background(), "Failed to execute job: %v", err)
 	}
 }
 
 // Read reads from fiename(s) specified by a glob string and a returns a PCollection<string>.
 func Read(s beam.Scope, glob string) beam.PCollection {
-	return textio.Read(s, glob)
+    return textio.Read(s, glob)
 }
 
 // ApplyTransform converts to uppercase all elements in a PCollection<string>.
 func applyTransform(s beam.Scope, input beam.PCollection) beam.PCollection {
-	return beam.ParDo(s, func(line string) float64 {
-		taxi := strings.Split(strings.TrimSpace(line), ",")
-		if len(taxi) > 16 {
-			cost, _ := strconv.ParseFloat(taxi[16],64)
-			return cost
-		}
-		return 0.0
-	}, input)
+    return beam.ParDo(s, func(line string) float64 {
+        taxi := strings.Split(strings.TrimSpace(line), ",")
+        if len(taxi) > 16 {
+            cost, _ := strconv.ParseFloat(taxi[16],64)
+            return cost
+        }
+        return 0.0
+    }, input)
 }
 
 func output(s beam.Scope, prefix string, input beam.PCollection) {
-	beam.ParDo0(s, func(elements []float64) {
+    beam.ParDo0(s, func(elements []float64) {
         for _, element := range elements {
         fmt.Println(prefix,element)
         }
-	}, input)
+    }, input)
 }
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index ee6f89ce1996..a90c79443839 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -11,142 +11,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-# Tour of Beam Programming Guide
-
-The Beam Programming Guide is intended for Beam users who want to use the Beam SDKs to create data processing pipelines. This guide provides guidance for using the Beam SDK classes to build and test pipelines. The programming guide is not intended to be an exhaustive reference, but rather a language-agnostic, high-level guide to programmatically building your Beam pipeline. As the programming guide is filled out, the text will include code samples in multiple languages to help illustrate how to implement Beam concepts in your pipelines.
-
-For a brief introduction to Beam’s basic concepts,take a look at the Basics of the Beam model page before reading the programming guide.
-
-### Overview
-
-To use Beam, you first need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs. It also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
-
-The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
-
-→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
-
-→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
-
-→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
-
-→ `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
-
-→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
-
-A typical Beam driver program works as follows:
-
-→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
-
-→ Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
-
-→ Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
-
-→ Use IOs to write the final, transformed PCollection(s) to an external source.
-
-→ Run the pipeline using the designated Pipeline Runner.
-
-When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
-
-### Creating a pipeline
-
-The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then using that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
-
-To use Beam, your driver program must first create an instance of the Beam SDK class Pipeline (typically in the main() function). When you create your `Pipeline`, you’ll also need to set some configuration options. You can set your pipeline’s configuration options programmatically, but it’s often easier to set the options ahead of time (or read them from the command line) and pass them to the Pipeline object when you create the object.
-
-```
-// beam.Init() is an initialization hook that must be called
-// near the beginning of main(), before creating a pipeline.
-beam.Init()
-
-// Create the Pipeline object and root scope.
-pipeline, scope := beam.NewPipelineWithRoot()
-```
-
-### Configuring pipeline options
-
-Use the pipeline options to configure different aspects of your pipeline, such as the pipeline runner that will execute your pipeline and any runner-specific configuration required by the chosen runner. Your pipeline options will potentially include information such as your project ID or a location for storing files.
-
-### Setting PipelineOptions from command-line arguments
-
-Use Go flags to parse command line arguments to configure your pipeline. Flags must be parsed before `beam.Init()` is called.
-
-```
-// If beamx or Go flags are used, flags must be parsed first,
-// before beam.Init() is called.
-flag.Parse()
-```
-
-This interprets command-line arguments this follow the format:
-
-```
---<option>=<value>
-```
-
-### Creating custom options
-
-You can add your own custom options in addition to the standard `PipelineOptions`.
-
-The following example shows how to add `input` and `output` custom options:
-
-```
-// Use standard Go flags to define pipeline options.
-var (
-	input  = flag.String("input", "", "")
-	output = flag.String("output", "", "")
-)
-```
-
-You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
-
-```
-var (
-	input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
-	output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
-)
-```
-
-### Creating PCollection
-
-Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
-
-There are several options on how to do that:
-
-→ You can create a PCollection of data stored in an in-memory collection class in your driver program.
-
-→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
-
-Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
-
-We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
-
-### Creating a PCollection from in-memory data
-
-You can use the Beam-provided Create transform to create a `PCollection` from an in-memory Go Collection. You can apply Create transform directly to your Pipeline object itself.
-
-The following example code shows how to do this:
-
-```
-func main() {
-	ctx := context.Background()
-
-    // First create pipline
-	p, s := beam.NewPipelineWithRoot()
-
-    //Now create the PCollection using list of strings
-	numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
-
-    //Create a numerical PCollection
-	numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-
-}
-```
-
-You can find the complete code of this example in the playground window you can run and experiment with.
-
-One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
-
-Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
-
 ### Reading from text file
 
 You use one of the Beam-provided I/O adapters to read from an external source. The adapters vary in their exact usage, but all of them read from some external data source and return a `PCollection` whose elements represent the data records in that source.
@@ -157,10 +21,10 @@ Each data source adapter has a Read transform; to read, you must apply that tran
 
 ```
 func main() {
-	ctx := context.Background()
+    ctx := context.Background()
 
     // First create pipline
-	p, s := beam.NewPipelineWithRoot()
+    p, s := beam.NewPipelineWithRoot()
 
     // Now create the PCollection by reading text files. Separate elements will be added for each line in the input file
     lines :=  textio.Read(scope, 'gs://some/inputData.txt')
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
index c68440511037..a88249e6a0cb 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/example/textIo.go
@@ -29,19 +29,19 @@
 package main
 
 import (
-	"context"
-	"fmt"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/log"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/filter"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
-	"regexp"
-	"github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/top"
+    "context"
+    "fmt"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/io/textio"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/log"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/filter"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/x/beamx"
+    "regexp"
+    "github.com/apache/beam/sdks/v2/go/pkg/beam/transforms/top"
 )
 
 var (
-	wordRE = regexp.MustCompile(`[a-zA-Z]+('[a-z])?`)
+    wordRE = regexp.MustCompile(`[a-zA-Z]+('[a-z])?`)
 )
 
 func less(a, b string) bool{
@@ -49,49 +49,49 @@ func less(a, b string) bool{
 }
 
 func main() {
-	p, s := beam.NewPipelineWithRoot()
+    p, s := beam.NewPipelineWithRoot()
 
-	file := Read(s, "gs://apache-beam-samples/shakespeare/kinglear.txt")
+    file := Read(s, "gs://apache-beam-samples/shakespeare/kinglear.txt")
 
-	lines := getLines(s, file)
-	fixedSizeLines := top.Largest(s,lines,10,less)
-	output(s, "Lines: ", fixedSizeLines)
+    lines := getLines(s, file)
+    fixedSizeLines := top.Largest(s,lines,10,less)
+    output(s, "Lines: ", fixedSizeLines)
 
-	words := getWords(s,lines)
-	fixedSizeWords := top.Largest(s,words,10,less)
-	output(s, "Words: ", fixedSizeWords)
+    words := getWords(s,lines)
+    fixedSizeWords := top.Largest(s,words,10,less)
+    output(s, "Words: ", fixedSizeWords)
 
-	err := beamx.Run(context.Background(), p)
-	if err != nil {
-		log.Exitf(context.Background(), "Failed to execute job: %v", err)
-	}
+    err := beamx.Run(context.Background(), p)
+    if err != nil {
+        log.Exitf(context.Background(), "Failed to execute job: %v", err)
+    }
 }
 
 // Read reads from fiename(s) specified by a glob string and a returns a PCollection<string>.
 func Read(s beam.Scope, glob string) beam.PCollection {
-	return textio.Read(s, glob)
+    return textio.Read(s, glob)
 }
 
 // Read text file content line by line. resulting PCollection contains elements, where each element contains a single line of text from the input file.
 func getLines(s beam.Scope, input beam.PCollection) beam.PCollection {
-	return filter.Include(s, input, func(element string) bool {
-		return element != ""
-	})
+    return filter.Include(s, input, func(element string) bool {
+        return element != ""
+    })
 }
 
 // getWords read text lines and split into PCollection of words.
 func getWords(s beam.Scope, input beam.PCollection) beam.PCollection {
-	return beam.ParDo(s, func(line string, emit func(string)) {
-		for _, word := range wordRE.FindAllString(line, -1) {
-			emit(word)
-		}
-	}, input)
+    return beam.ParDo(s, func(line string, emit func(string)) {
+        for _, word := range wordRE.FindAllString(line, -1) {
+            emit(word)
+        }
+    }, input)
 }
 
 func output(s beam.Scope, prefix string, input beam.PCollection) {
-	beam.ParDo0(s, func(elements []string) {
+    beam.ParDo0(s, func(elements []string) {
         for _, element := range elements {
         fmt.Println(prefix,element)
         }
-	}, input)
+    }, input)
 }
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index 9d04a2f88f47..594ac6d38c53 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -11,37 +11,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-
-### Overview
-
-To use Beam, you first need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs. It also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
-
-The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
-
-→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
-
-→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
-
-→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
-
-→ `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
-
-→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
-
-A typical Beam driver program works as follows:
-
-→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
-
-→ Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
-
-→ Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
-
-→ Use IOs to write the final, transformed PCollection(s) to an external source.
-
-→ Run the pipeline using the designated Pipeline Runner.
-
-When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
-
 ### Creating a pipeline
 
 The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then using that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
index 29d0afece5ae..dd46ad6e61ad 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -20,5 +20,6 @@
 id: pipeline-concepts
 name: Pipeline concepts
 content:
+- overview-pipeline
 - creating-pipeline
 - setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
new file mode 100644
index 000000000000..ce5cb7f69ff9
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
@@ -0,0 +1,43 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+### Overview
+
+To use Beam, you first need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs. It also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide several abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and then produces zero or more output PCollection objects.
+
+→ `Scope`: The Go SDK has an explicit scope variable used to build a `Pipeline`. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is then passed to `PTransform` functions that place them in the `Pipeline` that owns the `Scope`.
+
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+→ Create an initial `PCollection` for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a `PCollection` from in-memory data.
+
+→ Apply `PTransforms` to each `PCollection`. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until the processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
+
+→ Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and the transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..86b85b02ca47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: overview-pipeline
+name: Pipeline overview
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
index 7f4797b933bb..dc88b9d26a6e 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -40,8 +40,8 @@ The following example shows how to add `input` and `output` custom options:
 ```
 // Use standard Go flags to define pipeline options.
 var (
-	input  = flag.String("input", "", "")
-	output = flag.String("output", "", "")
+  input  = flag.String("input", "", "")
+  output = flag.String("output", "", "")
 )
 ```
 
@@ -49,7 +49,7 @@ You can also specify a description, which appears when a user passes `--help` as
 
 ```
 var (
-	input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
-	output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
+  input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
+  output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
 )
 ```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
index 1682149f707d..bb3dba69e273 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/main.go
@@ -68,6 +68,6 @@ func main() {
   err := beamx.Run(ctx, p)
 
   if err != nil {
-  		log.Exitf(ctx, "Failed to execute job: %v", err)
-  	}
+    log.Exitf(ctx, "Failed to execute job: %v", err)
+  }
 }
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index cc7945726206..d4795372678b 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -11,36 +11,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-### Overview
-
-To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
-
-The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
-
-→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
-
-→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
-
-→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
-
-→ `Scope`: The Go SDK has an explicit scope variable used to build a Pipeline. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is passed to PTransform functions to place them in the Pipeline that owns the Scope.
-
-→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
-
-A typical Beam driver program works as follows:
-
-→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
-
-→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
-
-→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
-
-→ Use IOs to write the final, transformed PCollection(s) to an external source.
-
-→ Run the pipeline using the designated Pipeline Runner.
-
-When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
-
 ### Creating a pipeline
 
 The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a `Pipeline` object, and then using that object as the basis for creating the pipeline’s data sets as `PCollection`s and its operations as `Transforms`.
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
index 29d0afece5ae..dd46ad6e61ad 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -20,5 +20,6 @@
 id: pipeline-concepts
 name: Pipeline concepts
 content:
+- overview-pipeline
 - creating-pipeline
 - setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
new file mode 100644
index 000000000000..6aa27fdb5b47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
@@ -0,0 +1,42 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Overview
+
+To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+
+→ `Scope`: The Go SDK has an explicit scope variable used to build a Pipeline. A Pipeline can return it’s root scope with the `Root()` method. The scope variable is passed to PTransform functions to place them in the Pipeline that owns the Scope.
+
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+
+→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
+
+→ Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..86b85b02ca47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: overview-pipeline
+name: Pipeline overview
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index 66e36477409d..3c8d57368556 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -11,34 +11,6 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
-### Overview
-
-To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program then defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
-
-The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
-
-→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
-
-→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
-
-→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
-
-→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
-
-A typical Beam driver program works as follows:
-
-→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
-
-→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
-
-→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
-
-→ Use IOs to write the final, transformed PCollection(s) to an external source.
-
-→ Run the pipeline using the designated Pipeline Runner.
-
-When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects that you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
-
 ### Creating a pipeline
 
 The `Pipeline` abstraction encapsulates all the data and steps in your data processing task. Your Beam driver program typically starts by constructing a Pipeline object, and then use that object as the basis for creating the pipeline’s data sets as PCollections and its operations as `Transforms`.
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
index 29d0afece5ae..dd46ad6e61ad 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/group-info.yaml
@@ -20,5 +20,6 @@
 id: pipeline-concepts
 name: Pipeline concepts
 content:
+- overview-pipeline
 - creating-pipeline
 - setting-pipeline
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
new file mode 100644
index 000000000000..2d51021e56ff
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/description.md
@@ -0,0 +1,40 @@
+<!--
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+### Overview
+
+To use Beam, you need to first create a driver program using the classes in one of the Beam SDKs. Your driver program then defines your pipeline, including all of the inputs, transforms, and outputs; it also sets execution options for your pipeline (typically passed by using command-line options). These include the Pipeline Runner, which, in turn, determines what back-end your pipeline will run on.
+
+The Beam SDKs provide a number of abstractions that simplify the mechanics of large-scale distributed data processing. The same Beam abstractions work with both batch and streaming data sources. When you create your Beam pipeline, you can think about your data processing task in terms of these abstractions. They include:
+
+→ `Pipeline`: A Pipeline encapsulates your entire data processing task, from start to finish. This includes reading input data, transforming that data, and writing output data. All Beam driver programs must create a Pipeline. When you create the Pipeline, you must also specify the execution options that tell the Pipeline where and how to run.
+
+→ `PCollection`: A PCollection represents a distributed data set that your Beam pipeline operates on. The data set can be bounded, meaning it comes from a fixed source like a file, or unbounded, meaning it comes from a continuously updating source via a subscription or other mechanism. Your pipeline typically creates an initial PCollection by reading data from an external data source, but you can also create a PCollection from in-memory data within your driver program. From there, PCollections are the inputs and outputs for each step in your pipeline.
+
+→ `PTransform`: A PTransform represents a data processing operation, or a step, in your pipeline. Every PTransform takes one or more PCollection objects as the input, performs a processing function that you provide on the elements of that PCollection, and produces zero or more output PCollection objects.
+
+→ `I/O transforms`: Beam comes with a number of “IOs” - library PTransforms that read or write data to various external storage systems.
+
+A typical Beam driver program works as follows:
+
+→ Create a Pipeline object and set the pipeline execution options, including the Pipeline Runner.
+
+→ Create an initial PCollection for pipeline data, either using the IOs to read data from an external storage system, or using a Create transform to build a PCollection from in-memory data.
+
+→ Apply PTransforms to each PCollection. Transforms can change, filter, group, analyze, or otherwise process the elements in a PCollection. A transform creates a new output PCollection without modifying the input collection. A typical pipeline applies subsequent transforms to each new output PCollection in turn until processing is complete. However, note that a pipeline does not have to be a single straight line of transforms applied one after another: think of PCollections as variables and PTransforms as functions applied to these variables: the shape of the pipeline can be an arbitrarily complex processing graph.
+
+→ Use IOs to write the final, transformed PCollection(s) to an external source.
+
+→ Run the pipeline using the designated Pipeline Runner.
+
+When you run your Beam driver program, the Pipeline Runner that you designate constructs a workflow graph of your pipeline based on the PCollection objects that you’ve created and transforms that you’ve applied. That graph is then executed using the appropriate distributed processing back-end, becoming an asynchronous “job” (or equivalent) on that back-end.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
new file mode 100644
index 000000000000..86b85b02ca47
--- /dev/null
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/overview-pipeline/unit-info.yaml
@@ -0,0 +1,21 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+id: overview-pipeline
+name: Pipeline overview
\ No newline at end of file

From 7444a90c8e6e2a591b61936f3c29a94a0586ae36 Mon Sep 17 00:00:00 2001
From: sirenbyte <abzal.tugan@gmail.com>
Date: Fri, 28 Oct 2022 19:10:43 +0600
Subject: [PATCH 29/31] add example description

---
 .../from-memory/description.md                |   2 +
 .../reading-from-csv/description.md           |   6 +-
 .../reading-from-text/description.md          |  12 +-
 .../creating-pipeline/description.md          |   9 +
 .../setting-pipeline/description.md           |  20 +-
 .../runner-concepts/description.md            |  36 +-
 .../from-memory/description.md                |   2 +
 .../reading-from-csv/description.md           |   2 +
 .../reading-from-text/description.md          |   6 +-
 .../creating-pipeline/description.md          |  10 +
 .../creating-pipeline/example/Task.java       |   4 +-
 .../setting-pipeline/description.md           |  14 +-
 .../runner-concepts/description.md            | 373 +++++++++++++++++-
 .../from-memory/description.md                |   2 +
 .../reading-from-csv/description.md           |   6 +-
 .../reading-from-text/description.md          |   6 +-
 .../creating-pipeline/description.md          |  21 +
 .../setting-pipeline/description.md           |  16 +-
 .../setting-pipeline/example/task.py          |   2 +-
 .../runner-concepts/description.md            | 103 ++++-
 20 files changed, 621 insertions(+), 31 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
index f4ca299d3e75..76aed3cdf753 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -47,6 +47,8 @@ func main() {
 }
 ```
 
+### Playground exercise
+
 You can find the complete code of this example in the playground window you can run and experiment with.
 
 One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index eaac324596f3..70093090ae27 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -20,10 +20,14 @@ Loading data from csv file requires some processing and consists of two main par
 * Loading text lines using `TextIO.Read` transform
 * Parsing lines of text into tabular format
 
+### Playground exercise
+
 Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
 
 Here is a list of fields and a sample record from this dataset:
 
 `VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
 
-`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
\ No newline at end of file
+`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index a90c79443839..4968aa7d9528 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -32,14 +32,10 @@ func main() {
 }
 ```
 
-In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
-
-One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+### Playground exercise
 
-### Read from csv file
+In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
 
-Data processing pipelines often work with tabular data. In many examples and challenges throughout the course, you’ll be working with one of the datasets stored as csv files in either beam-examples, dataflow-samples buckets.
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `top.Largest(s,lines,10,less)` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
 
-Loading data from csv file requires some processing and consists of two main part:
-* Loading text lines using `TextIO.Read` transform
-* Parsing lines of text into tabular format
\ No newline at end of file
+Overview [file](https://storage.googleapis.com/apache-beam-samples/shakespeare/kinglear.txt)
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index 594ac6d38c53..3aa6c64978cd 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -24,4 +24,13 @@ beam.Init()
 
 // Create the Pipeline object and root scope.
 pipeline, scope := beam.NewPipelineWithRoot()
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with. And you can create a `pipeline`, `scope` separately, it is an alternative to `beam.NewPipelineWithRoot()`. It is convenient if manipulations are needed before creating an element.
+
+```
+pipeline := beam.NewPipeline()
+scope := p.Root()
 ```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
index dc88b9d26a6e..bddbd9d41faf 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -40,16 +40,24 @@ The following example shows how to add `input` and `output` custom options:
 ```
 // Use standard Go flags to define pipeline options.
 var (
-  input  = flag.String("input", "", "")
-  output = flag.String("output", "", "")
+  input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
+  output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
 )
 ```
 
-You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with.
 
+You can transfer files of other extensions. For example, a csv file with taxi order data. And after making some transformations, you can write to a new csv file:
 ```
 var (
-  input  = flag.String("input", "gs://my-bucket/input", "Input for the pipeline")
-  output = flag.String("output", "gs://my-bucket/output", "Output for the pipeline")
+  input = flag.String("input", "gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv", "File(s) to read.")
+
+  output = flag.String("output", "output.csv", "Output file (required).")
 )
-```
\ No newline at end of file
+```
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
index 051a13c116c2..9aac75bdb681 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/runner-concepts/description.md
@@ -23,4 +23,38 @@ The Direct Runner executes pipelines on your machine and is designed to validate
 * elements are processed in an arbitrary order at all points
 * serialization of user functions (DoFn, CombineFn, etc.)
 
-Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
\ No newline at end of file
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.In the SDK Go, the default is runner **DirectRunner**.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/direct/)
+
+#### Run example
+
+```
+$ go install github.com/apache/beam/sdks/v2/go/examples/wordcount
+$ wordcount --input <PATH_TO_INPUT_FILE> --output counts
+```
+
+### Google Cloud Dataflow runner
+
+The Google Cloud Dataflow uses the Cloud Dataflow managed service. When you run your pipeline with the Cloud Dataflow service, the runner uploads your executable code and dependencies to a Google Cloud Storage bucket and creates a Cloud Dataflow job, which executes your pipeline on managed resources in Google Cloud Platform. The Cloud Dataflow Runner and service are suitable for large scale, continuous jobs, and provide:
+* a fully managed service
+* autoscaling of the number of workers throughout the lifetime of the job
+* dynamic work rebalancing
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/dataflow/)
+
+#### Run example
+
+```
+$ go install github.com/apache/beam/sdks/v2/go/examples/wordcount
+# As part of the initial setup, for non linux users - install package unix before run
+$ go get -u golang.org/x/sys/unix
+$ wordcount --input gs://dataflow-samples/shakespeare/kinglear.txt \
+--output gs://<your-gcs-bucket>/counts \
+--runner dataflow \
+--project your-gcp-project \
+--region your-gcp-region \
+--temp_location gs://<your-gcs-bucket>/tmp/ \
+--staging_location gs://<your-gcs-bucket>/binaries/ \
+--worker_harness_container_image=apache/beam_go_sdk:latest
+```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 0e672b84e395..12adb349cd97 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -51,6 +51,8 @@ public static void main(String[] args) {
 }
 ```
 
+### Playground exercise
+
 You can find the complete code of this example in the playground window you can run and experiment with.
 
 One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index eaac324596f3..dfc0e8d28ad1 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -20,6 +20,8 @@ Loading data from csv file requires some processing and consists of two main par
 * Loading text lines using `TextIO.Read` transform
 * Parsing lines of text into tabular format
 
+### Playground exercise
+
 Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
 
 Here is a list of fields and a sample record from this dataset:
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index e8c088529331..5c4ff2651f71 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -33,6 +33,10 @@ public static void main(String[] args) {
 }
 ```
 
+### Playground exercise
+
 In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
 
-One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
\ No newline at end of file
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/shakespeare/kinglear.txt)
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index d4795372678b..ecaed7319d19 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -23,4 +23,14 @@ PipelineOptions options = PipelineOptionsFactory.create();
 
 // Then create the pipeline.
 Pipeline p = Pipeline.create(options);
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with.
+
+When creating pipelines when writing arguments (String args[]), you can explicitly specify runner:
+
+```
+--runner=DirectRunner
 ```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
index ae7872e46463..1606e99f271d 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/example/Task.java
@@ -44,14 +44,14 @@ public static void main(String[] args) {
         PipelineOptions options = PipelineOptionsFactory.fromArgs(args).create();
         Pipeline pipeline = Pipeline.create(options);
 
-        PCollection<String> output = setupPipeline(pipeline);
+        PCollection<String> output = createPCollection(pipeline);
 
         output.apply("Log", ParDo.of(new LogOutput<String>()));
 
         pipeline.run();
     }
 
-    static PCollection<String> setupPipeline(Pipeline pipeline) {
+    static PCollection<String> createPCollection(Pipeline pipeline) {
         return pipeline.apply(Create.of("Hello Beam"));
     }
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
index 32f8d9fe3468..bfef2587eb4c 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -54,8 +54,6 @@ public interface MyOptions extends PipelineOptions {
 }
 ```
 
-You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
-
 You set the description and default value using annotations, as follows:
 
 ```
@@ -81,4 +79,14 @@ PipelineOptionsFactory.register(MyOptions.class);
 MyOptions options = PipelineOptionsFactory.fromArgs(args)
                                                 .withValidation()
                                                 .as(MyOptions.class);
-```
\ No newline at end of file
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with. And you can transfer files of other extensions. For example, a csv file with taxi order data. And after making some transformations, you can write to a new csv file:
+
+```
+--input=gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv --output=output.csv
+```
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
index bbb875bdc30f..cd22a1f7c079 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/runner-concepts/description.md
@@ -25,7 +25,7 @@ The Direct Runner executes pipelines on your machine and is designed to validate
 
 Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
 
-### Specify your dependency
+#### Specify your dependency
 
 When using Java, you must specify your dependency on the Direct Runner in your pom.xml.
 
@@ -38,10 +38,379 @@ When using Java, you must specify your dependency on the Direct Runner in your p
 </dependency>
 ```
 
-### Set runner
+#### Set runner
 
 In java, you need to set runner to `args` when you start the program.
 
 ```
 --runner=DirectRunner
+```
+
+### Google Cloud Dataflow runner
+
+The Google Cloud Dataflow uses the Cloud Dataflow managed service. When you run your pipeline with the Cloud Dataflow service, the runner uploads your executable code and dependencies to a Google Cloud Storage bucket and creates a Cloud Dataflow job, which executes your pipeline on managed resources in Google Cloud Platform. The Cloud Dataflow Runner and service are suitable for large scale, continuous jobs, and provide:
+* a fully managed service
+* autoscaling of the number of workers throughout the lifetime of the job
+* dynamic work rebalancing
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/dataflow/)
+
+#### Run example
+
+When using Java, you must specify your dependency on the Cloud Dataflow Runner in your `pom.xml`.
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-google-cloud-dataflow-java</artifactId>
+  <version>2.42.0</version>
+  <scope>runtime</scope>
+</dependency>
+```
+
+Then, add the mainClass name in the Maven JAR plugin.
+
+```
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-jar-plugin</artifactId>
+  <version>${maven-jar-plugin.version}</version>
+  <configuration>
+    <archive>
+      <manifest>
+        <addClasspath>true</addClasspath>
+        <classpathPrefix>lib/</classpathPrefix>
+        <mainClass>YOUR_MAIN_CLASS_NAME</mainClass>
+      </manifest>
+    </archive>
+  </configuration>
+</plugin>
+```
+
+Console:
+```
+java -jar target/beam-examples-bundled-1.0.0.jar \
+  --runner=DataflowRunner \
+  --project=<YOUR_GCP_PROJECT_ID> \
+  --region=<GCP_REGION> \
+  --tempLocation=gs://<YOUR_GCS_BUCKET>/temp/
+```
+
+### Apache Flink runner
+
+The Apache Flink Runner can be used to execute Beam pipelines using Apache Flink. For execution, you can choose between a cluster execution mode (e.g. Yarn/Kubernetes/Mesos) or a local embedded execution mode which is useful for testing pipelines. The Flink Runner and Flink are suitable for large scale, continuous jobs, and provide:
+* A streaming-first runtime that supports both batch processing and data streaming programs
+* A runtime that supports very high throughput and low event latency at the same time
+* Fault-tolerance with exactly-once processing guarantees
+* Natural back-pressure in streaming programs
+* Custom memory management for efficient and robust switching between in-memory and out-of-core data processing algorithms
+* Integration with YARN and other components of the Apache Hadoop ecosystem
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/flink/)
+
+#### Run example
+
+##### Portable
+1. Starting with Beam 2.18.0, pre-built Flink Job Service Docker images are available at Docker Hub: `Flink 1.10`, `Flink 1.11`, `Flink 1.12`, `Flink 1.13`, `Flink 1.14`.
+2. Start the JobService endpoint: `docker run --net=host apache/beam_flink1.10_job_server:latest`
+3. Submit the pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService). Optionally set environment_type set to LOOPBACK. For example:
+
+```
+import apache_beam as beam
+from apache_beam.options.pipeline_options import PipelineOptions
+
+options = PipelineOptions([
+    "--runner=PortableRunner",
+    "--job_endpoint=localhost:8099",
+    "--environment_type=LOOPBACK"
+])
+with beam.Pipeline(options) as p:
+    ...
+```
+
+##### Non portable
+
+When using Java, you must specify your dependency on the Cloud Dataflow Runner in your `pom.xml`.
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-flink-1.14</artifactId>
+  <version>2.42.0</version>
+</dependency>
+```
+
+Console:
+```
+mvn exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+    -Pflink-runner \
+    -Dexec.args="--runner=FlinkRunner \
+      --inputFile=/path/to/pom.xml \
+      --output=/path/to/counts \
+      --flinkMaster=<flink master url> \
+      --filesToStage=target/word-count-beam-bundled-0.1.jar"
+```
+
+### Apache Spark runner
+
+The Apache Spark Runner can be used to execute Beam pipelines using Apache Spark. The Spark Runner can execute Spark pipelines just like a native Spark application; deploying a self-contained application for local mode, running on Spark’s Standalone RM, or using YARN or Mesos.
+
+The Spark Runner executes Beam pipelines on top of Apache Spark, providing:
+
+* Batch and streaming (and combined) pipelines.
+* The same fault-tolerance guarantees as provided by RDDs and DStreams.
+* The same security features Spark provides.
+* Built-in metrics reporting using Spark’s metrics system, which reports Beam Aggregators as well.
+* Native support for Beam side-inputs via spark’s Broadcast variables.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/spark/)
+
+#### Run example
+
+##### Non portable
+1. Start the JobService endpoint:
+    * with Docker (preferred): docker run --net=host apache/beam_spark_job_server:latest
+    * or from Beam source code: ./gradlew :runners:spark:3:job-server:runShadow
+2. Submit the Python pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService), and environment_type set to LOOPBACK. For example:
+
+Console:
+```
+mvn compile exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+     -Dexec.args="--runner=SparkRunner --inputFile=pom.xml --output=counts" -Pspark-runner
+```
+
+##### Non Portable
+
+When using Java, you must specify your dependency on the Cloud Dataflow Runner in your `pom.xml`.
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-spark-3</artifactId>
+  <version>2.42.0</version>
+</dependency>
+```
+
+And shading the application jar using the maven shade plugin:
+
+```
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-shade-plugin</artifactId>
+  <configuration>
+    <createDependencyReducedPom>false</createDependencyReducedPom>
+    <filters>
+      <filter>
+        <artifact>*:*</artifact>
+        <excludes>
+          <exclude>META-INF/*.SF</exclude>
+          <exclude>META-INF/*.DSA</exclude>
+          <exclude>META-INF/*.RSA</exclude>
+        </excludes>
+      </filter>
+    </filters>
+  </configuration>
+  <executions>
+    <execution>
+      <phase>package</phase>
+      <goals>
+        <goal>shade</goal>
+      </goals>
+      <configuration>
+        <shadedArtifactAttached>true</shadedArtifactAttached>
+        <shadedClassifierName>shaded</shadedClassifierName>
+        <transformers>
+          <transformer
+            implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+        </transformers>
+      </configuration>
+    </execution>
+  </executions>
+</plugin>
+```
+
+
+Console:
+```
+mvn compile exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+     -Dexec.args="--runner=SparkRunner --inputFile=pom.xml --output=counts" -Pspark-runner
+```
+
+### Samza runner
+
+The Apache Samza Runner can be used to execute Beam pipelines using Apache Samza. The Samza Runner executes Beam pipeline in a Samza application and can run locally. The application can further be built into a .tgz file, and deployed to a YARN cluster or Samza standalone cluster with Zookeeper.
+
+The Samza Runner and Samza are suitable for large scale, stateful streaming jobs, and provide:
+
+* First class support for local state (with RocksDB store). This allows fast state access for high frequency streaming jobs.
+* Fault-tolerance with support for incremental checkpointing of state instead of full snapshots. This enables Samza to scale to applications with very large state.
+* A fully asynchronous processing engine that makes remote calls efficient.
+* Flexible deployment model for running the applications in any hosting environment with Zookeeper.
+* Features like canaries, upgrades and rollbacks that support extremely large deployments with minimal downtime.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/samza/)
+
+#### Run example
+
+You can specify your dependency on the Samza Runner by adding the following to your `pom.xml`:
+
+```
+<dependency>
+  <groupId>org.apache.beam</groupId>
+  <artifactId>beam-runners-samza</artifactId>
+  <version>2.42.0</version>
+  <scope>runtime</scope>
+</dependency>
+
+<!-- Samza dependencies -->
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-api</artifactId>
+  <version>${samza.version}</version>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-core_2.11</artifactId>
+  <version>${samza.version}</version>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-kafka_2.11</artifactId>
+  <version>${samza.version}</version>
+  <scope>runtime</scope>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-kv_2.11</artifactId>
+  <version>${samza.version}</version>
+  <scope>runtime</scope>
+</dependency>
+
+<dependency>
+  <groupId>org.apache.samza</groupId>
+  <artifactId>samza-kv-rocksdb_2.11</artifactId>
+  <version>${samza.version}</version>
+  <scope>runtime</scope>
+</dependency>
+```
+
+Console:
+```
+$ mvn exec:java -Dexec.mainClass=org.apache.beam.examples.WordCount \
+    -Psamza-runner \
+    -Dexec.args="--runner=SamzaRunner \
+      --inputFile=/path/to/input \
+      --output=/path/to/counts"
+```
+
+### Nemo runner
+
+The Apache Nemo Runner can be used to execute Beam pipelines using Apache Nemo. The Nemo Runner can optimize Beam pipelines with the Nemo compiler through various optimization passes and execute them in a distributed fashion using the Nemo runtime. You can also deploy a self-contained application for local mode or run using resource managers like YARN or Mesos.
+
+The Nemo Runner executes Beam pipelines on top of Apache Nemo, providing:
+
+* Batch and streaming pipelines
+* Fault-tolerance
+* Integration with YARN and other components of the Apache Hadoop ecosystem
+* Support for the various optimizations provided by the Nemo optimizer
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/nemo/)
+
+#### Run example
+
+You can specify your dependency on the Samza Runner by adding the following to your `pom.xml`:
+
+```
+<dependency>
+    <groupId>org.apache.nemo</groupId>
+    <artifactId>nemo-compiler-frontend-beam</artifactId>
+    <version>${nemo.version}</version>
+</dependency>
+<dependency>
+    <groupId>org.apache.hadoop</groupId>
+    <artifactId>hadoop-common</artifactId>
+    <version>${hadoop.version}</version>
+    <exclusions>
+        <exclusion>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </exclusion>
+        <exclusion>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-log4j12</artifactId>
+        </exclusion>
+    </exclusions>
+</dependency>
+```
+
+A self-contained application might be easier to manage and allows you to fully use the functionality that Nemo provides. Simply add the dependency shown above and shade the application JAR using the Maven Shade plugin:
+
+```
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-shade-plugin</artifactId>
+  <configuration>
+    <createDependencyReducedPom>false</createDependencyReducedPom>
+    <filters>
+      <filter>
+        <artifact>*:*</artifact>
+        <excludes>
+          <exclude>META-INF/*.SF</exclude>
+          <exclude>META-INF/*.DSA</exclude>
+          <exclude>META-INF/*.RSA</exclude>
+        </excludes>
+      </filter>
+    </filters>
+  </configuration>
+  <executions>
+    <execution>
+      <phase>package</phase>
+      <goals>
+        <goal>shade</goal>
+      </goals>
+      <configuration>
+        <shadedArtifactAttached>true</shadedArtifactAttached>
+        <shadedClassifierName>shaded</shadedClassifierName>
+        <transformers>
+          <transformer
+            implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+        </transformers>
+      </configuration>
+    </execution>
+  </executions>
+</plugin>
+```
+
+Console:
+```
+$ mvn package -Pnemo-runner && java -cp target/word-count-beam-bundled-0.1.jar org.apache.beam.examples.WordCount \
+     --runner=NemoRunner --inputFile=`pwd`/pom.xml --output=counts
+```
+
+### Jet runner
+
+The Hazelcast Jet Runner can be used to execute Beam pipelines using Hazelcast Jet.
+
+The Jet Runner and Jet are suitable for large scale continuous jobs and provide:
+
+* Support for both batch (bounded) and streaming (unbounded) data sets
+* A runtime that supports very high throughput and low event latency at the same time
+* Natural back-pressure in streaming programs
+* Distributed massively parallel data processing engine with in memory storage
+
+It’s important to note that the Jet Runner is currently in an EXPERIMENTAL state and can not make use of many of the capabilities present in Jet:
+
+* Jet has full Fault Tolerance support, the Jet Runner does not; if a job fails it must be restarted
+* Internal performance of Jet is extremely high. The Runner can’t match it as of now because Beam pipeline optimization/surgery has not been fully implemented.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/jet/)
+
+#### Run example
+
+```
+$ mvn package -P jet-runner && java -cp target/word-count-beam-bundled-0.1.jar org.apache.beam.examples.WordCount \
+     --runner=JetRunner --jetLocalMode=3 --inputFile=`pwd`/pom.xml --output=counts
 ```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
index aa192b723126..eb1314d0c463 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -43,6 +43,8 @@ with beam.Pipeline() as p:
 
 ```
 
+### Playground exercise
+
 You can find the complete code of this example in the playground window you can run and experiment with.
 
 One of the differences you will notice is that it also contains the part to output `PCollection` elements to the console. Don’t worry if you don’t quite understand it, as the concept of `ParDo` transform will be explained later in the course. Feel free, however, to use it in exercises and challenges to explore results.
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index 3adc3105bf2a..1c983ce3c133 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -19,9 +19,13 @@ Loading data from csv file requires some processing and consists of two main par
 * Loading text lines using `TextIO.Read` transform
 * Parsing lines of text into tabular format
 
+### Playground exercise
+
 Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
 Here is a list of fields and a sample record from this dataset:
 
 `VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
 
-`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
\ No newline at end of file
+`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
index 548debdd8b28..f7887bab796c 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-text/description.md
@@ -28,6 +28,10 @@ with beam.Pipeline() as p:
 
 ```
 
+### Playground exercise
+
 In the playground window, you can find an example that reads a king lear poem from the text file stored in the Google Storage bucket and fills PCollection with individual lines and then with individual words. Try it out and see what the output is.
 
-One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the `Sample.fixedSizeGlobally` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
\ No newline at end of file
+One of the differences you will see is that the output is much shorter than the input file itself. This is because the number of elements in the output `PCollection` is limited with the ` beam.combiners.Sample.FixedSizeGlobally(10)` transform. Use Sample.fixedSizeGlobally transform of is another technique you can use to troubleshoot and limit the output sent to the console for debugging purposes in case of large input datasets.
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/shakespeare/kinglear.txt)
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
index 3c8d57368556..a836c30ae6f3 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/creating-pipeline/description.md
@@ -22,4 +22,25 @@ import apache_beam as beam
 
 with beam.Pipeline() as pipeline:
   pass  # build your pipeline here
+```
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with.
+
+When creating pipelines, you can give an argument with explicitly specified parameters:
+
+```
+beam_options = PipelineOptions(
+    runner='DataflowRunner',
+    project='my-project-id',
+    job_name='unique-job-name',
+    temp_location='gs://my-bucket/temp',
+)
+```
+
+Creation based on option:
+
+```
+pipeline = beam.Pipeline(options=beam_options)
 ```
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
index 95e14a5c1700..421deab74685 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -49,8 +49,6 @@ class MyOptions(PipelineOptions):
     parser.add_argument('--output')
 ```
 
-You can also specify a description, which appears when a user passes `--help` as a command-line argument, and a default value.
-
 You set the description and default value using annotations, as follows:
 
 ```
@@ -67,4 +65,16 @@ class MyOptions(PipelineOptions):
         '--output', required=True, help='The path prefix for output files.')
 ```
 
-For Python, you can also simply parse your custom options with argparse; there is no need to create a separate PipelineOptions subclass.
\ No newline at end of file
+For Python, you can also simply parse your custom options with argparse; there is no need to create a separate PipelineOptions subclass.
+
+### Playground exercise
+
+You can find the full code of the above example in the playground window, which you can run and experiment with. And you can transfer files of other extensions. For example, a csv file with taxi order data. And after making some transformations, you can write to a new csv file:
+
+```
+--input=gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv --output=output.csv
+```
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
+
+Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
index a54067976263..91ce88c6fa5e 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/example/task.py
@@ -49,7 +49,7 @@ def expand(self, input):
         input | beam.ParDo(self._OutputFn())
 
 def main(argv=None, save_main_session=True):
-    """Main entry point; defines and runs the wordcount pipeline."""
+
     parser = argparse.ArgumentParser()
     parser.add_argument(
         '--input',
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
index 051a13c116c2..9a0ea4e487df 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/runner-concepts/description.md
@@ -23,4 +23,105 @@ The Direct Runner executes pipelines on your machine and is designed to validate
 * elements are processed in an arbitrary order at all points
 * serialization of user functions (DoFn, CombineFn, etc.)
 
-Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.
\ No newline at end of file
+Using the Direct Runner for testing and development helps ensure that pipelines are robust across different Beam runners. In addition, debugging failed runs can be a non-trivial task when a pipeline executes on a remote cluster. Instead, it is often faster and simpler to perform local unit testing on your pipeline code. Unit testing your pipeline locally also allows you to use your preferred local debugging tools.In the SDK Python, the default is runner **DirectRunner**.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/direct/)
+
+#### Run example
+
+```
+python -m apache_beam.examples.wordcount --input YOUR_INPUT_FILE --output counts
+```
+
+### Google Cloud Dataflow runner
+
+The Google Cloud Dataflow uses the Cloud Dataflow managed service. When you run your pipeline with the Cloud Dataflow service, the runner uploads your executable code and dependencies to a Google Cloud Storage bucket and creates a Cloud Dataflow job, which executes your pipeline on managed resources in Google Cloud Platform. The Cloud Dataflow Runner and service are suitable for large scale, continuous jobs, and provide:
+* a fully managed service
+* autoscaling of the number of workers throughout the lifetime of the job
+* dynamic work rebalancing
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/dataflow/)
+
+#### Run example
+
+```
+# As part of the initial setup, install Google Cloud Platform specific extra components.
+pip install apache-beam[gcp]
+python -m apache_beam.examples.wordcount --input gs://dataflow-samples/shakespeare/kinglear.txt \
+                                         --output gs://YOUR_GCS_BUCKET/counts \
+                                         --runner DataflowRunner \
+                                         --project YOUR_GCP_PROJECT \
+                                         --region YOUR_GCP_REGION \
+                                         --temp_location gs://YOUR_GCS_BUCKET/tmp/
+```
+
+### Apache Flink runner
+
+The Apache Flink Runner can be used to execute Beam pipelines using Apache Flink. For execution, you can choose between a cluster execution mode (e.g. Yarn/Kubernetes/Mesos) or a local embedded execution mode which is useful for testing pipelines. The Flink Runner and Flink are suitable for large scale, continuous jobs, and provide:
+  * A streaming-first runtime that supports both batch processing and data streaming programs
+  * A runtime that supports very high throughput and low event latency at the same time
+  * Fault-tolerance with exactly-once processing guarantees
+  * Natural back-pressure in streaming programs
+  * Custom memory management for efficient and robust switching between in-memory and out-of-core data processing algorithms
+  * Integration with YARN and other components of the Apache Hadoop ecosystem
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/flink/)
+
+#### Run example
+
+1. Starting with Beam 2.18.0, pre-built Flink Job Service Docker images are available at Docker Hub: `Flink 1.10`, `Flink 1.11`, `Flink 1.12`, `Flink 1.13`, `Flink 1.14`.
+2. Start the JobService endpoint: `docker run --net=host apache/beam_flink1.10_job_server:latest`
+3. Submit the pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService). Optionally set environment_type set to LOOPBACK. For example:
+
+```
+import apache_beam as beam
+from apache_beam.options.pipeline_options import PipelineOptions
+
+options = PipelineOptions([
+    "--runner=PortableRunner",
+    "--job_endpoint=localhost:8099",
+    "--environment_type=LOOPBACK"
+])
+with beam.Pipeline(options) as p:
+    ...
+```
+
+### Apache Spark runner
+
+The Apache Spark Runner can be used to execute Beam pipelines using Apache Spark. The Spark Runner can execute Spark pipelines just like a native Spark application; deploying a self-contained application for local mode, running on Spark’s Standalone RM, or using YARN or Mesos.
+
+The Spark Runner executes Beam pipelines on top of Apache Spark, providing:
+
+* Batch and streaming (and combined) pipelines.
+* The same fault-tolerance guarantees as provided by RDDs and DStreams.
+* The same security features Spark provides.
+* Built-in metrics reporting using Spark’s metrics system, which reports Beam Aggregators as well.
+* Native support for Beam side-inputs via spark’s Broadcast variables.
+
+Additionally, you can read [here](https://beam.apache.org/documentation/runners/spark/)
+
+#### Run example
+
+1. Start the JobService endpoint:
+   * with Docker (preferred): docker run --net=host apache/beam_spark_job_server:latest
+   * or from Beam source code: ./gradlew :runners:spark:3:job-server:runShadow
+2. Submit the Python pipeline to the above endpoint by using the PortableRunner, job_endpoint set to localhost:8099 (this is the default address of the JobService), and environment_type set to LOOPBACK. For example:
+```
+import apache_beam as beam
+from apache_beam.options.pipeline_options import PipelineOptions
+
+options = PipelineOptions([
+    "--runner=PortableRunner",
+    "--job_endpoint=localhost:8099",
+    "--environment_type=LOOPBACK"
+])
+with beam.Pipeline(options) as p:
+    ...
+```
+
+Console:
+```
+python -m apache_beam.examples.wordcount --input /path/to/inputfile \
+                                         --output /path/to/write/counts \
+                                         --runner SparkRunner
+```
\ No newline at end of file

From 33897ca7188145a5492cc052bb30eba5e1d11eb5 Mon Sep 17 00:00:00 2001
From: sirenbyte <abzal.tugan@gmail.com>
Date: Tue, 1 Nov 2022 03:36:54 +0600
Subject: [PATCH 30/31] minor fix

---
 .../creating-collections/from-memory/description.md    | 10 +++++-----
 .../reading-from-csv/description.md                    | 10 ++++++----
 .../pipeline-concepts/setting-pipeline/description.md  |  8 ++++++++
 .../go/introduction/introduction-guide/description.md  |  8 ++++----
 .../go/introduction/introduction-terms/description.md  |  2 +-
 .../creating-collections/from-memory/description.md    |  8 ++++----
 .../reading-from-csv/description.md                    | 10 +++++++---
 .../pipeline-concepts/setting-pipeline/description.md  | 10 ++++++++++
 .../introduction/introduction-guide/description.md     |  8 ++++----
 .../introduction/introduction-terms/description.md     |  2 +-
 .../creating-collections/from-memory/description.md    | 10 +++++-----
 .../reading-from-csv/description.md                    |  9 ++++++---
 .../pipeline-concepts/setting-pipeline/description.md  |  8 ++++++++
 .../introduction/introduction-guide/description.md     |  8 ++++----
 .../introduction/introduction-terms/description.md     |  2 +-
 15 files changed, 74 insertions(+), 39 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 76aed3cdf753..0a990668241e 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -15,13 +15,13 @@ limitations under the License.
 
 Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
 
-There are several options on how to do that:
+There are several options:
 
 → You can create a PCollection of data stored in an in-memory collection class in your driver program.
 
-→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+→ You can also read the data from a variety of external sources such as local or cloud-based files, databases, or other sources using Beam-provided I/O adapters
 
-Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
+Through the tour, most of the examples use either a `PCollection` created from in-memory data or data read from one of the cloud buckets "beam-examples" or "dataflow-samples". These buckets contain sample data sets specifically created for educational purposes.
 
 We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
 
@@ -35,11 +35,11 @@ The following example code shows how to do this:
 func main() {
     ctx := context.Background()
 
-    // First create pipline
+    // First create pipeline
     p, s := beam.NewPipelineWithRoot()
 
     //Now create the PCollection using list of strings
-    numbers := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
+    strings := beam.Create(s, "To", "be", "or", "not", "to", "be","that", "is", "the", "question")
 
     //Create a numerical PCollection
     numbers := beam.Create(s, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index 70093090ae27..fd3c6fd460eb 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -24,10 +24,12 @@ Loading data from csv file requires some processing and consists of two main par
 
 Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
 
-Here is a list of fields and a sample record from this dataset:
+Here is a small list of fields and an example record from this dataset:
 
-`VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
-
-`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
 
 Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
index bddbd9d41faf..23781b1e5ea2 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -58,6 +58,14 @@ var (
 )
 ```
 
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
 Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
 
 Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
index 392c78347302..912c640edc44 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -15,8 +15,8 @@ limitations under the License.
 
 Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
-You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
-Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
-Learning units are accompanied by examples that you can review in the right pane, and run by clicking ‘Run’ button to see the output.
+You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’. Output is displayed in the lower right pane.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
-Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
+Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
index 3af132c4c04d..73fbb2ff2fea 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-terms/description.md
@@ -29,7 +29,7 @@ limitations under the License.
 
 **Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
 
-**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in time order, or to always arrive at predictable intervals.
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in event time order, or to always arrive at predictable intervals.
 
 **Trigger** - A trigger determines when to aggregate the results of each window.
 
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
index 12adb349cd97..5265259b8f4a 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -15,13 +15,13 @@ limitations under the License.
 
 Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
 
-There are several options on how to do that:
+There are several options:
 
 → You can create a PCollection of data stored in an in-memory collection class in your driver program.
 
-→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+→ You can also read the data from a variety of external sources such as local or cloud-based files, databases, or other sources using Beam-provided I/O adapters
 
-Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
+Through the tour, most of the examples use either a `PCollection` created from in-memory data or data read from one of the cloud buckets "beam-examples" or "dataflow-samples". These buckets contain sample data sets specifically created for educational purposes.
 
 We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
 
@@ -38,7 +38,7 @@ public static void main(String[] args) {
     Pipeline pipeline = Pipeline.create(options);
 
     // Now create the PCollection using list of strings
-    PCollection<String> words =
+    PCollection<String> strings =
         pipeline.apply(
             Create.of("To", "be", "or", "not", "to", "be","that", "is", "the", "question")
         );
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index dfc0e8d28ad1..fd3c6fd460eb 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -24,8 +24,12 @@ Loading data from csv file requires some processing and consists of two main par
 
 Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
 
-Here is a list of fields and a sample record from this dataset:
+Here is a small list of fields and an example record from this dataset:
 
-`VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
 
-`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
\ No newline at end of file
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
index bfef2587eb4c..66ac439ffc0e 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -89,4 +89,14 @@ You can find the full code of the above example in the playground window, which
 --input=gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv --output=output.csv
 ```
 
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
+Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
+
 Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
index 392c78347302..912c640edc44 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
@@ -15,8 +15,8 @@ limitations under the License.
 
 Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
-You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
-Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
-Learning units are accompanied by examples that you can review in the right pane, and run by clicking ‘Run’ button to see the output.
+You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’. Output is displayed in the lower right pane.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
-Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
+Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
index 3af132c4c04d..73fbb2ff2fea 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-terms/description.md
@@ -29,7 +29,7 @@ limitations under the License.
 
 **Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
 
-**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in time order, or to always arrive at predictable intervals.
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in event time order, or to always arrive at predictable intervals.
 
 **Trigger** - A trigger determines when to aggregate the results of each window.
 
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
index eb1314d0c463..1eb3abd2d021 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/from-memory/description.md
@@ -15,13 +15,13 @@ limitations under the License.
 
 Now that you know how to create a Beam pipeline and pass parameters into it, it is time to learn how to create an initial `PCollection` and fill it with data.
 
-There are several options on how to do that:
+There are several options:
 
 → You can create a PCollection of data stored in an in-memory collection class in your driver program.
 
-→ You can also read the data from a variety of external sources such as local and cloud-based files, databases, or other sources using Beam-provided I/O adapters
+→ You can also read the data from a variety of external sources such as local or cloud-based files, databases, or other sources using Beam-provided I/O adapters
 
-Through the tour, most of the examples use either `PCollection` created from in-memory data or data read from one of the cloud buckets: beam-examples, dataflow-samples. These buckets contain sample data sets specifically created for educational purposes.
+Through the tour, most of the examples use either a `PCollection` created from in-memory data or data read from one of the cloud buckets "beam-examples" or "dataflow-samples". These buckets contain sample data sets specifically created for educational purposes.
 
 We encourage you to take a look, explore these data sets and use them while learning Apache Beam.
 
@@ -32,13 +32,13 @@ You can use the Beam-provided Create transform to create a `PCollection` from an
 The following example code shows how to do this:
 
 ```
-# First create pipline
+# First create pipeline
 with beam.Pipeline() as p:
 
     # Create a numerical PCollection
     (p | beam.Create(range(1, 11)))
 
-     # Now create the PCollection using list of strings
+    # Now create the PCollection using list of strings
     (p | beam.Create(['To', 'be', 'or', 'not', 'to', 'be', 'that', 'is', 'the', 'question']))
 
 ```
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
index 1c983ce3c133..910a39dbce04 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/creating-collections/reading-from-csv/description.md
@@ -22,10 +22,13 @@ Loading data from csv file requires some processing and consists of two main par
 ### Playground exercise
 
 Try to experiment with an example in the playground window and modify the code to process other fields from New York taxi rides dataset.
-Here is a list of fields and a sample record from this dataset:
 
-`VendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount`
+Here is a small list of fields and an example record from this dataset:
 
-`1,2018-01-01 00:21:05,2018-01-01 00:24:23,1,.50,1,N,41,24,2,4.5,0.5,0.5,0,0,0.3,5.8`
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
 
 Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
index 421deab74685..6c8217dbf535 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-concepts/pipeline-concepts/setting-pipeline/description.md
@@ -75,6 +75,14 @@ You can find the full code of the above example in the playground window, which
 --input=gs://apache-beam-samples/nyc_taxi/misc/sample1000.csv --output=output.csv
 ```
 
+Here is a small list of fields and an example record from this dataset:
+
+| cost | passenger_count | ... |
+|------|-----------------|-----|
+| 5.8  | 1               | ... |
+| 4.6  | 2               | ... |
+| 24   | 1               | ... |
+
 Overview [file](https://storage.googleapis.com/apache-beam-samples/nyc_taxi/misc/sample1000.csv)
 
 Do you also notice in what order elements of PCollection appear in the console? Why is that? You can also run the example several times to see if the output stays the same or changes.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
index 392c78347302..912c640edc44 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
@@ -15,8 +15,8 @@ limitations under the License.
 
 Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself with the Apache Beam.
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
-You can access list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
-Throughout the tour, you will find list of learning materials, examples, exercises and challenges for you to complete.
-Learning units are accompanied by examples that you can review in the right pane, and run by clicking ‘Run’ button to see the output.
+You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
+Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’. Output is displayed in the lower right pane.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
-Now let’s start the tour with learning core Beam principles.
\ No newline at end of file
+Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
index 3af132c4c04d..73fbb2ff2fea 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-terms/description.md
@@ -29,7 +29,7 @@ limitations under the License.
 
 **Window** - A PCollection can be subdivided into windows based on the timestamps of the individual elements. Windows enable grouping operations over collections that grow over time by dividing the collection into windows of finite collections.
 
-**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in time order, or to always arrive at predictable intervals.
+**Watermark** - A watermark is a guess as to when all data in a certain window is expected to have arrived. This is needed because data isn’t always guaranteed to arrive in a pipeline in event time order, or to always arrive at predictable intervals.
 
 **Trigger** - A trigger determines when to aggregate the results of each window.
 

From b4af54d2edd86eeab8914766a6b269763ca8daf0 Mon Sep 17 00:00:00 2001
From: oborysevych <oleg.borisevich@akvelon.com>
Date: Mon, 7 Nov 2022 17:18:10 +0200
Subject: [PATCH 31/31] minor code review comment

---
 .../go/introduction/introduction-guide/description.md           | 2 +-
 .../java/introduction/introduction-guide/description.md         | 2 +-
 .../python/introduction/introduction-guide/description.md       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
index 912c640edc44..9b9d7a09827e 100644
--- a/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/go/introduction/introduction-guide/description.md
@@ -17,6 +17,6 @@ Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
-Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’. Output is displayed in the lower right pane.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’ button. Output is displayed in the lower right pane.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
 Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
index 912c640edc44..9b9d7a09827e 100644
--- a/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/java/introduction/introduction-guide/description.md
@@ -17,6 +17,6 @@ Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
-Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’. Output is displayed in the lower right pane.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’ button. Output is displayed in the lower right pane.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
 Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file
diff --git a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
index 912c640edc44..9b9d7a09827e 100644
--- a/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
+++ b/learning/tour-of-beam/learning-content/python/introduction/introduction-guide/description.md
@@ -17,6 +17,6 @@ Welcome to a Tour Of Beam, a learning guide you can use to familiarize yourself
 The tour is divided into a list of modules that contain learning units covering various Apache Beam features and principles.
 You can access the full list of modules by clicking ‘<<’ button on the left . For each module, learning progress is displayed next to it.
 Throughout the tour, you will find learning materials, examples, exercises and challenges for you to complete.
-Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’. Output is displayed in the lower right pane.
+Learning units are accompanied by code examples that you can review in the upper right pane. You can edit the code, or just run the example by clicking the ‘Run’ button. Output is displayed in the lower right pane.
 Each module also contains a challenge based on the material learned. Try to solve as many as you can, and if you need help, just click on the ‘Hint’ button or examine the correct solution by clicking the ‘Solution’ button.
 Now let’s start the tour by learning some core Beam principles.
\ No newline at end of file