Status: Tags: Links: COGS 110 Projects
COGS 110 Project 1 - RISE principles in the real world
Recall Interleaving Spaced Repetition Elaboration Canvas Link
Information
Choose a learning practice that you have direct experience of, or you can interview somebody else about a practice they follow
- Important to access nuanced and detailed descriptions about the practice as a starting point for your reflection.
Elaborate a critical discussion about the practice and consider aspects about it that either follow or fail to apply the RISE principles
- Three aspects that each relate to one or more of the principles
- Two missed opportunities for leveraging the benefits of the principles
Structure
6 paragraphs long report, with the following structure:
Paragraph 1:
Briefly describe the learning situation (e.g., learning practices related to football, learning guitar, teaching children math, university learning…).
Paragraphs 2 to 4:
In each of these paragraphs, address one specific aspect of the learning practice. Begin with a description. And then relate that to the RISE principles. Explain how the example relates to the principles. Do not just claim or identify that it does.
Paragraphs 5 to 6:
In each of these paragraphs, address a missed opportunity for the practice. Begin with a description of an aspect of the learning practice that does not follow, or even contradicts, the RISE principles. Just as before do not just claim that it does. Explain and provide arguments to support your ideas. Then provide recommendations based on the principles to improve that aspect of the learning practice.
Outline
Learning how to create a mobile app
Good
- Spending an hour every day
- Spaced repetition
- Looking at other people’s code
- Elaboration, coming up with understanding and connecting it to your own
- When I would look back at a code I haven’t touched in a while, I would have to remind myself it’s purpose and functionality
- Recall
Bad
- Didn’t elaborate when code didn’t run
- Should have done rubber duck debugging
- Didn’t work on other projects at the same time, so I didn’t get to do much interleaving
- As a result, it required less effort to remember the syntax and principles of the programming language, so I wasn’t fully immersing myself in learning
Learning how to type on a split keyboard
Good
- Spaced repetition, did practice for an hour every day
- Recall as I would have to remember where the positioning of the keys is without looking
- Immediate feedback as I would see whether I pressed the correct key or not
- Interleaving as I switched between typing words, typing sentences, and typing code during my practice sessions
- Practice words were randomized and I didn’t retry the same one
Bad
- Didn’t switch between split and normal keyboard so it was blocked practice in a sense, which didn’t let me differentiate between the two typing kinds
- Didn’t think much about the mistakes I was making
- Lack of elaboration to see what I could improve on
Draft
In my learning situation, I challenged myself to independently program an Android mobile application. To successfully do this, I needed to learn a programming language called “Kotlin”, learn the architecture of the code for creating a mobile app, and learn how to use the programming environment that allowed me to code in the first place which was called “Android Studio”. After spending time every day working on learning/coding, referencing online resources and other people’s code, and recalling the functionality of my own code, I was able to effectively complete the project. However, when looking back, I realized that there were also ineffective practices like not fully elaborating on why code didn’t run at times, as well as not working on other projects at the same time.
First off, dedicating an hour or more to work on the project every day helped me with incorporating spaced repetition, as I was able to consistently engage my brain in the learning and coding process throughout the entire 1.5 month period in which I worked on the project. Through the frequent exposure and interactions with my coding application, I became quickly accustomed to the syntax of the language and the interface of Android Studio. Furthermore, it also encouraged active recall, as I was forced to remember the syntax and practices I learned in prior days to continue adding code to the program. Much like the studies of the geometry and algebra study, being exposed to the same concepts repeatedly helped me with long-term retention.
Second, looking at online resources and other people’s code required a lot of elaboration towards my previous coding experience and the actual project at hand. Since most programming languages have similar fundamentals, I was able to quickly understand more primitive concepts like variables, loops, and functions through my learnings in Java and Python, two languages I am already familiar with. Next, since the tutorials and resources only focused on explaining the fundamentals of the coding concepts, I had to find ways to implement it into my own needs of the program I was creating, which required me to satisfy the needs of my program by incorporating my newfound learnings. This combination of already-existing high knowledge mixed with elaboration proves to be effective in learning, as shown by the elaboration study involving Canadian and German students.
The last effective learning practice was trying to understand the already existing code I had already made, which helped me recall the various concepts I implemented into the entire project. Sometimes I needed to add onto previously made components in the program to add extra features, so I had to remember the purpose of the revisited functions and code. As a result, I had to deliberately recall the concepts required to allow me to understand how certain sections worked. If I still failed to understand, I would correct myself by searching up the answer on Google, much like how you would look at the back of a flashcard after failing to remember the answer. Not only does this help with recall, but it also allows for elaboration by connecting newly learned practices into already existing systems fostered by previously learned concepts.
Throughout my coding journey, I inevitably faced countless problems that prevented the program from running or working properly. When I was tasked with finding out the error, I would instantly search up the error online, and spent little time critically thinking on what the cause was in the context of the program. Instead of such mindless practice, I could have engaged in something similar to rubber duck debugging where I would actively explain what was happening in the code to something/someone else, which would have helped me be more attentive and descriptive to what was going on in the program, increasing the likeliness of spotting any incompatibilities or issues. Instead of imagining the program should be working as intended, I would objectively go through each line, explaining its function to a stuffed animal or a friend. Not only would it have helped me with troubleshooting due to the benefits of elaboration in problem-solving, it also would have helped me improve concept mastery by having to connecting the code I wrote into the fundamentals of the programming language.
Although this would have hindered my progress in completing the project, I didn’t work on other coding-related projects at the same time. As a result, I only needed to focus on Kotlin and app development, which made remembering less effortful. Next time, I can consider working on another project at the same time to force me to switch between different concepts. By doing this, I am given an opportunity to differentiate the practices/syntax of Kotlin and app development from other languages and types of programs. Considering the concerning the higher percentage of discrimination errors in the “Why does Interleaving work?” study, switching contexts can help me in the future by not mixing up the syntax of different languages.
References:
Created:: 2021-10-10 15:10