SWE 406: Open Source Software

Development and Applications

By

E. K. Olatunji

Software Engineering Programmme

FCAS
Thomas Adewumi University, Oko

April 2024
Course Description
• The course "Open-Source Software Development and Application"
provides an in-depth exploration of open-source software development
principles, methodologies, and best practices.
• It aims to equip students with the necessary skills and knowledge to
actively participate in open-source projects and contribute effectively
to the open-source community.
• Students will gain hands-on experience in using open-source tools and
frameworks, collaborating with developers worldwide, and creating
high-quality software applications
Course Contents
• Concepts, principles and applications of open-source software. Open-
source software development process.
• Economy, business, societal and intellectual property aspects of open-
source software.
• Hands-on experiences on open source software and related tools
through developing various open source software.
• Applications such as mobile application and web applications building
on existing open source frameworks and application development
platforms.
Course Objectives
• To discuss concepts, principles & applications of Open-source
software (OSS) development
• To discuss the processes, procedures, tools and trends in OSS
development
• To describe important variants of OSS
• To explain different OSS licenses and their implications
• To describe different ways of contributing to OSS project
• To describe and demonstrate the steps involved in creating a simple
project on GitHub platform
• To explain the meaning reasons, adv and disadv of forking
Learning Outcomes
• At the end of the course students should be able to :
• 1. list & distinguish among 3 variants of OSS
• 2. List and explain uses of 5 tools in OSS development
• 3. Explain the legal implications of two (2) OSS licenses
• 4. Specify and explain 5 guidelines on documentation writing
• 5. Explain at least 5 ways of contributing to an OSS project
• 6. Describe the steps involved in creating a simple project on the
GitHub
• Etc
Course Contents Sequencing
S/N SWE 406 Open-Source Software Development & Application No of hours
1. Week 1-2 Intro to OSS Concepts and applications 4hours
2. Week 3 OSS Variants and licenses 2 hours
3. week 4-5 Processes, procedures, Tools and trends in OSS development 4 hours
4. Week 6-7 OSS project – Contributing, selecting, writing documentation 4 hours
5 Week 8 CA1
6 Week 9-10 Important technical operational terms on OSS Platform and 4 hours
projects
7 Week 10 Steps in creating a simple project on GitHub Platform 2 hours
8 Week 11 Concept, reasons adv and disadv of forking OSS projects 2 hours
9 Week 12 CA 2
10 Week 13 etc
Reference Materials
• 1. w3school.com
• 2. docs.github.com
• 3. Online Resources
Reading List
• Producing Open Source Software: How to Run a Successful Free Software Project by Karl Fogel
• The Cathedral & the Bazaar: Musings on Linux and Open Source by an Accidental Revolutionary by Eric S.
Raymond
• Open Source Licensing: Software Freedom and Intellectual Property Law by Lawrence Rosen
• Git Pocket Guide: A Working Introduction by Richard E. Silverman
• GitHub For Dummies by Sarah Guthals, Phil Haack, and Jared DeMott
• Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation by Jez
Humble and David Farley

• The Art of Agile Development by James Shore and Shane Warden

SWE 406 Lecture Note Draft1a

Open-Source Software Development: A

Beginner’s Guide
From: https://www.knowledgehut.com/blog/web-development/open-source-software-development 03-
04-2024

By Vikra Gupta, March 2024

0. Introduction

Open source represents a paradigm shift in software development, prioritizing transparency,

collaboration, and community engagement over the restrictive practices of proprietary models.

Unlike closed-source software, where only the original creators have access to the source code,
open-source software is freely available for anyone to use, modify, and enhance. This approach
not only democratizes software development, allowing individuals and organizations worldwide
to contribute to its evolution, but also fosters innovation and flexibility.

High-quality, robust software solutions often emerge from this ecosystem, thanks to the
collective input and scrutiny of a diverse community of developers. Open-source principles
champion the sharing of knowledge and the building of software in a collaborative, public
manner. This guide delves into the essence of open-source software development, its
foundational principles, key benefits, and practical steps for newcomers to contribute effectively
to open-source projects.

By embracing open-source practices, developers can not only improve their skill sets but also
contribute to the technological commons, paving the way for more secure, efficient, and
innovative software solutions.

1. What is Open-source Software Development?

Now, let’s understand about Open-Source software development. Basically, it refers to the
practice of creating software with source code that anyone can inspect, modify, and enhance. It
emphasizes collaboration, transparency, and community-driven development.

Also on the flip side, unlike closed-source or proprietary software, where the source code is
restricted, Open-Source software encourages sharing and collaboration among developers
worldwide. This approach promotes innovation, accelerates software development, and often
leads to more reliable and secure software products. In essence, Open-Source software
development democratizes technology by making it accessible to everyone.

1
Example of Open-Source Software

One notable example of Open-Source software is Mozilla Firefox, a popular web browser
developed and maintained by a global community of volunteers and contributors. Firefox's
source code is publicly accessible, allowing users to examine, modify, and distribute it freely.

You should be passionate about software development to solve a problem irrespective of domain
or industry. You can opt for some software programs/courses. You can follow this link to learn
about such programs, Software Engineer programs near me.

2. Key Characteristics Distinguishing Open-Source Software

Open-source software stands out in the digital landscape through its unique approach to
development and distribution. Here's a closer look at its defining characteristics:

• Open-source code is available for inspection and modification.

• Global Collaboration: Development involves a diverse community of contributors.
• The Open-Source license allows users to freely use, modify, and distribute the software.
• Rapid development cycles and innovative solutions are often the result of collaboration.
• The software can be customized and adapted to meet the needs of the user.

These key characteristics not only differentiate open-source software from its proprietary counterparts
but also underscore its potential for fostering innovation, flexibility, and a sense of community among
developers worldwide.

3. Importance of Open-Source Software Development

It is crucial that open-source software is developed to drive innovation, foster collaboration, and
democratize access to technology. Through its free and open access to software solutions,
transparency, and rapid iteration and improvement, it empowers individuals and organizations.

Additionally, Open-Source software often leads to cost savings for businesses since licensing
fees and vendor lock-in are eliminated. Moreover, it encourages knowledge-sharing and
community engagement, which are essential to sustainable technological advancement in today's
interconnected world.

4. Types of Open-Source Software

• Operating Systems: Examples include Linux distributions like Ubuntu, Debian, and Fedora.
• Web Browsers: Mozilla Firefox, Chromium, and Brave are popular Open-Source web browsers.
• Office Suites: LibreOffice and Apache OpenOffice offer Open-Source alternatives to proprietary
office software.
• Content Management Systems (CMS): WordPress, Joomla, and Drupal are widely used Open-
Source CMS platforms.
• Development Tools: Git, Visual Studio Code, and Eclipse are examples of Open-Source
development tools.

2
 5. Open-Source Software Development Method

There are some methods that every software developer should follow a collaborative and
transparent method where source code is accessible to the public for inspection, modification,
and distribution. The method emphasizes community-driven contributions, peer review, and
open communication channels. Developers work collectively to identify bugs, suggest
improvements, and implement new features.

This method encourages diverse perspectives and fosters a culture of innovation and continuous
improvement. Also, Open-Source projects often adhere to established coding standards and
documentation practices to ensure clarity and maintainability.

I have seen developers use a lot of open software tools for large-scale application building. If
you are interested in building large-scale, containerized applications you can look at a Web
Development certificate online

6. Open-Source Software Development Process

The Open Source software development process typically involves several key stages:

1. Planning and Ideation: Developers and contributors discuss project goals, features, and
roadmap.
2. Coding and Implementation: Developers write and review code, adhering to project guidelines
and best practices.
3. Testing and Quality Assurance: The software undergoes rigorous testing to identify and address
bugs and compatibility issues.
4. Community Review and Feedback: Contributions are reviewed by the community, fostering
transparency and accountability.
5. Documentation and Release: Comprehensive documentation is prepared to guide users and
developers. The software is released with proper versioning and changelogs.
6. Maintenance and Support: The project continues to receive updates, patches, and community
support to ensure its longevity and relevance in the ecosystem.
7. Challenges and Considerations in Open-Source Software Development

1. Sustainability: Maintaining momentum and attracting contributors over the long term can be
challenging.
2. Governance and Decision Making: Balancing community-driven decision-making with project
leadership requires clear communication and consensus-building.
3. Intellectual Property: Ensuring compliance with licenses and addressing potential copyright or
patent issues is crucial.
4. Security: Managing security vulnerabilities and ensuring timely patches and updates are
essential to maintain trust in the software.
5. Documentation and User Support: Providing comprehensive documentation and responsive user
support can be resource-intensive but is vital for user adoption and retention.
6. Funding and Resources: Securing funding and resources to sustain development, infrastructure,
and community initiatives can pose significant challenges.

