Update glossary.rst

docs/userguide/glossary.rst

@@ -7,194 +7,172 @@ Our glossary is organized alphabetically by the English alphabet. Feel free to c
 
 .. _glossary:
 
-1. **App**
-   ----------
+.. _app:
+
+1. **App:**
+-----------
 
-   **App:** 
 In Parsl, an app is like a small, self-contained program that does a specific job. It's a piece of code, like a Python function or a Bash script, that you can run separately from your main program. Think of it as a mini-tool within your larger toolbox.
 
-   .. _app:
+.. _appfuture:
 
-2. **AppFuture**
-   ----------------
+2. **AppFuture:**
+-------------------
 
-   **AppFuture:**
 An AppFuture is like a placeholder for the result of an app that's running in the background. It's like a ticket you get when you order food at a restaurant – you get the ticket right away, but you have to wait for the food to be ready. Similarly, you get an AppFuture immediately when you start an app, but you have to wait for the app to finish before you can see the results.
 
-   .. _appfuture:
+.. _bashapp:
 
-3. **Bash App**
-   -------------
-
-   **Bash App:**
+3. **Bash App:**
+------------------
+
 A Bash app is a special kind of app in Parsl that lets you run commands from your computer's terminal (like the ones you type in the command prompt or shell). It's a way to use Parsl to automate tasks that you would normally do manually in the terminal.
 
-   .. _bashapp:
+.. _block:
 
-4. **Block**
-   ----------
+4. **Block:**
+--------------
 
-   **Block**
 A block is like a group of computers loaned to you for doing work. Parsl will manage passing out work to each of them to do. This way, you can get your work done faster by using multiple computers at the same time.
 
-   .. _block:
+ .. _checkpointing:
 
-5. **Checkpointing**
-   -----------------
+5. **Checkpointing:**
+-----------------------
 
-   **Checkpointing:**
 Checkpointing is like saving your progress in a video game. If something goes wrong, you can restart from the last saved point instead of starting all over again. In Parsl, checkpointing lets you save the state of your work so that you can resume it later if there's an interruption.
 
-   .. _checkpointing:
+.. _concurrency:
 
-6. **Concurrency**
-   ---------------
+6. **Concurrency:**
+---------------------
 
-   **Concurrency:**
 Concurrency means doing multiple things at the same time. In Parsl, it means that your apps can run simultaneously, even if they're not on the same computer. This can make your programs run much faster.
+
+.. _configuration:
 
-   .. _concurrency:
-
-7. **Configuration**
-   -----------------
+7. **Configuration:**
+-----------------------
 
-   **Configuration:**
-Configuration is like setting up the rules for how Parsl should work. It's like adjusting the settings on your phone – you can choose how you want things to look and behave. In Parsl, you can configure things like how many computers to use, where to store data, and how to handle errors.
+Configuration is like setting up the rules for how Parsl should work. It's like adjusting the settings on your phone – you can choose how you want things to look and behave. In Parsl, you can configure things like how many computers to use, where to store data, and how to handle errors. 
 
-   .. _configuration:
+.. _datafuture:
 
-8. **DataFuture**
-   --------------
+8. **DataFuture:**
+--------------------
 
-   **DataFuture:**
 A DataFuture is like a placeholder for a file that an app is creating. It's like a receipt for a package you're expecting – you get the receipt right away, but you have to wait for the package to arrive. Similarly, you get a DataFuture immediately when an app starts creating a file, but you have to wait for the file to be finished before you can use it.
+
+ .. _dfk:
 
-   .. _datafuture:
-
-9. **DataFlowKernel (DFK)**
-   ------------------------
+9. **DataFlowKernel (DFK):**
+------------------------------
 
-   **DataFlowKernel (DFK):**
 The DataFlowKernel is like the brain of Parsl. It's the part that controls how your apps run and how they share information. It's like the conductor of an orchestra, making sure that all the musicians play together in harmony.
 
-   .. _dfk:
+.. _elasticity:
 
-10. **Elasticity**
-    ---------------
+10. **Elasticity:**
+-----------------
 
-    **Elasticity:**
 Elasticity means being able to stretch or shrink. In Parsl, it means that you can easily add or remove blocks of computers as needed. This is useful if your workload changes – you can use more computers when you have a lot of work to do and fewer computers when you don't.
 
-    .. _elasticity:
+ .. _executionprovider:
 
-11. **Execution Provider**
-    -----------------------
+11. **Execution Provider:**
+-----------------------------
 
