Matt Davis on The Carpentries

Python Lesson Rewrite

Sun, 15 Nov 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Recent analysis and introspection regarding Software Carpentry's Python lesson has led us to conclude that the lesson would benefit from a complete rewrite. The subcommittee on lesson development met twice to plan much about the new lessons (yes, that's plural). This post will describe our plans for the new lessons.

We're going to write two new Python lessons, one intended for students who are completely new to programming (the "novice" lesson), and another for students with some programming experience in any language (the "intermediate" lesson). Data Carpentry also targets new programmers so we'll be developing the new novice lesson in collaboration with DC, and both DC and SWC will use the lesson. We decided to use Gapminder data for both the novice and intermediate lessons in order to have a consistent experience and approachable, meaningful data (and because some lessons are already using it).

SciPy 2015 Workshop Videos

Wed, 29 Jul 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Software Carpentry was pleased to present a full two-day workshop during the recent SciPy Conference tutorials. The entire conference was recorded, including all sessions of our workshop:

The course materials are accessible via the workshop webpage and GitHub repo.

The course would not have been possible without the help of several Software Carpentry members: Azalee Bostroem, Matt Davis, Jess Hamrick, Ted Hart, Katy Huff, Thomas Kluyver, Jens Nielsen, April Wright, and Elizabeth Seiver. Many thanks to these talented folks and to the SciPy organizers for inviting us!

Software Carpentry at SciPy 2015

Fri, 05 Jun 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

This year at SciPy 2015 Software Carpentry is excited to be running a full two-day workshop during the tutorials that precede the main conference. We'll be covering our standard topics of shell, introductory Python, and version control with Git. We'll also be teaching a unit introducing the basic libraries of scientific Python. Attendees need not have any experience with the topics we cover.

We have our usual goals of helping scientists do more in less time with less pain, but at SciPy we also have a bonus goal of easing Python novices into the conference. A technical conference can present a steep learning curve to people unfamiliar with the field and we hope that a Software Carpentry workshop beforehand will give attendees a boost before wading into the conference deluge by exposing them to basic Python concepts and fundamental scientific Python libraries.

There is still plenty of room in the Software Carpentry tutorial, so if this seems useful to you please register with SciPy. And if you know anyone who would benefit from a workshop and would be interested in the conference please share this with them. Hope to see you in Austin!

Workshops for Companies

Thu, 09 Apr 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

At our March 12, 2015 meeting, the Software Carpentry Foundation Steering Committee discussed whether and under what terms to provide workshops to for-profit corporations. There were no objections to the idea of doing workshops for corporations, but it is something new to Software Carpentry. We've decided to run a pilot program encompassing five corporate workshops so we can learn more about working with corporations. The pilot program will allow us to gauge corporate interest and collect feedback from instructors, coordinators, and others about how things go.

2015 Election: Matt Davis

Fri, 09 Jan 2015 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

In January 2012 I had the good luck to be in one of Greg Wilson's first workshops after he rebooted Software Carpentry in the current two-day format. I ended up as a helper in that workshop, and a month later I was in Toronto teaching Python as Software Carpentry's first volunteer instructor. Over the past three years I have:

taught at more workshops than I can remember
helped transition our materials from SVN to GitHub
written lessons and ipythonblocks
recruited and mentored new instructors
publicized Software Carpentry at conferences

Volunteering with Software Carpentry has been one of the most rewarding things I've ever done and I'd be honored to continue helping as a member of the SCF Steering Committee.

Software Carpentry at SciPy 2013

Tue, 23 Apr 2013 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Several members of Software Carpentry's vast network will be traveling to Austin, TX in June for SciPy 2013. We are especially excited that Katy Huff and Matt Davis will be teaching a tutorial titled “Version Control and Unit Testing for Scientific Software.” The tutorial is aimed at beginners and the only prerequisite experience will be basic use of Python and the shell. Matt and Katy will cover why testing and version control are good ideas for working scientists and show how to get started with each. Here's the tutorial abstract:

Teaching with ipythonblocks at UW

Sat, 02 Mar 2013 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

The recent University of Washington bootcamp was my first chance to try teaching Python with ipythonblocks, and it was a great success!

The students reported that the immediate feedback from ipythonblocks was a great way to see what their code was doing. We were able to move quickly through topics like for-loops and if-statements in relative comfort, and even cover slicing with ease.

Feedback from UW Room B

Fri, 01 Mar 2013 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Doug Latornell and Matt Davis taught in "Room B" at the recent University of Washington bootcamp. It was a great group of very enthusiastic students! Thanks also to our very capable helpers Jake Vanderplas and David Leen!

Here's our traditional good/bad feedback:

