Stage 2 Activities/2.3 ParticipantResponses 2014-11

From Foss2Serve
Jump to: navigation, search

Contents

B.4 FOSS in Courses Planning 1 and C.4 FOSS in Courses Planning 2

I have a number of ideas about how I might use FOSS in my courses.

CS2 Our CS2 starts with students reading code and using models to help understand the code. They extract control-flow diagrams, call graphs and UML class diagrams from existing code. We have searched for FOSS projects for the students to work with and often can't find appropriate projects. I'm interested in finding projects written in Java that are fairly small to use in the beginning of CS2.

Our students do about 5 assignments and a longer (5-6 week) project in CS2. I like some of the ideas at the bottom of http://www.xcitegroup.org/softhum/doku.php?id=f:50ways for our assignments. Specifically, I think our students would learn a lot from these assignments 

   - Find/study examples of well & poorly written code
   - Look at coding standard for an open source project (Java, Python)
   - Reformat code, rename variables, etc. (possibly commit back depending on project)
   - Test (perhaps a project that does JUnit testing).
   - Trace the execution of some piece of code.
   - Develop UML diagram from an existing project. 
   - Identify data structures used in a project.

CS2 is team taught at my university so I can't make decisions about its curriculum without consulting my colleagues. One of my colleagues will likely be spending a significant amount of time revising the CS2 curriculum between Sept 2015 - Aug 2016. After I attend the workshop in November I intend to talk to him and my other colleagues to see if we can integrate HFOSS into the curriculum.


Third-year project course We have a third-year project course that is always looking for clients who have projects the students can work on. There may be an opportunity to integrate an HFOSS project into this course if there was someone from the project who was willing to act as the contact or if I was able to learn enough about a specific project to act as a client.

Directed studies course Our university offers directed studies courses, in which a student (or students) and a faculty member submit a proposal to work on a project together for one or two semesters. The students get course credit for their work. I think this may be the easiest way to get a few students involved in HFOSS work.

In my reading of the various examples of folks using FOSS in their classes, I found a few exercises/ideas that I will incorporate into my courses int he future. Doing a whole day covering FOSS and going through some of the projects would be helpful in my software engineering course. Showing nonCS majors from the liberal arts how they could contribute to projects without having a programming background would be beneficial for most students planning careers in international organizations and NGOs.

Bug Tracker Activity

Define what each of the column names below indicate. Include the range of possible values for 2-7 below. Feel free to explore beyond the page to find more information. 

ID - id number of bug
Sev - describes the impact of a bug. (Blocker, Critical, Major, Normal, Minor, Trivial, Enhancement)	
Pri - important and order bug should be fixed.(Immediate, Urgent, High, Low)
OS - operating system the bug was found on.
Product- subsystem
Status - general health of a bug. (UNCONFIRMED, NEW, ASSIGNED, NEEDINFO, REOPENED, RESOLVED,VERIFIED and CLOSED)
Resolution - indicates what happened to this bug. (empty, FIXED, DUPLICATE, WONTFIX, NOTABUG, NOTGNOME, INCOMPLETE, INVALID, OBSOLETE) 
Summary - comment

The above definitions are further explained in the Reports link.

The bugs appear to be displayed by status and then priority.

I did not discover the meaning of the shading nor coloring of some bug reports.

The bug, 706966, was submitted - 2013-08-28 11:30. The reporter claims the display of the month information is too busy and needs a redesign. There has not been recent discussion about this bug. Is the bug current? - Yes Is the bug assigned? - No To fix the bug. - Duplicate the bug, review the code generating display of the feature, create an improved display of the feature.

Bug 692455 - Windows are not where they appear to be. Submitted 2013-01-24. There has been 3 comments on the bug mainly stating it was not reproducible. The bug is current but not assigned. The main challenge would be to reproduce the bug before any possible fix could be attempted.

Collective Reports

314 bug reports were opened in the last week. 423 were closed? More bugs were closed than opened in the past week. The top three bug closers were Bastien Nocera, Jean-François Fortin Tam,and Emmanuele Bassi. Why is this important to know? - Perhaps as individuals who would be helpful in contacting with help? The top three bug reporters were Michael Catanzaro, Jo, and Jean-François Fortin Tam. These are not the same as the top three bug closes. The is no overlap in these two lists. The top three contributors of patches were Ray Strode, Bastien Nocera, and Marcos Chavarria Teijeiro. The top three reviewers of patches were Sebastian Dröge, Florian Müllner, and Bastien Nocera. There is only 2 common in both of these lists

FOSS in courses 2

Some possible activities

