Organized by Ubuntu Nepal in collaboration with GNOME Nepal.
On Sunday, August 30, 2026, we conducted a session titled “Introduction to Open Source Communities, Linux and GNOME” at Madan Bhandari Memorial College (MBMC).
The session was conducted by three of us:
- Sailesh Singh (@saileshsingh) : Co-lead of Ubuntu Nepal and GNOME Nepal, System Network Administrator
- Shraddha Tiwari (@shraddhatiwari) : AI Engineer and open-source advocate
- Aaditya Binod Yadav (@aadityabyadav) : Full Stack Engineer and open-source contributor
We had around 50 undergraduate IT students participating in the session.
The session covered open source, communities, Linux, distributions, setup, and hands-on learning.
The Session
We started by introducing ourselves, GNOME Nepal, and Ubuntu Nepal. We shared how we started our journeys in open source, how communities helped us grow, and some of the things we have been involved in so far.
From there, we introduced students to open source. We discussed what it means, why it matters, and why contributions are not limited to coding. We wanted students to understand that open source is built around people and collaboration, and there are many ways to participate in a community.
The session then gradually moved through the following journey:
Open Source
↓
Communities
↓
Linux
↓
Linux Distributions
↓
Installation Methods
↓
Terminal
↓
Files and Directories
↓
Git
↓
GitHub
↓
Collaboration
↓
Pull Requests
↓
CI/CD
↓
Deployment
We introduced Linux and tried to clear up some common misconceptions around Linux, the Linux kernel, and Linux distributions. We discussed where Linux is used and the opportunities it creates in areas such as cloud computing, DevOps, system administration, networking, and other parts of the industry.
We also introduced several distributions and explained that different distributions exist for different purposes and users. Students were then shown different ways of getting started with Linux, including direct installation, virtual machines, and WSL.
After that, we moved into the hands-on part. We introduced the terminal, files and directories, basic Linux concepts, and commands. We also included quizzes during the session to keep things interactive and check how well students were following.
Git and GitHub: Starting From Scratch
The second major part of the session was Git and GitHub.
One thing we quickly realized was that many students had heard about these technologies or knew some of the theory, but practical experience was limited. Because of that, we decided to start from the beginning.
We covered Git configuration, repositories, adding files, commits, remotes, and pushing changes to GitHub.
For the practical session, I prepared a repository:
Sailesh-Singh/simpledemo — Practice Repository
Students could make changes, push them, and experience collaboration by creating their first Pull Request.
However, we did not want to stop at just:
git init → git add → git commit → git push
We wanted students to see what could happen after the code leaves their local machine.
So, we introduced a simple CI/CD workflow:
Local Development
↓
Git Commit
↓
Push to GitHub
↓
Continuous Integration
↓
Build
↓
Checks
↓
Artifact
↓
Deployment
↓
Live Website URL
This was one of the parts we were happiest about. Students could see the journey from writing something locally to pushing it to a remote repository, triggering automation, building the project, performing checks, and finally deploying it to a live URL.
For us, this was important because we wanted to introduce students to something closer to a real-world workflow, not just a list of Git commands.
What We Experienced During the Session
The session went well, but as instructors, we also experienced several challenges.
The biggest one was the difference between theoretical knowledge and practical experience. Many students were familiar with some concepts, but when it came to actually opening the terminal, configuring Git, installing tools, or resolving an error, we had to start from the basics.
Another challenge was the OS environment.
Everyone was using something different. Some students were on Ubuntu, Fedora, and Arch-based systems, while others were using macOS or different setups. Naturally, this meant different commands, package managers, installation methods, and configurations.
We could see the effect immediately during the hands-on part. Some students moved quickly, while others were still setting up their environment. At times, we had to repeat the same instruction two or three times and move between students to resolve individual problems.
This was probably the biggest lesson from the session:
A hands-on workshop is very different from a presentation.
You can prepare the content and slides, but once everyone starts running commands on their own machines, the actual environment becomes part of the workshop.
What We Will Improve
This experience gave us a clear idea of how we can make future sessions smoother.
The first thing is preparation before the actual event. Instead of spending a significant amount of time on installation and configuration, we plan to provide prerequisites and a setup guide beforehand.
A basic checklist could look like this:
✓ Git installed
✓ GitHub account created
✓ Terminal working
✓ Internet working
✓ Required repository accessible
✓ Editor installed
✓ Git configured
We also plan to recommend a common environment and configuration wherever possible. Supporting every possible distribution and operating system during a beginner-level hands-on workshop can slow down the entire session.
Another important improvement will be the teaching pace. We found that demonstrating each step on the screen and allowing students to follow works much better than explaining several steps verbally and expecting everyone to catch up.
For future sessions, we want to:
- Share prerequisites before the event.
- Provide installation and setup instructions in advance.
- Use a common environment where possible.
- Verify everyone’s setup before starting the hands-on part.
- Teach slowly and demonstrate each step on screen.
- Divide the practical session into smaller checkpoints.
- Have additional people available to help with individual issues.
- Provide repositories and resources for students to continue practicing after the session.
Final Thoughts
Overall, this was a good experience for us.
Our goal was not to make students experts in Linux, Git, or CI/CD within a single session. We simply wanted to give them a practical introduction to a world that many of them had previously known mostly through theory.
By the end, students had seen the journey from open source and communities to Linux, Git, GitHub, collaboration, Pull Requests, CI/CD, and deployment.
What made us happiest was that students did not only leave with the idea of:
git init,git add,git commit, andgit push.
They were also introduced to the idea of what happens beyond that: collaboration, automated builds, checks, artifacts, and deployment.
We also distributed stickers and merchandise after the session and received a token of love from the department and faculty, which we really appreciated.
A big thank you to Madan Bhandari Memorial College, the faculty, and all the students who participated.
And a special thanks to my fellow instructors, Shraddha Tiwari and Aaditya Binod Yadav, for being part of this session.
This session was successful, but the challenges were equally valuable. They helped us see what worked, what slowed us down, and what we need to improve.
Hopefully, the next one will be smoother—and we will keep improving from what we learned from this experience.