3
 7. Open-Source Software Business Models

• Support and Services: Companies provide high-quality support, consulting and training to users
of open-source software.
• Dual Licensing: Offering software both as open source and under a license that allows
commercial use with additional features or support.
• Free. Model: Provides a basic version of free software, paying for additional features or
commercial support.
• Donation-based: Support from donations or crowdfunding to support development and
maintenance.
• Commercial plugins: Developing and selling own plugins or extensions Open source software.

8. Future Trends in Open-Source Software Development

• Increased adoption: Companies continue to adopt open source for its flexibility, innovation and
cost-effectiveness.
• Broader collaboration: Expect more cross-disciplinary collaboration and partnership within the
open-source community.
• Focus on security: With a growing threat environment, security features and best practices will
receive more attention.
• Artificial intelligence and machine learning: open-source AI and ML projects are growing and
developing significantly.
• Use of containers and microservices: The adoption of container technologies such as Kubernetes
and Docker continue to grow and the demand for open-source solutions increases.

9. Difference Between Open Source and Closed Source Software

I’ve listed down the differences between open source and closed software projects in the table
below, this gives you a good summary to understand the differences:

Feature Open Source Software Closed Source Software

Source Code Available and accessible to anyone Proprietary and not accessible.
Cost Often free or low-cost Requires licensing fees.
Customization Can be customized and modified. Limited customization options.
Community Relies on community contributions. Developed and maintained by the
owning company.
Flexibility Offers flexibility and adaptability Limited flexibility and vendor lock-in
may occur.

10. Advantages and Disadvantages of Open source Software Development

Some of the open-source advantages and open source software disadvantages are listed below

4
Advantages

1. Cost-effective: License fees do not reduce operating costs.

2. Openness: Source code accessibility increases trust and innovation.
3. Community collaboration: Diverse contributions improve quality and functionality.
4. Flexibility: Customization options meet a wide range of user needs.
5. Security.: Fast error detection and correction ensures robustness.

Disadvantages

1. Support and Documentation: The level of support and documentation is inconsistent.

2. Integration Issues: Compatibility issues with proprietary software.
3. Fragmentation: Differences between versions and distributions can cause confusion.
4. Dependency Risks: Relying on community support can cause issues to be resolved more slowly.
5. Learning curve: Open-source tools and management processes can take time and effort.

You should always evaluate open-source software disadvantages, as it is important while

building in-house or enterprise large-scale applications. I have listed most of the advantages and
disadvantages of open-source software in the above programs.

Conclusion

Open-source software development empowers users and promotes collaboration, innovation, and
transparency in the technology sector. Despite its challenges, its advantages outweigh its
disadvantages, making it a compelling choice for individuals and organizations looking for cost-
effective, customizable, and reliable software solutions. Embracing open-source principles not
only promotes technological development but also stimulates engagement and knowledge
sharing in the digital age.

10. Frequently Asked Questions (FAQs)

1. What is an example of Open Source software?

An example of Open Source software is the Linux operating system. Linux is widely used
around the world in various forms, including distributions like Ubuntu, Fedora, and Debian. It is
known for its robustness, flexibility, and active community that continuously contributes to its
development.

2. What are the 4 principles of Open Source software?

The four principles of Open Source software are as follows:

• Free Redistribution: The software can be freely given away or sold.

• Source Code: The source code must be available to the public, and the license must allow
modifications and derived works.

5
 • Derived Works: Modifications and derived works are permitted and must be allowed
under the same license terms.

• Integrity of The Author's Source Code: While modifications are allowed, the license may
require that modifications be distributed as patch files.

3. Who owns Open Source software?

Open source software is not owned by any individual or company. All parts of the software are
copyrighted by their respective authors. However, it is available to the public under a license that
allows users to freely use, modify, share, and distribute the software as long as they follow the
license terms.

4. What are the features of Open Source software?

The features of Open Source software include:

• The source code is freely available to everyone who wishes to review, modify, or improve it.

• Developers can use the software for any purpose, modify it, and share their modified versions.

• There is often a strong community of developers and users who contribute, support, and help
develop the software.

• The open nature of software ensures clarity because users can see and understand how the
software functions.

By Vikram Gupta

= = ================================ ====================================

6
SWE 406 Lecture Note Draft1b

OSS Variants, Licences and Business Models

From Tutorialspoint,com

open source software, Freeware, Shareware, and Proprietary

Software
A software whose source code is freely distributed with a license to study, change and further
distributed to anyone for any purpose is called open source software. Open source software is
generally a team effort where dedicated programmers improve upon the source code and share
the changes within the community. Open source software provides these advantages to the users
due to its thriving communities −

• Security
• Affordability
• Transparent
• Interoperable on multiple platforms
• Flexible due to customizations
• Localization is possible

Freeware
A software that is available free of cost for use and distribution but cannot be modified as its
source code is not available is called freeware. Examples of freeware are Google Chrome,
Adobe Acrobat PDF Reader, Skype, etc.

Shareware
A software that is initially free and can be distributed to others as well, but needs to be paid for
after a stipulated period of time is called shareware. Its source code is also not available and
hence cannot be modified.

Proprietary Software
Software that can be used only by obtaining license from its developer after paying for it is
called proprietary software. An individual or a company can own such proprietary software. Its
source code is often closely guarded secret and it can have major restrictions like −

1
 • No further distribution
• Number of users that can use it
• Type of computer it can be installed on, example multitasking or single user, etc.

For example, Microsoft Windows is a proprietary operating software that comes in many
editions for different types of clients like single-user, multi-user, professional, etc.

What is open source software? From: IBM

The categories of open source software cited by IT professionals as the most common within
their organizations’ deployments include:

• Programming languages and frameworks

• Databases and data technologies
• Operating systems
• Git-based public repositories
• Frameworks for artificial intelligence, machine learning or deep learning

From other sources

** Examples of OSS Programming Languagess are

Python. Python is an interpreted, high-level, general-purpose programming language. ...

• Java. Java is an object-oriented, general-purpose programming language. ...

• C/C++ C and C++ are low-level, general-purpose programming languages. ...
• JavaScript. ...
• PHP. ...
• Rust. ...
• Go. ...
• R.

** Examples of OSS Databases and data technologies are

• MySQL. MySQL is the most popular open source database. ...

• PostgreSQL. PostgreSQL is another popular open source database system that offers
reliability, advanced features and flexibility. ...
• MariaDB. MariaDB is considered a clone of MySQL. ...
• MongoDB. ...
• SQLite. ...
• CockroachDB. ...
• Redis. ...
• CouchDB.

2
** Examples of OSS Operating Systems are
Linux, Open Solaris, Free RTOS, Open BDS, Free BSD, Minix, etc.

** Examples of OSS Git-based public resipository are

freeCodeCamp/freeCodeCamp.

• EbookFoundation/free-programming-books.
• jwasham/coding-interview-university.
• sindresorhus/awesome.
• kamranahmedse/developer-roadmap.
• public-apis/public-apis.
• donnemartin/system-design-primer.
• facebook/react.

** Examples of OSS Frameworks for AI are

TensorFlow, pytorch, Keras, Open AI, Rasa, Amason sagemaker, etc

3
From : Tutorialspoint

Open source software licenses

Again, Stallman’s GPL stipulated that anyone could rewrite his software however they saw fit, as
long as the resulting code was published free for all to use. In this way, the GPL copyleft license
created a new kind of quasi-public-domain intellectual property, yet with legally enforceable
restrictions imposed by the original copyright holder to protect against later claims of restrictive
ownership by others.

Since then, numerous open source software licenses have been developed; the Open Source
Initiative lists over 100 approved open source licenses. Some of these allow proprietary products
to be created from open source code.

Open source licenses are sometimes categorized as “permissive”—that is, allowing users to
copyright their own works—or “protective,” like copyleft. The MIT and BSD open source
licenses are the most commonly-used permissive licenses, while GPL remains one of the most
commonly used protective copyleft license. Numerous alternative licenses are compatible with
GPL or MIT, meaning that that software code written under this license can be used in another
application which uses the GPL or MIT license.

Open source business models

While it seems that the creation of open source software is a high-minded, even charitable
enterprise, there is work involved in creating, maintaining and evolving it, and getting this work
done is a matter of money. Fortunately there are a number of ways that open source projects—
and companies built around them—can prosper.

