add links and summarises to the self study notes for the courses

Author: liamjberrisford

course_homepages/R.ipynb

@@ -29,18 +29,40 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4e1826b4-ccc0-4823-be9f-aaae569a997a",
+   "cell_type": "markdown",
+   "id": "ffffdfd4-3e45-49c2-877b-f078c8abe7ea",
    "metadata": {
     "editable": true,
     "slideshow": {
      "slide_type": ""
     },
     "tags": []
    },
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Introduction to R Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/introduction_to_r.md)\n",
+    "\n",
+    "The course introduces students to using RStudio for writing scripts and executing R commands, emphasizing the importance of various data types and object structures for effective data storage. Participants will learn how to read, manipulate, and save data, visualize it through commonly used figures, and perform basic inferential statistical tests. Additionally, the course covers fundamental programming terminology and concepts, such as variables, functions, and for loops, which are transferable to other programming languages.\n",
+    "\n",
+    "## Regression Analysis with R Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/regression_analysis_with_R.md)\n",
+    "\n",
+    "The course provides a thorough understanding of regression analysis, including the types of questions it can address and the principles behind different regression models. Students will learn to fit both linear and logistic regression models with multiple predictor variables, as well as extract and summarize results from a variety of regression analyses. Additionally, the course emphasizes designing regression models that are tailored to specific research questions, ensuring that students can apply these techniques effectively in their own studies.\n",
+    "\n",
+    "## Advanced Regression Analysis with R Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/advanced_regression_analysis_with_R.md)\n",
+    "\n",
+    "The course equips students to use regression analysis to address a wide range of research questions, including fitting models with interactions between predictor variables and multi-level regression models. Participants will learn to extract and summarize results from various regression models, ensuring they can effectively interpret and communicate their findings. Additionally, the course emphasizes designing regression models tailored to specific research questions, enabling students to apply these techniques accurately in their own studies.\n",
+    "\n",
+    "## Working With Data in R Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/working_with_data_in_R.md)\n",
+    "\n",
+    "The course introduces the principles of the ‘tidy’ data format, a widely recognized convention for structuring data, and teaches how to read tabular data from files into dataframes. Students will learn to manipulate datasets by creating new variables, filtering, summarizing, sorting, joining multiple datasets, and reshaping data, as well as working with strings and dates when time permits. Additionally, the course provides hands-on experience with R notebooks for conducting and documenting data analysis effectively."
+   ]
   }
  ],
  "metadata": {

course_homepages/computational_thinking.ipynb

@@ -17,18 +17,22 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "405e2487-a0a0-46a5-ae07-09555bd7f90f",
+   "cell_type": "markdown",
+   "id": "ccd1c890-bbe5-41fb-adac-814e0554af12",
    "metadata": {
     "editable": true,
     "slideshow": {
      "slide_type": ""
     },
     "tags": []
    },
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Computational Thinking Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/computational_thinking.md)\n",
+    "\n",
+    "The course introduces the concept of algorithms and their essential role in coding, providing a solid foundation for understanding computational processes. Students will explore various computational thinking approaches and concepts for developing effective algorithms, enhancing their problem-solving skills. Additionally, the course teaches how to differentiate between syntax-related bugs and those stemming from the underlying algorithm, enabling more efficient and effective troubleshooting."
+   ]
   }
  ],
  "metadata": {

course_homepages/high_performance_computing.ipynb

@@ -29,18 +29,28 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "404ed0ff-3f41-43bb-a44f-add46cf661d6",
+   "cell_type": "markdown",
+   "id": "fd6e537e-d20c-4c5b-b619-1cf111ba7ec1",
    "metadata": {
     "editable": true,
     "slideshow": {
      "slide_type": ""
     },
     "tags": []
    },
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Introduction to HPC Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/introduction_to_hpc.md)\n",
+    "\n",
+    "The course introduces high-performance computing (HPC) clusters, explaining their functionality and the types of tasks they are best suited for. Students will learn how to access and navigate HPC environments, including logging onto clusters, managing the file system, and submitting and overseeing job tasks within the scheduler’s queue. Additionally, the course covers the array jobs syntax, a powerful tool for efficiently parallelizing repetitive tasks, enabling effective management of large computational workloads.\n",
+    "\n",
+    "## Parallel Computing Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/parallel_computing.md)\n",
+    "\n",
+    "The course offers an in-depth understanding of distributed and shared-memory parallelism, enabling participants to explain these concepts clearly. Students will learn to write software that runs across multiple processes using MPI and develop code that utilizes multithreading for parallel execution. Additionally, the course focuses on effectively dividing and parallelizing problems, providing hands-on experience in writing and optimizing parallel code."
+   ]
   }
  ],
  "metadata": {

course_homepages/julia.ipynb

@@ -29,18 +29,22 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dfe38367-7b5c-424c-9fcc-0a89b8cd8def",
+   "cell_type": "markdown",
+   "id": "33fc6106-5ac0-41aa-b1dc-bfcb1ceb098f",
    "metadata": {
     "editable": true,
     "slideshow": {
      "slide_type": ""
     },
     "tags": []
    },
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Introduction to Julia Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/introduction_to_julia.md)\n",
+    "\n",
+    "The course provides a comprehensive understanding of Julia’s high-level and high-performance features, including multiple dispatch. Students will learn to create and manipulate one-dimensional and multi-dimensional arrays, utilize conditional statements and loops to control program flow, and develop functions with various parameters and return types, including lambda functions. Additionally, the course covers performing input and output operations with different file types such as text, CSV, Excel, and JSON, enabling effective data handling and manipulation."
+   ]
   }
  ],
  "metadata": {

course_homepages/python.ipynb

@@ -27,6 +27,24 @@
    "source": [
     "The following set of courses discuss Python. The details for each of the courses can be found on their respective pages. "
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ff412eb-15fc-4112-b5c1-fd7b8876aa86",
+   "metadata": {},
+   "source": [
+    "## Introduction to Python Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/introduction_to_python.md)\n",
+    "\n",
+    "The course provides a foundational understanding of Python’s basic data types and the fundamental principles of control flow, including the use of for loops. Students will learn to define and implement functions with user-specified parameters, as well as perform simple data analysis and visualize tabular data effectively. Additionally, the course highlights how Python concepts relate to those in other programming languages, enhancing cross-language comprehension.\n",
+    "\n",
+    "## Python for Data Analysis Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/python_for_data_analysis.md)\n",
+    "\n",
+    "The course offers a comprehensive foundation in Python programming, covering essential topics such as data types, control structures, and functions, alongside advanced data manipulation using Pandas and NumPy for handling large datasets efficiently. Students will learn to create both static and interactive visualizations with Matplotlib and Plotly, apply machine learning techniques using Scikit-Learn for predictive modeling, and implement testing frameworks and virtual environments to manage dependencies effectively. Additionally, the course emphasizes reproducibility and validation of research by teaching methods to ensure that analyses can be replicated and validated by others.\n"
+   ]
   }
  ],
  "metadata": {

course_homepages/software_development.ipynb

@@ -29,18 +29,22 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "53c77588-aa4d-4d40-acd9-97b1034d696f",
+   "cell_type": "markdown",
+   "id": "4e78a55f-9041-4ac5-9534-1f945f5039a3",
    "metadata": {
     "editable": true,
     "slideshow": {
      "slide_type": ""
     },
     "tags": []
    },
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Software Development Best Practice Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/software_development_best_practice.md)\n",
+    "\n",
+    "The course provides a high-level understanding of software development tailored for research, enabling participants to collaborate on code effectively. Students will learn how to enhance the reproducibility of their research by creating code that is accessible and useful to others. Additionally, the course establishes the necessary foundations for intermediate-level courses that delve deeper into advanced software development topics."
+   ]
   }
  ],
  "metadata": {

course_homepages/unix.ipynb

@@ -29,18 +29,22 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d2b0c13e-f974-4d86-ab2b-2576828d40ea",
+   "cell_type": "markdown",
+   "id": "8102ce3d-d1cc-4066-bcc4-2c25069abb55",
    "metadata": {
     "editable": true,
     "slideshow": {
      "slide_type": ""
     },
     "tags": []
    },
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Introduction to UNIX Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/introduction_to_unix.md)\n",
+    "\n",
+    "The course introduces the fundamentals of the Unix shell, explaining what it is and how to access it effectively. Students will learn to navigate the Unix filesystem, inspect and manipulate files, and automate tasks through scripting. Additionally, the course covers running programs outside of integrated development environments (IDEs) and notebooks, enabling efficient command-line workflow management."
+   ]
   }
  ],
  "metadata": {

course_homepages/version_control.ipynb

@@ -29,18 +29,28 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a50a26c8-f891-45df-ab49-6784b6b8ca7a",
+   "cell_type": "markdown",
+   "id": "6b2c4fda-ea2d-4114-97e9-6602cbc1773a",
    "metadata": {
     "editable": true,
     "slideshow": {
      "slide_type": ""
     },
     "tags": []
    },
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Introduction to Version Control Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/introduction_to_version_control.md)\n",
+    "\n",
+    "The course teaches students how to effectively manage software development using Git, including understanding repositories and commits and applying essential Git commands such as cloning, pulling, pushing, adding, and committing changes. Participants will learn best practices for what should and should not be included in Git repositories, understand the relationship and differences between Git and platforms like GitHub and GitLab, and gain the skills to share their work publicly or collaboratively through GitHub. Additionally, the course builds confidence to explore and utilize more advanced Git and GitHub features, such as branches and pull requests, to enhance their development workflows.\n",
+    "\n",
+    "## Intermediate Version Control Self Study Notes\n",
+    "\n",
+    "[Clickable Link to Self Study Notes](../individual_modules/section_landing_pages/intermediate_version_control.md)\n",
+    "\n",
+    "The course delves into advanced Git configurations, enabling participants to understand and tailor Git settings to their development needs. Students will master branching and merging strategies, implement effective GitHub workflows for collaboration, and manage remote repositories while synchronizing local changes seamlessly. Additionally, the course covers techniques for rewriting Git history and recovering from mistakes, ensuring robust and resilient version control practices.\n"
+   ]
   }
  ],
  "metadata": {

individual_modules/section_landing_pages/parallel_computing.md

@@ -7,7 +7,6 @@
 This course will provide an introduction to parallel programming. Participants will gain practical experience in writing parallel software, understanding how to decompose problems for efficient execution across multiple processes and threads.
 
 ## Course Objectives 
-On completion of this series of workshops, participants will:
 - Be able to explain what is meant by distributed and shared-memory parallelism.
 - Know how to write software that can run across multiple processes using MPI.
 - Be able to write code that utilizes multithreading for parallel execution.

individual_modules/section_landing_pages/software_development_best_practice.md

@@ -7,11 +7,10 @@ The course is designed to be interactive, though all related resources are avail
 This course comprises two two-hour sessions. The course is designed to be interactive and so will be delivered within a seminar style with live demonstrations and activities. We have allowed plenty of time for discussion and questions throughout - please simply shout out any questions/comments you have or raise your physical/virtual hand. We will also have a short comfort break approximately three quarters of the way through the session. We will also share the slides and there is a list of resources on the website for this course.
 
 ## Course Objectives 
-- On completion of this course, we will:
-    - have a high-level understanding of software development for research.
-    - be able to collaborate on code effectively.
-    - be able to improve the reproducibility of our research by understanding how to make our code useful to others.
-    - have the necessary foundations for intermediate level courses that will delve deeper into software development topics.
+- have a high-level understanding of software development for research.
+- be able to collaborate on code effectively.
+- be able to improve the reproducibility of our research by understanding how to make our code useful to others.
+- have the necessary foundations for intermediate level courses that will delve deeper into software development topics.
 
 ## Pre-requisite Knowledge