Principle #1 - Creating a Learning Graph

Background

Earlier in the course, I asked you to work on a concept map and to discuss the ideas with your small group. In this activity we are going to work on something similar but a little more focussed. That is, the idea of a learning graph.

You read about learning graphs in week 2 when we worked with Principle #1 In the context of education and learning, a learning graph usually refers to a visual representation of a learner's progress through the individual elements of a subject. As a graph, it normally includes nodes - each representing concepts or skills - and edges - which represent the dependencies or relationships between these concepts.

This type of graph can help educators and learners visualize the learning process, identify areas of strength and weakness, and plan overall educational paths and instruction.

Activity

With a little bit of careful prompting, I asked ChatGPT to give me a list of the fundamental concepts of programming. With some editing to accurately reflect what we covered in the FOP course last fall, it gave me.

1. Data Types: Understanding the existance of different types of base data
   • integers
   • floating point numbers
   • strings
   • booleans
2. Functions/Methods: Modular blocks of code that perform a specific task. They promote code reusability and maintainability.
3. Lists (aka arrays): Collections of data that allow you to store and manipulate multiple values under a single variable.
4. Control Structures:
   1. Conditionals
   2. Loops
5. Input/Output (I/O):
   1. Reading from the command line (input())
   2. Writing to the command line (print()
   3. Reading from and writing to external sources such as files
6. Comments and Documentation: Writing comments to explain code and documenting functions and modules for better code understanding.
7. Creating variables
8. Testing and Debugging: Techniques for ensuring code correctness, identifying and fixing errors.
9. Basic Math Operations: Understanding and using arithmetic operations, such as addition, subtraction, multiplication, and division.
10. Basic String Operations: Understanding and using the individual characters inside of a string. Could include find(), upper()/lower(), split(), indexing and slicing (using [x] or [x : y]), etc.
11. Basic List Operations: Understanding and using the individual elements in a list. Could include in, append(), pop(), sort(), indexing and slicing (using [x] or [x : y]), etc.

I want you tear this list apart and build a learning graph for these ideas.

Where are there dependencies? What ideas should come first? What ideas should come later? What ideas could come in a variety of orderings with some careful planning.

Think carefully about how we actually use certain elements. For example, what kind of programming assignments could you give to demonstrate the power of some of these elements? Pay attention to which other elements are used in the process. To elaborate, it is easy to think that two ideas could go in any order until you realize that one idea is always used when assigning programs testing the other idea. In this case, idea one is a prerequisite concept.