From 78778f91c9a8255dfb6315657f0617034fa3332f Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 2 Jun 2018 13:41:02 +0100 Subject: [PATCH 01/24] First draft of nbgrader paper --- codemeta.json | 69 ++++++++++++++++++++++++ paper/paper.bib | 138 ++++++++++++++++++++++++++++++++++++++++++++++++ paper/paper.md | 74 ++++++++++++++++++++++++++ 3 files changed, 281 insertions(+) create mode 100644 codemeta.json create mode 100644 paper/paper.bib create mode 100644 paper/paper.md diff --git a/codemeta.json b/codemeta.json new file mode 100644 index 000000000..554f662b1 --- /dev/null +++ b/codemeta.json @@ -0,0 +1,69 @@ +{ + "@context": "https://raw.githubusercontent.com/codemeta/codemeta/master/codemeta.jsonld", + "@type": "Code", + "author": [ + { + "@type": "Organization", + "name": "Project Jupyter" + }, + { + "@id": "", + "@type": "Person", + "email": "bussonniermatthias@gmail.com", + "name": "Matthias Bussonnier", + "affiliation": "University of California, Berkeley" + }, + { + "@id": "http://orcid.org/0000-0003-4805-2216", + "@type": "Person", + "email": "jfrederic@google.com", + "name": "Jonathan Frederic", + "affiliation": "Google Inc." + }, + { + "@id": "", + "@type": "Person", + "email": "bgranger@calpoly.edu", + "name": "Brian E. Granger", + "affiliation": "Cal Poly, San Luis Obispo" + }, + { + "@id": "http://orcid.org/0000-0002-3860-0429", + "@type": "Person", + "email": "jessica.b.hamrick@gmail.com", + "name": "Jessica B. Hamrick", + "affiliation": "DeepMind" + }, + { + "@id": "http://orcid.org/0000-0002-5799-8524", + "@type": "Person", + "email": "page.lg@gmail.com", + "name": "Logan Page", + "affiliation": "University of Pretoria" + }, + { + "@id": "http://orcid.org/0000-0002-1023-7082", + "@type": "Person", + "email": "benjaminrk@gmail.com", + "name": "Benjamin Ragan-Kelley", + "affiliation": "Simula Research Laboratory" + }, + { + "@id": "http://orcid.org/0000-0002-9817-8485", + "@type": "Person", + "email": "willingc@gmail.com", + "name": "Carol Willing", + "affiliation": "Cal Poly, San Luis Obispo" + } + ], + "identifier": "", + "codeRepository": "https://github.com/jupyter/nbgrader", + "datePublished": "2018-06-02", + "dateModified": "2018-06-02", + "dateCreated": "2014-09-13", + "description": "A system for assigning and grading Jupyter notebooks", + "keywords": "jupyter, jupyterhub, grading, autograding", + "license": "Modified BSD", + "title": "nbgrader", + "version": "v0.6.0-dev" +} diff --git a/paper/paper.bib b/paper/paper.bib new file mode 100644 index 000000000..9f9b4a7fe --- /dev/null +++ b/paper/paper.bib @@ -0,0 +1,138 @@ +@manual{JupyterHub, +author = {{Jupyter Development Team}}, +title = {{JupyterHub}}, +year = {2018} +} + +@inproceedings{kluyver2016jupyter, + title={Jupyter Notebooks-a publishing format for reproducible computational workflows.}, + author={Kluyver, Thomas and Ragan-Kelley, Benjamin and P{\'e}rez, Fernando and Granger, Brian E and Bussonnier, Matthias and Frederic, Jonathan and Kelley, Kyle and Hamrick, Jessica B and Grout, Jason and Corlay, Sylvain and others}, + booktitle={ELPUB}, + pages={87--90}, + year={2016} +} + +@article{Cortina2007, +author = {Cortina, Thomas J.}, +doi = {10.1145/1227504.1227387}, +isbn = {1595933611}, +issn = {00978418}, +journal = {ACM SIGCSE Bulletin}, +number = {1}, +pages = {218}, +title = {{An introduction to computer science for non-majors using principles of computation}}, +volume = {39}, +year = {2007} +} + +@article{Forte2005, +author = {Forte, Andrea and Guzdial, Mark}, +journal = {IEEE Transactions on Education}, +number = {2}, +pages = {248--253}, +title = {{Motivation and non-majors in computer science: Identifying discrete audiences for introductory courses}}, +volume = {48}, +year = {2005} +} + +@article{Guzdial2005, +author = {Guzdial, Mark and Forte, Andrea}, +doi = {10.1145/1047124.1047468}, +isbn = {1581139977}, +issn = {00978418}, +journal = {ACM SIGCSE Bulletin}, +number = {1}, +pages = {361}, +title = {{Design process for a non-majors computing course}}, +volume = {37}, +year = {2005} +} + +@article{Carlisle2004, +author = {Carlisle, Martin C and Wilson, Terry A and Humphries, Jeffrey W and Hadfield, Steven M}, +journal = {Journal of Computing Sciences in Colleges}, +number = {4}, +pages = {52--60}, +title = {{RAPTOR: Introducing Programming to Non-Majors with Flowcharts}}, +volume = {19}, +year = {2004} +} + +@article{Resnick2009, +author = {Resnick, Mitchel and Maloney, John and Monroy-Hern\'{a}ndez, Andr\'{e}s and Rusk, Natalie and Eastmond, Evelyn and Brennan, Karen and Millner, Amon and Rosenbaum, Eric and Silver, Jay and Silverman, Brian and Kafai, Yasmin}, +doi = {10.1145/1592761.1592779}, +journal = {Communications of the ACM}, +number = {11}, +pages = {60-67}, +title = {{Scratch: Programming for All}}, +volume = {52}, +year = {2009} +} + +@manual{mathematica, + Author={{Wolfram Research, Inc.}}, + Title={Mathematica}, + Address={Champaign, IL}, + year = {2018} +} + +@manual{maple, + title = {Maple}, + author = {{Maplesoft, a division of Waterloo Maple Inc.}}, + Address = {Waterloo, Ontario} +} + +@manual{matlab, + Author={{The MathWorks, Inc.}}, + Title={{MATLAB}}, + Address={Natick, MA}, + year = {2018} +} + +@manual{sage, + Key = {Sage}, + Author = {W.\thinspace{}A. Stein and others}, + Organization = {The Sage Development Team}, + Title = {{S}age {M}athematics {S}oftware}, + Year = {2018}, +} + +@Article{PerezGranger2007, + Author = {P\'erez, Fernando and Granger, Brian E.}, + Title = {{IP}ython: a System for Interactive Scientific Computing}, + Journal = {Computing in Science and Engineering}, + Volume = {9}, + Number = {3}, + Pages = {21--29}, + month = may, + year = 2007, + url = "http://ipython.org", + ISSN = "1521-9615", + doi = {10.1109/MCSE.2007.53}, + publisher = {IEEE Computer Society}, +} + +@misc{Castano_Jupyter_Map_Dataset, + author = {Castaño, Ezequiel Leonardo}, + title = {Jupyter Usage in Institutions with Coordinates}, + month = may, + year = 2018, + doi = {10.5281/zenodo.1244833}, + url = {https://doi.org/10.5281/zenodo.1244833} +} + +@article{Wilson2014, +archivePrefix = {arXiv}, +arxivId = {1307.5448}, +author = {Wilson, Greg}, +doi = {10.12688/f1000research.3-62.v1}, +eprint = {1307.5448}, +issn = {2046-1402}, +journal = {F1000Research}, +pages = {62}, +pmid = {24715981}, +title = {{Software Carpentry: lessons learned}}, +url = {http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=3976103\&tool=pmcentrez\&rendertype=abstract}, +volume = {3}, +year = {2014} +} diff --git a/paper/paper.md b/paper/paper.md new file mode 100644 index 000000000..ce6e4ae88 --- /dev/null +++ b/paper/paper.md @@ -0,0 +1,74 @@ +--- +title: 'nbgrader: A Tool for Creating and Grading Assignments in the Jupyter Notebook' +tags: +- jupyter +- jupyterhub +- grading +- autograding +authors: +- name: Project Jupyter +- name: Matthias Bussonnier + orcid: + affiliation: 1 +- name: Jonathan Frederic + orcid: 0000-0003-4805-2216 + affiliation: 2 +- name: Brian Granger + orcid: + affiliation: 3 +- name: Jessica Hamrick + orcid: 0000-0002-3860-0429 + affiliation: 4 +- name: Logan Page + orcid: 0000-0002-5799-8524 + affiliation: 5 +- name: Fernando Pérez + orcid: + affiliation: 1 +- name: Benjamin Ragan-Kelley + orcid: 0000-0002-1023-7082 + affiliation: 6 +- name: Carol Willing + orcid: 0000-0002-9817-8485 + affiliation: 3 +affiliations: +- name: University of California, Berkeley + index: 1 +- name: Google Inc. + index: 2 +- name: Cal Poly, San Luis Obispo + index: 3 +- name: DeepMind + index: 4 +- name: University of Pretoria + index: 5 +- name: Simula Research Laboratory + index: 6 +date: 2 June 2018 +bibliography: paper.bib +--- + +# Summary + +nbgrader is a tool for creating and grading assignments in the Jupyter notebook [@kluyver2016jupyter]. nbgrader allows instructors to create a single, master copy of the assignment, from which the student version is generated—thus obviating the need to maintain two separate versions. nbgrader automatically grades submitted assignments by executing the notebooks and storing the results in a database. After auto-grading, instructors can provide partial credit or manually grade free-responses using the *formgrader* notebook extension. Finally, instructors can use nbgrader to leave personalized feedback for each student, including instructor comments as well as detailed error information. + +When used with JupyterHub [@JupyterHub], nbgrader provides additional workflow functionality that covers the entire grading process. After creating the assignment, instructors can release it to students, who can then fetch a copy of the assignment directly through the notebook server interface. Students can submit their completed version through the same interface, making it available for instructors to collect with one command. After that, instructors can use the auto-grading functionality as normal and may access the formgrader as a JupyterHub service. + +Since its conception in September 2014, nbgrader has been "battle-tested" in a number of classes all over the world, including at UC Berkeley, Cal Poly San Luis Obispo, University of Pretoria, University of Edinburgh, Northeastern University, Central Connecticut State University, KTH Royal Institute of Technology Stockholm, CU Boulder, University of Amsterdam, George Washington University, Texas A&M University, Bryn Mawr College, and University of Maryland; and, as of May 2018, over 10,000 nbgrader-based notebooks exist on GitHub. In addition to its core functionality, nbgrader has expanded to support a number of features, including the ability to handle multiple classes on the same JupyterHub instance; the option to either include or hide autograder tests; customizable late penalties; and support for importing assignment files downloaded from a LMS (Learning Management System). As we continue to develop nbgrader, we always keep it’s original aim in mind: to provide a flexible, straightforward system for creating and grading assignments in the Jupyter notebook. + +# Statement of Need + +The use of computational methods has become increasingly widespread in fields outside of computer science. As these disciplines require more computational tools, undergraduate curricula also begin to include topics in programming and computer science. However, because students are focused on their own discipline—and programming is likely a secondary interest—teaching students through traditional computer science offerings is not always effective [@Cortina2007; @Forte2005; @Guzdial2005]. While there are visual programming languages such as Raptor [@Carlisle2004] or Scratch [@Resnick2009] that are intended to be easy and enjoyable for non-computer science majors to learn, they lack the specialized tools that are required for effective work in domain sciences, such as numerical or data visualization libraries. A hybrid approach is to teach students computational concepts in an interactive environment where it is possible to quickly write, test, and tweak small pieces of code. Many such environments exist, including Mathematica [@mathematica], Maple [@maple], Matlab [@matlab], Sage [@sage] and IPython [@PerezGranger2007]. + +In recent years the IPython project introduced the *Jupyter notebook* [@kluyver2016jupyter], an interface that is particularly conducive to interactive and literate computing where programmers can interleave prose with code and figures. The Jupyter notebook is ideal for educators because it allows them to create assignments which include instructions along with cells, in which students can provide solutions to exercises. Students can, for example, be asked to write code both to compute and visualize a particular result. Because of the interactive nature of the notebook, students can iterate on a coding problem without having to switch back and forth between the command line and a text editor, and they can see the results of their code almost instantly. + +Instructors in many fields have already begun using the Jupyter notebook as a teaching platform. The notebook has appeared in over 70 classes [@Castano_Jupyter_Map_Dataset] on subjects including geology, mathematics, mechanical engineering, data science, chemical engineering, and bioinformatics, just to name a few. Software Carpentry, which aims to teach graduate students basic computational skills, has also adopted the notebook for some of its lessons [@Wilson2014]. + +Despite its appearance in many classrooms—prior to the existence of nbgrader—the notebook was rarely used on a large scale for *graded* assignments. Instead, it was often used either for ungraded in-class exercises; or in classes small enough that notebooks can be graded by hand. This is because there are several challenges to using the notebook for graded assignments at scale. First, for large class sizes, it is not feasible for an instructor to manually grade the code that students write: there must be a way of autograding the assignments. A Jupyter notebook is not a typical script that can be run and may contain multiple parts of a problem within the same notebook. Second, for many courses, the programming is a means to an end for understanding concepts in a specific domain. Instructors may also want students to provide written free-responses interpreting the results of their code, and thus need to be able to rely on autograding for the coding parts of an assignment, but also be able to manually grade the written responses in the surrounding context of the student's code. Third, the process of distributing assignments to students and later collecting them can be tedious, and this is true even more so with Jupyter notebooks because there is a separate interface for accessing them beyond the standard system file browser. This often leads to confusion on the part of students about how to open notebooks after downloading them, and where to find the notebooks in order to submit them. + +nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and student. Overall, nbgrader improves the learning experience as students and instructors can focus on content and building understanding by minimizing or automating the tedious and repetitive tasks. + +# References + +* nbgrader source code: [https://github.com/jupyter/nbgrader](https://github.com/jupyter/nbgrader) +* nbgrader documentation: [http://nbgrader.readthedocs.io/en/stable/](http://nbgrader.readthedocs.io/en/stable/) From 420dc91154dfecc674f9369279876b849fe9b9fd Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 2 Jun 2018 14:38:21 +0100 Subject: [PATCH 02/24] Add Fernando to codemeta.json --- codemeta.json | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/codemeta.json b/codemeta.json index 554f662b1..8321dace4 100644 --- a/codemeta.json +++ b/codemeta.json @@ -41,6 +41,13 @@ "name": "Logan Page", "affiliation": "University of Pretoria" }, + { + "@id": "", + "@type": "Person", + "email": "Fernando.Perez@berkeley.edu", + "name": "Fernando Pérez", + "affiliation": "University of California, Berkeley" + }, { "@id": "http://orcid.org/0000-0002-1023-7082", "@type": "Person", From bd1aab4444ea3afb8fd615365945b61053a8a0c8 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 2 Jun 2018 16:20:42 +0100 Subject: [PATCH 03/24] Add David Bourgin as an author --- codemeta.json | 7 +++++++ paper/paper.md | 3 +++ 2 files changed, 10 insertions(+) diff --git a/codemeta.json b/codemeta.json index 8321dace4..ebe9abd5e 100644 --- a/codemeta.json +++ b/codemeta.json @@ -6,6 +6,13 @@ "@type": "Organization", "name": "Project Jupyter" }, + { + "@id": "http://orcid.org/0000-0003-1039-6195", + "@type": "Person", + "email": "ddbourgin@berkeley.edu", + "name": "David Bourgin", + "affiliation": "University of California, Berkeley" + }, { "@id": "", "@type": "Person", diff --git a/paper/paper.md b/paper/paper.md index ce6e4ae88..8d4647082 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -7,6 +7,9 @@ tags: - autograding authors: - name: Project Jupyter +- name: David Bourgin + orcid: 0000-0003-1039-6195 + affiliation: 1 - name: Matthias Bussonnier orcid: affiliation: 1 From 9f1cf98c1d989bf0ba913c095b75cf823ce08baa Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 2 Jun 2018 16:29:29 +0100 Subject: [PATCH 04/24] Add note about authorship order to paper --- paper/paper.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/paper/paper.md b/paper/paper.md index 8d4647082..b62c2857d 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -51,6 +51,8 @@ date: 2 June 2018 bibliography: paper.bib --- +*Note: Authors on this paper are listed in alphabetical order.* + # Summary nbgrader is a tool for creating and grading assignments in the Jupyter notebook [@kluyver2016jupyter]. nbgrader allows instructors to create a single, master copy of the assignment, from which the student version is generated—thus obviating the need to maintain two separate versions. nbgrader automatically grades submitted assignments by executing the notebooks and storing the results in a database. After auto-grading, instructors can provide partial credit or manually grade free-responses using the *formgrader* notebook extension. Finally, instructors can use nbgrader to leave personalized feedback for each student, including instructor comments as well as detailed error information. From 3af242031c43e43e22bd0b5e50a84b02b24ba0d9 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 11:31:13 +0100 Subject: [PATCH 05/24] Add Doug Blank as an author --- codemeta.json | 7 +++++++ paper/paper.md | 5 +++++ 2 files changed, 12 insertions(+) diff --git a/codemeta.json b/codemeta.json index ebe9abd5e..673b54e4e 100644 --- a/codemeta.json +++ b/codemeta.json @@ -6,6 +6,13 @@ "@type": "Organization", "name": "Project Jupyter" }, + { + "@id": "http://orcid.org/0000-0003-3538-8829", + "@type": "Person", + "email": "dblank@brynmawr.edu", + "name": "Douglas Blank", + "affiliation": "Bryn Mawr College" + }, { "@id": "http://orcid.org/0000-0003-1039-6195", "@type": "Person", diff --git a/paper/paper.md b/paper/paper.md index b62c2857d..739016ce9 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -7,6 +7,9 @@ tags: - autograding authors: - name: Project Jupyter +- name: Douglas Blank + orcid: 0000-0003-3538-8829 + affiliation: 7 - name: David Bourgin orcid: 0000-0003-1039-6195 affiliation: 1 @@ -47,6 +50,8 @@ affiliations: index: 5 - name: Simula Research Laboratory index: 6 +- name: Bryn Mawr College + index: 7 date: 2 June 2018 bibliography: paper.bib --- From 2b6b6cf1114fd249ed386be79110d5e5d148e74f Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 20:45:43 +0100 Subject: [PATCH 06/24] Add Jordan Suchow as an author [ci skip] --- codemeta.json | 7 +++++++ paper/paper.md | 3 +++ 2 files changed, 10 insertions(+) diff --git a/codemeta.json b/codemeta.json index 673b54e4e..305732c65 100644 --- a/codemeta.json +++ b/codemeta.json @@ -69,6 +69,13 @@ "name": "Benjamin Ragan-Kelley", "affiliation": "Simula Research Laboratory" }, + { + "@id": "http://orcid.org/0000-0001-9848-4872", + "@type": "Person", + "email": "suchow@berkeley.edu", + "name": "Jordan W. Suchow", + "affiliation": "University of California, Berkeley" + }, { "@id": "http://orcid.org/0000-0002-9817-8485", "@type": "Person", diff --git a/paper/paper.md b/paper/paper.md index 739016ce9..472ea7a1b 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -34,6 +34,9 @@ authors: - name: Benjamin Ragan-Kelley orcid: 0000-0002-1023-7082 affiliation: 6 +- name: Jordan W. Suchow + orcid: 0000-0001-9848-4872 + affiliation: 1 - name: Carol Willing orcid: 0000-0002-9817-8485 affiliation: 3 From fe68507dd69d7c15bee9383ff41ebd200b22f845 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 20:49:00 +0100 Subject: [PATCH 07/24] Wrap lines in paper.md --- paper/paper.md | 97 +++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 89 insertions(+), 8 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 472ea7a1b..9b283c6b8 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -63,23 +63,104 @@ bibliography: paper.bib # Summary -nbgrader is a tool for creating and grading assignments in the Jupyter notebook [@kluyver2016jupyter]. nbgrader allows instructors to create a single, master copy of the assignment, from which the student version is generated—thus obviating the need to maintain two separate versions. nbgrader automatically grades submitted assignments by executing the notebooks and storing the results in a database. After auto-grading, instructors can provide partial credit or manually grade free-responses using the *formgrader* notebook extension. Finally, instructors can use nbgrader to leave personalized feedback for each student, including instructor comments as well as detailed error information. +nbgrader is a tool for creating and grading assignments in the Jupyter notebook +[@kluyver2016jupyter]. nbgrader allows instructors to create a single, master +copy of the assignment, from which the student version is generated—thus +obviating the need to maintain two separate versions. nbgrader automatically +grades submitted assignments by executing the notebooks and storing the results +in a database. After auto-grading, instructors can provide partial credit or +manually grade free-responses using the *formgrader* notebook extension. +Finally, instructors can use nbgrader to leave personalized feedback for each +student, including instructor comments as well as detailed error information. -When used with JupyterHub [@JupyterHub], nbgrader provides additional workflow functionality that covers the entire grading process. After creating the assignment, instructors can release it to students, who can then fetch a copy of the assignment directly through the notebook server interface. Students can submit their completed version through the same interface, making it available for instructors to collect with one command. After that, instructors can use the auto-grading functionality as normal and may access the formgrader as a JupyterHub service. +When used with JupyterHub [@JupyterHub], nbgrader provides additional workflow +functionality that covers the entire grading process. After creating the +assignment, instructors can release it to students, who can then fetch a copy of +the assignment directly through the notebook server interface. Students can +submit their completed version through the same interface, making it available +for instructors to collect with one command. After that, instructors can use the +auto-grading functionality as normal and may access the formgrader as a +JupyterHub service. -Since its conception in September 2014, nbgrader has been "battle-tested" in a number of classes all over the world, including at UC Berkeley, Cal Poly San Luis Obispo, University of Pretoria, University of Edinburgh, Northeastern University, Central Connecticut State University, KTH Royal Institute of Technology Stockholm, CU Boulder, University of Amsterdam, George Washington University, Texas A&M University, Bryn Mawr College, and University of Maryland; and, as of May 2018, over 10,000 nbgrader-based notebooks exist on GitHub. In addition to its core functionality, nbgrader has expanded to support a number of features, including the ability to handle multiple classes on the same JupyterHub instance; the option to either include or hide autograder tests; customizable late penalties; and support for importing assignment files downloaded from a LMS (Learning Management System). As we continue to develop nbgrader, we always keep it’s original aim in mind: to provide a flexible, straightforward system for creating and grading assignments in the Jupyter notebook. +Since its conception in September 2014, nbgrader has been "battle-tested" in a +number of classes all over the world, including at UC Berkeley, Cal Poly San +Luis Obispo, University of Pretoria, University of Edinburgh, Northeastern +University, Central Connecticut State University, KTH Royal Institute of +Technology Stockholm, CU Boulder, University of Amsterdam, George Washington +University, Texas A&M University, Bryn Mawr College, and University of Maryland; +and, as of May 2018, over 10,000 nbgrader-based notebooks exist on GitHub. In +addition to its core functionality, nbgrader has expanded to support a number of +features, including the ability to handle multiple classes on the same +JupyterHub instance; the option to either include or hide autograder tests; +customizable late penalties; and support for importing assignment files +downloaded from a LMS (Learning Management System). As we continue to develop +nbgrader, we always keep it’s original aim in mind: to provide a flexible, +straightforward system for creating and grading assignments in the Jupyter +notebook. # Statement of Need -The use of computational methods has become increasingly widespread in fields outside of computer science. As these disciplines require more computational tools, undergraduate curricula also begin to include topics in programming and computer science. However, because students are focused on their own discipline—and programming is likely a secondary interest—teaching students through traditional computer science offerings is not always effective [@Cortina2007; @Forte2005; @Guzdial2005]. While there are visual programming languages such as Raptor [@Carlisle2004] or Scratch [@Resnick2009] that are intended to be easy and enjoyable for non-computer science majors to learn, they lack the specialized tools that are required for effective work in domain sciences, such as numerical or data visualization libraries. A hybrid approach is to teach students computational concepts in an interactive environment where it is possible to quickly write, test, and tweak small pieces of code. Many such environments exist, including Mathematica [@mathematica], Maple [@maple], Matlab [@matlab], Sage [@sage] and IPython [@PerezGranger2007]. +The use of computational methods has become increasingly widespread in fields +outside of computer science. As these disciplines require more computational +tools, undergraduate curricula also begin to include topics in programming and +computer science. However, because students are focused on their own +discipline—and programming is likely a secondary interest—teaching students +through traditional computer science offerings is not always effective +[@Cortina2007; @Forte2005; @Guzdial2005]. While there are visual programming +languages such as Raptor [@Carlisle2004] or Scratch [@Resnick2009] that are +intended to be easy and enjoyable for non-computer science majors to learn, they +lack the specialized tools that are required for effective work in domain +sciences, such as numerical or data visualization libraries. A hybrid approach +is to teach students computational concepts in an interactive environment where +it is possible to quickly write, test, and tweak small pieces of code. Many such +environments exist, including Mathematica [@mathematica], Maple [@maple], Matlab +[@matlab], Sage [@sage] and IPython [@PerezGranger2007]. -In recent years the IPython project introduced the *Jupyter notebook* [@kluyver2016jupyter], an interface that is particularly conducive to interactive and literate computing where programmers can interleave prose with code and figures. The Jupyter notebook is ideal for educators because it allows them to create assignments which include instructions along with cells, in which students can provide solutions to exercises. Students can, for example, be asked to write code both to compute and visualize a particular result. Because of the interactive nature of the notebook, students can iterate on a coding problem without having to switch back and forth between the command line and a text editor, and they can see the results of their code almost instantly. +In recent years the IPython project introduced the *Jupyter notebook* +[@kluyver2016jupyter], an interface that is particularly conducive to +interactive and literate computing where programmers can interleave prose with +code and figures. The Jupyter notebook is ideal for educators because it allows +them to create assignments which include instructions along with cells, in which +students can provide solutions to exercises. Students can, for example, be asked +to write code both to compute and visualize a particular result. Because of the +interactive nature of the notebook, students can iterate on a coding problem +without having to switch back and forth between the command line and a text +editor, and they can see the results of their code almost instantly. -Instructors in many fields have already begun using the Jupyter notebook as a teaching platform. The notebook has appeared in over 70 classes [@Castano_Jupyter_Map_Dataset] on subjects including geology, mathematics, mechanical engineering, data science, chemical engineering, and bioinformatics, just to name a few. Software Carpentry, which aims to teach graduate students basic computational skills, has also adopted the notebook for some of its lessons [@Wilson2014]. +Instructors in many fields have already begun using the Jupyter notebook as a +teaching platform. The notebook has appeared in over 70 classes +[@Castano_Jupyter_Map_Dataset] on subjects including geology, mathematics, +mechanical engineering, data science, chemical engineering, and bioinformatics, +just to name a few. Software Carpentry, which aims to teach graduate students +basic computational skills, has also adopted the notebook for some of its +lessons [@Wilson2014]. -Despite its appearance in many classrooms—prior to the existence of nbgrader—the notebook was rarely used on a large scale for *graded* assignments. Instead, it was often used either for ungraded in-class exercises; or in classes small enough that notebooks can be graded by hand. This is because there are several challenges to using the notebook for graded assignments at scale. First, for large class sizes, it is not feasible for an instructor to manually grade the code that students write: there must be a way of autograding the assignments. A Jupyter notebook is not a typical script that can be run and may contain multiple parts of a problem within the same notebook. Second, for many courses, the programming is a means to an end for understanding concepts in a specific domain. Instructors may also want students to provide written free-responses interpreting the results of their code, and thus need to be able to rely on autograding for the coding parts of an assignment, but also be able to manually grade the written responses in the surrounding context of the student's code. Third, the process of distributing assignments to students and later collecting them can be tedious, and this is true even more so with Jupyter notebooks because there is a separate interface for accessing them beyond the standard system file browser. This often leads to confusion on the part of students about how to open notebooks after downloading them, and where to find the notebooks in order to submit them. +Despite its appearance in many classrooms—prior to the existence of nbgrader—the +notebook was rarely used on a large scale for *graded* assignments. Instead, it +was often used either for ungraded in-class exercises; or in classes small +enough that notebooks can be graded by hand. This is because there are several +challenges to using the notebook for graded assignments at scale. First, for +large class sizes, it is not feasible for an instructor to manually grade the +code that students write: there must be a way of autograding the assignments. A +Jupyter notebook is not a typical script that can be run and may contain +multiple parts of a problem within the same notebook. Second, for many courses, +the programming is a means to an end for understanding concepts in a specific +domain. Instructors may also want students to provide written free-responses +interpreting the results of their code, and thus need to be able to rely on +autograding for the coding parts of an assignment, but also be able to manually +grade the written responses in the surrounding context of the student's code. +Third, the process of distributing assignments to students and later collecting +them can be tedious, and this is true even more so with Jupyter notebooks +because there is a separate interface for accessing them beyond the standard +system file browser. This often leads to confusion on the part of students about +how to open notebooks after downloading them, and where to find the notebooks in +order to submit them. -nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and student. Overall, nbgrader improves the learning experience as students and instructors can focus on content and building understanding by minimizing or automating the tedious and repetitive tasks. +nbgrader streamlines the repetitive tasks found in course management and +grading, and its flexibility allows greater communication between instructor and +student. Overall, nbgrader improves the learning experience as students and +instructors can focus on content and building understanding by minimizing or +automating the tedious and repetitive tasks. # References From f502d82684c1d0cb9f414fde08ed40064883822a Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 21:17:16 +0100 Subject: [PATCH 08/24] Address comments from @suchow and @ddbourgin [ci skip] --- paper/paper.md | 158 ++++++++++++++++++++++++------------------------- 1 file changed, 79 insertions(+), 79 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 9b283c6b8..47e2b167b 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -63,104 +63,104 @@ bibliography: paper.bib # Summary -nbgrader is a tool for creating and grading assignments in the Jupyter notebook -[@kluyver2016jupyter]. nbgrader allows instructors to create a single, master -copy of the assignment, from which the student version is generated—thus -obviating the need to maintain two separate versions. nbgrader automatically -grades submitted assignments by executing the notebooks and storing the results -in a database. After auto-grading, instructors can provide partial credit or -manually grade free-responses using the *formgrader* notebook extension. -Finally, instructors can use nbgrader to leave personalized feedback for each -student, including instructor comments as well as detailed error information. +nbgrader is a flexible tool for creating and grading assignments in the Jupyter +notebook [@kluyver2016jupyter]. nbgrader allows instructors to create a single, +master copy of an assignment, including tests and canonical solutions. From the +master copy, a student version is generated without the solutions, thus +obviating the need to maintain two separate versions. nbgrader also +automatically grades submitted assignments by executing the notebooks and +storing the results of the tests in a database. After auto-grading, instructors +can manually grade free responses and provide partial credit using the +*formgrader* notebook extension. Finally, instructors can use nbgrader to leave +personalized feedback for each student's submission, including comments as well +as detailed error information. When used with JupyterHub [@JupyterHub], nbgrader provides additional workflow -functionality that covers the entire grading process. After creating the +functionality, covering the entire grading process. After creating an assignment, instructors can release it to students, who can then fetch a copy of the assignment directly through the notebook server interface. Students can -submit their completed version through the same interface, making it available -for instructors to collect with one command. After that, instructors can use the -auto-grading functionality as normal and may access the formgrader as a -JupyterHub service. +submit their completed assignment through the same interface, making it +available for instructors. Afterwards, instructors can collect the assignments +with a single command and use the auto-grading functionality in the normal way. -Since its conception in September 2014, nbgrader has been "battle-tested" in a -number of classes all over the world, including at UC Berkeley, Cal Poly San -Luis Obispo, University of Pretoria, University of Edinburgh, Northeastern -University, Central Connecticut State University, KTH Royal Institute of -Technology Stockholm, CU Boulder, University of Amsterdam, George Washington -University, Texas A&M University, Bryn Mawr College, and University of Maryland; -and, as of May 2018, over 10,000 nbgrader-based notebooks exist on GitHub. In -addition to its core functionality, nbgrader has expanded to support a number of -features, including the ability to handle multiple classes on the same -JupyterHub instance; the option to either include or hide autograder tests; -customizable late penalties; and support for importing assignment files -downloaded from a LMS (Learning Management System). As we continue to develop -nbgrader, we always keep it’s original aim in mind: to provide a flexible, -straightforward system for creating and grading assignments in the Jupyter -notebook. +Since its conception in September 2014, nbgrader has been battle-tested in a +number of classes all over the world, including at the UC Berkeley, Cal Poly, +University of Pretoria, University of Edinburgh, Northeastern University, +Central Connecticut State University, KTH Royal Institute of Technology, CU +Boulder, University of Amsterdam, George Washington University, Texas A&M, Bryn +Mawr, and University of Maryland; and, as of May 2018, over 10,000 +nbgrader-based notebooks exist on GitHub. In addition to its core functionality, +nbgrader has expanded to support a number of other features, including the +ability to handle multiple courses on the same JupyterHub instance; the option +to either include or hide autograder tests; customizable late penalties; and +support for importing assignment files downloaded from a Learning +Management System (LMS). # Statement of Need The use of computational methods has become increasingly widespread in fields -outside of computer science. As these disciplines require more computational +outside of computer science. As these disciplines begin to require computational tools, undergraduate curricula also begin to include topics in programming and -computer science. However, because students are focused on their own -discipline—and programming is likely a secondary interest—teaching students -through traditional computer science offerings is not always effective -[@Cortina2007; @Forte2005; @Guzdial2005]. While there are visual programming -languages such as Raptor [@Carlisle2004] or Scratch [@Resnick2009] that are -intended to be easy and enjoyable for non-computer science majors to learn, they -lack the specialized tools that are required for effective work in domain -sciences, such as numerical or data visualization libraries. A hybrid approach -is to teach students computational concepts in an interactive environment where -it is possible to quickly write, test, and tweak small pieces of code. Many such -environments exist, including Mathematica [@mathematica], Maple [@maple], Matlab -[@matlab], Sage [@sage] and IPython [@PerezGranger2007]. +computer science. However, because students are focused on the discipline that +is the object of their study—and programming is likely a secondary +interest—teaching students through traditional computer science offerings is not +always effective [@Cortina2007; @Forte2005; @Guzdial2005]. While there are +visual programming languages such as Raptor [@Carlisle2004] and Scratch +[@Resnick2009] that are intended to be easy and enjoyable for non-computer +science majors to learn, they lack specialized tools such as numerical or data +visualization libraries, which are required for effective work in domain +sciences. A hybrid approach is to teach students computational concepts in an +interactive environment where it is possible to quickly write, test, and tweak +small units of code. Many such environments exist, including Mathematica +[@mathematica], Maple [@maple], MATLAB [@matlab], Sage [@sage] and IPython +[@PerezGranger2007]. -In recent years the IPython project introduced the *Jupyter notebook* -[@kluyver2016jupyter], an interface that is particularly conducive to -interactive and literate computing where programmers can interleave prose with -code and figures. The Jupyter notebook is ideal for educators because it allows -them to create assignments which include instructions along with cells, in which -students can provide solutions to exercises. Students can, for example, be asked -to write code both to compute and visualize a particular result. Because of the -interactive nature of the notebook, students can iterate on a coding problem -without having to switch back and forth between the command line and a text -editor, and they can see the results of their code almost instantly. +In recent years, the IPython project introduced the *Jupyter notebook* +[@kluyver2016jupyter], an interface that is conducive to interactive and +literate computing, where programmers can interleave prose with code and +figures. The Jupyter notebook is ideal for educators because it allows them to +create assignments which include instructions along with code or Markdown cells, +in which students can provide solutions to exercises. Students can, for example, +write code both to compute and visualize a particular result. Because the +notebook is interactive, students can iterate on a coding problem without +needing to switch back and forth between a command line and a text editor, and +they can rapidly see results alongside the code which produced them. -Instructors in many fields have already begun using the Jupyter notebook as a -teaching platform. The notebook has appeared in over 70 classes +Instructors in many fields have begun using the Jupyter notebook as a teaching +platform. The notebook has appeared in over 70 classes [@Castano_Jupyter_Map_Dataset] on subjects including geology, mathematics, -mechanical engineering, data science, chemical engineering, and bioinformatics, -just to name a few. Software Carpentry, which aims to teach graduate students -basic computational skills, has also adopted the notebook for some of its -lessons [@Wilson2014]. +mechanical engineering, data science, chemical engineering, and bioinformatics. +Software Carpentry, an organization that aims to teach graduate students basic +computational skills, has also adopted the notebook for some of its lessons +[@Wilson2014]. -Despite its appearance in many classrooms—prior to the existence of nbgrader—the -notebook was rarely used on a large scale for *graded* assignments. Instead, it -was often used either for ungraded in-class exercises; or in classes small -enough that notebooks can be graded by hand. This is because there are several +Despite its appearance in many classrooms, before to the existence of nbgrader, +the notebook was rarely used on a large scale for *graded* assignments. Instead, +it was often used either for ungraded in-class exercises, or in classes small +enough that notebooks could be graded by hand. This is because there are several challenges to using the notebook for graded assignments at scale. First, for -large class sizes, it is not feasible for an instructor to manually grade the -code that students write: there must be a way of autograding the assignments. A -Jupyter notebook is not a typical script that can be run and may contain -multiple parts of a problem within the same notebook. Second, for many courses, -the programming is a means to an end for understanding concepts in a specific -domain. Instructors may also want students to provide written free-responses -interpreting the results of their code, and thus need to be able to rely on -autograding for the coding parts of an assignment, but also be able to manually -grade the written responses in the surrounding context of the student's code. -Third, the process of distributing assignments to students and later collecting -them can be tedious, and this is true even more so with Jupyter notebooks -because there is a separate interface for accessing them beyond the standard -system file browser. This often leads to confusion on the part of students about -how to open notebooks after downloading them, and where to find the notebooks in -order to submit them. +large classes, it is not feasible for an instructor to manually grade the code +that students write: there must be a way to autograde the assignments. However, +a Jupyter notebook is not a typical script that can be run and may contain +multiple parts of a problem within the same notebook; thus, autograding a +notebook is less straightforward than it is for a traditional script. Second, +for many courses, programming is a means to an end: understanding concepts in a +specific domain. Specifically, instructors may want students to provide both +code and written free-responses interpreting the results of that code. +Instructors thus need to be able to rely on autograding for the coding parts of +an assignment, but also be able to manually grade the written responses in the +surrounding context of the student's code. Third, the process of distributing +assignments to students and later collecting them can be tedious, even more so +with Jupyter notebooks because there is a separate interface for accessing them +beyond the standard system file browser. This often leads to confusion on the +part of students about how to open notebooks after downloading them, and where +to find the notebooks in order to submit them. nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and -student. Overall, nbgrader improves the learning experience as students and +student. Overall, nbgrader improves the learning experience because students and instructors can focus on content and building understanding by minimizing or -automating the tedious and repetitive tasks. +automating the tedious and repetitive tasks associated with grading. # References From ea6e86216e5001cdfba6dc91156d6ddab90f4189 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 21:23:54 +0100 Subject: [PATCH 09/24] Address a few more comments [ci skip] --- paper/paper.bib | 11 +++++++++++ paper/paper.md | 43 ++++++++++++++++++++++--------------------- 2 files changed, 33 insertions(+), 21 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index 9f9b4a7fe..71e126c99 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -136,3 +136,14 @@ @article{Wilson2014 volume = {3}, year = {2014} } + +@article{wing2008computational, + title={Computational thinking and thinking about computing}, + author={Wing, Jeannette M}, + journal={Philosophical transactions of the royal society of London A: mathematical, physical and engineering sciences}, + volume={366}, + number={1881}, + pages={3717--3725}, + year={2008}, + publisher={The Royal Society} +} diff --git a/paper/paper.md b/paper/paper.md index 47e2b167b..1c0058067 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -84,7 +84,7 @@ available for instructors. Afterwards, instructors can collect the assignments with a single command and use the auto-grading functionality in the normal way. Since its conception in September 2014, nbgrader has been battle-tested in a -number of classes all over the world, including at the UC Berkeley, Cal Poly, +number of educational contexts, including courses at UC Berkeley, Cal Poly, University of Pretoria, University of Edinburgh, Northeastern University, Central Connecticut State University, KTH Royal Institute of Technology, CU Boulder, University of Amsterdam, George Washington University, Texas A&M, Bryn @@ -93,27 +93,27 @@ nbgrader-based notebooks exist on GitHub. In addition to its core functionality, nbgrader has expanded to support a number of other features, including the ability to handle multiple courses on the same JupyterHub instance; the option to either include or hide autograder tests; customizable late penalties; and -support for importing assignment files downloaded from a Learning -Management System (LMS). +support for importing assignment files downloaded from a Learning Management +System (LMS). # Statement of Need The use of computational methods has become increasingly widespread in fields -outside of computer science. As these disciplines begin to require computational -tools, undergraduate curricula also begin to include topics in programming and -computer science. However, because students are focused on the discipline that -is the object of their study—and programming is likely a secondary -interest—teaching students through traditional computer science offerings is not -always effective [@Cortina2007; @Forte2005; @Guzdial2005]. While there are -visual programming languages such as Raptor [@Carlisle2004] and Scratch -[@Resnick2009] that are intended to be easy and enjoyable for non-computer -science majors to learn, they lack specialized tools such as numerical or data -visualization libraries, which are required for effective work in domain -sciences. A hybrid approach is to teach students computational concepts in an -interactive environment where it is possible to quickly write, test, and tweak -small units of code. Many such environments exist, including Mathematica -[@mathematica], Maple [@maple], MATLAB [@matlab], Sage [@sage] and IPython -[@PerezGranger2007]. +outside of computer science [@wing2008computational]. As these disciplines begin +to require computational tools, undergraduate curricula also begin to include +topics in programming and computer science. However, because students are +focused on the discipline that is the object of their study—and programming is +likely a secondary interest—teaching students through traditional computer +science offerings is not always effective [@Cortina2007; @Forte2005; +@Guzdial2005]. While there are visual programming languages such as Raptor +[@Carlisle2004] and Scratch [@Resnick2009] that are intended to be easy and +enjoyable for those unfamiliar with programming to learn, they lack specialized +tools such as numerical or data visualization libraries, which are required for +effective work in domain sciences. A hybrid approach is to teach students +computational concepts in an interactive environment where it is possible to +quickly write, test, and tweak small units of code. Many such environments +exist, including Mathematica [@mathematica], Maple [@maple], MATLAB [@matlab], +Sage [@sage] and IPython [@PerezGranger2007]. In recent years, the IPython project introduced the *Jupyter notebook* [@kluyver2016jupyter], an interface that is conducive to interactive and @@ -158,9 +158,10 @@ to find the notebooks in order to submit them. nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and -student. Overall, nbgrader improves the learning experience because students and -instructors can focus on content and building understanding by minimizing or -automating the tedious and repetitive tasks associated with grading. +student. Overall, nbgrader improves the learning experience for both instructors +and students, enabling them to focus on content and building understanding by +minimizing or automating the tedious and repetitive tasks associated with +grading. # References From d9a66135ea1b913658bda63b991e900e813d4041 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 21:39:01 +0100 Subject: [PATCH 10/24] Reword final sentence [ci skip] --- paper/paper.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 1c0058067..31a837d0a 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -159,9 +159,7 @@ to find the notebooks in order to submit them. nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and student. Overall, nbgrader improves the learning experience for both instructors -and students, enabling them to focus on content and building understanding by -minimizing or automating the tedious and repetitive tasks associated with -grading. +and students, enabling them to focus on content and building understanding. # References From d11b7bbdde33cdf00011babb45e1a5d2278615a3 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 22:55:32 +0100 Subject: [PATCH 11/24] Address comments from @dsblank [ci skip] --- paper/paper.bib | 18 ++++++++ paper/paper.md | 114 +++++++++++++++++++++++++----------------------- 2 files changed, 77 insertions(+), 55 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index 71e126c99..482e9922c 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -112,6 +112,24 @@ @Article{PerezGranger2007 publisher = {IEEE Computer Society}, } +@misc{Hamrick2016, + author = {Hamrick, Jessica B. and Jupyter Development Team}, + title = {2016 Jupyter Education Survey}, + month = may, + year = 2016, + doi = {10.5281/zenodo.51701}, + url = {https://github.com/jupyter/datasets/tree/master/surveys/2016-05-education-survey} +} + +@misc{Castano_Jupyter_Map, + author = {Castaño, Ezequiel Leonardo}, + title = {Jupyter Map}, + month = may, + year = 2018, + doi = {10.5281/zenodo.1245087}, + url = {https://elc.github.io/jupyter-map/} +} + @misc{Castano_Jupyter_Map_Dataset, author = {Castaño, Ezequiel Leonardo}, title = {Jupyter Usage in Institutions with Coordinates}, diff --git a/paper/paper.md b/paper/paper.md index 31a837d0a..f99af578e 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -75,20 +75,23 @@ can manually grade free responses and provide partial credit using the personalized feedback for each student's submission, including comments as well as detailed error information. -When used with JupyterHub [@JupyterHub], nbgrader provides additional workflow +nbgrader can also be used with JupyterHub [@JupyterHub], which is a centralized, +server-based installation that manages user logins and management of Jupyter +notebooks. When used with JupyterHub, nbgrader provides additional workflow functionality, covering the entire grading process. After creating an -assignment, instructors can release it to students, who can then fetch a copy of -the assignment directly through the notebook server interface. Students can +assignment, instructors can distribute it to students, who can then fetch a copy +of the assignment directly through the notebook server interface. Students can submit their completed assignment through the same interface, making it -available for instructors. Afterwards, instructors can collect the assignments -with a single command and use the auto-grading functionality in the normal way. +available for instructors. After students submit their assignments, instructors +can collect the assignments with a single command and use the auto-grading +functionality in the normal way. -Since its conception in September 2014, nbgrader has been battle-tested in a +Since its conception in September 2014, nbgrader has been used in a number of educational contexts, including courses at UC Berkeley, Cal Poly, University of Pretoria, University of Edinburgh, Northeastern University, Central Connecticut State University, KTH Royal Institute of Technology, CU Boulder, University of Amsterdam, George Washington University, Texas A&M, Bryn -Mawr, and University of Maryland; and, as of May 2018, over 10,000 +Mawr College, and University of Maryland; and, as of May 2018, over 10,000 nbgrader-based notebooks exist on GitHub. In addition to its core functionality, nbgrader has expanded to support a number of other features, including the ability to handle multiple courses on the same JupyterHub instance; the option @@ -101,65 +104,66 @@ System (LMS). The use of computational methods has become increasingly widespread in fields outside of computer science [@wing2008computational]. As these disciplines begin to require computational tools, undergraduate curricula also begin to include -topics in programming and computer science. However, because students are -focused on the discipline that is the object of their study—and programming is -likely a secondary interest—teaching students through traditional computer -science offerings is not always effective [@Cortina2007; @Forte2005; -@Guzdial2005]. While there are visual programming languages such as Raptor -[@Carlisle2004] and Scratch [@Resnick2009] that are intended to be easy and -enjoyable for those unfamiliar with programming to learn, they lack specialized -tools such as numerical or data visualization libraries, which are required for -effective work in domain sciences. A hybrid approach is to teach students -computational concepts in an interactive environment where it is possible to -quickly write, test, and tweak small units of code. Many such environments -exist, including Mathematica [@mathematica], Maple [@maple], MATLAB [@matlab], -Sage [@sage] and IPython [@PerezGranger2007]. +topics in programming and computer science. However, perhaps because students +are focused on the discipline that is the object of their study—and programming +is likely a secondary interest—it has been shown that teaching computer science +can be more effective when courses include interdisciplinary motivations +[@Cortina2007; @Forte2005; @Guzdial2005]. One approach for teaching programming +in a way that facilitates exploration with interdisciplinary questions is to +teach students computational concepts in an interactive environment where it is +possible to quickly write, test, and tweak small units of code. Many such +environments exist, including Mathematica [@mathematica], Maple [@maple], MATLAB +[@matlab], Sage [@sage] and IPython [@PerezGranger2007]. In recent years, the IPython project introduced the *Jupyter notebook* [@kluyver2016jupyter], an interface that is conducive to interactive and -literate computing, where programmers can interleave prose with code and -figures. The Jupyter notebook is ideal for educators because it allows them to -create assignments which include instructions along with code or Markdown cells, -in which students can provide solutions to exercises. Students can, for example, -write code both to compute and visualize a particular result. Because the -notebook is interactive, students can iterate on a coding problem without -needing to switch back and forth between a command line and a text editor, and -they can rapidly see results alongside the code which produced them. +literate computing, where programmers can interleave prose with code, figures, +and other media. The Jupyter notebook is ideal for educators because +it allows them to create assignments which include instructions along with code +or Markdown cells, in which students can provide solutions to exercises. +Students can, for example, write code both to compute and visualize a particular +result. Because the notebook is interactive, students can iterate on a coding +problem without needing to switch back and forth between a command line and a +text editor, and they can rapidly see results alongside the code which produced +them. Instructors in many fields have begun using the Jupyter notebook as a teaching -platform. The notebook has appeared in over 70 classes -[@Castano_Jupyter_Map_Dataset] on subjects including geology, mathematics, -mechanical engineering, data science, chemical engineering, and bioinformatics. -Software Carpentry, an organization that aims to teach graduate students basic -computational skills, has also adopted the notebook for some of its lessons -[@Wilson2014]. +platform. The notebook has appeared in over 100 classes [@Hamrick2016; +@Castano_Jupyter_Map; @Castano_Jupyter_Map_Dataset] on subjects including +geology, mathematics, mechanical engineering, data science, chemical +engineering, and bioinformatics. Software Carpentry, an organization that aims +to teach graduate students basic computational skills, has also adopted the +notebook for some of its lessons [@Wilson2014]. -Despite its appearance in many classrooms, before to the existence of nbgrader, +Despite its appearance in many classrooms, yet before the existence of nbgrader, the notebook was rarely used on a large scale for *graded* assignments. Instead, it was often used either for ungraded in-class exercises, or in classes small -enough that notebooks could be graded by hand. This is because there are several -challenges to using the notebook for graded assignments at scale. First, for -large classes, it is not feasible for an instructor to manually grade the code -that students write: there must be a way to autograde the assignments. However, -a Jupyter notebook is not a typical script that can be run and may contain -multiple parts of a problem within the same notebook; thus, autograding a -notebook is less straightforward than it is for a traditional script. Second, -for many courses, programming is a means to an end: understanding concepts in a -specific domain. Specifically, instructors may want students to provide both -code and written free-responses interpreting the results of that code. -Instructors thus need to be able to rely on autograding for the coding parts of -an assignment, but also be able to manually grade the written responses in the -surrounding context of the student's code. Third, the process of distributing -assignments to students and later collecting them can be tedious, even more so -with Jupyter notebooks because there is a separate interface for accessing them -beyond the standard system file browser. This often leads to confusion on the -part of students about how to open notebooks after downloading them, and where -to find the notebooks in order to submit them. +enough that notebooks could be graded by hand (sometimes even by printing them +out on paper and grading them like a traditional assignment). This is because +there are several challenges to using the notebook for graded assignments at +scale. First, for large classes, it is not feasible for an instructor to +manually grade the code that students write: there must be a way to autograde +the assignments. However, a Jupyter notebook is not a typical script that can be +run and may contain multiple parts of a problem within the same notebook; thus, +autograding a notebook is less straightforward than it is for a traditional +script. Second, for many courses, programming is a means to an end: +understanding concepts in a specific domain. Specifically, instructors may want +students to provide both code and written free-responses interpreting the +results of that code. Instructors thus need to be able to rely on autograding +for the coding parts of an assignment, but also be able to manually grade the +written responses in the surrounding context of the student's code. Third, the +process of distributing assignments to students and later collecting them can be +tedious, even more so with Jupyter notebooks because there is a separate +interface for accessing them beyond the standard system file browser. This often +leads to confusion on the part of students about how to open notebooks after +downloading them, and where to find the notebooks in order to submit them. nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and -student. Overall, nbgrader improves the learning experience for both instructors -and students, enabling them to focus on content and building understanding. +student. Overall, does—and with further development will continue to—improve the +learning experience for both instructors and students, enabling them to focus on +content and building understanding. + # References From 3af0c277fee774e847ab0ce9e59a3b440fbf225f Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sun, 3 Jun 2018 23:04:59 +0100 Subject: [PATCH 12/24] Remove unused references; fix typo [ci skip] --- paper/paper.bib | 21 --------------------- paper/paper.md | 6 +++--- 2 files changed, 3 insertions(+), 24 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index 482e9922c..73b70f08e 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -48,27 +48,6 @@ @article{Guzdial2005 year = {2005} } -@article{Carlisle2004, -author = {Carlisle, Martin C and Wilson, Terry A and Humphries, Jeffrey W and Hadfield, Steven M}, -journal = {Journal of Computing Sciences in Colleges}, -number = {4}, -pages = {52--60}, -title = {{RAPTOR: Introducing Programming to Non-Majors with Flowcharts}}, -volume = {19}, -year = {2004} -} - -@article{Resnick2009, -author = {Resnick, Mitchel and Maloney, John and Monroy-Hern\'{a}ndez, Andr\'{e}s and Rusk, Natalie and Eastmond, Evelyn and Brennan, Karen and Millner, Amon and Rosenbaum, Eric and Silver, Jay and Silverman, Brian and Kafai, Yasmin}, -doi = {10.1145/1592761.1592779}, -journal = {Communications of the ACM}, -number = {11}, -pages = {60-67}, -title = {{Scratch: Programming for All}}, -volume = {52}, -year = {2009} -} - @manual{mathematica, Author={{Wolfram Research, Inc.}}, Title={Mathematica}, diff --git a/paper/paper.md b/paper/paper.md index f99af578e..032bc9a47 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -160,9 +160,9 @@ downloading them, and where to find the notebooks in order to submit them. nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and -student. Overall, does—and with further development will continue to—improve the -learning experience for both instructors and students, enabling them to focus on -content and building understanding. +student. Overall, nbgrader does—and with further development will continue +to—improve the learning experience for both instructors and students, enabling +them to focus on content and building understanding. # References From 29dbf34c6c40a3a19b3c64580d51b6a0944b1449 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 9 Jun 2018 12:54:10 +0100 Subject: [PATCH 13/24] Add Alexander Brown as an author --- codemeta.json | 7 +++++++ paper/paper.md | 5 +++++ 2 files changed, 12 insertions(+) diff --git a/codemeta.json b/codemeta.json index 305732c65..f29179fca 100644 --- a/codemeta.json +++ b/codemeta.json @@ -20,6 +20,13 @@ "name": "David Bourgin", "affiliation": "University of California, Berkeley" }, + { + "@id": "https://orcid.org/0000-0002-3945-7337", + "@type": "Person", + "email": "brownaa@lafayette.edu", + "name": "Alexander Brown", + "affiliation": "Lafayette College" + }, { "@id": "", "@type": "Person", diff --git a/paper/paper.md b/paper/paper.md index 032bc9a47..899640b7d 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -13,6 +13,9 @@ authors: - name: David Bourgin orcid: 0000-0003-1039-6195 affiliation: 1 +- name: Alexander Brown + orcid: 0000-0002-3945-7337 + affiliation: 8 - name: Matthias Bussonnier orcid: affiliation: 1 @@ -55,6 +58,8 @@ affiliations: index: 6 - name: Bryn Mawr College index: 7 +- name: Lafayette College + index: 8 date: 2 June 2018 bibliography: paper.bib --- From 764759aa881235ace0a8541c25208edf2652cd55 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 9 Jun 2018 12:58:55 +0100 Subject: [PATCH 14/24] Add orcid for Brian --- codemeta.json | 2 +- paper/paper.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/codemeta.json b/codemeta.json index f29179fca..02b7aae9e 100644 --- a/codemeta.json +++ b/codemeta.json @@ -42,7 +42,7 @@ "affiliation": "Google Inc." }, { - "@id": "", + "@id": "http://orcid.org/0000-0002-5223-6168", "@type": "Person", "email": "bgranger@calpoly.edu", "name": "Brian E. Granger", diff --git a/paper/paper.md b/paper/paper.md index 899640b7d..fcb87286a 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -23,7 +23,7 @@ authors: orcid: 0000-0003-4805-2216 affiliation: 2 - name: Brian Granger - orcid: + orcid: 0000-0002-5223-6168 affiliation: 3 - name: Jessica Hamrick orcid: 0000-0002-3860-0429 From 4ec68e13a0937a574bab2eba2c95b5359e821418 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 9 Jun 2018 13:01:14 +0100 Subject: [PATCH 15/24] Address comments from @ellisonbg [ci skip] --- paper/paper.md | 75 +++++++++++++++++++++++++------------------------- 1 file changed, 37 insertions(+), 38 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index fcb87286a..fa9869a6f 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -91,18 +91,17 @@ available for instructors. After students submit their assignments, instructors can collect the assignments with a single command and use the auto-grading functionality in the normal way. -Since its conception in September 2014, nbgrader has been used in a -number of educational contexts, including courses at UC Berkeley, Cal Poly, -University of Pretoria, University of Edinburgh, Northeastern University, -Central Connecticut State University, KTH Royal Institute of Technology, CU -Boulder, University of Amsterdam, George Washington University, Texas A&M, Bryn -Mawr College, and University of Maryland; and, as of May 2018, over 10,000 -nbgrader-based notebooks exist on GitHub. In addition to its core functionality, -nbgrader has expanded to support a number of other features, including the -ability to handle multiple courses on the same JupyterHub instance; the option -to either include or hide autograder tests; customizable late penalties; and -support for importing assignment files downloaded from a Learning Management -System (LMS). +Since its conception in September 2014, nbgrader has been used in a number of +educational contexts, including courses at UC Berkeley, Cal Poly, University of +Pretoria, University of Edinburgh, Northeastern University, Central Connecticut +State University, KTH Royal Institute of Technology, CU Boulder, University of +Amsterdam, George Washington University, Texas A&M, Bryn Mawr College, and +University of Maryland; and, as of May 2018, over 10,000 nbgrader-based +notebooks exist on GitHub. In addition to its core functionality, nbgrader has +expanded to support a number of other features, including the ability to handle +multiple courses on the same JupyterHub instance; the option to either include +or hide automatically graded tests; customizable late penalties; and support for +importing assignment files downloaded from a Learning Management System (LMS). # Statement of Need @@ -120,19 +119,18 @@ possible to quickly write, test, and tweak small units of code. Many such environments exist, including Mathematica [@mathematica], Maple [@maple], MATLAB [@matlab], Sage [@sage] and IPython [@PerezGranger2007]. -In recent years, the IPython project introduced the *Jupyter notebook* +In recent years, the IPython project introduced the *Jupyter Notebook* [@kluyver2016jupyter], an interface that is conducive to interactive and -literate computing, where programmers can interleave prose with code, figures, -and other media. The Jupyter notebook is ideal for educators because -it allows them to create assignments which include instructions along with code -or Markdown cells, in which students can provide solutions to exercises. -Students can, for example, write code both to compute and visualize a particular -result. Because the notebook is interactive, students can iterate on a coding -problem without needing to switch back and forth between a command line and a -text editor, and they can rapidly see results alongside the code which produced -them. +literate computing, where programmers can interleave prose with code, equations, +figures, and other media. The Jupyter Notebook is ideal for educators because it +allows them to create assignments which include instructions along with code or +Markdown cells, in which students can provide solutions to exercises. Students +can, for example, write code both to compute and visualize a particular result. +Because the notebook is interactive, students can iterate on a coding problem +without needing to switch back and forth between a command line and a text +editor, and they can rapidly see results alongside the code which produced them. -Instructors in many fields have begun using the Jupyter notebook as a teaching +Instructors in many fields have begun using the Jupyter Notebook as a teaching platform. The notebook has appeared in over 100 classes [@Hamrick2016; @Castano_Jupyter_Map; @Castano_Jupyter_Map_Dataset] on subjects including geology, mathematics, mechanical engineering, data science, chemical @@ -147,21 +145,22 @@ enough that notebooks could be graded by hand (sometimes even by printing them out on paper and grading them like a traditional assignment). This is because there are several challenges to using the notebook for graded assignments at scale. First, for large classes, it is not feasible for an instructor to -manually grade the code that students write: there must be a way to autograde -the assignments. However, a Jupyter notebook is not a typical script that can be -run and may contain multiple parts of a problem within the same notebook; thus, -autograding a notebook is less straightforward than it is for a traditional -script. Second, for many courses, programming is a means to an end: -understanding concepts in a specific domain. Specifically, instructors may want -students to provide both code and written free-responses interpreting the -results of that code. Instructors thus need to be able to rely on autograding -for the coding parts of an assignment, but also be able to manually grade the -written responses in the surrounding context of the student's code. Third, the -process of distributing assignments to students and later collecting them can be -tedious, even more so with Jupyter notebooks because there is a separate -interface for accessing them beyond the standard system file browser. This often -leads to confusion on the part of students about how to open notebooks after -downloading them, and where to find the notebooks in order to submit them. +manually grade the code that students write: there must be a way to +automatically grade the assignments. However, a Jupyter Notebook is not a +typical script that can be run and may contain multiple parts of a problem +within the same notebook; thus, automatically grading a notebook is less +straightforward than it is for a traditional script. Second, for many courses, +programming is a means to an end: understanding concepts in a specific domain. +Specifically, instructors may want students to provide both code and written +free-responses interpreting the results of that code. Instructors thus need to +be able to rely on automatic grading for the coding parts of an assignment, but +also be able to manually grade the written responses in the surrounding context +of the student's code. Third, the process of distributing assignments to +students and later collecting them can be tedious, even more so with Jupyter +Notebooks because there is a separate interface for accessing them beyond the +standard system file browser. This often leads to confusion on the part of +students about how to open notebooks after downloading them, and where to find +the notebooks in order to submit them. nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and From 72ba5e90a4bda1e0c467e4ad6bb7699e8c5e3adb Mon Sep 17 00:00:00 2001 From: Matthias Bussonnier Date: Sat, 23 Jun 2018 09:58:17 -0700 Subject: [PATCH 16/24] orcid Matthias Bussonnier --- codemeta.json | 2 +- paper/paper.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/codemeta.json b/codemeta.json index 02b7aae9e..cd1f9aba3 100644 --- a/codemeta.json +++ b/codemeta.json @@ -28,7 +28,7 @@ "affiliation": "Lafayette College" }, { - "@id": "", + "@id": "https://orcid.org/0000-0002-7636-8632", "@type": "Person", "email": "bussonniermatthias@gmail.com", "name": "Matthias Bussonnier", diff --git a/paper/paper.md b/paper/paper.md index fa9869a6f..0ddb85d03 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -17,7 +17,7 @@ authors: orcid: 0000-0002-3945-7337 affiliation: 8 - name: Matthias Bussonnier - orcid: + orcid: 0000-0002-7636-8632 affiliation: 1 - name: Jonathan Frederic orcid: 0000-0003-4805-2216 From a8b000ab2018f8864302bbd1cbf0a2754a0302a9 Mon Sep 17 00:00:00 2001 From: Matthias Bussonnier Date: Sun, 24 Jun 2018 13:56:16 -0700 Subject: [PATCH 17/24] add kyle --- codemeta.json | 7 +++++++ paper/paper.md | 5 +++++ 2 files changed, 12 insertions(+) diff --git a/codemeta.json b/codemeta.json index cd1f9aba3..113136b28 100644 --- a/codemeta.json +++ b/codemeta.json @@ -69,6 +69,13 @@ "name": "Fernando Pérez", "affiliation": "University of California, Berkeley" }, + { + "@id": "http://orcid.org/0000-0002-4281-9351", + "@type": "Person", + "email": "rgbkrk@gmail.com", + "name": "Kyle Kelley", + "affiliation": "Netflix, Inc" + }, { "@id": "http://orcid.org/0000-0002-1023-7082", "@type": "Person", diff --git a/paper/paper.md b/paper/paper.md index 0ddb85d03..d4f3671c3 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -43,6 +43,9 @@ authors: - name: Carol Willing orcid: 0000-0002-9817-8485 affiliation: 3 +- name: Kyle Kelley + orcid: 0000-0002-4281-9351 + affiliation: 9 affiliations: - name: University of California, Berkeley index: 1 @@ -60,6 +63,8 @@ affiliations: index: 7 - name: Lafayette College index: 8 +- name: Netflix, Inc: + index: 9 date: 2 June 2018 bibliography: paper.bib --- From 7155826ce7c7d53f192b2020bd24ca2eceac4c0c Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 7 Jul 2018 15:44:11 +0100 Subject: [PATCH 18/24] Use https consistently [ci skip] --- codemeta.json | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/codemeta.json b/codemeta.json index 113136b28..287fd1a5a 100644 --- a/codemeta.json +++ b/codemeta.json @@ -7,14 +7,14 @@ "name": "Project Jupyter" }, { - "@id": "http://orcid.org/0000-0003-3538-8829", + "@id": "https://orcid.org/0000-0003-3538-8829", "@type": "Person", "email": "dblank@brynmawr.edu", "name": "Douglas Blank", "affiliation": "Bryn Mawr College" }, { - "@id": "http://orcid.org/0000-0003-1039-6195", + "@id": "https://orcid.org/0000-0003-1039-6195", "@type": "Person", "email": "ddbourgin@berkeley.edu", "name": "David Bourgin", @@ -35,28 +35,35 @@ "affiliation": "University of California, Berkeley" }, { - "@id": "http://orcid.org/0000-0003-4805-2216", + "@id": "https://orcid.org/0000-0003-4805-2216", "@type": "Person", "email": "jfrederic@google.com", "name": "Jonathan Frederic", "affiliation": "Google Inc." }, { - "@id": "http://orcid.org/0000-0002-5223-6168", + "@id": "https://orcid.org/0000-0002-5223-6168", "@type": "Person", "email": "bgranger@calpoly.edu", "name": "Brian E. Granger", "affiliation": "Cal Poly, San Luis Obispo" }, { - "@id": "http://orcid.org/0000-0002-3860-0429", + "@id": "https://orcid.org/0000-0002-3860-0429", "@type": "Person", "email": "jessica.b.hamrick@gmail.com", "name": "Jessica B. Hamrick", "affiliation": "DeepMind" }, { - "@id": "http://orcid.org/0000-0002-5799-8524", + "@id": "https://orcid.org/0000-0002-4281-9351", + "@type": "Person", + "email": "rgbkrk@gmail.com", + "name": "Kyle Kelley", + "affiliation": "Netflix, Inc" + }, + { + "@id": "https://orcid.org/0000-0002-5799-8524", "@type": "Person", "email": "page.lg@gmail.com", "name": "Logan Page", @@ -70,28 +77,21 @@ "affiliation": "University of California, Berkeley" }, { - "@id": "http://orcid.org/0000-0002-4281-9351", - "@type": "Person", - "email": "rgbkrk@gmail.com", - "name": "Kyle Kelley", - "affiliation": "Netflix, Inc" - }, - { - "@id": "http://orcid.org/0000-0002-1023-7082", + "@id": "https://orcid.org/0000-0002-1023-7082", "@type": "Person", "email": "benjaminrk@gmail.com", "name": "Benjamin Ragan-Kelley", "affiliation": "Simula Research Laboratory" }, { - "@id": "http://orcid.org/0000-0001-9848-4872", + "@id": "https://orcid.org/0000-0001-9848-4872", "@type": "Person", "email": "suchow@berkeley.edu", "name": "Jordan W. Suchow", "affiliation": "University of California, Berkeley" }, { - "@id": "http://orcid.org/0000-0002-9817-8485", + "@id": "https://orcid.org/0000-0002-9817-8485", "@type": "Person", "email": "willingc@gmail.com", "name": "Carol Willing", From 5a5ab893d27b6f5e0b57a47d9d4c802d26169616 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 7 Jul 2018 15:44:36 +0100 Subject: [PATCH 19/24] Add changes from @Alexanderallenbrown [ci skip] --- paper/paper.md | 42 ++++++++++++++++++++++++------------------ 1 file changed, 24 insertions(+), 18 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index d4f3671c3..35880a111 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -28,6 +28,9 @@ authors: - name: Jessica Hamrick orcid: 0000-0002-3860-0429 affiliation: 4 +- name: Kyle Kelley + orcid: 0000-0002-4281-9351 + affiliation: 9 - name: Logan Page orcid: 0000-0002-5799-8524 affiliation: 5 @@ -43,9 +46,6 @@ authors: - name: Carol Willing orcid: 0000-0002-9817-8485 affiliation: 3 -- name: Kyle Kelley - orcid: 0000-0002-4281-9351 - affiliation: 9 affiliations: - name: University of California, Berkeley index: 1 @@ -100,13 +100,14 @@ Since its conception in September 2014, nbgrader has been used in a number of educational contexts, including courses at UC Berkeley, Cal Poly, University of Pretoria, University of Edinburgh, Northeastern University, Central Connecticut State University, KTH Royal Institute of Technology, CU Boulder, University of -Amsterdam, George Washington University, Texas A&M, Bryn Mawr College, and -University of Maryland; and, as of May 2018, over 10,000 nbgrader-based -notebooks exist on GitHub. In addition to its core functionality, nbgrader has -expanded to support a number of other features, including the ability to handle -multiple courses on the same JupyterHub instance; the option to either include -or hide automatically graded tests; customizable late penalties; and support for -importing assignment files downloaded from a Learning Management System (LMS). +Amsterdam, George Washington University, Texas A&M, Bryn Mawr College, Lafayette +College, and University of Maryland; and, as of May 2018, over 10,000 +nbgrader-based notebooks exist on GitHub. In addition to its core functionality, +nbgrader has expanded to support a number of other features, including the +ability to handle multiple courses on the same JupyterHub instance; the option +to either include or hide automatically graded tests; customizable late +penalties; and support for importing assignment files downloaded from a Learning +Management System (LMS). # Statement of Need @@ -122,18 +123,23 @@ in a way that facilitates exploration with interdisciplinary questions is to teach students computational concepts in an interactive environment where it is possible to quickly write, test, and tweak small units of code. Many such environments exist, including Mathematica [@mathematica], Maple [@maple], MATLAB -[@matlab], Sage [@sage] and IPython [@PerezGranger2007]. +[@matlab], Sage [@sage] and IPython [@PerezGranger2007]. However, these are +often focused on programming in a single language, and lack an efficient system +for distributing, collecting, and evaluating student work. In recent years, the IPython project introduced the *Jupyter Notebook* [@kluyver2016jupyter], an interface that is conducive to interactive and literate computing, where programmers can interleave prose with code, equations, -figures, and other media. The Jupyter Notebook is ideal for educators because it -allows them to create assignments which include instructions along with code or -Markdown cells, in which students can provide solutions to exercises. Students -can, for example, write code both to compute and visualize a particular result. -Because the notebook is interactive, students can iterate on a coding problem -without needing to switch back and forth between a command line and a text -editor, and they can rapidly see results alongside the code which produced them. +figures, and other media. Jupyter notebooks were originally developed for +programming in the Python programming language, but multiple languages are now +supported using the same infrastructure. The Jupyter Notebook is ideal for +educators because it allows them to create assignments which include +instructions along with code or Markdown cells, in which students can provide +solutions to exercises. Students can, for example, write code both to compute +and visualize a particular result. Because the notebook is interactive, students +can iterate on a coding problem without needing to switch back and forth between +a command line and a text editor, and they can rapidly see results alongside the +code which produced them. Instructors in many fields have begun using the Jupyter Notebook as a teaching platform. The notebook has appeared in over 100 classes [@Hamrick2016; From ff88b898e6ffafa1d0cda0f31ad2f0406f5a9c84 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Sat, 7 Jul 2018 15:47:28 +0100 Subject: [PATCH 20/24] Add note about class sizes [ci skip] --- paper/paper.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 35880a111..22849f6c5 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -175,9 +175,12 @@ the notebooks in order to submit them. nbgrader streamlines the repetitive tasks found in course management and grading, and its flexibility allows greater communication between instructor and -student. Overall, nbgrader does—and with further development will continue -to—improve the learning experience for both instructors and students, enabling -them to focus on content and building understanding. +student. nbgrader has moreover enabled instructors to use notebook-based +assignments in classes with hundreds of students, which was previously not +possible to do without excessive human effort. Overall, nbgrader does—and with +further development will continue to—improve the learning experience for both +instructors and students, enabling them to focus on content and building +understanding. # References From 3e2c76676f6ef5768e9c5d404815265d4bd25421 Mon Sep 17 00:00:00 2001 From: Matthias Bussonnier Date: Tue, 17 Jul 2018 10:46:32 -0700 Subject: [PATCH 21/24] Add Fernadno ORCID --- codemeta.json | 2 +- paper/paper.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/codemeta.json b/codemeta.json index 287fd1a5a..449521543 100644 --- a/codemeta.json +++ b/codemeta.json @@ -70,7 +70,7 @@ "affiliation": "University of Pretoria" }, { - "@id": "", + "@id": "http://orcid.org/0000-0002-1725-9815", "@type": "Person", "email": "Fernando.Perez@berkeley.edu", "name": "Fernando Pérez", diff --git a/paper/paper.md b/paper/paper.md index 22849f6c5..a14eca8eb 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -35,7 +35,7 @@ authors: orcid: 0000-0002-5799-8524 affiliation: 5 - name: Fernando Pérez - orcid: + orcid: 0000-0002-1725-9815 affiliation: 1 - name: Benjamin Ragan-Kelley orcid: 0000-0002-1023-7082 From 267f14d03e830514e5d7087d0021ae5e0d79b3b4 Mon Sep 17 00:00:00 2001 From: "Jessica B. Hamrick" Date: Wed, 18 Jul 2018 19:36:26 +0100 Subject: [PATCH 22/24] Add Tom Griffiths and M Pacer as authors [ci skip] --- codemeta.json | 16 +++++++++++++++- paper/paper.md | 8 +++++++- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/codemeta.json b/codemeta.json index 449521543..cdb5040be 100644 --- a/codemeta.json +++ b/codemeta.json @@ -48,6 +48,13 @@ "name": "Brian E. Granger", "affiliation": "Cal Poly, San Luis Obispo" }, + { + "@id": "https://orcid.org/0000-0002-5138-7255", + "@type": "Person", + "email": "tom_griffiths@berkeley.edu", + "name": "Thomas L. Griffiths", + "affiliation": "University of California, Berkeley" + }, { "@id": "https://orcid.org/0000-0002-3860-0429", "@type": "Person", @@ -60,7 +67,14 @@ "@type": "Person", "email": "rgbkrk@gmail.com", "name": "Kyle Kelley", - "affiliation": "Netflix, Inc" + "affiliation": "Netflix, Inc." + }, + { + "@id": "", + "@type": "Person", + "email": "mpacer.phd@gmail.com", + "name": "M Pacer", + "affiliation": "Netflix, Inc." }, { "@id": "https://orcid.org/0000-0002-5799-8524", diff --git a/paper/paper.md b/paper/paper.md index a14eca8eb..4e9c58aa7 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -25,12 +25,18 @@ authors: - name: Brian Granger orcid: 0000-0002-5223-6168 affiliation: 3 +- name: Thomas L. Griffiths + orcid: 0000-0002-5138-7255 + affiliation: 1 - name: Jessica Hamrick orcid: 0000-0002-3860-0429 affiliation: 4 - name: Kyle Kelley orcid: 0000-0002-4281-9351 affiliation: 9 +- name: M Pacer + orcid: + affiliation: 9 - name: Logan Page orcid: 0000-0002-5799-8524 affiliation: 5 @@ -63,7 +69,7 @@ affiliations: index: 7 - name: Lafayette College index: 8 -- name: Netflix, Inc: +- name: Netflix, Inc. index: 9 date: 2 June 2018 bibliography: paper.bib From b5c348424039d0f9fdf4387a00870f7419968e54 Mon Sep 17 00:00:00 2001 From: M Pacer Date: Fri, 20 Jul 2018 12:41:06 -0700 Subject: [PATCH 23/24] add M Pacer orcid & approval --- codemeta.json | 2 +- paper/paper.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/codemeta.json b/codemeta.json index cdb5040be..cdd2a709a 100644 --- a/codemeta.json +++ b/codemeta.json @@ -70,7 +70,7 @@ "affiliation": "Netflix, Inc." }, { - "@id": "", + "@id": "https://orcid.org/0000-0002-6680-2941", "@type": "Person", "email": "mpacer.phd@gmail.com", "name": "M Pacer", diff --git a/paper/paper.md b/paper/paper.md index 4e9c58aa7..53689276e 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -35,7 +35,7 @@ authors: orcid: 0000-0002-4281-9351 affiliation: 9 - name: M Pacer - orcid: + orcid: 0000-0002-6680-2941 affiliation: 9 - name: Logan Page orcid: 0000-0002-5799-8524 From d13cb20dea36a85f6274a8af7ef2901e4d81863a Mon Sep 17 00:00:00 2001 From: Matthias Bussonnier Date: Sun, 22 Jul 2018 19:01:00 -0700 Subject: [PATCH 24/24] Make link https --- paper/paper.bib | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.bib b/paper/paper.bib index 73b70f08e..2b0a5a6b6 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -85,7 +85,7 @@ @Article{PerezGranger2007 Pages = {21--29}, month = may, year = 2007, - url = "http://ipython.org", + url = "https://ipython.org", ISSN = "1521-9615", doi = {10.1109/MCSE.2007.53}, publisher = {IEEE Computer Society},