View source for Possible Pathways and Learning Activities

== Pathway Model - Candidate Paths to HFOSS Contribution ==

{{Category:Pathways}}

This page contains:
* a list of possible pathways for the HFOSS contribution pathways model
* learning activities that may support a path step 
* learning activities that may help students gain general HFOSS knowledge.

See the [[Glossary]] for terms used to make the lists more concise and avoid duplication.

== Curated Pathways ==

# [[:Category:Verify a Bug (Pathway)|Verify a Bug (Pathway)]]
#* Examples: [[Bug Gardening]]
# [[:Category:Fix a Bug (Pathway)|Fix a Bug (Pathway)]]
#* Examples: [[Document Code with Meaningful Comments (Activity)]]
# [[:Category:Test User Installation Instructions (Pathway)|Test User Installation Instructions (Pathway)]]
#* Examples: [[Test Installation Instructions]]
# Test download and installation instructions for the development environment
# [[:Category:Create Unit Tests (Pathway)|Create Unit Tests (Pathway)]]
# [[:Category:Add a Feature (Pathway)|Add a Feature (Pathway)]]
# Create a new defect report from mailing list or personal experience
#* Examples: [[Write a Bug Report (Activity)]]
# Develop UML diagram from an existing project
# Identify user roles and write user stories for a feature (Design a feature)
# Introduce new users to the project
#* Examples:
#** [[Intro to IRC (Activity)]]
#** [[Connect with the Community (Activity)]]
# Access security: does the existing code meet security guidelines?

== Other Candidate Pathways ==

=== Project Promotion ===

* Write an article about a topic related to FOSS and submit to a FOSS news blog/web site
** Good blogs/sites for publication?
* Write a review / tutorial / comparison of one or more FOSS
** Good blogs/sites for publication?
* Write an article on “what I wish I knew” - about FOSS; before starting a project or course
* Add a personal project blog to an appropriate planet / blog aggregator
* Create a lecture that provides a tour of the application domain landscape of FOSS
** Show market segment leaders (Apache, MySQL), tools (Eclipse, Notepad++), games (game engine), humanitarian, industry specific (e.g., ERP), etc. - this may be a pre/post-scavenger hunt lecture
** Video it, Keep it short & modular for remixing.
** Create a list of wanted topics, get community to contribute.
** See examples from entrepreneurship education
*** http://www.prendismo.com/collection/ (was Cornell eClips)
*** http://ecorner.stanford.edu/

=== Specification & Coding ===