-    **Execution Provider:**
 An execution provider is like a bridge between Parsl and the computers you want to use. It's the part that knows how to talk to different types of computers, like your laptop, a cluster, or a cloud service.
 
-    .. _executionprovider:
+.. _executor:
 
-12. **Executor**
-    -------------
+12. **Executor:**
+-------------------
 
-    **Executor:**
 An executor is like a manager for your apps. It's the part that decides which app should run on which computer and when. It's like a traffic controller, directing the flow of apps to make sure they all get where they need to go.
+
+.. _future:
 
-    .. _executor:
+13. **Future:**
+-----------------
 
-13. **Future**
-    ----------
-
-    **Future:**
 A future is a placeholder for the result of a task that hasn't finished yet. Both AppFuture and DataFuture are types of Futures. You can use the `.result()` method to get the actual result when it's ready.
+
+.. _launcher:
 
-    .. _future:
-
-14. **Launcher**
-    -------------
+14. **Launcher:**
+-------------------
 
-    **Launcher:**
 A launcher is like a starter for your apps. It's the part that actually starts the apps running on the computers. It's like a coach telling the athletes when to start running.
 
-    .. _launcher:
+ .. _memoization:
 
-15. **Memoization**
-    ----------------
+15. **Memoization:**
+----------------------
 
-    **Memoization:**
 Memoization is like remembering something so you don't have to do it again. In Parsl, it means that if you run an app with the same inputs multiple times, Parsl will remember the result from the first time and give it to you again instead of running the app again. This can save a lot of time.
 
-    .. _memoization:
+.. _mpiapp:    
 
-16. **MPI App**
-    -------------
+16. **MPI App:**
+------------------
 
-    **MPI App:**
 An MPI app is a special kind of app that uses a technology called Message Passing Interface (MPI) to communicate between different computers. It's like a walkie-talkie that lets different apps talk to each other.
 
-    .. _mpiapp:
+.. _parallelism:
 
-17. **Parallelism**
-    ----------------
+17. **Parallelism:**
+-----------------------
 
-    **Parallelism:**
 Parallelism means doing multiple things at the same time. In Parsl, it means that your apps can run simultaneously on different computers. This can make your programs run much faster.
 
-    .. _parallelism:
+.. _parslscript:    
 
-18. **Parsl Script**
-    ----------------
+18. **Parsl Script:**
+------------------------
 
-    **Parsl Script:**
 A Parsl script is a file that contains the instructions for how to run your apps in parallel. It's like a recipe that tells you what ingredients to use and how to combine them.
+
+.. _plugin:
 
-    .. _parslscript:
-
-19. **Plugin**
-    -----------
+19. **Plugin:**
+------------------
 
-    **Plugin:**
 A plugin is like an add-on for Parsl. It's a piece of code that you can add to Parsl to give it new features or change how it works. It's like an extra tool that you can add to your toolbox.
 
-    .. _plugin:
+.. _pythonapp: 
 
-20. **Python App**
-    ---------------
+20. **Python App:**
+----------------------
 
-    **Python App:**
 A Python app is a special kind of app in Parsl that's written in the Python programming language. It's a way to use Parsl to run your Python code in parallel.
 
-    .. _pythonapp:
+.. _serialization:    
 
-21. **Serialization**
-    -----------------
+21. **Serialization:**
+-------------------------
 
-    **Serialization:**
 Serialization is like packing your belongings into a suitcase so you can take them on a trip. In Parsl, it means converting your data into a format that can be sent over a network to another computer.
 
-    .. _serialization:
+.. _staging:    
 
-22. **Staging**
-    ------------
+22. **Staging:**
+-------------------
 
-    **Staging:**
 Staging is like setting the stage for a play. In Parsl, it means preparing the data that your apps need before they start running. This can involve things like copying files to the right location or converting them into the right format.
 
-    .. _staging:
+.. _thread:    
 
-23. **Thread**
-    ----------
+23. **Thread:**
+-----------------
 
-    **Thread:**
 A thread is like a smaller part of a program that can run independently. It's like a worker in a factory who can do their job at the same time as other workers.
 
-    .. _thread:
+.. _workflow:    
 
-24. **Workflow**
-    -------------
+24. **Workflow:**
+--------------------
 
-    **Workflow:**
 A workflow is like a series of steps that you follow to complete a task. In Parsl, it's a way to describe how your apps should run and how they depend on each other. It's like a flowchart that shows you the order in which things need to happen.
 
-    .. _workflow:
+