Code reviews for students with some coding background (any programming course, SE course, Capstone course). Learning goals could include: Identify program code and documentation style for a specific HFOSS project. Provide possible areas for improvement in a projects code along with a resulting bug report reduction benefit.

For non-CS courses going through process examples such as prioritizing todo tasks and learning roles to fill in humanitarian relief efforts would be useful. No prerequisite would be needed. Learning goals could include: Identifying HFOSS projects and defined roles for select projects. Be able to actively participate in an HFOSS communication channel. Identify non-programming roles in an HFOSS project.

Reviewing bug reports to see process of software development would also be a useful exercise for both technical and non-technical courses. Learning goals could include: Demonstrate parts and processes of a bug report. Be able to submit a bug report or bug fix.

With the exception of the communication channel activity, the above activities could all be done independently of the community. The channel communication (e.g. IRC) activity would need to span a long enough period to cover channel use by the HFOSS community.

All activities I would create as group projects with grading being based upon the group's final report/product shared with the class. It would be helpful to have a rubric for each of the activities to establish guidelines on expectations.

For contributions to a HFOSS project I think it would require substantial class time just to get students able to see the parts of the process (understand project, download a project, follow project contribution channels and understand protocols for contributions, etc.)

Going through the process of learning about HFOSS projects, it seems gaining an understanding of a particular project would be necessary for the faculty member to adequately make the class experience not such a frustrating learning curve. Relying on project members to help achieve this would seem non-realistic in terms of a timeline for course deadlines.

I am interesting in the design and architecture of the FOSS projects in general. To be able to reverse engineer a project and model the design. To evaluate the design and suggest improvements. My students are using FreeMind this semester to map the design and architecture. I could have benefited form the project evaluation activity to help students understand the project.

I would like to integrate open source development in my Software Design and Architecture class. One way would be to discuss the architecture of one of the projects and use it as a case study. For there term project, students can reverse engineer a code base and extract the underling design and architecture of the application. I would expect them to be able to contribute to the project through bug fixing or enhancements.

Learning outcomes for a an term project

  1. Evaluate an existing project and analyze its current documentation
  2. Read and understand professionally written code
  3. Appreciate the importance of code documentation and project documentation
  4. Identify, describe and test bugs.
  5. Develop architecture and design documentation for an existing project
  6. Recognize coding conventions and design patterns.
  7. Contribute to open source development

Pre-requisite knowledge needed to complete the activity OOP and java

Estimate the time required for instructor prep, for student completion and elapsed calendar time . Are you going to have to synchronize your activity with the community or can the activity/topic be covered independent of the HFOSS community schedule. Input required from the HFOSS community I will need help to better understand the project and technologies involved

Contribution and its usefulness Complete documentation of the project design This project is a team project. It will be evaluated on the correctness of the design and architecture creating. Also understanding the different technologies involved. I don't think the work should be submitted to the HFOSS community except if the students manage to contribute to the project. The main barrier could be the complexity of the project and the amount of technologies/architectures and configurations the students need to learn.

For my software engineering course, I liked the Heidi Ellis's Case Study using a FOSS project as a running project in a software engineering course. I am thinking that OpenMRS could play an excellent role in this course, giving students a chance to: figure out what a component in a complex software project does and document it, with an audience of developers (e.g. UML diagramming) or users; perform tests; write automated tests. I might also be able to use it in the section on using revision control systems, but I would need to make a local repository they could mess around in.

For my data mining course, I generally give a large project that the class as a whole tackles. For this to work, I need something that can be broken into about 5 components that different groups of students can work on. I think that my idea of adding support for the adverse drug events data would work very well for that. One group of students can figure out how OpenMRS stores data, and how best the Adverse Event data should be incorporated into the existing database schema. Another group can work on the import itself, including parsing and cleaning the data and converting it into a format that integrates nicely with OpenMRS. Another group can work on extracting data about a specific patient for a personalized view of the adverse events. Another group can focus on mining the data given that other groups have imported it and provided an appropriate model of the target patient. The last group can manage the project and handle integration issues with the other teams.

I am also wondering about using OpenMRS a little in my computer security course. It could be a good example of an application with strict legal and ethical privacy and auditing constraints. I don't want to make that too strong a component of the course yet, because I am really hoping to not redesign this course quite yet....

I am using the mediawiki project in our senior capstone class. My team of students are productively lost at this moment. The mediawiki project is very health, but the similar activities as in part B would have helped my students better navigate the terrain. I plan to compile a list of bite-size activities to guide my students in the right decisions.