Good	Bad
Learning about Python and NumPy, especially the practice exercises.	Too much shell stuff (already shell proficient).
We talked about best practice issues in software development.	Difficult to keep up with instructor when switching between screens.
Great holistic crash course on Python and git. Did well with a range of expertise the room.	Too much typing while trying to listen.
Overall great intro to many great topics.	Would have preferred basic Python scripting instead of NumPy intro.
The one-on-one help and the exercises.	matplotlib and NumPy were a little dry.
Pace was quick, almost too fast, but not quite!	The Python part was rushed and we didn't have time to see all of the code.
Intuitive approach.	Command line tutorial was slow (but that was probably necessary for some).
Intro to IPython Notebook.	A bit too fast in some content.
Very well structured. Good collection of topics for introduction. Staff very responsive.	NumPy section could use more exercises/interaction.
Very helpful and useful.	Wanted to learn about SciPy.
The existence of Software Carpentry and the integrated exercises.	The software engineering felt too rushed -- if I made an error in my code I easily fell behind and was lost.
	Wanted just Python.

Expanding Our Bootcamp Types

Fri, 15 Feb 2013 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Prompted by a recent email I gave some thought to our plans to expand the types of bootcamps we offer, especially when it comes to a sort of "next level" bootcamp and whether we might offer bootcamps that introduce traditional software developers to the world of scientific programming:

There is significant discussion on the best way to expand Software Carpentry. Longer bootcamps, advanced bootcamps, etc. At some point we need to start actually experimenting with these things, but we have many constraints, most notably a severe shortage of person-hours to devote to developing curriculum and staffing events. Scientists, it turns out, are very busy people!

Making a Difference at LBL

Fri, 16 Nov 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Without any doubt, the best thing about teaching for Software Carpentry is making a difference for someone and getting to hear about it. One of our students at the Lawrence Berkeley Lab, nuclear engineer Dr. Bethany Goldblum, was impressed enough by Katy Huff's presentation of git that she wanted her team to start using version control.

Bethany's description of her team's past code management practices is typical of academic projects, with many people modifying their own copy of a code until that "resulted in over 20 versions of the codes, each with bugs of its own." On their current project "a postdoc is in the process of developing the code, but now every time he makes a change, he uploads it to a different directory on our analysis machine and we just have multiple copies of almost the same code floating around. Unless one is careful, they may not know which code is the most recent version. I believe there is some fear there to undo anything that the original developer put in place."

Feedback from UC Berkeley

Mon, 22 Oct 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

We just finished up our UC Berkeley bootcamp with me, Katy Huff, and Justin Kitzes teaching. Here's the feedback:

Good	Bad
first day good with no programming experience	couldn't run the VM on underpowered computer
good general intro to basics of Python and VC	don't see why Python is better than R
liked the intro/advanced Python split	would like a longer bootcamp with more focus on Python
good git introduction	didn't want to learn Python
IPython notebook helped me learn	would like to give anonymous feedback
got to see real software engineering	didn't catch some important details that held things up
good coverage of Python + software engineering	have better setup instructions, test scripts
wanted to learn Python	Python instruction was too slow/basic
liked simple examples	got left behind sometimes
IPython/shell interaction awesome	not sure how to integrate git into workflow, have practical demos, case studies
good job squeezing a lot of content in	hard to type/listen/watch all at once
introduced scientific Python	would be nice to have a data cleaning example, workflow example
liked the showcase demos of matplotlib/IPython features	could have sped up introductory topics
combination of topics was good	have more content summaries, workflow visualizations
liked intro Python exercises	reading suggestions to follow up bootcamp
understand the basics of version control	wanted to see object oriented programming/calling C code

Unfortunately I missed a pre-workshop memo that most of the attendees would be experienced R users and I could have sped up/skipped some of the introductory programming material in favor of more scientific Python. The second day material on version control and software engineering still seemed to hit home, though, so we didn't totally waste their time. In future workshops I'll try to do a better job getting attendee profiles beforehand.

Feedback from Lawrence Berkeley National Lab

Sat, 20 Oct 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Katy Huff, Justin Kitzes, and I wrapped up our LBL workshop yesterday. We had ~25 participants with a broad range of backgrounds and levels of experience. Here's our traditional table of good/bad feedback:

Good	Bad
can use python better	don't know how to apply git to work
covered lots of material	covered too much material
can use git better now	group felt too large for number of helpers
covered from basics to advanced programming	felt unprepared for git instruction
helpers were knowledgeable and nice	couldn't run VM, add system reqs
motivated version control well	python level was too easy
started with basics, had good help	need well defined goals for exercises
got exposed to a lot	group people by experience
all the material is available on GitHub	would have liked a more detailed description of course
learned enough to get started	didn't get any emails on the waitlist
have hope	getting info ahead of time
good overview for later	whole thing too fast
format - work through code live	topics jumped around
testing cases	maybe too language (Python) dependent, no objects
self-consistent complete package	burnt out at end of first day (fast)
inspirational	9-4:30 draining, more breaks between topics
great intro to vocabulary, how programmers think	didn't expect to program at end, was right
gained confidence from seeing experts	switch morning git with afternoon python on 2nd day
seeing github, advice on resources	not clear that mac users needed to install software ahead, why certain steps
had to do exercises, version control in beginner class	some hard to follow along, relies on previous success with commands
instructors :-D, with real-world experience	more relevant examples to audience, day to day data/problems
demo writing, troubleshooting, testing very valuable	what was xcode for?
	falling behind in python - 2 tiered exercises
	documentation needs comments
	is there help for release management?
	advanced math?
	third day - integrative exercise, case study - start to finish
	follow up project, final suggested homework assignment

