Topic 1 – Licenses
How did the lecture on copyleft licenses informed your license choice?
As the creator and contributor to an open-source project, I had to make sure licenses were researched and added wherever necessary as a key part of maintaining good open-source practice.
Since my project is multifaceted—comprising a website, a public repository for student work, individual code files for each lesson, and the lesson delivery itself—I needed to address licensing and attribution carefully for each part, or at least make a clear attempt to do so. This involved adding appropriate licenses and ensuring proper attribution, all of which is documented transparently. As this was quite an unconventional project, there wasn’t much direct guidance provided in class, and I didn’t have sufficient time to ask all the questions I wanted. Therefore, much of my approach has been based on general research, after-class materials, and my own judgement. Naturally, I expect to refine and adjust this as I progress further into the project.
Initially, I was hesitant and confused about why such a simple piece of code for teaching coding would require copyright protection. The code was straightforward and simple so it seemed unlikely that it needed legal safeguards. It was probably similar to code found elsewhere, as it mainly demonstrated the foundational principles of the curriculum, with a few additions and lesson notes.
As I explored licensing further, I came to understand its importance. Although the code itself was simple, it formed part of a larger & structured curriculum. Within this context, the code served a specific and intentional role in delivering educational content. Its value lay not in complexity but in its function as part of an integrated framework. This gave the work meaning, coherence, and originality as a component of intellectual property. That insight made clear why copyright is not only applicable but essential—it protects the integrity and authorship of the entire curriculum, not just isolated parts.
While I wrote the code modules, I recognise that both the code and curriculum were influenced by many sources: previous lesson plans and open educational resources. Although I may not be able to directly attribute my code to others, it is natural that simple concepts reflect those of earlier contributors. For this reason, I committed to transparency and respect for the collaborative nature of educational content. I wanted thus to go with a permissive license that allows others to freely use, adapt, and build upon this work, just as I have benefited from the contributions of others.
After reviewing various licenses and studying class materials on copyleft—which allows others to freely use, modify, and distribute a work as long as derivative works are shared under the same license, unlike traditional copyright that grants exclusive control to the creator—I chose the Creative Commons Attribution (CC BY) for my curriculum and site, which is the most permissive. Creative Commons licenses are tailored for non-software creative works, such as lesson plans, textbooks, website content, videos, and other educational materials. They offer flexible terms for sharing and attribution that suit the way creative content is typically reused, adapted, and credited, which was suitable for my intent to openly share educational resources while ensuring proper recognition. For my coding, I opted for the standard MIT License. For the coding parts themselves, the MIT License is specifically designed to handle software and code. It allows others to freely use, modify, and distribute the code in my teaching curriculum with minimal restrictions, while legally protecting me as the creator. This made it ideal for the programming examples within the curriculum.
For the student work repository, I applied a more restrictive Creative Commons licence—the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Licence (CC BY-NC-ND 4.0)—to respect students’ ownership of their work and prevent unauthorised reuse or modification. Despite researching, I was unsure if this was best practice: whether to use the same licence as my curriculum or code, since the student work is derived from there, or to restrict use entirely, as the work isn’t technically mine. Since these student responses and assignments are their original creations based on my curriculum, I concluded from class sources and my own research that they retain ownership and may not want their work freely copied, altered, or used commercially without permission. The more permissive MIT licence would not adequately protect their rights, so I chose the more restrictive Creative Commons licence.
Separating the licenses helped me start to learn and understand how each part of my project can be used, even though there is a long way to go. The code portions are governed by the MIT License, enabling technical reuse and development, while the overall curriculum and website content fall under a Creative Commons license to encourage sharing and adaptation with appropriate attribution.
References
https://pzwiki.wdka.nl/mediadesign/Open_licenses
https://labs.creativecommons.org/2011/demos/license-layers
https://opensource.guide/starting-a-project/#your-pre-launch-checklist
https://monoskop.org/images/1/1e/Liang_Lawrence_Guide_to_Open_Content_Licenses_v1_2_2015.pdf
https://en.wikipedia.org/wiki/Copyleft
https://pzwiki.wdka.nl/mediadesign/Open_licenses
Topic 2 – Open Source Collaboration
How did different presentations and study cases on open and collaborative coding projects inspire your approach to your contribution?
Based on the lecture on open-source collaborative production case studies and my own research into collaborative coding projects, my main inspiration came not from the case studies themselves but from the governance models section. I was particularly drawn to the founder-leader model and the idea of a Benevolent Dictator For Life (BDFL). This model is most common in new or small projects where the individual or group who started the project administers it, sets the vision, and controls code merges. I really like this approach because it offers me a lot of personal freedom. I also explored p5.js education resources and noticed many amazing open-source lessons and workshops are led by one or two people who designed them themselves. I love the idea of pioneering something, leading a small group or one-on-one sessions that gradually grow, while I maintain the creative vision and direction for the project.
Even though my project started small with one-on-one lessons, as mentioned and demonstrated in the lecture, the founder-leader model’s limitations became clear as it grew. Founder-leaders can become bottlenecks for decision-making. Although I started the project, managing everything alone became overwhelming, and I began to wonder if I should have adopted more of a do-ocracy approach, where governance is more implicit – but ultimately, I did not have the capacity to be able to find and approve collaborators for this project, which might have been a really good add to better the outcome.
In the Week 9 lecture, we discussed the prompt:
“Starting your own open source project usually means also being a maintainer. Being inherently public and collaborative, how will you work with people and diverse feedback? How can you ensure the community around your project is healthy and inclusive?”
This got me thinking about my own approach. I planned to hold the workshop/lessons with just one person and get deep feedback—since I don’t know many people—but with the goal to gradually expand to other animation students and iteratively improve as I gained feedback each time. Because of this, my first conducting of the lessons and the lesson delivery was somewhat unconventional. Instead of following a strict chronology, there was a lot of back-and-forth about what was clear, what could be added or removed, and even how my speaking style might change for clarity. I documented all feedback and implemented it as best as I could within the timeframe, and I recorded this process in my blog.
Looking ahead, for a larger and more refined curriculum and workshop, I hope to use open Padlets provided after a lesson, as we do in class, to gather anonymous feedback continuously, remain open to critique, and follow open source best practices, such as creating a clear code of conduct (which I have yet to explore in depth). This project has been very personal and enjoyable for me—more so than a typical debugging or translation task—because it is hands-on and collaborative, and I had more control over it, which worked well for me. I’m excited to extend it in the future.
References
https://opensource.guide/starting-a-project/#your-pre-launch-checklist
https://www.redhat.com/en/blog/understanding-open-source-governance-models
Topic 3 – Community
What strategies and methods did you find relevant when coming closer to the communities and projects you are contributing to?
My communities were two-fold. On one hand, the student I worked with and the prospective students formed my immediate community. On the other hand, I hoped that my educational resource built with p5.js could eventually become part of the broader p5.js community, gaining recognition and being featured once it grew large and polished enough.
In terms of the first community—the student I taught and prospective students—the biggest factor that helped me engage better was confidence. My first two lessons were a bit shaky, but as I delivered more, I became more assertive, and that confidence translated clearly across the screen. I learned that in a founder-leader governance model, when the community or individual believes the founder knows what they’re talking about, they engage more actively and learn more effectively.
The second key learning was the importance of being available and supportive. While this level of involvement might not be typical in larger communities, because this was a 1-on-1 setting, I could jump on calls whenever I was free to walk them through confusing parts—like when my student couldn’t understand my documentation. I helped them live by improving the repo together, adding code comments, and explaining things in real time and repeatedly. I realised how effective live, hands-on collaboration can be in fostering community engagement, even if it’s not always scalable.
This led me to think about sustainability. To make students feel supported even when I’m not there live, I want to include fun video recordings, supportive materials, other people’s perspectives on the concept, and reading resources—so there are multiple learning paths available for every lesson.
Finally, it was important to show students that their work and feedback were valued. I did this by incorporating their suggestions into future lessons, openly acknowledging their input, and protecting their contributions with the right license in the student work repo.
In terms of the p5.js community itself, I was only able to initiate a pull request fairly late into the development of my lessons, curriculum, and website, so I didn’t expect much back-and-forth or interaction to help me understand what an effective communication strategy might look like. Through the pull request I initiated, I learned more about the technical process, codes of conduct, and best practices involved in contributing, but less about the community dynamics themselves, since interaction was limited. However, I did notice that the p5.js community is quite diverse and welcoming to contributions of all levels—especially in the area of educational resources. This made me feel more at ease and welcomed. It also made me realise how important it is to display a diverse range of examples, so that contributors who might feel intimidated or unsure about the quality of their work still feel encouraged to participate. This insight led me to include a note in my student work repository stating that all kinds of work—unfinished, unpolished, or basic—were welcome. My aim was to create an encouraging environment that valued learning and participation over competition or perfectionism.
When I had reached out for translations, I didn’t receive a response until much later, which made it difficult from these encounters to gauge how to engage effectively with the community. However, based on the class material on open source collaboration, as well as conversations with peers about their own contributions, I’m developing a better understanding of how to engage with such communities. In future, I plan to apply these principles by, for example, reaching out to moderators on platforms where they’re most active, often Discord, ensuring they are open to contributions, following any posted codes of conduct, and communicating through the appropriate channels.
References
https://dev.to/buildwebcrumbs/navigating-open-source-a-guide-to-effective-community-engagement-5gb9
https://docs.github.com/en/site-policy/github-terms/github-community-code-of-conduct
Leave a Reply