For example, I plan to reproduce a list of easy to reproduce bugs and research ways to fix them. Next, they need to dig through mailing list and IRC logs to research the history of the bugs. At last, if they don't know how to fix the bugs they need to seek help from other on IRC channels or the mailing lists.

I have several ideas where I could include FOSS.

  • In "CSC 120 - Survey of Computing" course, I plan to:
  • give our students an introduction to FOSS.
  • use http://www.sourceforge.net/ for an overview of different languages used in Software Development. In particular, students should be able to see how different Software Categories will use certain programming languages more often than others.
  • use http://www.ohloh.net/ for an overview of particular projects (such as Chromium (Google Chrome), and Mozilla Firefox). There are several interesting metrics to show students, in particular: Lines of Code, Programming Languages used, recent activity on the project
- Learning Outcomes: Students will get some understanding and appreciation for the diversity of applications that are produced in the "Real World". They will learn some basic vocabulary and basic principles used in FOSS. Get an idea about the complexity and size of applications that many of the students may already be familiar with (e.g. Google Chrome, Mozilla Firefox, etc.). Trying to identify the most commonly used programming languages for different categories such as: Games, Web Applications, Science Applications, etc. Many Computer Science and Information Technology terms can be introduced here.
- Prerequisite knowledge: None.
- Estimation for the time required for instructor prep, for student completion and elapsed calendar time:
- Synchronize the activity with the community or can the activity/topic be covered independent of the FOSS community schedule: N/A These topics will be introduced independently from the FOSS community schedule
- If the result of the activity is contributed back to the FOSS project, describe the contribution and its usefulness: N/A
- Assessment/grading approach: It can be done as individual tests, individual project, or group project.


  • In "CSC 150 - Computer Science I" course, I plan to:
  • Look at several projects' source code to:
  • identify "bad" vs "good" coding style, including code layout styles, variable names, etc.
  • identify the importance of writing good comments
  • use the available debugging tools to study and test an unfamiliar code
- Learning Outcomes: The students should be able to learn about different coding styles, and naming notation. They should gain an appreciation for using extensive comments in coding (especially since they will be exposed to code developed by somebody else). The students should be able to get familiar with debugging tools and other techniques that can be used to study and test code. Most of the testing will be unit tests.
- Prerequisite knowledge: They should be familiar with basic Programming techniques, such as: comments, simple statements, conditional statements, loops and functions.
- Estimation for the time required for instructor prep, for student completion and elapsed calendar time:
- Synchronize the activity with the community or can the activity/topic be covered independent of the FOSS community schedule: Most of the tasks should be independent from the FOSS community schedule. Some tasks, however, can involve helping the community and therefore may need to be synchronized with the FOSS community.
- If the result of the activity is contributed back to the FOSS project, describe the contribution and its usefulness: The students can start by writing extensive documentation and comments in existing projects. That should be a good starting point for the to get involved with some FOSS projects. In some cases, the students should be able to provide some basic unit testcases. Students will be asked to analyze pieces of code, and in some (rare) occasions that some logical bug is found, it should be reported to the FOSS community.
- Assessment/grading approach: Can be done as an individual project (mostly), or group project.


  • In "CSC 250 - Computer Science II" course, I plan to:
  • Look at several projects' source code to:
  • identify data structures used in some source files
  • develop UML diagrams for a specific project
  • identify and analyze some of the data structures used in the project.