One route is through charitable contributions to foundations. Corporations have an interest in

supporting open source software since it provides such significant functionality at such
significant cost savings, and will often contribute funds and even dedicate salaried employees to
work on open source projects. But this provides primarily for long-term maintenance of the
technology, and does not lead to profits for the open source project.

A more common business model is to charge customers for support and expertise. In 1993, Red
Hat® began selling its enterprise redistribution of the Linux operating system, charging
customers for support and added features aimed specifically at solving problems an enterprise
might encounter when deploying a non-curated, continually updated operating system. In 2012,
Red Hat became the first open source software company to surpass USD 1 billion in revenue; in
2019 IBM® Corporation acquired Red Hat for USD 34 billion, the largest software acquisition
in history.

4
WordPress, originally a blogging platform, is now widely used for building, managing and
hosting websites. WordPress operates as a cloud-based or software-as-a-service platform, and
charges customers tiered subscription fees for web hosting, support and added site functionality
(for example, e-commerce capability or SEO tools).

Other open software creators charge nothing for their software, but earn significant revenues due
to the traffic their software generates. For example, GitHub earns revenues based on advertising
that appears on their site; Mozilla Firefox earns revenues from search engines it supports.

= = ==============

5
SWE 406 ChatGpt Answers to some OSS Questions
Meaning, Processes, Procedures, Tools and Trends in OSS development
1. What is open-source software with reference
Open-source software (OSS) refers to computer software with its source code made available
and licensed with a license that grants the right to study, modify, and distribute the software to
anyone for any purpose. This open approach contrasts with proprietary software, where the
source code is typically kept secret and controlled by the software's owner.

The Open Source Initiative (OSI) provides a widely accepted definition of open source
software, known as the Open Source Definition. According to this definition, open source
software must meet criteria such as free redistribution, access to the source code, and allowing
modifications and derived works.

Reference:
- Open Source Initiative. (n.d.). The Open Source Definition. Retrieved from
https://opensource.org/osd

Open-source software has become increasingly popular due to several advantages:

1. **Transparency**: Users can inspect the source code to understand how the software works,
which enhances transparency and trust.

2. **Community Collaboration**: Open-source projects often have vibrant communities of

developers contributing improvements, bug fixes, and new features.

3. **Cost Savings**: Open-source software is typically available for free, reducing the cost of
software acquisition and licensing for individuals and organizations.

4. **Customizability**: Users can modify the software to suit their specific needs, providing
flexibility and customization options that may not be available with proprietary software.

1
5. **Innovation**: The open nature of open-source software fosters innovation by allowing
anyone to build upon existing code and share their enhancements with others.

6. **Security**: With many eyes scrutinizing the code, security vulnerabilities can be
identified and fixed more quickly in open-source software compared to proprietary software.

Examples of popular open-source software include the Linux operating system, the Apache
web server, the Mozilla Firefox web browser, and the WordPress content management system.
These projects demonstrate the widespread adoption and success of the open-source
development model in various domains.

2
2. What is open-source software development with refernce?
Open-source software development refers to the collaborative process of creating and
improving software by making its source code freely available for anyone to study, modify,
and distribute. It involves a community of developers who contribute code, report bugs,
suggest features, and review changes. Open-source development fosters transparency,
innovation, and collaboration among participants.

The Open Source Initiative (OSI) provides a widely accepted definition of open source
software development, emphasizing principles such as free redistribution, access to the source
code, and allowing modifications and derived works.

Reference:
- Open Source Initiative. (n.d.). The Open Source Definition. Retrieved from
https://opensource.org/osd

Key aspects of open-source software development include:

1. **Collaborative Model**: Open-source projects typically operate using a collaborative

model, where developers from around the world contribute code, documentation, and other
resources to improve the software.

2. **Public Access to Source Code**: The source code of open-source software is made
publicly available, allowing anyone to inspect, modify, and distribute it according to the terms
of the open-source license.

3. **Community Involvement**: Open-source projects rely on active participation from a

community of developers, users, and enthusiasts who contribute to the project's development,
testing, and documentation.

4. **Version Control Systems**: Version control systems such as Git are commonly used in
open-source development to manage changes to the source code, facilitate collaboration among
developers, and track the history of the project.

3
 5. **Issue Tracking and Bug Reporting**: Open-source projects often use issue tracking
systems to manage bug reports, feature requests, and other issues reported by users and
developers. This helps in prioritizing and resolving issues efficiently.

6. **Licensing**: Open-source software is typically distributed under licenses approved

by organizations such as the OSI, which ensure that the software remains open and free for
anyone to use, modify, and distribute. Common open-source licenses include the GNU
General Public License (GPL) and the MIT License.

7. **Governance Models**: Open-source projects may adopt various governance models to

manage decision-making processes, resolve conflicts, and maintain the project's direction.
Common governance models include meritocracy, consensus-based decision making, and
benevolent dictatorship.
8. **Iterative Improvement**: Open-source software undergoes continuous improvement through
iterative development cycles. Developers release frequent updates, patches, and new versions to
address bugs, add features, and enhance performance based on feedback from the community.

Overall, open-source software development empowers individuals and communities to

collaborate on building high-quality software that is freely available to everyone. It has become
a prominent model for software development in a wide range of domains, driving innovation,
and democratizing access to technology.

Reference:
- Raymond, E. S. (1999). The Cathedral & the Bazaar: Musings on Linux and Open Source
by an Accidental Revolutionary. O'Reilly Media.

Eric S. Raymond's book "The Cathedral & the Bazaar" is a seminal work that explores the
principles and practices of open-source software development. It provides insights into the
motivations, dynamics, and benefits of open-source development, drawing from
Raymond's experiences in the open-source community, particularly with the Linux
operating system.

4
3. What are the methods of open-source software development with reference?

Open-source software development encompasses various methods and practices that

facilitate collaboration, transparency, and community involvement. Here are some key
methods of open-source software development, along with a reference:

1. **Decentralized Development**: Open-source projects often adopt a decentralized

development model, where contributions come from a diverse community of developers
worldwide. This model allows for greater flexibility, innovation, and scalability, as
contributors can work independently on different aspects of the software.

2. **Collaborative Coding**: Collaboration is at the core of open-source development,

with developers contributing code, bug fixes, documentation, and other resources to the
project. Collaboration platforms such as GitHub, GitLab, and Bitbucket facilitate
asynchronous collaboration, enabling developers to share code, review changes, and
coordinate efforts effectively.

3. **Issue Tracking and Bug Reporting**: Open-source projects use issue tracking systems
to manage bug reports, feature requests, and other issues reported by users and developers.
These systems provide a centralized platform for tracking and prioritizing tasks, assigning
responsibilities, and communicating progress. Popular issue tracking platforms include
GitHub Issues, Jira, and Bugzilla.

4. **Version Control**: Version control systems, such as Git, are essential tools in open-
source development for managing changes to the source code, tracking revisions, and
facilitating collaboration among developers. Version control enables developers to work on
different features concurrently, merge changes seamlessly, and revert to previous versions
if needed.

5. **Community Feedback and Testing**: Open-source projects actively solicit feedback

from users and developers through mailing lists, forums, and community discussions.
Community feedback helps identify usability issues, prioritize feature requests, and
improve the overall quality of the software. Additionally, open-source projects rely on
community-driven testing to identify bugs, verify fixes, and ensure compatibility across
different platforms and environments.

6. **Release Management**: Open-source projects follow release management practices

to plan, schedule, and coordinate software releases. Release cycles may vary depending on
the project's size, complexity, and development pace. Some projects adhere to a time-based
release schedule, while others release new versions in response to specific milestones or
feature completions.

5
Reference:
- Fogel, K. (2005). Producing Open Source Software: How to Run a Successful Free
Software Project. O'Reilly Media.

"Producing Open Source Software" by Karl Fogel is a comprehensive guide that provides
practical advice and best practices for running successful open-source projects. It covers
various aspects of open-source development, including project management, community
building, and collaboration tools. Fogel draws from his extensive experience in the open-
source community to offer insights and strategies for managing open-source projects
effectively.

6
4. What are the processes of open-source software development with references?
Open-source software development involves several processes and practices that enable
collaborative creation, transparency, and community participation. Here are some key
processes of open-source software development, along with references:

1. **Requirement Gathering and Planning**: Similar to traditional software development,

