fix(links): more broken links

Author: lwasser

clean-modular-code/part-1-data.json renamed to clean-modular-code/data/part-1-data.json

@@ -46,13 +46,13 @@ Modularity means that code is separated into independent units that can be reuse
 
 :::{figure} /images/clean-code/functions-for-all-things.png
 :alt: You can implement strategies such as loops and functions in your code to replace tasks that you are performing over and over. Source: Francois Michonneau.
-:target: /images/clean-code/write-functions-for-all-things.png
+:target: /images/clean-code/functions-for-all-things.png
 
 You can use loops and functions in your code to replace repeating tasks.  
 Source: Francois Michonneau.
 :::
 
-## The Benefits of Functions
+## The benefits of functions
 
 * Modularity: Functions only need to be defined once in a workflow. Functions that you write for specific tasks can be used over and over, without needing to redefine the function again. A function that you write for one **Python** workflow can also be reused in other workflows especially if you make your code installable.
 
@@ -64,7 +64,7 @@ Source: Francois Michonneau.
 
 * Tests & checks: Writing functions allows you you to your code to handle issues and edge cases in your code. It also can make it easier to write tests for your code.
 
-### Write Modular Functions and Code
+### Write modular functions and code
 
 A well-defined function only does one thing, but it does it well and often in various contexts. Often, the operations contained in a good function are generally useful for many tasks.
 
@@ -84,58 +84,57 @@ np.mean(arr)
 ```
 
 <!-- #region editable=true slideshow={"slide_type": ""} -->
-The `np.mean()` function is modular, and it can be easily combined with other functions to accomplish a variety of tasks.
+The `np.mean()` function is modular, and it can be easily combined with other functions to accomplish various tasks.
 
 When you write modular functions, you can reuse them for other workflows and projects. Some people even write their own **Python** packages for personal and professional use that contain custom functions for tasks that they have to complete regularly.
 
-### Functions Create Fewer Variables
+### Variables produced in functions are discarded after the function runs
 
-When you code tasks line by line, you often create numerous intermediate variables that you do not need to use again.
+When coding tasks step by step, you are likely creating many intermediate variables that are not needed again but are
+stored in your computer's memory.
 
-This is inefficient and can cause your code to be repetitive, if you are constantly creating variables that you will not use again.
+By using functions, these intermediate variables are confined to the function’s local scope. Once the function finishes executing, the variables created within the function are discarded making your code cleaner and more efficient  
 
-Functions allow you to focus on the inputs and the outputs of your workflow, rather than the intermediate steps, such as creating extra variables that are not needed.
+## Reasons why functions improve code readability
 
-## Reasons Why Functions Improve Code Readability
+### Functions help you document your code  
 
-### Functions Can Result in Better Documentation
+Ideally, your code is easy to understand and is well-documented with **Python** comments (or **Markdown** in **Jupyter Notebook**). However, what might seem clear to you now might not be clear 6 months from now, or even 3 weeks from now.
 
-Ideally, your code is easy to understand and is well-documented with **Python** comments (and **Markdown** in **Jupyter Notebook**). However, what might seem clear to you now might not be clear 6 months from now, or even 3 weeks from now.
+Well-written functions help you document your workflow if:
 
-Well-written functions help you document your workflow because:
+* They have clear docstrings that outline the function's inputs and outputs.
+* They use descriptive names that clearly describe the task that the function performs.
 
-* They are well-documented by clearly outlining the inputs and outputs.
-* They use descriptive names that help you better understand the task that the function performs.
-
-### Expressive Function Names Make Code Self-Describing
+### Expressive function names make code self-describing
 
 When writing your own functions, you should name functions using verbs and/or clear labels to indicate what the function does (i.e. `in_to_mm` for converting inches to millimeters).
 
 This makes your code more expressive (or self-describing), and in turn, makes it easier to read for you, your future self, and your colleagues.
 
-### Modular Code is Easier to Maintain and Edit
+### Modular code is easier to maintain and edit
 
 If all your code is written line by line (with repeated code in multiple parts of your document) it can be challenging to maintain and edit.
 
 Imagine having to fix one element of a line of code that is repeated many times. You will have to find and replace that code to implement the fix in EVERY INSTANCE it occurs in your code!
 
-You may also be duplicating your comments where you duplicate parts of your code. So how do you keep the duplicated comments in sync?
+Repeated code cause you to duplicated comment. So how do you keep the duplicated comments in sync?
 
-A comment that is misleading because the code changed is actually worse than no comment at all.
+A comment that is misleading because the code changed is worse than no comment.
 
 Organizing your code using functions from the beginning allows you to explicitly document the tasks that your code performs, as all code and documentation for the function is contained in the function definition.
 
-### You Can Incorporate Testing To Ensure Code Runs Properly
+### Functions and tests  
 
-While you will not learn about testing in this chapter, note that functions are also very useful for testing.
+While you will not learn about testing in this lessons, note that functions are also very useful for testing.
 
 As your code gets longer and more complex, it is more prone to mistakes. For example, if your analysis relies on data that gets updated often, you may want to make sure that all the columns in your spreadsheet are present before performing an analysis. Or, that the new data are not formatted in a different way.
 
 Changes in data structure and format could cause your code to not run. Or, in the worse case scenario, your code may run but return the wrong values!
 
 If all your code is made up of functions (with built-in tests to ensure that they run as expected), then you can control the input to the function and test that the output returned is correct for that input. It is something that would be difficult to do if all of your code is written line by line with repeated steps.
 
-## Summary of Writing Modular Code with Functions
+## Summary of writing modular code with functions
 
 It is a good idea to learn how to: