According to the United Nations, twenty-two global issues face society [31]. Many of these—Health, Food, Water, Poverty, and Migration—relate to Climate Change, while others are social issues related to Democracy, International Law and Justice, Gender Equality, and Human Rights. Each of these issues deserves the attention of the computing community, and in turn, demands the attention of computing educators. As a community, we dare not continue with business as usual. Specifically, we must do our part to fill the pipeline of future computing professionals with practitioners who deeply understand that they can use their unique skills to tackle the major social issues of our time

Introduction

The United Nations doesn't mince words.

Climate change is the defining issue of our time and now is the defining moment to do something about it. There is still time to tackle climate change, but it will require an unprecedented effort from all sectors of society. [30]

The technology sector is well-positioned "to do something about it." Consider the TechStars Sustainability Accelerator initiative, which assists entrepreneurs who want to address global issues like climate change by ensuring technology "innovates to make the world a better place to live." [28] While applauding such initiatives, we believe that computing education must also step up and help lead the changes that society needs. We likewise assert that computing education should not continue with "business as usual." Instead, we propose presenting and teaching computer science as a discipline possessing key insights towards making headway on these pressing social, environmental, and economic problems, and whose practitioners have been educated in how to use their skills to contribute to their resolution.

This perspective speaks directly to the question of why study (or offer) computing? Computing faculty bristle at the accusation that we are essentially engaged in vocational training for potential lucrative development careers. If one sees computing as an engineering discipline, then perhaps we should be inspired by the obligation from the Order of the Engineer to "serve humanity." [17] Alternatively, if computing belongs among the liberal arts, we should focus on the formation of tomorrow's leaders who will be tasked with solving the problems of the day. Regardless, computing educators have the content and pedagogical know-how to prepare students to make a difference in the world by further improving the human condition.

We argue that many computing educators live in a well-meaning but potentially counter-productive bubble. As with other insular groups, we hold preconceptions and assumptions not held by others. For example, on the one hand most of us take for granted that obtaining a CS degree can lead to a well-paying job, exciting careers, and opportunities to make a difference in the world. On the other hand, one of the authors, Lisa, in working with disadvantaged populations as a Program Evaluator, has observed that not everyone believes in these outcomes. Some time ago, while investigating barriers that impede K-12 students from participating in coding programs targeting them, she was initially surprised to hear someone say that the students were being discouraged by their parents. Why? It turned out that neither the students nor their families believed that studying computing would lead to a good job! Not only that, the notion of a "good job" only partially had to do with salary; equally important was the ability to give back to one's family and community. Admittedly, these findings were anecdotal, however, what isn't anecdotal is the fact that while enrollments in undergraduate CS programs are growing at unprecedented rates, participation in CS programs by women and underrepresented minorities continues to lag, in the USA at least [16].

We also know that

  • student orientation towards social activism has been a consistent negative predictor of interest in CS over the past 40+ years [23];
  • women place greater emphasis on social activism than men [23]; and
  • choice of major is influenced by one's values rather than one's interests [3,23].

Taken together, these findings send a message that we have an as yet unrealized opportunity to increase the interest and sustained commitment of women and other underrepresented groups in computing through curricular change.

This paper advocates that the CS discipline should present itself to students as what one should study if one wants to make important socially relevant contributions to our communities and our world. A key ingredient to this approach is that our curriculum needs to have projects and assignments that reflect this perspective. This approach is called CSG-Ed; CS educational activities that emphasize computing for the social good.


This paper advocates that the CS discipline should present itself to students as what one should study if one wants to make important socially relevant contributions to our communities and our world. A key ingredient to this approach is that our curriculum must have projects and assignments that reflect this perspective.


CSG-Ed is an umbrella term meant to incorporate any educational activity, from small to large, that endeavors to convey and reinforce computing's social relevance and potential for positive societal impact [7,8,10]. Many of the ideas in CSG-Ed are not entirely new but this paper serves as an introduction to new audiences and a proposed standardization of terminology and approaches for those educators already focused on endeavors that promote computing for the social good. Our goal also includes presenting easy to adopt strategies for incorporating CSG-Ed into all of one's courses.

Back in 1971, Ben Schneiderman argued that students should be equally stimulated to study sociological modeling as faster algorithms for eigenvalue calculations [26]. More recently, there has been a growing body of initiatives (HFOSS [20,29], ICT4D [12], ICT4Peace [13], LIMITS [15], ACM Compass [1]) and experience reports describing CSG-Ed in upper division courses, such as software engineering [4,6,19], capstone courses [2,14,27], and service learning experiences [21,22,25]. Unfortunately, the majority of examples in the literature focus on upper-division courses; well beyond the crucial decision influencing introductory course. This orientation implies that only those students who have survived two or more years of programming disconnected from its real-world impact will get exposed to the potential social value contributions of computing. Currently, the literature for describing CSG-Ed activities for the introductory sequence is thin. In response, this paper presents easy to adopt strategies for incorporating CSG-Ed throughout the curriculum with a focus on the introductory sequence.

Change Starts at Home

Or, in this case, the classroom. Consider your CS0/1 Intro to Computing course, for example. What do you do on your first day to illustrate what computer science is all about? You have only one chance to make your first impression of choice. Known examples of what has historically been done range from the nifty [18] or humorous (shoe tying exercise or the construction of a peanut and butter sandwich [5]), exemplar (demonstrate Google search - the most lucrative algorithm yet created, or any other application of choice), enticing (pick your game of choice from Klondike to League of Legends—a potential future National Collegiate Athletic Association esport), to the trivial (long-division, sorting), to the serious/socially relevant (The Reuniting Families Day One exercise [9]).

Now take a moment to reflect on what message you transmitted about the discipline to your students. Did you make it clear that CS can be about changing people's lives for the better? Making a difference in their world? Addressing issues that are meaningful to them? Understand that the challenge of messaging is not a problem that other, older, STEM disciplines face to the same extent. Engineers build things, doctors heal the sick, etc. Computer science in general and software and algorithm creation/development, in particular, often remains obscure to non-practitioners.

Extend this first impression exercise to the balance of the course. Again, consider the motivating examples you presented/solved in class as well as any programming projects. How serious is computer science, as a discipline, to these students? Consider a STEM talented student who wishes to make an impact on the world and explores computer science. Did your course convince this student to at least continue their exploration of computing? Seriously consider this question in light of the research results summarized above and the results from the BRAID Initiative (Building, Recruiting, and Inclusion of Diversity) that what happens in the first course (first day?) strongly influences students' decision whether to continue in computing [24]. What happens in one's introductory CS course matters: 60% of undecided majors enrolled in CS 1 conclude that a computing major is not for them [24]. We may not be able to change what students come into our class on Day 1 believing, but we can change what they leave class that day, and every day thereafter, understanding.

Having set the stage on the first day and for the remainder of the first computing course, it is equally important to continue to reinforce throughout the rest of the CS curriculum the understanding that CS is about changing people's lives for the better. We argue that such continued reinforcement serves as priming for every computing student to consider social issues during their subsequent professional careers.

What is Involved For Adopting CSG-ED Practices?

• A Taxonomy For CSG-ED Activities

We propose the following taxonomy for levels of CSG-Ed involvement.

  • Level 1: The low hanging fruit—redefine an existing example/project with a CSG-Ed narrative.
  • Level 2: Explicitly address a social good problem, though often in a simplified form.
  • Level 3: A real world problem solved as an exercise.
  • Level 4: A real world problem brought by stakeholders and with real world benefits rather than just an exercise.

Like all taxonomies, its purpose is to facilitate the categorization, comparison, and discussions among CSG-Ed practitioners.

Furthermore, as we demonstrate below, this taxonomy illustrates that the bar to getting started as a CSG-Ed practitioner is very low.

• Suggestions For CS0 and CS1

The easiest approach (Level 1) is to deliver the very same course you currently have but reframe your in- class/motivating examples and problems, along with all of the programming projects.

Take that CS0/1 for example. For a first day activity in CS0/1, instead of the problematic Peanut Butter & Jelly sandwich making [5] exercise in which the "recipe" for making a sandwich is intended to teach the concept of an algorithm (did you know that in many societies students would never have tasted peanut butter and that the notion of making a sandwich might be meaningless altogether?) we recommend the "unplugged" Reuniting Families [9] CSG-Ed activity.

A common topic in CS1 are arrays and the list-oriented algorithms for searching, sorting, and analyzing them. By simply reframing these tasks, they can take on a new and hopefully socially relevant meaning.

  • Searching
    • The array can represent chromosomes in a DNA molecule. One can search for a specific pattern that represents a given characteristic such as likelihood of developing a particular disease. Similarly, one can count the frequency of a given pattern for similar reasons. Great lead-in for discussing heredity diseases predominantly found in certain populations such as sickle cell anemia or Tay-Sachs disease.
    • The array can represent energy usage by the occupants of a building. One can search for the most energy efficient occupant, or the greatest energy hog. Frequently, one can often obtain real data for this. An opportunity to compare data for buildings in different real estate markets or socio-economic regions.
    • Using the Media Computation approach, the array can represent a picture [11]. In addition to the standard picture manipulations (blue tint, invert, flip, etc.) one can search the image for a particular color blob of a certain size; a minimum number of adjacent pixels all of the same color. This can represent image analysis for search and rescue operations.
  • Sorting

Instead of sorting random numbers, one can sort climate data, donors and their donations to a non-profit, CO2 emissions by industry, or even terrorist attacks by the devastation wrought or participants and their country of origin. Our experience shows that such examples generally lead to great classroom discussions concerning issues such as profiling based on incomplete or inadequate data analysis.

Objects are another common CS1 topic. A common assignment/project is to iterate over a container instance composed of objects. One can model an election: a collection of vote objects. Now, instead of just calculating which candidate achieved the greatest vote tally, one can also analyze the container object applying different vote counting algorithms such as preference voting. An opportunity to discuss the impact of voting participation.

Open data provides additional CSG-Ed opportunities. Each object in a container class can represent a call to and the response by the fire department in one's city. By iterating over the collection, one can answer many interesting questions. These include a social justice-based question—which zip code receives the best aggregate fire department response times, and which receives the worst?

Graphics-based introductory programming (e.g., Green-foot) also presents CSG-Ed opportunities. The radioactive mice problem is described in [8]. Similarly, one can visually examine different elevator scheduling algorithms, or how swarm algorithms can exhibit emergent behavior. One classic application of this, using Greenfoot, is to illustrate how segregation still occurs even when each individual, acting autonomously, is willing to live in an integrated neighborhood, and will only move out when they become part of the minority.

• Suggestions For CS2 and CS3

In these courses one can leverage the coverage of advanced data structures into more realistic CSG-Ed problem domains.

The 2012 ITiCSE Working Group Report on CSG-Ed describes the "Red Cross Response" problem: given an undirected graph representing cities and connecting roadways, one of the cities is designated as having a disaster, while n other cities are designated as having a Red Cross response team. Which team should respond is simply a Level 1 wrapping for a Shortest Path assignment [8].

The Reuniting Families problem can be revisited, though this time with the use of computing agents. Keeping track of registered survivors can be modeled using a binary search tree. Each family unit is a node in the tree, and the members of the unit are kept in a container class inside the node.

A hospital emergency waiting room can be modeled by a priority queue. A queue can be used to model any service that utilizes a FIFO ordering. This is especially useful since one can use this example to illustrate algorithm bias: FIFO services are positively biased towards "long" jobs.

Sometimes, one can extract CSG-Ed assignments from the local paper. In 2014 the Elk River suffered a serious pollution event/chemical spill. The Elk river is a tributary of the Kanawha River, which in turn is a tributary of the Ohio River. As this large toxic pollution puddle traveled downstream it threatened the water supply of numerous communities. Cincinnati, OH in particular was located at a point where it was not certain if sufficient dilution had occurred or not. Students can model this environment as a discrete event simulation (Level 2) to determine if the drinking water supply would be threatened or not.

Government actions provide additional opportunities for extracting CSG-Ed examples. For instance, the sequence of steps associated with Britain exiting the European Union may be used to introduce pushdown stacks or directed (precedence) graphs. As depicted in Figure 1, a Finite State Automaton can capture the process in which a Bill becomes a United States Law. Naturally, such examples may be introduced wherever they occur in the curriculum including: CS1, CS2, CS3, Principles of Programming Languages, Computation Theory, etc.

• Suggestions For Upper Division Courses

It is insufficient and disingenuous to abandon CSG-Ed in the intermediate and upper division courses. While CSG-Ed enjoys greater popularity with software engineering and capstone courses, there are other courses at these curricular levels that could benefit from a CSG-Ed focus.

The previous sections illustrated how one can recast existing assignments (e.g., shortest path algorithms, list algorithms, priority queues) into CSG-Ed based assignments. Another strategy is to focus on a whole course instead of individual assignments. The following are two examples of intermediate or upper level courses that utilize this strategy.

Database Systems. It seems to be an invariant of database textbooks that they use a running example throughout the text and that the example be either a university registration/grade system, a banking application, or a reservation system. Instead, one could run an identical course, only use one's own running CSG-Ed based example. A good candidate for this is the local Red Cross blood donation network. This example has multiple donation centers (equivalent to bank branches), different types of transactions (blood donation, platelets, red cells only, failed donations), a customer/donor set, etc. As with the banking/university/reservation examples, complexity is added in as students gain topic mastery. The same is true for the Red Cross blood donation system—employees can be added, employee shifts, supervisors and for ambitious adopters, mobile donation trucks.

Opioid Crisis. Another intermediate course gaining in popularity is the "open-ended problem solving" course. Students are given an open problem and a semester to see what they can do with it. Pedagogically, the idea is for students to figure out what it is they need to learn, go off and learn it, and then utilize it in their solutions. Solutions then get measured (against a student developed metric) and then the development cycle iterates. Alternatively, the development cycle can be handled using an agile method organized around two-week sprints.

Key to this style of course is a problem of sufficient complexity. Recently, one of the authors in running this style of course, elected to focus on the burgeoning opioid crisis. Students in an elongated hackathon style approach first learned about the problem, went through an ideation phase, voted on three winning applications, self-sorted themselves into three teams and spent the majority of the semester utilizing an agile development methodology to achieve their goals. The course was an excellent Level 3 CSG-Ed exercise.

Unbeknownst to the course instructor, both the Dean and Development Office got wind of the project. Soon thereafter a small grant was received to support two small student teams to complete the two mobile apps—elevating them to Level 4 projects with deliverables to community partners.

This strategy for adopting a Level 3 approach to the organization of a whole course is not limited to the opioid crisis. Any NP-Complete problem will do. For example, using a city's Open Data set one can attempt to optimize the location of a new fire station, police station, soup kitchen, etc.

Dream Big, Really Really Big. An alternative Level 3 approach is found in the work of another author, Richard, which was developed in conjunction with Johanna Blumenthal, upper-division Ethical Leadership in Computer Science course at Regis University. In this course, we require each student to select a significant social problem of their own choosing, which becomes the focus for their semester length project. Students are encouraged to "dream big" and are only limited by the constraint that the resolution to their selected problem requires, in part, a computing solution. To address stakeholder and scoping issues that arise with Level 4 approaches, students are not required to implement, in the programming sense, their proposed solution. A variety of techniques are used throughout the course to promote consideration of the common social good in developing a solution to their chosen problem [32]. As an example, students must identify all societal stakeholders that may be impacted by their computing solution (this identification is an aspect of the first ethical principle in the ACM Code of Ethics and Professional Conduct), predict the positive and negative consequences for such stakeholders, applying a system of ethics to analyze these impacts, and make socially and ethically informed decisions based on this analysis.

It is also worth noting that several Level 1 and 2 approaches are used throughout the Regis University CS curriculum to help prime students towards considering the common social good. Besides socially focused examples in the CS1-CS3 sequence (Level 1), the Software Engineering course, for example, requires students to implement a semester-length programming solution to a suitably scoped social problem, once again of their own choosing (Level 2). With a few exceptions, student feedback in these social-focused computing courses has been very positive. Furthermore, the shift to socially focused problems has not negatively impacted other computing-centric learning outcomes and implementation of these socially focused Level 1-3 approaches required very little additional faculty effort.

Go Big, Really Really Big. A significant problem with Level 4 (and Level 3) projects is one of timing and scope. The real world, and our real-world community partners do not operate on an academic calendar:

At Xavier University, the lead author, Mikey, championed a department-level CSG-Ed buy in. The department picked a single CSG-Ed topic for a two-year period. Each faculty member now endeavors to incorporate CSG-Ed themes, projects, etc. into their courses. The first topic was Poverty in the local community. Poverty related CSG-Ed activities fall into roughly three categories.

  • Level 1 and 2 projects for courses in the three-course introductory sequence.
  • Level 3 and 4 projects for upper division courses. Projects at this level span both course and semester boundaries. For example, one community partner's project spans both our database course and our software engineering course. Each course will work on their project over multiple semesters.
  • Department-wide events for students enrolled in courses that do not lend themselves to CSG-Ed activities. (e.g., Languages and Automata). Examples include a "Poverty Simulation" and an ideation session brainstorming approaches to increase the response rate for the upcoming 2020 census.

Reasons For Not Adopting CSG-ED Practices and Why You Shouldn't Let Them Stop You

Although we'd like to believe that by now you are convinced of the importance of incorporating CSG-Ed throughout the CS curriculum, starting with your own courses, in our experience, people express several common reasons for shying away from CSG-Ed [8]. We want to address these issues head on. This list includes:

  • Mindset and historical precedent
  • Lack of domain knowledge
  • Overworked instructors, especially with current enrollments
  • Stakeholders not pushing for this
  • Fear of extraneous cognitive load
  • Lack of textbook support

It is our experience, informed through leading CSG-Ed workshops, over the past few years, that most educators, when they consider creating (or even just adopting) a socially relevant project or assignment, believe that they need to achieve Level 3 or 4. Believing that one must achieve this degree of depth is one of the primary triggers for a number of the pitfalls: lack of domain knowledge, overworked, lack of textbook support, and so forth.

As the CSG-Ed taxonomy illustrates, this "go deep or don't do it" mentality is a misconception. One can still present computing as socially relevant even when only employing projects and assignments from Levels 1 and 2. Modify your current projects/assignments with a CSG-Ed wrapper/narrative from a context already familiar to students. The Red Cross Response problem described above is a canonical example. Once you become comfortable integrating Levels 1 and 2 into your classes you can consider integrating Levels 3 or 4 into your classes as part of your ongoing curricular updates.

However, even if one accepts our argument that one does NOT need to go deep or don't do it, other factors may still inhibit adoption of CSG-Ed. In these days of understaffed programs with overenrolled student populations, it is hard to persuade an overworked educator to not simply redeploy previously developed projects. Hopefully, you now believe that the effort is worth it. We recommend starting small; change one assignment from one course. Next semester change two—may-be one you develop yourself, and one taken from the literature. Even though the primary stakeholders are not pushing for this, hopefully, student enthusiasm will provide appropriate feedback and reward.

It is also our hope that as time goes on some of these barriers will erode or disappear. If the computing education community demands it, textbook authors will respond accordingly. As the body of literature for CSG-Ed grows and resource sharing technologies mature (e.g., The CSG-Ed discussion group) the need to create for oneself versus adopting what others have already done will grow. Finally, as with anything else, the more one practices CSG-Ed, regardless of which level one strives for, the easier it gets.

Conclusion

As computer scientists and educators, we have an obligation to reflect deeply regarding our mission. Regardless of how we may have been taught and trained ourselves, in today's world it is insufficient to present computer science as either a purely abstract mathematical discipline or little more than a collection of skills leading to a high paying job. The world faces serious social and environmental challenges at the same time that computing technology is becoming globally ubiquitous. We argue that not only are we ethically obligated to integrate CSG-Ed into our curriculum, we are more than equipped to do so. The CSG-Ed Taxonomy provides a guide for getting started. We just need to step up and start preparing our students to change the world.

References

1. ACM Compass; http://acmcompass.org/. Accessed 2019 July 30.

2. Anderson, R.J., Anderson, R.E., Borriello, G., and Pal, J. An approach to integrating ICTD projects into an undergraduate curriculum. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education (SIGCSE '10). (New York, USA, ACM, 2010), 529–533.

3. Buckley, M., Nordlinger, J., and Subramanian, D. Socially relevant computing. In Proceedings of the 39th ACM Technical Symposium on Computer Science Education (SIGCSE '08). (New York, USA, ACM, 2008), 347–351.

4. Buckley, M., Kershner, H., Schindler, K., Alphonce, C., and Braswell, J. Benefits of using socially relevant projects in computer science and engineering education. In Proceedings of the 35th ACM Technical Symposium on Computer Science Education (SIGCSE '04). (New York, USA, ACM, 2004), 482–486.

5. Davis J. and Rebelsky, S.A. Food-first computer science: Starting the first course right with PB&J. In Proceedings of the 38th ACM Technical Symposium on Computer Science Education (SIGCSE '07). (New York, USA, ACM, 2007), 372–376.

6. Ellis, H.J.C., Morelli, R.A., de Lanerolle, T.R., Damon, J., and Raye, J., Can humanitarian open-source software development draw new students to cs? In Proceedings of the 38th ACM Technical Symposium on Computer Science Education (SIGCSE '07). (New York, USA, ACM, 2007), 551–555.

7. Goldweber, M. Computer science education for social good. SIGCAS Computer Society, 45, 2 (2015), 29–30.

8. Goldweber, M., Barr, J., Clear, T., Davoli, R., Mann, S., Patitsas, E., and Portnoff, S. A framework for enhancing the social good in computing education: A values approach. In Proceedings of the 17th Annual Conference reports on Innovation and Technology in Computer Science Education - working group reports (ITiCSE-WGR '12). (New York, USA, ACM, 2012).

9. Goldweber, M. A day one computing for the social good activity. ACM Inroads, 3, 3 (2012), 46–49.

10. Goldweber, M., Davoli, R., Little, J.C., Riedesel, C., Walker, H., Cross, G. and Von Konsky, B.R. Enhancing the social issues components in our computing curriculum: Computing for the social good. ACM Inroads, 2, 1 (2011), 64–82.

11. Guzdial, M. A media computation course for non-majors. In Proceedings of the 8th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE'03). (New York, USA, ACM, 2003), 104–108.

12. Heeks, R. ICT4d 2.0: The next phase of applying ICT for international development. Computer, 41, 6 (2008), 26–33. DOI: http://dx.doi.org/10.1109/MC.2008.192.

13. Hourcade, J.P., Give peace a chance: a call to design technologies for peace. In Proceedings of the 27th international conference extended abstracts on Human factors in computing systems (CHI EA '09). (New York, USA, ACM, 2009), 2499–2508. DOI: http://doi.acm.org/10.1145/1520340.1520354

14. Leidig, P.M, Ferguson, R., and Leidig, J. The use of community-based non-profit organizations in information systems capstone projects. In Proceedings of the 11th Annual Conference on Innovation and Technology in Computer Science Education (ITICSE '06). (New York, USA, ACM, 2006), 148–152.

15. LIMITS; http://computingwithinlimits.org. Accessed 2019 July 22.

16. National Academy of Sciences. Assessing and responding to the growth of computer science undergraduate enrollments. (Washington, DC, USA, The National Academic Press, 2018); https://doi.org/10.17226/24926.

17. Order of the Engineer; http://www.order-of-the-engineer.org/ Accessed 2019 July 22.

18. Parlante, N. Nifty assignments; http://nifty.stanford.edu/ Accessed: 2019 July 19.

19. Pauca. V.P. and Guy, R.T. Mobile apps for the greater good: A socially relevant approach to software engineering. In Proceedings of the 43rd ACM Technical Symposium on Computer Science Education (SIGCSE '12). (New York, USA, ACM, 2012), 535–540.

20. Postner, L., Burdge, D., Jackson, S., Ellis, H., Hislop, G., and Goggins, S. Using humanitarian free and open source software (HFOSS) to introduce computing for the social good. SIGCAS Computer Society, 45, 2 (2015), 35–35.

21. Purewal, Jr., T.S., Bennett, C., and Maier, F. Embracing the social relevance: Computing, ethics and the community. In Proceedings of the 38th ACM Technical Symposium on Computer Science Education (SIGCSE '07). (New York, USA, ACM, 2007), 556–560.

22. Reiser, S. and Bruce, R. Service learning meets mobile computing. In Proceedings of the 46th Annual Southeast Regional Conference on XX (ACM-SE 46). (New York, USA, ACM, 2008), 108–113.

23. Sax, L., Lehman, K., Jacobs, J., Kanny, A., Lim, G., Monje-Paulson, L., and Zimmerman, H. Anatomy of an enduring gender gap: The evolution of women's participation in computer science. The Journal of Higher Education, 88, 2 (2017), 258–293. DOI:https://doi.org/10.1080/00221546.2016.1257306.

24. Sax, L. Braid research update. https://braidresearch.gseis.ucla.edu/wp-content/uploads/2016/04/BRAIDSummit_2017_Updated8.8.pdf. Accessed 2019 March 6.

25. Scorce, R.A. Perspectives concerning the utilization of service learning projects for a computer science course. Journal of Computer Sciences in Colleges, 25, 3 (2010), 75–81.

26. Schneiderman, B. Computer science education and social relevance. SIGCSE Bulletin, 3, 1 (1971), 21–24.

27. Smith, L. and Mann, S. Sustainable software engineering. In Proceedings of the 1st Annual Conference of Computing and Information Technology, Education and Research in New Zealand (incorporating 23rd Annual NACCQ), S. Mann and M. Verhaart, Eds. (CITRENZ/NACCQ, 2010), 366–367.

28. Techstars Sustainability Accelerator; https://www.techstars.com/sustainability-program/. Accessed 2019 June 6.

29. Tucker, A., Morelli, R., and Lanerolle, T.D. The humanitarian FOSS project: Goals, activities, and outcomes. In Proceedings of the 2011 IEEE Global Humanitarian Technology Conference (GHTC '11). (Washington, DC, USA, IEEE Computer Society, 2011); DOI:http://dx.doi.org/10.1109/GHTC.2011.78.

30. United Nations Climate Action Summit 2019; https://www.un.org/climatechange/. Accessed 2019 July 10.

31. United Nations Global Issues; https://www.un.org/en/sections/issues-depth/global-issues-overview/. Accessed 2010 July 22.

32. Urman, J. and Blumenthal, R. An undergraduate ethics course for promoting common good computing: A progress report. Journal of Computing Sciences in Colleges, 34, 2 (2018), 39–45.

Authors

Mikey Goldweber
Department of Computer Science
Xavier University, 3800 Victory Parkway, Cincinnati, OH USA
[email protected]

Lisa Kaczmarczyk
PhD Consulting, LLC
Lisa Kaczmarczyk PhD Consulting, LLC
[email protected]

Richard Blumenthal
Department of Computer Science
Regis University, 3333 Regis Blvd., Denver, CO USA
[email protected]

Figures

F1Figure 1. A Level 1 CSG-Ed example modeling the United States Bill to Law process, as a Finite State Automaton.

©2019 ACM  2153-2184/19/12  $15.00

Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and full citation on the first page. Copyright for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or fee.

The Digital Library is published by the Association for Computing Machinery. Copyright © 2019 ACM, Inc.

Contents available in PDF
View Full Citation and Bibliometrics in the ACM DL.

Comments

There are no comments at this time.

 

To comment you must create or log in with your ACM account.