open-source projects begin with gathering requirements and planning the scope of the project.
This involves defining user needs, feature requests, and project goals through community
discussions, surveys, and issue tracking systems.

2. **Design and Architecture**: Open-source projects may follow various approaches to

design and architecture, depending on factors such as project size, complexity, and
development methodology. Design decisions are often made collaboratively, with input from
developers, users, and other stakeholders.

3. **Coding and Implementation**: Developers contribute code to open-source projects by

forking the project repository, making changes locally, and submitting pull requests for review
and integration. Coding standards, style guides, and code reviews help maintain code quality
and consistency across the project.

4. **Testing and Quality Assurance**: Open-source projects rely on community-driven testing

to identify bugs, verify fixes, and ensure software quality. Testing practices may include unit
testing, integration testing, regression testing, and user acceptance testing. Continuous
integration (CI) systems automate the testing process and provide feedback to developers in
real-time.

5. **Documentation**: Comprehensive documentation is essential for open-source projects to

help users understand how to install, configure, and use the software. Documentation may
include user manuals, API references, tutorials, and troubleshooting guides. Documentation
efforts are often collaborative, with contributions from developers and users alike.

6. **Community Engagement and Support**: Open-source projects actively engage with the
community through mailing lists, forums, chat channels, and social media platforms.
Community members provide support, answer questions, and share knowledge and

7
experiences related to the project. Community engagement helps build a vibrant and inclusive
ecosystem around the project.

7. **Release Management**: Open-source projects follow release management practices to

plan, schedule, and coordinate software releases. Release cycles may vary depending on the
project's development pace, stability, and user feedback. Release announcements, release
notes, and versioning conventions help communicate changes and updates to users and
developers.

References:
- Fogel, K. (2005). Producing Open Source Software: How to Run a Successful Free Software
Project. O'Reilly Media.
- Osterloh, M., & Rota, S. (2007). Open Source Software Development — Just another Case
of Collective Invention? Research Policy, 36(2), 157–171. doi:10.1016/j.respol.2006.11.001.

"Producing Open Source Software" by Karl Fogel is a practical guide that provides insights
and best practices for running successful open-source projects. Fogel draws from his
experience in the open-source community to offer advice on project management,
collaboration tools, and community building.

The research article "Open Source Software Development — Just another Case of Collective
Invention?" by Osterloh and Rota explores the dynamics of open-source software development
and its similarities to other forms of collective invention. The authors analyze the motivations,
incentives, and governance structures that drive open-source projects to success.

8
5. What are the tools that are used for open-source software development?

Certainly! Open-source software development relies on a variety of tools and platforms to

support collaboration, version control, communication, project management, and more.
Here are some commonly used tools for open-source software development, along with a
reference:

1. **Version Control Systems (VCS)**:

- **Git**: A distributed version control system widely used for tracking changes in
source code during software development. Platforms like GitHub, GitLab, and Bitbucket
provide hosting services for Git repositories and collaborative features such as pull requests
and issue tracking.
- **Reference**: Chacon, S., & Straub, B. (2014). Pro Git. Apress.

2. **Issue Tracking and Project Management**:

- **GitHub Issues**: An integrated issue tracking system within GitHub repositories,
allowing developers to report bugs, suggest features, and track tasks.
- **Reference**: Dugger, M. (2015). GitHub Essentials. Packt Publishing.

3. **Communication and Collaboration**:

- **Slack**: A messaging platform for teams, facilitating real-time communication, file
sharing, and collaboration.
- **Reference**: Ray, T. (2017). Slack For Dummies. Wiley.

4. **Continuous Integration and Continuous Deployment (CI/CD)**:

- **Jenkins**: An open-source automation server for implementing continuous
integration and continuous delivery pipelines.
- **Reference**: Smart, J. (2011). Jenkins: The Definitive Guide. O'Reilly Media.

5. **Code Review and Collaboration**:

- **Gerrit**: A code review and collaboration tool designed for use with Git repositories,
often used in projects such as Android and Chromium.
- **Reference**: Luca, M., & Kapur, S. (2013). Gerrit Code Review. Packt Publishing.

6. **Documentation**:
- **Read the Docs**: A platform for hosting and generating documentation from source
code repositories, supporting various markup formats such as reStructuredText and
Markdown.
- **Reference**: Goldsmith, R., & Atienza, D. (2018). Writing for Software Developers.
Manning Publications.

9
7. **Wikis and Knowledge Management**:
- **MediaWiki**: An open-source wiki software used for collaborative documentation
and knowledge sharing.
- **Reference**: Kiser, L. (2016). MediaWiki Administrators' Tutorial Guide. Packt
Publishing.

These tools, along with many others, form the infrastructure that supports the collaborative
development of open-source software projects. They enable developers to work together
efficiently, manage projects effectively, and produce high-quality software that is freely
available to the community.

10
6. What are the procedures for open-source software development?

Open-source software development involves a set of procedures and practices that guide
the collaborative creation, maintenance, and distribution of open-source software. Here are
the procedures for open-source software development, along with a reference:

1. **Establish Project Governance**: Define the governance structure of the project,

including decision-making processes, contributor guidelines, and project leadership roles.
This ensures clarity and accountability within the project community.

2. **Define Project Scope and Goals**: Clearly define the scope and goals of the project,
including the target audience, desired features, and project milestones. This helps align the
efforts of contributors and maintain focus throughout the development process.

3. **Setup Version Control**: Create a version control repository (e.g., Git repository) for
the project to track changes to the source code and facilitate collaboration among
developers. Choose a hosting platform (e.g., GitHub, GitLab) that supports collaborative
features like pull requests and issue tracking.

4. **Establish Contribution Guidelines**: Define contribution guidelines for developers

interested in contributing to the project. This includes instructions for forking the
repository, submitting pull requests, adhering to coding standards, and licensing
requirements.

5. **Implement Issue Tracking System**: Set up an issue tracking system (e.g., GitHub
Issues, Jira) to manage bug reports, feature requests, and other project tasks. Use labels,
milestones, and assignees to organize and prioritize issues effectively.

6. **Adopt Continuous Integration**: Implement continuous integration (CI) to automate

the process of building, testing, and deploying the software. Use CI tools (e.g., Jenkins,
Travis CI) to run automated tests, detect errors early, and maintain code quality.

7. **Encourage Community Engagement**: Foster a vibrant and inclusive community

around the project by encouraging participation, providing support to contributors, and
organizing community events (e.g., hackathons, meetups, conferences). Use
communication channels (e.g., mailing lists, forums, chat platforms) to facilitate
discussions and collaboration among community members.

8. **Document the Project**: Create and maintain documentation for the project, including
installation instructions, user guides, API references, and contribution guidelines. Host the
documentation on platforms like Read the Docs to make it accessible and easy to update.

11
9. **Release Management**: Plan, schedule, and coordinate software releases to deliver
new features, bug fixes, and improvements to users. Follow versioning conventions (e.g.,
Semantic Versioning) and provide release notes to communicate changes and updates.

Reference:
- Fogel, K. (2005). Producing Open Source Software: How to Run a Successful Free
Software Project. O'Reilly Media.

"Producing Open Source Software" by Karl Fogel is a comprehensive guide that provides
practical advice and best practices for running successful open-source projects. Fogel's
book covers various aspects of open-source development, including project governance,
community building, version control, and release management. It offers valuable insights
into the procedures and processes involved in open-source software development.

12
7. Describe concisely the trends in open-source software development

Certainly! Here's a concise overview of the trends in open-source software development:

1. **Increased Adoption**: Open-source software is being increasingly adopted across

industries and sectors due to its cost-effectiveness, flexibility, and transparency.

2. **Collaboration Platforms**: Collaboration platforms like GitHub, GitLab, and

Bitbucket continue to play a crucial role in facilitating collaboration, version control, and
community engagement in open-source projects.

3. **Diversification of Contributors**: The contributor base of open-source projects is

becoming more diverse, with contributions coming from individual developers,
corporations, educational institutions, and non-profit organizations.

4. **Focus on Sustainability**: There's a growing emphasis on ensuring the sustainability

and long-term viability of open-source projects, including funding models, governance
structures, and support mechanisms.

5. **Emergence of New Technologies**: Open-source development is driving innovation

in emerging technologies such as artificial intelligence, blockchain, Internet of Things
(IoT), and edge computing, leading to the creation of new open-source projects and
ecosystems.

6. **Shift Towards Microservices and Containers**: Open-source technologies like

Kubernetes, Docker, and Istio are gaining traction for building and managing
microservices-based architectures and containerized applications.

7. **Rise of DevOps Practices**: Open-source tools and practices that support DevOps
principles, such as continuous integration, continuous delivery, infrastructure as code, and
site reliability engineering, are becoming increasingly popular in open-source development
workflows.

8. **Focus on Security and Compliance**: There's a growing focus on enhancing security

and compliance measures in open-source projects, including vulnerability management,
code scanning, and license compliance tools.

9. **Community-driven Innovation**: Open-source communities are driving innovation

by collaborating on projects, sharing knowledge and resources, and building ecosystems
around open-source software.

13
 10. **Legal and Policy Developments**: Legal and policy developments, such as open-
source licensing updates, patent pledges, and community guidelines, continue to shape the
landscape of open-source software development.

These trends reflect the evolving nature of open-source software development and its
growing importance in the broader software industry.

Reference:
- Weber, S. (2004). The Success of Open Source. Harvard University Press.

Steven Weber's book "The Success of Open Source" provides insights into the dynamics of open-
source software development, including its evolution, governance models, and impact on the
software industry. The book offers valuable perspectives on the trends shaping the open-source
landscape and its implications for the future of software development.
References Accumulated

14
SWE 406 Lecture Note Draft3a

OPEN-SOURCE SOFTWARE PROJECTS

1. Contributing to OSS Projects

2. Finding and selecting OSS Projects
3. Setting a development Environment for OSS Projects
4. Writing Documentation for an OSS project
Ways to contribute to OSS Projects (from special Sources)
There are numerous ways to contribute to open-source projects, and your choice depends on
your skills, interests, and availability. Here are some common ways you can contribute:

1. **Code Contributions**:
- **Fixing Bugs**: Look for open issues labeled as bugs or issues tagged with "help wanted"
and submit pull requests with fixes.
- **Adding Features**: Implement new features or enhancements suggested in the project's
roadmap or issue tracker.
- **Code Reviews**: Review pull requests submitted by other contributors. Provide feedback,
suggestions, and help ensure code quality.
- **Optimizations**: Identify areas of the codebase that can be optimized for performance or
efficiency and contribute improvements.

2. **Documentation**:
- **Writing**: Contribute to project documentation by writing guides, tutorials, API
references, or improving existing documentation.
- **Editing and Proofreading**: Review and edit documentation for clarity, correctness, and
consistency.
- **Translating**: Translate documentation or user interfaces into different languages to make
the project accessible to a wider audience.

3. **Testing**:
- **Writing Tests**: Create automated tests for existing code to improve test coverage and
ensure code reliability.
- **Quality Assurance**: Help test new features, bug fixes, or releases to identify and report
issues.
4. **Community Engagement**:
- **Answering Questions**: Participate in community forums, mailing lists, or chat channels to
help answer questions from other users and contributors.
- **Support**: Provide support to users experiencing issues with the software by
troubleshooting problems and offering solutions.
- **Evangelism**: Spread awareness about the project by writing blog posts, giving talks, or
promoting it on social media platforms.

5. **Design**:
- **User Interface (UI) Design**: Design and prototype user interfaces for software projects,
focusing on usability and accessibility.
- **User Experience (UX) Design**: Conduct user research and design experiences that
improve the overall usability and satisfaction of the software.

6. **Accessibility**:
- **Audit and Improve Accessibility**: Assess the accessibility of the project's user interfaces
and contribute improvements to ensure it is usable by people with disabilities.

7. **Localization**:
- **Translation**: Translate user interfaces, documentation, or other project materials into
different languages to make the project accessible to non-English-speaking users.

8. **Community Management**:
- **Moderation**: Help moderate community forums, chat channels, or issue trackers to
ensure a healthy and inclusive community environment.
- **Organizing Events**: Plan and organize community events such as hackathons, workshops,
or meetups to bring contributors and users together.
9. **Financial Support**:
- **Donations**: Support the project financially by making donations to maintain project
infrastructure, fund development efforts, or support contributors.

10. **Project Management**:

- **Issue Triage**: Assist in triaging incoming issues by verifying bugs, reproducing reported
problems, and assigning priorities.
- **Roadmap Planning**: Participate in discussions about the project's future direction,
priorities, and feature planning.

Remember that contributing to open-source is not just about writing code. Every contribution,
regardless of size, helps improve the project and its community. Find the areas where you can
make the most impact and enjoy the process of collaborating with others to build something
great!
==
Finding and Selecting OSS (other sources)
Finding and selecting a suitable open-source project involves several key steps:

1. **Identify Interests and Skills**: Determine your interests and the skills you want to develop
or contribute. Consider your expertise in programming languages, frameworks, and tools.

2. **Explore Platforms**: Visit popular platforms like GitHub, GitLab, and Bitbucket. Browse
through project directories, search by tags, languages, and topics to find projects aligning with
your interests.

3. **Evaluate Project Activity**: Look for projects with recent activity, such as commits, issues
being addressed, and releases. Active projects indicate community engagement and ongoing
development.

4. **Review Documentation and Community**: Check project documentation, README files,

and community guidelines to understand project goals, contribution guidelines, and
communication channels.

5. **Assess Project Size and Complexity**: Consider the size and complexity of the project.
Beginners may prefer smaller projects or those with well-defined issues labeled as "good first
issue" or "beginner-friendly."

6. **Contribute Small Fixes**: Start by contributing small fixes or improvements to get familiar
with the project's workflow and community dynamics. This can help you gauge your interest
and compatibility with the project.

7. **Engage with the Community**: Actively participate in discussions, forums, or mailing lists
related to the project. Engaging with the community helps build relationships, gain insights, and
receive feedback on contributions.
8. **Evaluate Licensing and Governance**: Ensure the project has a clear licensing model
compatible with your goals. Understand the project's governance structure to assess its stability
and sustainability.

9. **Consider Personal Goals**: Reflect on your personal goals and what you aim to achieve by
contributing to open source. Whether it's skill enhancement, building a portfolio, or
contributing to a cause, align your choice with your objectives.

10. **Seek Mentorship and Feedback**: Don't hesitate to seek mentorship from experienced
contributors or maintainers. They can provide guidance, review your contributions, and help
you navigate the project effectively.

By following these steps, you can find and select a suitable open-source project that matches
your interests, skills, and goals while contributing meaningfully to the open-source community.
= = ========================
Setting up a Development Environment for OSS
Setting up a development environment for open-source software can vary depending on the
project and the technologies it utilizes. However, here's a general guide you can follow:

1. **Choose a Project**: Identify the open-source project you want to contribute to. Look for
projects that interest you and align with your skills and expertise.

2. **Read the Documentation**: Most open-source projects have documentation on how to set
up a development environment. This documentation typically includes information on
prerequisites, dependencies, and setup steps. Make sure to read through it carefully.

3. **Install Prerequisites**: Identify and install any prerequisites needed for the project. This
might include programming languages, frameworks, libraries, databases, and other tools. Make
sure to install the correct versions specified by the project documentation.

4. **Version Control**: If the project uses version control (e.g., Git), fork the repository on the
platform where it's hosted (e.g., GitHub, GitLab). Clone your forked repository to your local
machine.

5. **Set Up Development Environment**: Depending on the project, you might need to set up a
specific development environment. This could involve configuring IDEs (Integrated Development
Environments), editors, virtual environments, and other tools. Follow the instructions provided
in the project documentation.

6. **Install Dependencies**: Use package managers or build tools to install project

dependencies. This could involve running commands like `npm install` for Node.js projects or
`pip install -r requirements.txt` for Python projects.

7. **Configuration**: Some projects require configuration files for things like database
connections, API keys, or environment variables. Make sure to set up these configurations as
needed.
8. **Run Tests**: Before making any changes, it's a good practice to run the project's test suite
to ensure everything is working correctly. This helps catch any issues early on.

9. **Start Contributing**: Once your development environment is set up, you can start
contributing to the project. Look for open issues or features that interest you, and submit pull
requests with your changes. Make sure to follow the project's contribution guidelines and
coding standards.

10. **Continuous Integration**: Many open-source projects use continuous integration (CI)
systems to automatically run tests and checks whenever code is pushed to the repository. Make
sure your changes pass the CI checks before submitting a pull request.

11. **Communicate**: Don't hesitate to communicate with the project maintainers and other
contributors. Ask questions, seek clarification, and participate in discussions related to the
project.

12. **Stay Updated**: Keep your development environment and dependencies up to date with
the latest changes in the project. Pull the latest changes from the upstream repository regularly
to stay in sync with the main development branch.

By following these steps, you should be able to set up a development environment for
contributing to open-source software effectively. Remember that every project is different, so
always refer to the project-specific documentation and guidelines for the most accurate setup
instructions.
Guidelines on Writing Documentation for OSS Projects
Writing documentation for open-source projects is a crucial contribution that helps users
understand how to use the software, contribute to the project, and troubleshoot issues. Here's
a guide on how to effectively write documentation:

1. **Understand the Audience**: Identify the target audience for the documentation. It could
include end-users, developers, contributors, or administrators. Tailor the content to their needs
and expertise level.

2. **Organize the Content**: Structure the documentation in a logical and easy-to-navigate

format. Use headings, subheadings, and bullet points to break down information into digestible
chunks. Consider creating separate sections or pages for different topics such as installation,
configuration, usage, troubleshooting, and contribution guidelines.

3. **Use Clear and Concise Language**: Write in clear, concise language that is easy to
understand for the target audience. Avoid technical jargon or complex terminology unless
necessary, and define terms when they are first introduced.

4. **Provide Examples and Use Cases**: Include examples, code snippets, and use cases to
illustrate how to use the software in real-world scenarios. These examples help users
understand concepts and how to apply them effectively.

5. **Include Visuals**: Use diagrams, screenshots, and videos to complement textual

explanations. Visual aids can enhance understanding and make the documentation more
engaging.

6. **Keep it Up-to-Date**: Regularly update the documentation to reflect changes in the

software, new features, bug fixes, or improvements. Outdated documentation can lead to
confusion and frustration among users.

7. **Include Installation and Setup Instructions**: Provide detailed instructions on how to

install and set up the software, including system requirements, dependencies, and configuration
steps. Consider including different installation methods for various platforms (e.g., Windows,
macOS, Linux).

8. **Document Configuration Options**: Explain the various configuration options available in

the software and how to customize them to suit specific needs. Provide examples of common
configurations and best practices.

9. **Cover Troubleshooting and FAQs**: Anticipate common issues and questions users might
encounter and provide troubleshooting tips and solutions. Create a frequently asked questions
(FAQ) section to address common queries.

10. **Include Contribution Guidelines**: If the project welcomes contributions from the
community, include guidelines on how to contribute code, documentation, or other
contributions. Explain the contribution process, coding standards, and how to submit pull
requests.

11. **Solicit Feedback**: Encourage users and contributors to provide feedback on the
documentation. Include contact information or links to discussion forums where users can ask
questions or suggest improvements.

12. **Versioning**: If the project has multiple versions, clearly indicate which version of the
documentation corresponds to each version of the software. Provide links to documentation for
older versions if necessary.

By following these guidelines, you can create comprehensive and user-friendly documentation
that enhances the usability and accessibility of the open-source project. Remember that
documentation is an ongoing effort, and it's essential to continuously review and improve it
based on user feedback and changes to the project.
 1

SWE 406 Lecture Note Draft4a

SOME IMPORTANT TERMS ON OPEN SOURCE SOFTWARE (OSS) PLATFORMS & PROJECTS

GitHub

This is the largest host of source codes in the world and is owned by Microsoft since 2018
(w3schools.com)

Git

Git is a popular version control system. It was created by Linus Torvalds in 2005, It is used for:

• Tracking code changes

• Tracking who made changes
• Coding collaboration

What does Git do?

• Manage projects with Repositories

• Clone a project to work on a local copy
• Control and track changes with Staging and Committing
• Branch and Merge to allow for work on different parts and versions of a project
• Pull the latest version of the project to a local copy
• Push local updates to the main project

Repository

This is a place where something can be stored; e.g, a box, a ware house, a room, for safekeeping

A repository in GitHub is a place where you can store your codes, your files and each revision history.

Repository can have multiple collaborators and can either be public or private. To create a new
repository, go to https://github.com/

Branch

• Create a New Branch (from w3school.com)

• Branching is a key concept in Git. And it works around the rule that the master branch is
ALWAYS deployable.
• That means, if you want to try something new or experiment, you create a new branch!
Branching gives you an environment where you can make changes without affecting the
main branch.
• When your new branch is ready, it can be reviewed, discussed, and merged with the main
branch when ready.
 2

• When you make a new branch, you will (almost always) want to make it from the master
branch

Pull Request

Pull request enables you to tell others about changes you have made to a branch in a repository on
GitHub

It is a mechanism for a developer to notify others that they have completed a feature.

Pull Request (PRs) is used by software developers to initiate the process of integrating new code changes
into the main project.

Pull Requests keep records of changes to your code, and if you commented and named changes
well, you can go back and understand why changes and decisions were made.

Git Pull and Git Merge

Git pull request is the same as Git Merge. Both requests achieve the same result; i.e, merging a
developers branch with the project’s main branch.

GitHub uses Git pull request, while GitLab uses Git merge request

Forking a repository

A fork is a new repository that shares code and visibility setting with the original “Upstream” repository

Fork is used to iterate an idea or changes before they are pro... back to the upstream repository.

Fork allows you to make changes to a project without affecting the original repository, also known as
“upstream” repository .

A fork is a copy of a repository. Forking a repository allows you to freely experiment with changes
without affecting the original project

Forking is a good tool for copying source codes from someone’s repository to your repository and
contribute to it

A fork is a copy of a repository. This is useful when you want to contribute to someone else's
project or start your own project based on theirs. fork is not a command in Git, but something
offered in GitHub and other repository hosts

The two (2) most commonly used methods for copying a repository on GitHub are cloning and forking
 3

Forking creates a separate copy on a remote server;

Cloning downloads the entire repository on to your computer. This allows you to work on the code
locally, makes changes and contribution to the project without needing continuous internet access

Cloning - creates a local copy on your computer that you can sync with he remote GitHub.

A fork is a copy of a repository of repository that allows you to make changes without impacting the
original project.

Pushing code to a repository

It is the act of sending, uploading code from a branch in your local source code repository to a branch in
the remote repository

It is GitHub-coined term, the way to transfer your code from where you created it into a location where
it can be used.

Commits

It is a snapshot along the timeline of a Git project

In Git, a branch is a pointer to one specific commit, while a commit is a snapshot of your repository at a
specific point in time.

Your branch pointer moves along with each new commit you made.

Make Changes and Add Commits (w3schools.com)

After the new branch is created, it is time to get to work. Make changes by adding, editing and
deleting files. Whenever you reach a small milestone, add the changes to your branch by
commit.

Adding commits keeps track of your work. Each commit should have a message explaining what
has changed and why. Each commit becomes a part of the history of the branch, and a point you
can revert back to if you need to.

Note: commit messages are very important! Let everyone know what has changed and why.
Messages and comments make it so much easier for yourself and other people to keep track of
changes.

Forking vs. Branching

- **Branching**: Involves creating a parallel version of a repository within the same project. It is typically
used for feature development, bug fixes, or experiments that are intended to be merged back into the
main branch.
 4

- **Forking**: Creates an entirely separate copy of the repository. It is used when you want to develop
independently or contribute to someone else’s project without having direct write access to the original
repository.

==
 1

SWE 406 Lecture Note Draft4b

Practical Open-Source Software Projects

Hello World (from https://docs.github.com/en/get-started/start-your-journey/hello-

world on 27-05-2024)

Introduction

This tutorial teaches you GitHub essentials like repositories, branches, commits, and pull
requests. You'll create your own Hello World repository and learn GitHub's pull request
workflow, a popular way to create and review code.

Prerequisites

• You must have a GitHub account. For more information, see "Creating an account on
GitHub."
• You don't need to know how to code, use the command line, or install Git (the version
control software that GitHub is built on).

Step 1: Create a repository

The first thing we'll do is create a repository. You can think of a repository as a folder that
contains related items, such as files, images, videos, or even other folders. A repository usually
groups together items that belong to the same "project" or thing you're working on.

Often, repositories include a README file, a file with information about your project.
README files are written in Markdown, which is an easy-to-read, easy-to-write language for
formatting plain text. We'll learn more about Markdown in the next tutorial, "Setting up your
profile."

GitHub lets you add a README file at the same time you create your new repository. GitHub
also offers other common options such as a license file, but you do not have to select any of them
now.

Your hello-world repository can be a place where you store ideas, resources, or even share and
discuss things with others.

1. In the upper-right corner of any page, select

 2

, then click New repository.

2. In the "Repository name" box, type hello-world.

3. In the "Description" box, type a short description. For example, type "This repository is
for practicing the GitHub Flow."
4. Select whether your repository will be Public or Private.
5. Select Add a README file.
6. Click Create repository.

Step 2: Create a branch

Branching lets you have different versions of a repository at one time.

By default, your repository has one branch named main that is considered to be the definitive
branch. You can create additional branches off of main in your repository.

Branching is helpful when you want to add new features to a project without changing the main
source of code. The work done on different branches will not show up on the main branch until
you merge it, which we will cover later in this guide. You can use branches to experiment and
make edits before committing them to main.

When you create a branch off the main branch, you're making a copy, or snapshot, of main as it
was at that point in time. If someone else made changes to the main branch while you were
working on your branch, you could pull in those updates.

This diagram shows:

Creating a branch

1. Click the Code tab of your hello-world repository.

2. Above the file list, click the dropdown menu that says main.
3. • Type a branch name, readme-edits, into the text box.
4. • Click Create branch: readme-edits from main.

Now you have two branches, main and readme-edits. Right now, they look exactly the same. Next
you'll add changes to the new readme-edits branch.

Step 3: Make and commit changes

When you created a new branch in the previous step, GitHub brought you to the code page for
your new readme-edits branch, which is a copy of main.

You can make and save changes to the files in your repository. On GitHub, saved changes are
called commits. Each commit has an associated commit message, which is a description
 3

explaining why a particular change was made. Commit messages capture the history of your
changes so that other contributors can understand what you’ve done and why.

1. Under the readme-edits branch you created, click the README.md file.
2. To edit the file, click
3. In the editor, write a bit about yourself.
4. Click Commit changes.
5. In the "Commit changes" box, write a commit message that describes your changes.
6. Click Commit changes.

These changes will be made only to the README file on your readme-edits branch, so now
this branch contains content that's different from main

proposing your changes and requesting that someone review and pull in your contribution and
merge them into their branch. Pull requests show diffs, or differences, of the content from both
branches. The changes, additions, and subtractions are shown in different colors.

As soon as you make a commit, you can open a pull request and start a discussion, even before
the code is finished.

In this step, you'll open a pull request in your own repository and then merge it yourself. It's a
great way to practise the GitHub flow before working on larger projects.

1. Click the Pull requests tab of your hello-world repository.

2. Click New pull request.
3. In the Example Comparisons box, select the branch you made, readme-edits, to
compare with main (the original).
4. Look over your changes in the diffs on the Compare page, make sure they're what you
want to submit.
5. • Click Create pull request.
6. • Give your pull request a title and write a brief description of your changes. You can
include emojis and drag and drop images and gifs.
7. • Click Create pull request.

Reviewing a pull request

When you start collaborating with others, this is the time you'd ask for their review. This allows
your collaborators to comment on, or propose changes to, your pull request before you merge the
changes into the main branch.

Step 5: Merge your pull request

In this final step, you will merge your readme-edits branch into the main branch. After you
merge your pull request, the changes on your readme-edits branch will be incorporated into
main.
 4

Sometimes, a pull request may introduce changes to code that conflict with the existing code on
main. If there are any conflicts, GitHub will alert you about the conflicting code and prevent
merging until the conflicts are resolved. You can make a commit that resolves the conflicts or
use comments in the pull request to discuss the conflicts with your team members.

In this walk-through, you should not have any conflicts, so you are ready to merge your branch
into the main branch.

1. At the bottom of the pull request, click Merge pull request to merge the changes into main.
2. Click Confirm merge. You will receive a message that the request was successfully merged and
the request was closed.
3. Click Delete branch. Now that your pull request is merged and your changes are on main, you
can safely delete the readme-edits branch. If you want to make more changes to your project,
you can always create a new branch and repeat this process.
4. Click back to the Code tab of your hello-world repository to see your published changes on
main.

==
 5

STEPS TO CREATE THE HELLO WORLD PROGRAM IN GITHUB

Creating a "Hello World" program and hosting it on GitHub involves several steps, from setting up GitHub
and your local development environment to writing the code and pushing it to a repository. Here's a
step-by-step guide:

### Step 1: Set Up GitHub

1. **Create a GitHub Account**:

- If you don't already have a GitHub account, go to [GitHub](https://github.com) and sign up.

2. **Create a New Repository**:

- Log in to your GitHub account.

- Click the "+" icon in the upper-right corner and select "New repository."

- Name your repository (e.g., "hello-world").

- Optionally, add a description.

- Choose the visibility (public or private).

- Optionally, initialize the repository with a README file.

- Click "Create repository."

### Step 2: Set Up Git and Your Local Development Environment

1. **Install Git**:

- If Git is not already installed, download and install it from [git-scm.com](https://git-scm.com).

2. **Configure Git**:

- Open a terminal or command prompt and set your Git username and email:

```bash

git config --global user.name "Your Name"

git config --global user.email "[email protected]"

```
 6

### Step 3: Clone the Repository

1. **Clone the Repository to Your Local Machine**:

- In the terminal or command prompt, navigate to the directory where you want to store your project.

- Clone the repository using the URL from the GitHub repository page:

```bash

git clone https://github.com/your-username/hello-world.git

```

- Change into the project directory:

```bash

cd hello-world

```

### Step 4: Create the "Hello World" Program

1. **Create a New File for the Program**:

- Using a text editor or IDE, create a new file in your project directory. The file extension will depend on
the programming language you choose (e.g., `hello_world.py` for Python, `hello_world.java` for Java,
`hello_world.c` for C).

2. **Write the "Hello World" Code**:

- **Python** (`hello_world.py`):

```python

print("Hello, World!")

```

- **Java** (`HelloWorld.java`):

```java

public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello, World!");
 7

```

- **C** (`hello_world.c`):

```c

#include <stdio.h>

int main() {

printf("Hello, World!\n");

return 0;

```

### Step 5: Commit and Push the Code to GitHub

1. **Add the File to the Repository**:

- In the terminal or command prompt, add the new file to the staging area:

```bash

git add hello_world.py # or the appropriate filename

```

2. **Commit the Changes**:

- Commit the file to the repository with a message:

```bash

git commit -m "Add Hello World program"

```

3. **Push the Changes to GitHub**:

- Push the commit to the GitHub repository:

```bash
 8

git push origin main

```

- Note: If you created a branch other than `main`, push to that branch instead.

### Step 6: Verify on GitHub

1. **Verify the Code on GitHub**:

- Go to your GitHub repository page.

- Verify that the new file has been uploaded and the code appears as expected.

By following these steps, you will have created a "Hello World" program, committed it to a local Git
repository, and pushed it to a remote repository on GitHub. This process forms the basis of version
control and collaboration using Git and GitHub.

==
SWE 406 Lecture Note Draft5a

THE CONCEPT OF FORKING IN OPEN-SOURCE SOFTWARE DEVELOPMENT

Forking is a fundamental concept in open-source software development, allowing developers to take a

copy of a repository and develop it independently from the original project. This concept plays a crucial
role in the collaborative and decentralized nature of open-source projects. Here’s a detailed explanation
of the concept of forking:

### What is Forking?

- **Forking a Repository**: Forking involves creating a personal copy of someone else’s project
repository. This action is typically performed on platforms like GitHub, GitLab, or Bitbucket.

- **Independence**: Once a repository is forked, the copy is entirely independent of the original
repository, meaning changes made to the forked repository do not affect the original one unless
explicitly merged back.

### How Forking Works

1. **Create a Fork**:

- On a platform like GitHub, navigate to the repository you want to fork.

- Click the "Fork" button, usually found at the top right of the repository page.

- GitHub creates a copy of the repository under your account, preserving its entire history, branches,
and files.

2. **Clone the Forked Repository**:

- Clone the forked repository to your local machine to start working on it:

```bash

git clone https://github.com/your-username/forked-repo.git

cd forked-repo

```

3. **Make Changes**:

- You can now make changes to the codebase in your forked repository. These changes can include
adding new features, fixing bugs, or modifying existing functionalities.

1
4. **Commit and Push Changes**:

- After making changes, commit them to your forked repository:

```bash

git add .

git commit -m "Your commit message"

git push origin main

```

5. **Pull Requests**:

- If you want to contribute your changes back to the original project, you can create a pull request. This
request notifies the original project maintainers of your changes and allows them to review and merge
your contributions if they deem them valuable.

### Benefits of Forking

- **Innovation and Experimentation**: Forking allows developers to experiment with new ideas without
affecting the stability of the original project.

- **Independence**: Developers can take a project in a new direction if they have different visions or
goals from the original maintainers.

- **Collaboration**: Forking makes it easier for multiple developers to work on a project simultaneously,
contributing to its growth and improvement.

- **Safety**: It provides a safe environment to make changes without the risk of breaking the original
project.

### Example Scenario: Open-Source Contribution

1. **Identify a Project**: You find an open-source project that you’re interested in on GitHub.

2. **Fork the Repository**: Click the fork button to create a personal copy of the repository.

3. **Clone and Develop**: Clone your forked repository to your local machine and start working on new
features or bug fixes.

4. **Commit and Push**: After making changes, commit them to your fork and push to GitHub.

5. **Create a Pull Request**: Go to the original repository and create a pull request, describing your
changes and why they should be merged.

2
6. **Review and Merge**: The project maintainers review your pull request and, if accepted, merge your
changes into the original project.

### Conclusion

Forking is a powerful feature in open-source software development that fosters innovation,

collaboration, and growth of software projects. It allows developers to independently explore and
contribute to projects while maintaining the integrity and stability of the original codebase.

== ==

3
REASONS DEVELOPERS MAY WANT TO FORK A PROJECT,
Forking a project in an open-source software environment can serve multiple purposes, reflecting the
diverse motivations and goals of developers. Here are some key reasons why developers may choose to
fork a project:

### 1. **Personal Customization**

- **Specific Needs**: Developers may fork a project to tailor it to their specific needs or preferences.
This customization can involve adding features, modifying existing functionalities, or integrating the
software with other tools or systems.

- **Local Changes**: Sometimes the changes needed are too specific to be of general interest to the
wider community, making a personal fork a practical solution.

### 2. **Experimentation and Innovation**

- **Testing New Ideas**: Forking allows developers to experiment with new features, technologies, or
approaches without affecting the stability of the original project.

- **Proof of Concept**: Developers can create forks to test the feasibility of new concepts or solutions in
a controlled environment.

### 3. **Learning and Skill Development**

- **Educational Purposes**: New developers or students may fork projects to learn from the codebase,
practice coding skills, or experiment with new programming techniques.

- **Understanding Code**: Working on a forked repository helps developers understand the inner
workings of a project and how to manage complex codebases.

### 4. **Contributing to the Original Project**

- **Bug Fixes and Improvements**: Developers often fork a project to work on bug fixes, performance
improvements, or other enhancements before submitting their changes back to the original project
through pull requests.

- **Feature Development**: Forking allows developers to independently develop new features that can
later be proposed to the original project.

4
### 5. **Disagreement with Original Maintainers**

- **Vision and Direction**: Developers may fork a project if they disagree with the direction, priorities,
or vision of the original maintainers. A fork allows them to pursue their own path and develop the
project according to their vision.

- **Management and Governance**: Disagreements over project governance, decision-making

processes, or community management can also lead to forks.

### 6. **Inactive or Abandoned Projects**

- **Reviving a Project**: If the original project is inactive or abandoned, developers may fork it to
continue development and keep the project alive.

- **Maintenance and Support**: A fork can ensure continued support, bug fixes, and updates for a
project that no longer receives attention from the original maintainers.

### 7. **Security and Privacy**

- **Security Concerns**: Developers may fork a project to address security vulnerabilities or implement
security features that are not prioritized by the original project.

- **Privacy Requirements**: Specific privacy requirements or concerns can lead developers to fork a
project and implement necessary adjustments.

### 8. **Commercial and Proprietary Use**

- **Business Requirements**: Companies may fork open-source projects to adapt them to their specific
business needs, integrate them into proprietary systems, or create a commercial product based on the
open-source code.

- **Licensing Issues**: Forking can help businesses comply with open-source licenses while making
necessary modifications for commercial use.

### 9. **Localization and Internationalization**

- **Language and Region**: Developers may fork a project to add localization and internationalization
features, making the software accessible and usable in different languages and regions.

### 10. **Community and Collaboration**

- **Building a Community**: Forking can be a way to build a new community around a shared vision or
set of goals, especially if the original community is not responsive or inclusive.

5
- **Collaborative Projects**: Developers may fork a project to create a collaborative space for a specific
sub-community or interest group within the larger open-source ecosystem.

### Conclusion

Forking is a powerful and versatile tool in the open-source software environment, enabling developers to
pursue a wide range of goals, from personal customization and experimentation to addressing
disagreements and reviving inactive projects. By allowing developers to independently develop and
innovate, forking contributes to the diversity, robustness, and evolution of open-source software.

==

6
POTENTIAL BENEFITS AND CHALLENGES ASSOCIATED WITH FORKING.IN
OPEN-SOURCE SOFTWARE DEVELOPMENT
Forking in open-source software development can bring a variety of benefits as well as challenges.
Here’s an in-depth look at both:

Benefits of Forking
1. **Innovation and Experimentation**
- **Freedom to Innovate**: Developers can experiment with new features, technologies, or
approaches without restrictions imposed by the original project maintainers.
- **Rapid Prototyping**: Forking allows for quick testing and iteration on new ideas, which can
later be integrated back into the original project if successful.

2. **Customization and Personalization**

- **Tailored Solutions**: Developers can customize the software to better meet specific needs
or preferences that may not align with the general user base of the original project.
- **Specialized Use Cases**: Forking enables the creation of versions of the software that cater
to niche or specialized use cases.

3. **Revitalizing Inactive Projects**

- **Continued Development**: Forking can breathe new life into projects that have been
abandoned or are no longer actively maintained, ensuring continued improvements and support.
- **Community-Driven Maintenance**: The community can take ownership of a project’s
future, driving its development and maintenance.

4. **Educational Opportunities**
- **Learning by Doing**: Forking a project provides a practical way for developers to learn by
working with real-world codebases, enhancing their skills and understanding of software
development practices.
- **Exploring Codebases**: Developers can explore and understand different coding styles,
architectures, and design patterns.

7
5. **Conflict Resolution**
- **Diverging Visions**: When there are disagreements over the direction of a project, forking
allows each party to pursue their vision without conflict, potentially leading to multiple successful
projects.
- **Independence**: Developers can maintain autonomy and make decisions independently of
the original project’s governance structure.

6. **Security and Privacy Enhancements**

- **Addressing Vulnerabilities**: Forking enables developers to address security issues
promptly if the original maintainers are slow to respond.
- **Custom Privacy Features**: Developers can implement specific privacy features required
for their use case.

Challenges of Forking

1. **Fragmentation**
- **Splitting the Community**: Forking can divide the user and developer community, leading
to fragmentation and potentially weakening the overall support and development effort for the
original project.
- **Duplication of Effort**: Multiple forks working on similar features or improvements can
result in duplicated efforts, which might have been more efficiently addressed collaboratively.

2. **Maintenance Overhead**
- **Resource Intensive**: Maintaining a fork can be resource-intensive, requiring significant
time and effort to keep up with changes in the original project and to continue independent
development.
- **Sustaining Long-Term Development**: Ensuring the long-term viability of a fork requires a
dedicated team and ongoing contributions, which can be challenging to sustain.

3. **Compatibility Issues**
- **Upstream Changes**: Keeping a fork in sync with the upstream project can be difficult,
especially if the original project is frequently updated with significant changes.

8
 - **Integration Challenges**: Integrating new features or bug fixes from the original project into
the fork (or vice versa) can be complex and time-consuming.

4. **Legal and Licensing Concerns**

- **Compliance**: Ensuring that the fork complies with the original project’s license and other
legal requirements is crucial to avoid legal issues.
- **Contributors’ Agreements**: New contributors to the fork need to understand and agree to
the licensing terms, which can sometimes be a barrier to contribution.

5. **Reputation and Trust**

- **Building Credibility**: A fork must build its own reputation and trust within the community,
which can be challenging if the original project is well-established and respected.
- **Perception Issues**: Forks can sometimes be perceived negatively, especially if they are
seen as a result of conflicts or disagreements.

6. **Coordination and Collaboration**

- **Coordination Efforts**: Effective collaboration and coordination among developers working
on the fork can be challenging, especially in distributed, volunteer-driven open-source projects.
- **Contribution Back to Original**: Managing contributions and ensuring that valuable
improvements in the fork are contributed back to the original project, if applicable, requires careful
coordination.

### Conclusion
Forking in open-source software development offers significant benefits, such as fostering
innovation, enabling customization, and revitalizing inactive projects. However, it also presents
challenges, including community fragmentation, maintenance overhead, and legal concerns.
Balancing these benefits and challenges is crucial for the successful use of forking as a strategy
in open-source software development