- Learning Outcomes:
- Prerequisite knowledge:
- Estimation for the time required for instructor prep, for student completion and elapsed calendar time:
- Synchronize the activity with the community or can the activity/topic be covered independent of the FOSS community schedule:
- If the result of the activity is contributed back to the FOSS project, describe the contribution and its usefulness:
- Assessment/grading approach:


  • Ideally, I should get some students involved in a 1-year-long projects where students can:
  • study one particular project (of student's choice)
  • start with including more comments and updating existing test cases
  • get to fix existing bugs
  • develop new source code/adding new features
  • ideally the student will stay involved with the project even after the end of the 1-semester-long project.
- Learning Outcomes: Work with a large, "Real World", project. Work and colaborate with other developers (most likely accross the World) through the channels used by the project (IRC's, forums, google groups, etc). Provide some support to the FOSS community.
- Prerequisite knowledge: At least CS 1-2 (CSC 150 - CSC 250).
- Estimation for the time required for instructor prep, for student completion and elapsed calendar time: 2-semester course.
- Synchronize the activity with the community or can the activity/topic be covered independent of the FOSS community schedule: Synchronize the activity with the community.
- If the result of the activity is contributed back to the FOSS project, describe the contribution and its usefulness: Bug fixes, documentation update, and hopefully new features added and/or proposed, that were accepted by the FOSS community.
- Assessment/grading approach: Depending on the length of the project, the student should have set a minimum number of commits that were accepted to be included in a future release of the project. Community feed-back, although not required, will be very welcomed and appreciated. The students need to engage, or at least try to engage, in communicating with other members of the project on a regular basis. In extreme cases, where the feedback is very slow, or not received in time, the instructor should be able to provide feedback to the students.

We have a significant curricular investment in matriculating students towards a comprehensive software engineering experience. And it is from the perspective of "experiences" and not "courses" that focuses my attention. Much of the provided content and activities for FOSS engagement are highly relevant to contributing to this effort. I think that the POSSE workshop structure is an excellent starting point; this is especially true given its roots and focus stemming from the classroom experiences of others. My intention is to outline some activities and experiences similar to those from POSSE and then change them at various levels of breadth and depth within and across different courses. Below are some specific activities to potentially develop:

  • Compare and contrast FOSS to Commercial SW projects using the guides provided for FOSS Field Trip

The outcome here would be to comprehend the similarities and differences in the various dimensions characterizing SW projects. While much of the detailed data available via SourceForge and ohloh would be a challenge to find for commercial vendors, students would be able to articulate important questions about projects independent of type (FOSS vs. Comm). This could be extremely useful in a job or internship interview setting.

  • Focus on Documentation

As was pointed on in Andy Lester's Blog, documentation often "gets short shrift." As is common in most CS/IT/SWE programs, the "D-word" carries a burdensome and negative image. And as we all well know, documentation is at least as important as the code when it comes to project management and evaluation. For this activity I would ask students to examine various FOSS project documentation for its clarity of writing, topical focus, and relevancy to its intended purpose. Then based on the use of objectively defined rubrics and standards, the documentation would be rewritten and peer-evaluated. The final step would be to propose submission to the FOSS project. Clearly this is a writing intensive assignment lacks a certain sex appeal, but is one of the biggest differentiators for students in getting hired and eventually promoted; nobody likes documenting.

  • Enhancing Coder self-efficacy

Needless to say, making coding contributions to a FOSS project is what many of us aspire to. It is the most popular aspect, the first thought by those interested, but at the same time deemed out of reach. Several of the POSSE articles for this section discuss the fact that even though "genius coders" are not necessary, it seems my code is likely not good enough to contribute. I believe this is a mind-set and something to be overcome though practice and comparison and contract. In this activity, after examining what FOSS is and its rich history and usefulness, I would identify within a FOSS project some code that performs some specific action or behavior. I would recast that code block into a well formed and detailed SRS (complete with style and functional & structural requirement) and make it a programming assignment. Upon completion, the students code would be compared and contrasted to what is actually used in the FOSS project. I would escalate the complexity of the problems and code until students coding self-efficacy increased -- as well as their objective ability. Now we are confident in our ability and ready to make a contribution.

Goal:

I will be taking what I have learned during POSSE and applying it this spring with 3 or 4 students as part of my sabbatical - I am wanting to develop a highly structured and supportive independent learning experience in "distributed software engineering" using FOSS projects. The item below are my initial outline in achieving this goal.

  • Compare and contrast FOSS to Commercial SW projects using the guides provided for FOSS Field Trip

The outcome here would be to comprehend the similarities and differences in the various dimensions characterizing SW projects. While much of the detailed data available via SourceForge and ohloh would be a challenge to find for commercial vendors, students would be able to articulate important questions about projects independent of type (FOSS vs. Comm). This could be extremely useful in a job or internship interview setting.

Update:

This assignment would be the pre-requisite knowledge needed for conducting the other tasks. Obviously there would be some significant amount of reading on FOSS, its history and evolution similar what we have been doing.

Modifying the existing lessons to focus differently will require several hours of effort per module. I anticipate little if any traditional lecture but more of a discussion format since this activity will be part of a hybrid/blended course. As with many assignments in a hybrid/blended/flipped environment, students underestimate the time commitments necessary to complete at a high-level of accomplishment (/me don't I know it); this is especially true when the work is self-directed. This concern will also apply to the professor during execution and delivery - I must be available via electronic media at relevant and opportune time. These would be some of the possible concerns.

  • Focus on Documentation

As was pointed on in Andy Lester's Blog, documentation often "gets short shrift." As is common in most CS/IT/SWE programs, the "D-word" carries a burdensome and negative image. And as we all well know, documentation is at least as important as the code when it comes to project management and evaluation. For this activity I would ask students to examine various FOSS project documentation for its clarity of writing, topical focus, and relevancy to its intended purpose. Then based on the use of objectively defined rubrics and standards, the documentation would be rewritten and peer-evaluated. The final step would be to propose submission to the FOSS project. Clearly this is a writing intensive assignment lacks a certain sex appeal, but is one of the biggest differentiators for students in getting hired and eventually promoted; nobody likes documenting.


Update:

Some students are more interested in the NON-Coding aspects of software development and this task would allow the project-manager type to explore more deeply these aspects of FOSS. Given the experience with Part C and the bug-tracking, this too would allow students to generate reports and examine the management of projects from a perspective that just cannot be replicated in the traditional learning classroom. Once students become familiar with the tools and the project, they would be better able to contribute in a more traditional fashion to a FOSS project. As such, I think the FOSS community would be very open and welcoming to this. Taking the existing lessons and tweaking them to do more - both broadly and deeply, would require several hours to complete. For this I do not seem too many obstacles or stumbling blocks.

  • Enhancing Coder self-efficacy

Needless to say, making coding contributions to a FOSS project is what many of us aspire to. It is the most popular aspect, the first thought by those interested, but at the same time deemed out of reach. Several of the POSSE articles for this section discuss the fact that even though "genius coders" are not necessary, it seems my code is likely not good enough to contribute. I believe this is a mind-set and something to be overcome though practice and comparison and contract. In this activity, after examining what FOSS is and its rich history and usefulness, I would identify within a FOSS project some code that performs some specific action or behavior. I would recast that code block into a well formed and detailed SRS (complete with style and functional & structural requirement) and make it a programming assignment. Upon completion, the students code would be compared and contrasted to what is actually used in the FOSS project. I would escalate the complexity of the problems and code until students coding self-efficacy increased -- as well as their objective ability. Now we are confident in our ability and ready to make a contribution.


Update:

Obviously this is the one that the true "programmer" wants to be involved in. It is likely the most involved pedagogically for the faculty and preparation wise for the student. A very in-depth study of a programming language will be necessary - this is true especially for projects using a language unfamiliar to the student or faculty. Project knowledge too will have to be gained quickly but some of that can be managed using the evaluation template so students and faculty alike can size up a project from a number of dimensions. This task is likely to take many hours to structure so that it truly guides the student in both process and content. Dropping a student into a project with little guidance or support along the way will be a sure way to alienate students from FOSS and make this a poor learning and teaching experience.

Step 3.

For my undergraduate software engineering course, the motivation is to give students experience working with a large code base, and to get them thinking about the design of software. So I am interested in having the students add functionality to the project (along with corresponding test cases) but also to think about how they’re identifying components, the relationship between those components, etc.

For my graduate software engineering course, the emphasis is on “what is good code?” so we spend a lot of time reviewing code and figuring out ways to improve it. So the HFOSS-related activities would include conducting code inspections and then refactoring code to improve its design and internal quality, as well as bug fixing and regression testing.

Step 4.

For the undergraduate course, the activities would be based on the proposed CS2 assignments from the “50 ways to be a FOSSer” blog. I would have the students look at the existing code and document the design using UML, and also ask them to identify the usage (or attempted usage) of the design patterns we study in class. Then I would have them propose a feature, design the components using appropriate patterns, and then implement and test the feature.

For the graduate course, I would use some combination of the “Quality & Testing” and “Coding & Style” activities from the same blog. Students would start out by choosing one of the open defects, writing a test case that demonstrates that bug, and then fixing the bug. I would also ask them to create additional test cases for that component using test set adequacy metrics and then fix any other bugs they reveal. Then, once they’re comfortable with the expected functionality, they would conduct a code inspection, document “code smells”, and then refactor the code to improve its quality.

Part 1.

For both my undergraduate and graduate courses, I imagine that the FOSS activities would consist of two homework assignments: one in which the students evaluate the existing code, and then another in which they add to the code base or somehow improve the code.

I can imagine having a lecture around the benefits of FOSS for the undergrads, but I wouldn't think it's necessary for the homework assignments, which are simply focused on "existing code".

As for a project, we typically do customer-focused apps for our local community, and for undergrads the focus is on developing an app from scratch, but if a group of graduate students was particularly interested in contributing to a FOSS project, we could certainly explore that option.

Part 2.

Learning outcomes: For the undergrads, to be able to document the design (e.g. using UML) of existing code, to convert a set of requirements into a design, and to implement and test the code. For the graduate students, to be able to adequately test existing code, to debug code, and to refactor code.

Pre-requisite knowledge: Aside from the programming language of choice, I don't think there's much in the way of pre-reqs. Part of the challenge, especially for the graduates, would be to figure out the intent of the code as they are working with it.

Time estimates: It may take quite a while (~20 hours) to identify a project, figure out parts of the code to work with, identify the work that can realistically be done, and then write up the assignment and put together a grading rubric. For the undergrads, if we want to contribute new features to the project, we'd definitely need to coordinate that with the community, particularly as we have 130+ students in that class.

Input required for community: If we want to add new features, we will likely need to have those approved/vetted. For things like bug fixing and refactoring, though, I suspect the primary input will be coding conventions.

Assessment: For the undergrads, the documentation of the design of the code can be an individual assignment. If they are to design and implement new features, though, that would probably be in groups, primarily to address issues of scale. I wouldn't want to associate getting the work committed with the grade, though, as that is somewhat out of our control. For the graduates, the assignments (fixing bugs, writing tests, refactoring) could be done in pairs, and I might be more inclined to require that bug fixes or refactoring be committed, since presumably someone in the community would be able to assess their work as "good enough".

Questions/concerns: The more I think about this, the more concerned I get about issues of scale. My undergrad class has over 130 students; the graduate class has around 80. Documenting the design of the existing code is something that scales, since I wouldn't expect that we'd actually contribute that back to the project. But for the undergrads, even if they work in groups of four, what sort of effort will it take on my part to coordinate 30-something new contributions to existing projects? Will the groups all work on distinct features? How would they be graded? It wouldn't really make sense for multiple groups to work on the exact same feature, since only one implementation would be committed. Likewise, for the graduates, do the 80 students work on fixing 80 different bugs? And then refactor 80 different pieces of code? Again, it wouldn't make sense to have them all refactoring the same piece of code.

Here are a couple of activities I would like to use my class. I didn't find any existing material.

  1. Mining Software Repositories (MSR) has become a very popular research topic. For a seminar-style class where students read MSR papers, we could use FOSS projects as case studies. Some examples of questions we could try answering and compare two projects:
    • Do bugs get fixed faster?
    • Are there better tests?
    • Is the code 'better' - more readable, better designed, etc.?
    • Is there a correlation between the above?
    • When do code commits happen?
    • What are the processes for merging in patches/bug fixes? (E.g., do smaller bug fixes in terms of LOC get merged in faster than larger bug fixes)
    • Who collaborates with whom?
    • ...
  2. Using data from FOSS projects and combining them with other data sets can lead to very interesting mashups, data visualization, etc. It would be interesting to do this in the context of a class.

3. My students in software design class have implemented an EMR software for nursing faculty before. There are expensive software that does have similar (more elaborate) functionality. It would be nice to be able to connect that effort with OpenMRS's EMR project. Also, any development type activity will be of interest to me.

4. Getting involved in "API support for Order Entry" would be a good project for both software design class and also students in database management class. I can forsee a collaborative project done by students in both these classes and two faculty jointly overseeing the project. I did see some sample project ideas (templates), which can help with the initial work of the project creation.

[1]

  1. 2 - List the revised activities on your wiki page. For each activity/topic:

-- Identify some possible learning outcomes that should be fulfilled with the activities/task.

  • Use Git effectively
  • Learn about EMR and rules
  • Work in teams with different project responsibilities (programming and database)
  • Navigate the world of FOSS
  • Expand their knowledge and skills of other tools (those that are currently used in the OpenMRS)
  • Read and understand other programmer's code


-- Describe any pre-requisite knowledge needed to complete the activity. This does not need to be a complete list.

  • Learning basics of Git
  • Reading/learning about tools that are currently used


- Estimate the time required for instructor prep, for student completion and elapsed calendar time. Are you going to have to synchronize your activity with the community or can the activity/topic be covered independent of the HFOSS community schedule.

  • There will be at least 10 hours of prep needed and students should be given a few weeks to complete only a couple of improvements into the project. If students use the version that was worked on by previous year students, then this can be done independent of HFOSS while targeting some of improvements that are common in both projects.

- Think about possible input required from the HFOSS community. How much input is required and what kind?

  • Input will most likely be in the form of answering specific questions by both the instructor (while preparing the project) and students to understand the premise as well as conducting the work in conjunction with HFOSS community.

- If the result of the activity is contributed back to the HFOSS project, describe the contribution and its usefulness.

  • Since the intent is to find improvement type activity, then the contribution is expected to be very useful. Once the class project is completed, the improvements will be committed, in collaboration with someone in the HFOSS circle to avoid mishap.

- Describe the assessment/grading approach - What will the basis for grading be? Will this be a team activity or individual? Is there a role for the HFOSS community in helping assess student work? For instance, must the work be committed or otherwise accepted by the community?

  • As described above, this will be a team project and any work committed should be (I hope )supervised by someone in the community. The grading will be like any other project, which will be based on quality of development, on-time completion, and appropriate teamwork effort.

- List any questions or concerns that you have about the activity/task.

  • The communication/collaboration with community members and whether we can connect with a specific contact person throughout the project.

- List any stumbling blocks or barriers to carrying out the activity/task.

  • I don't call it barriers, but coordination with faculty who teaches database course, can add to the prep time.

5. --- Download/Install

I signed up for OpenMRS on the website, but could not complete install since I am using a MAC.


[2]


Recalling your list of activities/topics from the "FOSS in Courses Planning 1" activity, identify the ways that these FOSS activities/topics can be structured.
For software engineering especially, aim for a stream of related activities, including lectures, in-class activities, homework assignments. Detailed:
Lectures, e.g. on FOSS contribution, Git and other FOSS tools.
In-class activities practicing being productively lost and figuring our how a system works.
In-class activity, looking at design documentation for OpenMRS and discssuing the architectural choices that were made, pros, cons, alternatives.
Homework, creating documentation for OpenMRS, including design diagrams, tutorials, general documentation of how to use a specific feature.
Homework, designing and conducting tests
Homework, fixing a bug
Project, large, whole-class project adding an enhancement to OpenMRS. 
   List the revised activities on your wiki page. For each activity/topic:
   
   Software Engineering
Identify some possible learning outcomes that should be fulfilled with the activities/task.
Learn to read and understand design documentation.
Create design documentation.
Learn/practice interviewing users to gather requirements. This can probably be done in collaboration with the hospital or the School of Nursing.
Learn to use version control systems effectively.
Learn to design tests for a specific requirement and to conduct tests.
Learn to use a bug tracking effectively, especially refining existing defects so they are easier to fix but also logging new defects.
Practice finding the source of a bug, fixing it and making a patch.
Describe any pre-requisite knowledge needed to complete the activity. This does not need to be a complete list.
This is tied into the general software engineering curriculum I normally teach, so for example I would be lecturing on the specification process in connection with assignments on interviewing users to gather requirements. The main additional content needed would be a lecture introducing the students to working on a small piece of a very large project, FOSS philosphy and work styles, Git for revision control, problem solving strategies for isolating, fixing, regression checking bugs.
Estimate the time required for instructor prep, for student completion and elapsed calendar time. Are you going to have to synchronize your activity with the community or can the activity/topic be covered independent of the HFOSS community schedule.
Instructor prep is probably several hours each week, especially selecting appropriate hints to get the students going in the right direction. Student effort is probably quite high: even though the assignments I envision would be similar to what I currently give, the extra complexity of working on a very large project will require substantial more startup time. Plus, the assignments will probably take longer to complete than the relatively simple analogs I have been using. I doubt my students will produce anything good enough to actually submit a patch, but they might well produce useful tutorials, bug reports, etc. This kind of contribution should not need any special coordination.
Think about possible input required from the HFOSS community. How much input is required and what kind?
None needed, although having an experienced FOSS contributor visit could be energizing.
If the result of the activity is contributed back to the HFOSS project, describe the contribution and its usefulness.
The main contribution would be tests, bug report maintenance, documentation and tutorials. Testing and working with the defect databases would have practical value to the developers. The documentation would likely be only a first pass, so I do not know if that is useful or not. Any tutorials are likely to help beginners.
Describe the assessment/grading approach - What will the basis for grading be? Will this be a team activity or individual? Is there a role for the HFOSS community in helping assess student work? For instance, must the work be committed or otherwise accepted by the community?
For this course, I require teams of 2 or rarely 3 students. I will be doing the assessment, and will base the grade on whether they complete the requirements of the assignments. Often this will mean it is not quite up to par for contributing back to the FOSS project, but may be a good start.
List any questions or concerns that you have about the activity/task.
I haven't taken a good look at the documentation for OpenMRS, so I am not sure whether there is plenty of work the students can do or if it is already in great shape. I am also concerned with whether I can select projects that do not require a complex setup on the student machines. I think if I avoid having them work on the OpenMRS core and instead work on some of the optional modules that it might be fine.
List any stumbling blocks or barriers to carrying out the activity/task.
Again, the code base is large, and it will be hard to get my students to successfully navigate it. Also install could be a concern. 
      Data Mining
Identify some possible learning outcomes that should be fulfilled with the activities/task.
Understand data preparation.
Learn to select and apply relevant machine learning algorithms for a data mining task.
Feature engineering: defining and extracting and using appropriate features.
Usability and user interface design for a data mining project.
Privacy aspects of personalized medical data mining tasks.
Ability to work with a HFOSS community to integrate enhancements cleanly, both from a technical and social point of view.
Practice data mining with large, real-world datasets.
Describe any pre-requisite knowledge needed to complete the activity. This does not need to be a complete list.
The students will need to understand the nature of medical records, the nature of adverse drug events and how they can be related. They also need to know how to select cases that are relevant to a particular user and how to model the selected cases in order to perform a personalized risk analysis from the data. HFOSS philosophy and practical workflow.
Estimate the time required for instructor prep, for student completion and elapsed calendar time. Are you going to have to synchronize your activity with the community or can the activity/topic be covered independent of the HFOSS community schedule.
This is intended to be the core of a course, with substantial prep time for the instructor, on the order of 5 weeks of preparation over the summer. That is OK since the course is next taught in the fall. The student effort is also substantial, on the order of 1,000 hours in aggregrate. We should be able to have the enhancement at the alpha level by the end of the semester. I would need to investigate if the proposed functionality is already present in OpenMRS, but I doubt that it is.
Think about possible input required from the HFOSS community. How much input is required and what kind?
We need to make sure that the project integrates properly with OpenMRS, which probably means publishing our plans to the OpenMRS architects pretty early on and getting feedback on the details. We also need to balance the needs of the class project with being open to contributions form outside contributors.
If the result of the activity is contributed back to the HFOSS project, describe the contribution and its usefulness.
We would be contributing a module that allows practitioners to identify records in the FDA's adverse drug event database that are similar to a specific patient, in order to better understand the risks of a drug to a specific patient. The data set is public, but access to it in a meaningful form is only currently available through expensive for-profit options as far as I know. This would be highly valuable for the project.
Describe the assessment/grading approach - What will the basis for grading be? Will this be a team activity or individual? Is there a role for the HFOSS community in helping assess student work? For instance, must the work be committed or otherwise accepted by the community?
For this course, I always split the work into about 5 parts and then have the students submit a resume and cover letter for which team they want to join. Since the project is really a research project, the grading is largely based on appropriate levels of effort and quality of work. I can use the revision control system to track the individual contributions for assessment. I generally also have the students provide feedback to other teams, and assess how well they respond to the feedback.
List any questions or concerns that you have about the activity/task.
None really.
List any stumbling blocks or barriers to carrying out the activity/task.
I think that OpenMRS comes with mock medical records that we can use for testing, but there could eventually be issues related to human subjects research and approval of the tool if it is perceived as a medical device. 


    Computer Security
Identify some possible learning outcomes that should be fulfilled with the activities/task.
Understand HIPAA and its implications for MRS.
Analyze the security of a complex system.
Develop security requirements for a complex system.
Describe any pre-requisite knowledge needed to complete the activity. This does not need to be a complete list.
The students will need an understanding of what a MRS is and the kinds of data it contains.
Estimate the time required for instructor prep, for student completion and elapsed calendar time. Are you going to have to synchronize your activity with the community or can the activity/topic be covered independent of the HFOSS community schedule.
Instructor prep time is a few hours for each of several lectures and assignments. The effort on these assignments for the students is about 10 hours per assignment. The activity does not require any coordination with the FOSS project.
Think about possible input required from the HFOSS community. How much input is required and what kind?
It would be great if the students could interview members of the HFOSS community who have a special interest in privacy and security.
If the result of the activity is contributed back to the HFOSS project, describe the contribution and its usefulness.
There may be contribution in the form of security-related bug reports the students identify.
Describe the assessment/grading approach - What will the basis for grading be? Will this be a team activity or individual? Is there a role for the HFOSS community in helping assess student work? For instance, must the work be committed or otherwise accepted by the community?
I will encourage the students to work in groups of 2-3 students, but most will opt to go it alone. I will use a traditional assessment based on the quality of their security analysis and their ability to coherently write about what they find or design.
List any questions or concerns that you have about the activity/task.
None
List any stumbling blocks or barriers to carrying out the activity/task.
None
Retrieved from "http://foss2serve.org/index.php?title=Stage_2_Activities/2.3_ParticipantResponses_2014-11&oldid=4671"
Personal tools
Namespaces
Variants
Actions
Events
Learning Resources
HFOSS Projects
Evaluation
Navigation
Toolbox