The good news is that they liked our material and they liked us (and seemed to think we knew what we were talking about). The bad news is a lot of them had a hard time keeping up and a couple complained it was too slow. These are typical complaints of our shotgun approach to teaching to a random sampling of scientists. We'd like to do more discipline specific bootcamps where we can tailor things better. Another typical complaint was they they aren't sure how to apply what they've learned to their research. We're still working on that one.

Transitioning to the IPython Notebook

Thu, 04 Oct 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Here at Software Carpentry we've been teaching Python for a little while. We teach Python in our bootcamps and we have a library of instructional videos on Python topics including basics, dictionaries, regular expressions, and object oriented programming.

As usual, though, we're not satisfied with the status quo. For both our bootcamps and our online material we're in the process of switching to the IPython Notebook. The Notebook lets the user write and execute Python code and see the results, all inside their favorite web browser.

Number Crunching with Python: DC Python Workshop

Thu, 13 Sep 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

On November 11, 2012 I'll be giving a workshop in Washington, D.C. on number crunching with Python. The event is organized by DC Python and Data Science DC, who were kind enough to ask me to teach. The focus of the workshop will be on core scientific Python packages like NumPy, SciPy, matplotlib, IPython, and, with the help of Skipper Seabold, pandas.

The workshop filled up fast but there is a wait list you can join in case people drop out or we find a bigger venue. Details are at http://meetup.dcpython.org/events/81931062/.

Feedback from Johns Hopkins

Wed, 20 Jun 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Today we wrapped up our 2-day bootcamp at Johns Hopkins University in Baltimore. We had a pretty small group of about 12 each day (out of 20 signed up). In a really pleasant surprise we had students come from Brooklyn, NY and Virginia, plus two students who commuted up from Sigma Space in Lanham, MD. Overall feedback seemed quite positive:

Good

Bad

advanced bash (find, pipes)
git and GitHub are cool
all the bootcamp material is online (at GitHub)
intro to Python
free
intro to shell
saw some advanced Python
testing/debugging
branching in git
bootcamp was local
examples relevant to scientists
watching how someone else works
we covered everything we planned (from Matt)

show/use more IPython features (from someone who already uses it)
shell went too slow, Python went too fast
projector small/dim (+fonts small)
had to take time off work (about half said they would have come on the weekend.)
would like domain specific Python examples
would like a third day (majority would have come for another day)
hard if you miss the first day
want more NumPy, SciPy, etc.
get left behind if you make a mistake
don't see complexity when writing examples from scratch, could provide some pre-written code
more step-by-step instructions online
wanted to see professional workflow with IPython notebook (from Josh)
could use pre-class surveys to tailor lessons

Big thanks to the other instructors Joshua, Sasha, and Mike!

Tutorial: NumPy, SciPy, and matplotlib

Thu, 07 Jun 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Today I did a toy data analysis of some annual temperature data in Australia and Canada over the last ~100 years. The goal of the exercise was to demonstrate loading data, inspecting it, and fitting trends. My last tutorial didn't involve any real data so this week we wanted to change that.

Like my previous tutorial I used the IPython HTML notebook to present. I hadn't been planning to use pylab mode or inline plots but some issues with my matplotlib forced me in that direction. There's an awkward situation here because I actually recommend people not use the pylab interface to matplotlib because the behind-the-scenes magic can cause problems (difficult to debug problems), but for doing demos the inline plots are really the way to go. The obvious upside is that the plots I made as part of the tutorial are embedded in the notebook for you to see now.

Introduction to NumPy Tutorial

Fri, 01 Jun 2012 00:00:00 +0000

This post originally appeared on the Software Carpentry website.

Today I did a tutorial moving quickly through the basic usage of NumPy, the essential library for doing numeric computing with Python. We covered building arrays; indexing; array math; NumPy's element-wise functions; array attributes and methods; random numbers; masked arrays; and array comparison.

I presented using the IPython HTML Notebook. I enjoyed it because I never had to switch between a terminal and text editor, but I wonder what the people viewing thought. A nice feature of the notebook is that I can export it, both as a PDF and in the .ipynb format importable by IPython. The PDF is here, and the .ipynb file here.