* Contribute code
** Build a feature (is this the same as "contribute code"? It's going to involve design and stakeholder analysis all the way through to production and testing)
** Build a plugin (as in, this will not affect the rest of the codebase, so might have less stakeholder analysis, integration with the core etc)
** Fix a bug
* Design a feature (Business analysis and user experience design):
** Conduct stakeholder analysis 
** Identify user roles and write user stories for a feature
** Create wireframes for a feature
** Gathering feedback on wireframes
** Specify the MVP for a feature
** Add information to ongoing discussion on design decisions
** Ask relevant and appropriate questions to bound a problem

=== Community Development ===

* Organize & conduct a tutorial session for a FOSS
* Participate in / Support / Organize a hackathon
* Raise money or other resources for an open source project
* Promote a project of interest using multiple tools/channels
* Improve awareness of the project:
** Evidence gathering - collect publicity on a project, collect information on breadth of use of an HFOSS project
*** How many people impacted?
*** How many deployments?
*** Data analysis of impact
** Fundraising efforts/Funding models
** Create/contribute to marketing for a project (social media)
*** Data analysis around social media
*** Blog posts
* Help build the community
** Find install instances (e.g. by social media search) 
** Find articles about application and its uses
** Improve outreach to users
** Improve project visibility (e.g. via social media strategy, tweeting etc)
** Analyse project's social media reach and influence
** Create/install a new theme for the project web site

=== Documentation ===

* Review a page and summarize problems found and submit proposed revision
* Find & improve a page that could benefit from editing / rewriting / improvement
** Find references (to other pages or resources) and add them (with appropriate links)
* Find a "stub" page and expand it with research and related references
* Create a new page with appropriate research & related references
* “Garden” a site or other documentation – prune, restructure, etc
** Instructor could clone or create a sandbox area for this
** Major restructuring might require advance planning
* Test documentation (e.g. installation instructions) and summarize problems found
** [[Test_Installation_Instructions]]
* Rewrite & simplify installation instructions for typical (non-technical) computer users
* Write concise and helpful instructions to install and configure FOSS on a specific system
** Specify version or date when install instructions become obsolete
* Create or update a glossary or vocabulary list for a FOSS
* Translate a page to a different language using automated tools or expert knowledge
* Convert written docs to video docs
* Convert video docs to written docs
* Develop UML diagram from an existing project
** Generate and review Javadoc
** [[UML a Project]]
* Verify Installation instructions (on different platforms) - if it doesn't work, update the install instructions or file as issue, if it does work indicate the platform it works on
** Update installation instructions
** Create/Fix user documentation
** Create/fix developer documentation
** Create release packaging
** Improve onboarding materials: install instructions, how to find issues lists etc.
** Improve globalization / localisation (e.g. translating UI and documentation to different languages)
** Confirm, improve or create install and code setup on different platforms
* Make the project more accessible
** Build a demo server
** Maintain a demo server
** Maintain a download site
** Maintain the project web site

=== Visual Design ===

* Create a storyboard or paper prototype, evaluate with users, revise, & summarize, submit to project
* Create instructional comics and submit to project
* Create a font or icon set and submit to project

=== Quality & Testing ===

* Choose an open defect or feature request from mailing list / tracker / wiki, verify that it exists, and expand & improve formal report (in tracker or wiki)
** Create a new defect report from mailing list or personal experience
** Find a "bad" report and make it a "good" report
** [[Write a Bug Report (Activity)]]
* Brainstorm list of possible enhancements for project, choose a few to document (see above) and submit a feature request
* Evaluate usability of a specified feature and summarize results & conclusions (in tracker or wiki)
** using formal guidelines or rubric
** using heuristic evaluation [[Wikipedia:Heuristic_evaluation]]
* Test documentation.
** Evaluate (and improve) installation instructions and submit revision to the project
** Verify (and fix) development environment documentation and submit revision to the project
* Develop an automated test suite or repeatable test script, contribute code, summarize results.
* Test the system
** Verify a bug
** Report a bug
** Add to the explanation of a bug
** Test release candidates
** Test security: can the existing code be compromised?
** Audit security: does the existing code meet security guidelines?
** Improve accessibility: audit app against disability guidelines (e.g. https://www.w3.org/standards/webdesign/accessibility)
** Check app for gender/culture bias in text, images etc
* Evaluate security for a FOSS project and report the results to the project
** Look for common security flaws
** Conduct penetration testing
** Compare with commercial products, industry practices

== Learning Activities ==

* FOSS scavenger hunt: Study a FOSS to answer a set of questions (overview about project and product features)  
** Could also look at a forge (# of projects, what application domains, what languages, # added recently)
* In teams, students generate test sets for given code and an understanding of the codes purpose, and test that code.
** see http://piratenpad.de/softhum-workshop-template-testsets

=== Privacy / Security ===

* Evaluate security for a FOSS: how many intrusions, severity, etc.
** Compare with commercial products, industry practices
* Write privacy policy
* Develop security guidelines
* Write about implications of software choice for security.
** Diaspora (Facebook clone) and problems w.r.t. privacy/security
** FOSS DBs, etc. (OpenMRS) -- issues, privacy, etc.

=== Quality & Testing ===

* Choose a fixed defect or feature, research its history (when & how reported, when & how fixed), and summarize in a 5 min format (in  tracker, wiki, blog post, podcast, vlog, etc).
** see http://piratenpad.de/softhum-workshop-write-feature-description
* Test (perhaps a project that does JUnit testing).
** Trace the execution of some piece of code.

=== Specification and Design ===

* Explore a new feature for an existing project
** Discuss how it might be implemented
** Show actual code and implementation
* Identify data structures used in a project.
* Study code & docs, diagram system architecture, evaluate, summarize.
** using guidelines supplied by instructor

=== Coding & Style ===

* Analyze the sequence of function calls that produces a specified { feature | page | screen }.
** http://piratenpad.de/softhum-workshop-analysis
* Identify examples of a given { coding construct | data structure | pattern } in a FOSS.
**  could provide teachers with examples to use in other courses
* Given specification & code, provide an itemized list of tasks and describe how each was met.
* Given a problem and 2+ solutions to a problem, compare, summarize, & present.
** naming conventions, coding style, efficiency, etc...
* Given a problem, find 2+ solutions (to same or similar problem) and summarize the differences between the solutions.
* Determine how well a { FOSS | component } meets its specifications.
* Develop a code walkthrough
** In teams of 2-3, students walk through working, uncommented code to determine its purpose.
** Deliverables: A brief summary (1-2 paragraphs) describing the purpose of the code.
** Could be senior level assignment, where students are asked to understand a complicated segement of code from a larger project. CS1-2: students are given a partial implementation of a class as to determine what a specific method does.
** http://piratenpad.de/softhum-workshop-template-walkthrough
** https://teachingopensource.org/Document_code_with_meaningful_comments
* Find/study examples of well & poorly written code - style wise (layout, variable names) 
** Look at coding standard for an open source project (Java, Python)
** Reformat code, rename variables, etc. 
* Given coding standard & sample code, list the changes needed for code to meet standard.
* Given sample code, infer and document coding standard.
* Analyze existing code to understand what it does and how it works.
* Reformat, document, & refactor existing (others') code to make it more readable & consistent.
* Given a comment, defect, or feature request, study & fix it, and submit as patch.
** FOSS with plugins may be easier for this:
** Drupal (e.g. shopping cart), Firefox, GreaseMonkey, Moodle
** wiki formatting plugins
* Develop UML diagram(s) for a FOSS and submit to the project
** FOSS UML tool: http://argouml.tigris.org/
** PC Clements, & DL Parnas. 1986. “A rational design process: How and why to fake it.” IEEE Transactions on Software Engineering 12 (2): 251-257.
* Add comments to a piece of code that has no or poor comments.
** https://teachingopensource.org/Document_code_with_meaningful_comments

=== Product Packaging and Distribution ===

* Maintain a build host. //needs more detail//
* Understand and identify installation and IT support needs. //needs more detail//
* Configure FOSS according to given criteria or specification.
** What are good examples of configurable FOSS - Drupal, wiki, 
** design & create a custom distribution
** Share custom distribution with the FOSS community.


== Learning Activities for General HFOSS Knowledge ==

=== Introduction ===

* Read recent article(s) and { answer questions | summarize | critique | present material }.
** e.g. product reviews, culture of writing software, use within some environment, etc.
** sites: opensource.com,teachingopensource.org
** print: Linux Journal, Linux Magazine
* Interview a FOSS user and find out why they use FOSS, benefits/drawbacks, etc.
* Study a FOSS contributor’s activities over time { week | month | semester } to understand the level of engagement and the type of interactions/contributions the person has made.
* Interview a FOSS contributor to find out how they got involved, their role(s), their background, etc.
* Shadow a FOSS contributor over time to see what they do, & summarize.
 
=== FOSS History ===

* Research the history of a FOSS & summarize. 
** When did it start?  How many releases?  How many users? 
** Reading history on the site, talk to people involved, etc.
* Review an archived discussion of a { chat | thread | forum | list } over a { day | week | month } and { summarize | categorize | reflect on } the content.
** e.g. developer list, support list,
* Study a completed defect or feature proposal, and create a concise summary, including details, people involved & their roles, steps taken.

=== Use & Evaluate ===

* Search forge(s) or the Internet for FOSS that interests you.
* Use & evaluate a FOSS that has been installed.
* Download, install, use, & evaluate FOSS.
** http://piratenpad.de/softhum-workshop-analysis
* Read review(s) of FOSS, then download a "good" one, based on different criteria 
** e.g. community, features, ease of maintenance
* Evaluate how good a FOSS would be to { use | contribute to} based on:
** Size, maturity, level of activity, size of community, etc.
** Features described in documentation or demos.
** How easy it is to set up for use:  e.g., download, install, customize, apply updates.
* Compare and contrast 2+ FOSS to determine which to { use | contribute to }.
** criteria from instructor, student, or target user
* Install (help others install) one or more FOSS and/or FOSS plugins.
* Install PortableApps on a flash drive, along with several portable FOSS for later use.
** http://portableapps.com
* Install FOSS operating system on a flash drive.
** http://www.pendrivelinux.com/
** http://unetbootin.sourceforge.net/

=== Communication & Tools ===

* Choose, investigate, and report on a forge. //what is the motivation or LO?//
* View newest FOSS on a forge, then see how many new FOSS are created in a { day | week }.
* Choose a (FOSS) RSS client, subscribe to RSS feeds for FOSS, read, and summarize.
** RSS clients: Google Reader, RSSOwl
** RSS feeds: any planet (feed aggregator), FOSS
* Define IRC, determine why IRC is an appropriate means of communication within a community - what are the benefits, drawbacks?
* Subscribe to an IRC channel, listen to a meeting, write summary of the content of the meeting and any observations about the mode of communication/type of communication.
* Study IRC meetings: lurk; participate; write minutes or summary; plan agenda; run meeting.
** https://teachingopensource.org/Connect_with_the_Community_(Activity)
* Work remotely (using IRC, email, twitter, whatever) with another student to develop profiles for each other. (a web-page about you and your tech skills and interests).
* Ask, comment on, answer, respond to question (on web forum, mailing list, IRC).
* Study the social norms of communication within a FOSS community. (i.e. how to ask questions, respond, etc.)
* Become familiar with public/private keys. //what is the motivation or LO?//
** Generate public and private keys for use with SSH.
** Install public key on remote server for passwordless access via SSH.
** Exchange public keys with another student.
** Use exchanged keys to send signs and/or encrypted messages.
** Sign another student's public key
** Get your public key signed by another student.
* Sign a Contributors License Agreement (CLA) for a FOSS. //what is the motivation or LO?//
** see http://en.wikipedia.org/wiki/Contributor_License_Agreement
* [meta] Learn to interact with the community by using various tools such as blogs, wiki changesets, ticketing systems, etc. // expand to specific tasks with specific tools //
* [meta] Learn a tool, and teach others how to use it.
* [meta] Learn that a text editor is a text editor, regardless of what it is. //how to do this?//
* [meta] Learn how to choose a set of tools to use for a FOSS.

=== Culture, Intellectual Property ===

See: http://piratenpad.de/softhum-workshop-template-culture
* Research how a FOSS is organized, summarize findings, & reflect.
** How many people are employed, who is employed, how they get paid.
** Business model - how is the project funded, who is in charge, etc.
* Select a FOSS, identity primary contributors (no more than 10), find their educational and work experiences, and summarize.
* Understand why a major company (like IBM for example) contributes to FOSS.  
** What are the market pressures involved from an economic point of view?  
* Study software licensing (in general) and then discuss FOSS intellectual property issues.  
** Why is it OK to download & install some software but not other?  
** Why would developers give up their rights?
* Compare & contrast 2+ FOSS licenses (e.g. in a matrix).

=== Philosophy / Politics ===

* Study why people choose to use FOSS as opposed to other software.
* Read "Little Brother" (by Cory Doctorow) //what is the motivation or LO?//
* Study the international influence in FOSS projects, both as contributors and consumers.
** cultural perspectives – freedom from multinationals companies (e.g. China, India)
* Study cultural/policy implications of CC, GPL, etc.
** Implications for pre-health, pre-law, etc.
* Explore implications of philosophy/culture of FOSS for public policy.
** Uber database of FOSS public policy decisions. Linked from Mel's blog.


[[Category:Reference]]
[[Category:Pathways]]