typos

Author: facontidavide

blog/2022-10-09-welcome/index.md

@@ -10,16 +10,16 @@ I expected **BehaviorTree.CPP** to gain so much adoption in the robotic communit
 Even if that is generally meant as a rhetorical question that expects and humble answer,
 I usually answer "yes". 
 
-There are few reasons why I was optimistic about the fact that this
+There are a few reasons why I was optimistic about the fact that this
 library might be well received:
 
-- It helps implementing a crucial component of a robotic software system,
+- It helps implement a crucial component of a robotic software system,
 Task Planning; this part is often neglected until the end of the project.
 
-- I spent an unusual amount of time (may be 30% of my whole development time)
+- I spent an unusual amount of time (maybe 30% of my whole development time)
 writing documentation.
 
-- I wanted to build an inclusive project, where people needs and opinions are heard.
+- I wanted to build an inclusive project, where people's needs and opinions are heard.
 I am the "benevolent dictator" of the project, but I **do** listen and I **do** learn from others!
 
 ## Adoption in recent years, 
@@ -34,8 +34,8 @@ This data was obtained from the paper:
  [Behavior Trees and State Machines in Robotics Applications](https://arxiv.org/abs/2208.04211)
 
 SMACH is still the strongest contender,
-but you can also note as **BT.CPP** and **PyTrees** are gained more
-an more popularity in our community.
+but you can also note as **BT.CPP** and **PyTrees** 
+have gained more and more popularity in our community.
 
 If you want to learn more about the 
 methodology used to obtain these numbers, 
@@ -54,12 +54,12 @@ My personal version of it is:
 
 In both cases, we know that the answer is (or might be) **"yes"**, but hopefully you see what I mean.
 
-Very often, open source is about "scratching your own hitch" and share what you did with others. That is fine!
+Very often, open source is about "scratching your own hitch" and sharing what you did with others. That is fine!
 
 But in my case, This project was created **specifically to help others**; the more it is adopted and used, the more
 I feel that my initial goal has been achieved.
 
-In my career, I learn that the best way to drive adoption is:
+In my career, I have learned that the best way to drive adoption is:
 
 - built something that people need.
 - build trust with your users.
@@ -69,11 +69,11 @@ The latter point is particularly important and it is often underestimated.
 For me, lowering the entry barrier involved three key steps:
 
 - writing good documentation (this website).
-- adding tutorials which give the new users a sense of progression.
-- providing a tool that help people learn visually (Groot).
+- adding tutorials that give the new users a sense of progression.
+- providing a tool that helps people learn visually (Groot).
 
 The documentation of **BT.CPP** is not perfect, but probably a little above the average,
-considering the average open source project: this costed a lot of time, but paid off enormously.
+considering the average open source project: this cost a lot of time, but paid off enormously.
 
-If you have any suggestion about how to improve this site, 
+If you have any suggestions about how to improve this site, 
 [let me know](https://github.com/BehaviorTree/btcpp_website/issues).

docs/tutorial-advanced/asynchronous_nodes.md

@@ -31,12 +31,12 @@ We achieve reactive behaviors through "concurrency" and asynchronous execution.
 In other words, an Action that takes a long time to execute should
 return as soon as possible the state RUNNING.
 
-This tells the tree executor that the action was started and need more time to return
+This tells the tree executor that the action was started and needs more time to return
 the state SUCCESS or FAILURE.
 We need to tick that Node again, to know if the state changed or not (polling).
 
 An Asynchronous node may delegate this long execution either to another process
-(usning inter-process communication) or another thread.
+(using inter-process communication) or another thread.
 
 ## Asynchronous vs Synchronous
 
@@ -63,7 +63,7 @@ the __StatefulAsyncAction__.
 
 using namespace std::chrono;
 
-// Example of Asynchronous node that use StatefulActionNode as base class
+// Example of Asynchronous node that uses StatefulActionNode as base class
 class SleepNode : public BT::StatefulAsyncAction
 {
   public:
@@ -128,7 +128,7 @@ This may return SUCCESS immediately if the sleep time is 0 or will return RUNNIN
 A **wrong** way to implement the `SleepNode` would be this one:
 
 ```c++
-// This is the synchronous version of the Node. probably not what we want.
+// This is the synchronous version of the Node. Probably not what we want.
 class BadSleepNode : public BT::ActionNodeBase
 {
   public:
@@ -152,7 +152,7 @@ class BadSleepNode : public BT::ActionNodeBase
 
     void halt() override
     {
-      // No one can invoke this method, because I freezed the tree.
+      // No one can invoke this method, because I froze the tree.
       // Even if this method COULD be executed, there is no way I can
       // interrupt std::this_thread::sleep_for()
     }

docs/tutorial-advanced/pre_post_conditions.md

@@ -6,11 +6,11 @@ sidebar_position: 2
 
 Leveraging the power of the scripting language
 introduced in the [previous tutorial](tutorial-advanced/scripting.md),
-BT.CPP 4.x introcude the concept of Pre and Post Conditions,
-i.e script that can run either before or after the actual 
+BT.CPP 4.x introduces the concept of Pre and Post Conditions,
+i.e scripts that can run either before or after the actual 
 __tick()__ of a Node.
 
-Pre and Post condition are supported by __all__ the nodes and
+Pre and Post conditions are supported by __all__ the nodes and
  don't need any modifications in your C++ code.
 
 :::caution
@@ -20,7 +20,7 @@ reduce the need for custom C++ Nodes in very simple
 use cases.
 
 If your scripts become too long, you may want to 
-reconsider your decision of using them.
+reconsider your decision to use them.
 :::
 
 ## Pre conditions
@@ -30,11 +30,11 @@ reconsider your decision of using them.
 | **_skipIf**    |  Skip the execution of this Node, if the condition is true   |
 | **_failureIf** |  Skip and return FAILURE, if the condition os true |
 | **_successIf** |  Skip and return SUCCESS, if the condition os true |
-| **_while**     |  Same as _skipIf, but mau also interrupt a RUNNING Node if  the condition becomes false. |
+| **_while**     |  Same as _skipIf, but may also interrupt a RUNNING Node if  the condition becomes false. |
 
 ### Example
 
-In a previous tutorials we saw how to build an if-then-else
+In previous tutorials we saw how to build an if-then-else
 logic in the tree using a fallback.
 
 The new syntax is much more compact:
@@ -106,16 +106,16 @@ New implementation:
 
 One of the areas where Behavior Trees may struggle, when 
 compared to State Machines, is in those patterns where
-a diferent strategy should be executed based on the 
+a different strategy should be executed based on the 
 result of an Action. 
 
 Since BTs are limited to SUCCESS and FAILURE, that could 
 be unintuitive.
 
-A solution is to store the __result / error code__ in the
+A solution is storing the __result / error code__ in the
 blackboard, but that was cumbersome in version 3.X.
 
-Pre conditions can help us implementing code that is more
+Pre conditions can help us implement code that is more
 readable, like this one:
 
 ![error_codes.svg](images/error_codes.svg)
@@ -124,26 +124,26 @@ In the tree above, we added an Output port __return__ to
 __MoveBase__ and we conditionally take the second or third branch
 of the Sequence based on the value of `error_code`.
 
-# Design pattern: states and declarrative trees
+# Design pattern: states and declarative trees
 
 Even if the promise of Behavior Tree is to free us from 
-the tiranny of states, but the truth is that sometimes it is
+the tyranny of states, but the truth is that sometimes it is
 hard to reason about our application without states.
 
-Using states can make our Tree easier. For instance we can 
+Using states can make our Tree easier. For instance, we can 
 take a certain branch of the tree only when the robot
 (or a subsystem) is in a particular state.
 
 Consider this Node and its pre/post conditions:
 
 ![landing.svg](images/landing.svg)
 
-This node will be executed only if state is equal to **DO_LANDING** and, once the value of `altitude` is small
-enough, the stated is changed to **LANDED**.
+This node will be executed only if the state is equal to **DO_LANDING** and, once the value of `altitude` is small
+enough, the state is changed to **LANDED**.
 
 Note as DO_LANDING and LANDED are enums, not strings
 
 :::tip
-A surprising side effect of this patterns is that we made our
+A surprising side effect of this pattern is that we made our
 Node more __declarative__ i.e. it is easier to move this specific Node/Subtree into a different portion of the tree.
 :::

docs/tutorial-advanced/scripting.md

@@ -7,13 +7,13 @@ sidebar_position: 1
 Behavior Tree 4.X introduces a simple but powerful new concept:
 a scripting language with XML.
 
-The implemented scriting language has a familiar syntax; it allow the user to quickly
-read from / writeto the variables of the blackboard.
+The implemented scripting language has a familiar syntax; it allows the user to quickly
+read from / write to the variables of the blackboard.
 
 The simpler way to learn how scripting works is using the built-in action __Script__,
-that was introcuded first in the [second tutorial](tutorial-basics/tutorial_02_basic_ports.md)
+which was introduced in the [second tutorial](tutorial-basics/tutorial_02_basic_ports.md)
 
-## Assignemnt operators, strings and numbers
+## Assignment operators, strings and numbers
 
 Example:
 
@@ -28,9 +28,9 @@ message = 'hello world'
 - The third line assigns the string "hello world" to the blackboard entry __message__.
 
 :::tip
-The difference beyween the operator __":="__ and __"="__ is that the former
+The difference between the operator __":="__ and __"="__ is that the former
 may create a new entry in the blackboard, if it doesn't exist, whilst the latter will throw
-an exception of the blackboard doesn't contain the entry.
+an exception if the blackboard doesn't contain the entry.
 :::
 
 You can also use __semicolons__ to add multiple
@@ -40,7 +40,7 @@ commands in a single script.
 A:= 42; B:=24
 ```
 
-### Arithmetic operators and parentesis 
+### Arithmetic operators and parenthesis 
 
 Example:
 
@@ -53,7 +53,7 @@ param_C := (param_A * 3) + param_B
 
 The resulting values of `param_B` is 10 and `param_C` is 31. 
 
-The following operatos are supported:
+The following operators are supported:
 
 | Operator | Assign Operator  | Description |
 |----------|---------|---------|
@@ -62,14 +62,14 @@ The following operatos are supported:
 | *        |  *=     | Multiply |
 | /        |  /=     | Divide   |
 
-Note that the addition operator is the only one that works also with string (used to cancatenate two strings).
+Note that the addition operator is the only one that also works with string (used to concatenate two strings).
 
 ## Bitwise operator and hexadecimal numbers
 
-This operators work only if the value can be casted to
+These operators work only if the value can be cast to
 an integer number.
 
-Trying to use them with a string or real number will
+Using them with a string or real number will
 cause an exception.
 
 Example:
@@ -129,8 +129,8 @@ val_B = (val_A > 1) ? 42 : 24
 
 ## C++ example
 
-Demonstration of the scripting langiage, including how to use enums to 
-represent **integer value**.
+Demonstration of the scripting language, including how to use enums to 
+represent **integer values**.
 
 The XML:
 
@@ -158,7 +158,7 @@ The C++ code to register the Nodes and the enums:
 ``` cpp
 int main()
 {
-  // Simple tree: a sequence of two asycnhronous actions,
+  // Simple tree: a sequence of two asynchronous actions,
   // but the second will be halted because of the timeout.
 
   BehaviorTreeFactory factory;

docs/tutorial-basics/tutorial_01_first_tree.md

@@ -12,7 +12,7 @@ What happens inside these callbacks is up to you.
 We will use the expression  __"to invoke the callback"__ and __"to tick"__ interchangeably.
 
 In this tutorial series, most of the time our dummy Actions will simply
-print some information on console,
+print some information on the console,
 but keep in mind that real "production" code would probably do something
 more complicated.
 
@@ -51,7 +51,7 @@ As you can see:
 - The method __tick()__ is the place where the actual Action takes place.
   It must always return a `NodeStatus`, i.e. RUNNING, SUCCESS or FAILURE. 
 
-Alternatively, we can use __dependecy injection__ to create a TreeNode given 
+Alternatively, we can use __dependency injection__ to create a TreeNode given 
 a function pointer (i.e. "functor"). 
 
 The only requirement of the functor is to have either one of these signatures:

docs/tutorial-basics/tutorial_02_basic_ports.md

@@ -20,7 +20,7 @@ Similar to functions, we often want to:
 BehaviorTree.CPP provides a basic mechanism of __dataflow__
 through __ports__, that is simple to use but also flexible and type safe.
 
-In this tutorial we will create the following tree:
+In this tutorial, we will create the following tree:
 
 ![Tutorial2](images/tutorial_blackboard.svg)
 
@@ -36,7 +36,7 @@ can write into an entry.
 
 A valid Input can be either:
 
-- a __static string__ which the Node will read and parse, or
+- a __static string__ that the Node will read and parse, or
 - a "pointer" to an entry of the Blackboard, identified by a __key__.
 
 Let's suppose that we want to create an ActionNode called `SaySomething`, 
@@ -51,7 +51,7 @@ Consider these alternative XML syntaxes:
 <SaySomething name="second" message="{greetings}" />
 ```
 
-- In the __first__ node, the port receive the string "hello world";
+- In the __first__ node, the port receives the string "hello world";
 - The __second__ node, instead, is asked to find the value in the blackboard,
 using the entry "greetings".
 
@@ -124,7 +124,7 @@ periodically.
 ## Output ports
 
 An input port pointing to the entry of the blackboard will be valid only
-if another node have already written "something" inside that same entry.
+if another node has already written "something" inside that same entry.
 
 `ThinkWhatToSay` is an example of Node that uses an __output port__ to write a 
 string into an entry.
@@ -164,7 +164,7 @@ about the [new scripting language inside BT.CPP](tutorial-advanced/scripting.md)
 
 :::tip
 If you are migrating from BT.CPP 3.X, __Script__ is a drop-in replacement
-for __SetBlackboard__, that is now discouraged.
+for __SetBlackboard__, which is now discouraged.
 :::
 
 ## A complete example

docs/tutorial-basics/tutorial_03_generic_ports.md

@@ -12,9 +12,9 @@ Next, we will show how to assign generic C++ types to your ports.
 
 ## Parsing a string
 
-__BehaviorTree.CPP__ supports automatic conversion of strings into common
+__BehaviorTree.CPP__ supports the automatic conversion of strings into common
 types, such as `int`, `long`, `double`, `bool`, `NodeStatus`, etc.
-User defined types can be supported easily as well. 
+User-defined types can be supported easily as well. 
 
 For instance: