Merge pull request #294 from coding-for-reproducible-research/157_alt_text

All Alt Text for all images

Author: liamjberrisford

_config.yml

@@ -106,3 +106,6 @@ execute:
       - 'individual_modules/Introduction_to_Markdown_in_R/RMarkdown_Components_Formatted_Text.md'
       - 'individual_modules/Introduction_to_Markdown_in_R/RMarkdown_Components_Visual_Prelude.md'
       - 'individual_modules/Introduction_to_Markdown_in_R/RMarkdown_Components_YAML_Header.md'
+      - 'individual_modules/introduction_to_python/analysis_task_1.ipynb'
+      - 'individual_modules/introduction_to_python/analysis_task_2.ipynb'
+      - 'individual_modules/introduction_to_python/analysis_task_3.ipynb'

contributing/contributing.ipynb

@@ -67,7 +67,7 @@
     ":figclass: align-center\n",
     ":align: center\n",
     "\n",
-    "Example Github Issue Button on the CfRR Website\n",
+    "A flowchart depicting an \"Agile Software Development Methodology.\" The process starts with \"Requirements Gathering,\" leads to \"Design,\" then a cyclical \"Implementation\" and \"Testing\" phase, with a feedback loop from \"Testing\" back to \"Design\" for \"review progress & reflect on requirements.\" Finally, the process moves to \"Deployment\" and \"Maintenance\" in a linear fashion.\n",
     "```\n",
     "\n",
     "Once you have clicked the button, a new tab will open taking you into a ready-made GitHub Issue form that you can then add content to explain the issue in more depth. The button will automatically populate the title with the page that the issue is on - please leave that in the title as it makes it easier for whoever fixes the issue to find the issue being discussed. \n",
@@ -92,7 +92,7 @@
     ":figclass: align-center\n",
     ":align: center\n",
     "\n",
-    "Example Filled Out GitHub Issue Form \n",
+    "A screenshot of a GitHub webpage focusing on an issue titled \"Issue on page /contributing.html Provide example issues that can be fixed within the highlighting issues section of the website. #22\". The issue, which is closed, displays comments from user \"berrli\" outlining the purpose of the issue and providing a detailed numbered list of various types of errors that could be included as examples. The right sidebar shows issue details like assignees, labels (\"provide_examples\" is present), projects, milestone, and notification options.\n",
     "```\n",
     "\n",
     "### Making Changes\n",
@@ -127,7 +127,7 @@
     ":figclass: align-center\n",
     ":align: center\n",
     "\n",
-    "Example Pull Request Banner\n",
+    "A screenshot of a GitHub page showing a banner at the top. The banner displays the repository name \"CfRR_Courses_Contribution_Tutorial\" (marked as \"Public\"), which is forked from \"coding-for-reproducible-research/CfRR_Courses.\" Below this, a yellow box highlights that the \"contribution_tutorial_changes\" branch \"had recent pushes 2 seconds ago\" and offers a green button to \"Compare & pull request.\"\n",
     "```\n",
     "\n",
     "##### Pull Request Form\n",
@@ -138,7 +138,7 @@
     ":figclass: align-center\n",
     ":align: center\n",
     "\n",
-    "Example Pull Request Submission Form \n",
+    "A screenshot of a GitHub webpage displaying a form to \"Open a pull request.\" The form specifies the base repository (\"coding-for-reproducible-research/...\") and the head repository (\"berrli/CfRR_Courses_Contribution_Tutorial\") with their respective branches. A green message \"Able to merge. These branches can be automatically merged.\" is displayed. The form allows for adding a title, such as \"Small changes to the contribution markdown file,\" and a description with rich text editing options. Below the description, an option \"Allow edits by maintainers\" is checked, and a \"Create pull request\" button is present. On the right, sections for \"Reviewers,\" \"Assignees,\" \"Labels,\" \"Projects,\" and \"Milestone\" are visible.\n",
     "```\n",
     "\n",
     "### Testing Changes\n",

individual_modules/Introduction_to_Markdown_in_R/Getting_Started_with_Markdown_in_R.md

@@ -43,7 +43,7 @@ Once the `rmarkdown` package has been installed, a new, blank R Markdown documen
 4. Clicking `Create Empty Document` on the resultant pop-up screen
 
 Completing the above four steps should result in an RStudio window that looks like the following:
-![Blank RMarkdown file](Embedded_Display_Items/Blank_RMarkdown_View.png)
+![A screenshot of the RStudio integrated development environment (IDE). The main panel shows an empty R Markdown file named "Untitled1" in the "Source" view. There are tabs for "Visual" and "Source" editing modes. Above the main panel are various menu options and icons, including "File," "Edit," "Code," "View," "Plots," "Session," "Build," "Debug," "Profile," and "Tools," along with buttons like "Knit," "Save," "Run," and "Publish." On the right side, the "Environment" pane is open, showing "Environment is empty" under "Global Environment." Below the Environment pane are tabs for "Files," "Plots," and "Packages." At the bottom of the RStudio window, the "Console" tab is active, displaying R version information ("R version 4.4.3") and introductory text about R, including how to get help and quit. Other tabs visible next to "Console" are "Terminal" and "Background Jobs."](Embedded_Display_Items/Blank_RMarkdown_View.png)
 
 ### Saving a (new) R Markdown document:
 

individual_modules/Introduction_to_Markdown_in_R/Processing_RMarkdown_Files.md

@@ -24,7 +24,7 @@ This will automatically produce the output format type as defined in the YAML he
 
 RStudio offers an alternative, user-friendly functionality for rendering R Markdown files, known as **knitting**. Strictly speaking the knitting process operates programatically, but does so under the hood, enabling the user to complete the rendering process simply by clicking buttons.
 
-Knitting a `.Rmd` file in RStudio can be performed by clicking the ![knit button](./Embedded_Display_Items/knit_button.png) button. Clicking directly on the blue ball of wool will automatically render the output format type as defined in the YAML header of the R Markdown file. Nevertheless, clicking on the drop-down arrow part of the button will bring up alternative output format options should they be desired. 
+Knitting a `.Rmd` file in RStudio can be performed by clicking the ![A small icon of a blue ball of yarn with a knitting needle sticking out of it, next to the word "Knit" in black text, with a small black downward-pointing triangle to its right, indicating a dropdown menu.](./Embedded_Display_Items/knit_button.png) button. Clicking directly on the blue ball of wool will automatically render the output format type as defined in the YAML header of the R Markdown file. Nevertheless, clicking on the drop-down arrow part of the button will bring up alternative output format options should they be desired. 
 
 
 

individual_modules/Introduction_to_Markdown_in_R/RMarkdown_Components_Embedded_Code.md

@@ -23,7 +23,8 @@ The number pi equals `r round(x = pi, digits = 3)` when rounded to three decimal
 
 Whenever a `.Rmd` file with in-line code is processed, the code gets evaluated, and the result is displayed in place of the code within the output. For the above example, the resultant HTML output would look like:
 
-![in-line code](Embedded_Display_Items/inline_code.png)
+![
+A screenshot of a simple HTML document. The title "My html document" is displayed at the top, followed by "John Smith" and the date "2025-05-01". The main content reads: "The number pi equals 3.142 when rounded to three decimal places."](Embedded_Display_Items/inline_code.png)
 
 ## How are code chunks embedded into an R Markdown document?
 
@@ -39,7 +40,9 @@ Here, the R code chunk is initiated by starting a new line with `` ```{r} ``. R
 
 - Manually typing the code chunk syntax
 - Using the keyboard shortcut `Ctrl + Alt + I` (or `Cmd + Option + I` on a Mac)
-- Clicking the ![add chunk](./Embedded_Display_Items/add_code_chunk.png) button in RStudio and then selecting ![r chunk](./Embedded_Display_Items/select_r_code_chunk.png)
+- Clicking the ![
+A button icon featuring a light green square with a white "C" in the center, signifying "Chunk." Overlaid on the top-left of the square is a white circle with a green plus sign, indicating an "add" function. To the right of the button, there is a small black downward-pointing triangle, suggesting a dropdown menu.](./Embedded_Display_Items/add_code_chunk.png) button in RStudio and then selecting ![
+A digital icon showing a document page with the letter "R" in a blue circle overlaying its bottom left corner. To the right of the icon, a prominent black letter "R" is displayed, representing an R code chunk.](./Embedded_Display_Items/select_r_code_chunk.png)
 
 By default, when a `.Rmd` file gets processed, code chunks are evaluated and displayed alongside their results in the final output document. This behaviour can, however, be controlled *via* optional arguments definable within the `{r}` part of the code chunk. Some important custom options for code chunks in R Markdown are:
 
@@ -64,17 +67,20 @@ print(x)
 
 Will display in a HTML output as:
 
-![eval T echo T](Embedded_Display_Items/evalT_echoT.png)
+![
+A screenshot of a simple HTML document. The title "My html document" is displayed at the top, followed by "John Smith" and the date "2025-05-01". Below this, there is a grey box containing the R code x <- mean(1:10) and print(x). Underneath this code box, another grey box displays the output of the R code: ## [1] 5.5.](Embedded_Display_Items/evalT_echoT.png)
 
 Using `eval = TRUE` and `echo = FALSE` will run the code chunk when the R Markdown file is processed, but only show the result of the code chunk in the final output. For the above example, this would display in a HTML output as:
 
-![eval T echo F](Embedded_Display_Items/evalT_echoF.png)
+![A screenshot of a simple HTML document. The title "My html document" is displayed at the top, followed by "John Smith" and the date "2025-05-01". Below this, a single grey box contains the output ## [1] 5.5. The code that generated this output is not visible.](Embedded_Display_Items/evalT_echoF.png)
 
 Just having the result of a code chunk in the output but not the code itself is particularly useful when wanting to display figures produced using R code. Nevertheless, it can also be helpful sometimes to display the contents of code chunk in the output but not have it ran when the `.Rmd` file is processed, for example when drafting and debugging code, or showing example code without running it. In which case, the combination of `eval = FALSE` and `echo = TRUE` can be used. For the above example, this would display in a HTML output as:
 
-![eval F echo T](Embedded_Display_Items/evalF_echoT.png)
+![A screenshot of a simple HTML document. The title "My html document" is displayed at the top, followed by "John Smith" and the date "2025-05-01". Below this, there is a grey box containing the R code x <- mean(1:10) and print(x). There is no output displayed from the code.](Embedded_Display_Items/evalF_echoT.png)
 
-Multiple code chunks can be embedded into a single R Markdown document, and it is good practice to partition your whole code into smaller, sensible code chunks that fit in and round descriptive formatted plain text to improve readability. It is also possible to run code chunks in real time within an R Markdown document itself. For a given code chunk in a `.Rmd` file, clicking ![run above chunks](./Embedded_Display_Items/run_code_chunks_above.png) will run all code chunks above it in real time, while clicking ![run current chunk](./Embedded_Display_Items/run_current_chunk.png) will run that code chunk itself in real time. This is helpful when dynamically trialing and testing code while you write it into the R Markdown document. Note that if a code chunk depends on an output generated by any code chunk above it, the depending code chunk(s) above will need to be ran first.
+Multiple code chunks can be embedded into a single R Markdown document, and it is good practice to partition your whole code into smaller, sensible code chunks that fit in and round descriptive formatted plain text to improve readability. It is also possible to run code chunks in real time within an R Markdown document itself. For a given code chunk in a `.Rmd` file, clicking ![
+A square icon on a black background, featuring a grey downward-pointing triangle above a solid green horizontal rectangle. The design suggests an action related to "running" or "executing" something from above.](./Embedded_Display_Items/run_code_chunks_above.png) will run all code chunks above it in real time, while clicking ![
+A vibrant green right-pointing triangle, resembling a play button, set against a solid black background.](./Embedded_Display_Items/run_current_chunk.png) will run that code chunk itself in real time. This is helpful when dynamically trialing and testing code while you write it into the R Markdown document. Note that if a code chunk depends on an output generated by any code chunk above it, the depending code chunk(s) above will need to be ran first.
 
 ## Task
 
@@ -88,6 +94,6 @@ Try to implement this new content in your own R Markdown file.
 
 ### *Task HTML output:*
 
-![code task output](Embedded_Display_Items/Embedding_Code_Task_HTML_Output.png)
+![A multi-page HTML document titled "Skeletal Muscle and Exercise" by John Smith presents a research paper on muscle adaptations to different exercise types. It includes an embedded R code chunk that generates a plot illustrating muscle mass progression over time for both resistance and endurance training. The document further details molecular differences in muscle adaptations and concludes with a references section.](Embedded_Display_Items/Embedding_Code_Task_HTML_Output.png)