<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Matthew Turk on Medium]]></title>
        <description><![CDATA[Stories by Matthew Turk on Medium]]></description>
        <link>https://medium.com/@matthewturk?source=rss-3c8be61d760b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*AU8N9PA_Qln6Taog.jpg</url>
            <title>Stories by Matthew Turk on Medium</title>
            <link>https://medium.com/@matthewturk?source=rss-3c8be61d760b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 12:18:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@matthewturk/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[10 Years of yt]]></title>
            <link>https://medium.com/@matthewturk/10-years-of-yt-c93b2f1cef8c?source=rss-3c8be61d760b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c93b2f1cef8c</guid>
            <category><![CDATA[scientific-software]]></category>
            <category><![CDATA[academia]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[data-visualization]]></category>
            <category><![CDATA[yt-project]]></category>
            <dc:creator><![CDATA[Matthew Turk]]></dc:creator>
            <pubDate>Wed, 08 Feb 2017 22:42:54 GMT</pubDate>
            <atom:updated>2017-02-08T22:42:54.761Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-nd/4.0/</cc:license>
            <content:encoded><![CDATA[<p>Today is the 10th birthday of the <a href="http://yt-project.org/">yt</a> source code repository. That’s nearly 30% of my days. I don’t get as much of a chance to contribute code to yt as I used to, which is a bit sad for me, but it’s still a huge part of my life. In many ways, it has been a driver of professional and personal developments. I’ve written before about things like struggles with <a href="https://medium.com/@matthewturk/the-loneliness-of-the-computational-scientist-a3ebd97e050c">diversity</a> and <a href="https://medium.com/@matthewturk/the-royal-we-in-scientific-software-development-9deea495b3b6">credit</a>, but today I thought I’d share a couple images and ancedotes from its history that I don’t really share that often but that mean a lot to me. In writing this, I was reminded of the work ahead of us in improving diversity, especially as I reflected on the early stages of the community.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*Pb3GG8qmhDvGXG4rZ7yx2Q.png" /></figure><p>The first line of code of what became yt was written in 2006; I think I have some of that somewhere laying about, but it was originally written to read data from <a href="http://enzo-project.org/">Enzo</a>, ship it over to <a href="http://www.slac.stanford.edu/grp/ek/hippodraw/">HippoDraw</a> and use that for visualization. HippoDraw was a remarkable piece of software that is mostly unmaintained now, but it provided really responsive visualization and a succinct Python API. The first version of yt was called EnzoPotamus. If I am remembering correctly, some of the code for EnzoPotamus was written by John Wise, but I do know that we iterated with the author of HippoDraw a number of times to make sure that it all worked correctly. At this time, I think we were still using Python 2.4 for the majority of our work; I remember even having to write both Numeric and NumPy API calls to get things to work inside HippoDraw.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NH5-ZbcAMGwprvCPyYROOg.jpeg" /><figcaption>A stop on the way back, with orange sodium lights in the distance</figcaption></figure><p>After a while, it started to grow out into something a bit more extensive, that allowed for selecting data along different axes than just spatial axes. At this point I started calling it Raven and it lived inside a CVS repository that also stored the version of <a href="http://enzo-project.org/">Enzo</a> that I used in grad school; I think I have a dusty export of this somewhere. That December, of 2006, I remember taking a trip to an <a href="http://ipam.ucla.edu/">IPAM</a> reunion conference with John, and on the drive down talking about ideas for data selection and so forth. In the evenings at the conference I implemented spheres and (I think?) rectangular regions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*ts4JEj3lNMjh09C_-okgnQ.jpeg" /></figure><p>The repository for yt itself, along with the name change, happened on February 8, 2007. I didn’t know it then, but February 8 also happens to be my wife’s birthday. That Summer, at the <a href="http://2sn.org/firststars/3/">First Stars III</a> conference, I had my first paper. By this time, yt had started to pick up a couple users, mostly people I worked with directly, and we’d moved to using <a href="http://matplotlib.org/">matplotlib</a> for our plotting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/240/1*NWTMEm8tqUwsT563k6WAmQ.jpeg" /></figure><p>In 2008, Jeff Oishi and I started work on making yt more generically usable beyond Enzo. This was a really fun project, and one guided nearly entirely by Jeff’s vision. We had to re-scope and re-design a number of things in yt to remove assumptions about how Enzo thought of data. At this time, the number of analysis operations wasn’t that large, and there were still many places where things like box size and so forth we just sort of implicitly assumed to be Enzo-specific.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*797YIZlZTh44rWT0g58dmw.jpeg" /><figcaption>Froyo in LA</figcaption></figure><p>Ultimately, we traveled to SciPy 2008, where I gave the first talk I have ever given about yt itself. We also found a really cool frozen yogurt place in Los Angeles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*qRblPwe2SRy1ylwILbcAeg.jpeg" /><figcaption>Some VTK-based renderings using yt to provide data</figcaption></figure><p>There were some really fun experiments along the way, too. For a while, we experimented with using VTK, via TVTK, as an engine for visualization. This worked great for isocontours, but we could never quite get the volume rendering to work. The science that led to my first peer-reviewed paper was guided by these visualizations in the visualization lab at the Fred Kavli Building at <a href="http://kipac.stanford.edu/">KIPAC</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*A8qtQhiQVy0Add5X9DAp3Q.png" /></figure><p>For a while, we even had a wxPython GUI that was all hand-written, using signals and pubsub and everything. Sam Skillman used it quite a lot, if I remember correctly; he even sent me an email once with the subject “yt working window not working”. As you can see from the image he attached, he was correct: the yt working window was <em>indeed</em> not working. We called this GUI, as we call all the GUIs, Reason. I used it, and I hear every so often from early yt-adopters that they miss it still. I miss it too.</p><p>A few other things stand out. We started experimenting with distributed version control in early 2009, specifically with keeping a mercurial copy of the repository in sync with the “primary” subversion repository. I imported a couple changesets and I would manually merge back in a big, monolithic patch every so often. This wasn’t terribly efficient on the merging side, but it worked out well on the development side!</p><p>In 2010, John ZuHone and I spoke over email about adding support for FLASH to yt. This happened during a summer school at UC Santa Cruz held by <a href="http://hipacc.ucsc.edu/">HIPACC</a>; HIPACC, and its director Joel Primack, have always been enormous supporters of yt and its development. I remember very clearly working with John over email to add support for FLASH data to yt, making it the third supported data format. I would wake up early in the dorm room they put me up in, and I’d work on that while waiting for the day to begin. I had just gotten a new android phone, and I almost managed to get yt to run on it after patching NumPy to build in <a href="https://groups.google.com/forum/#!forum/python-for-android">Py4A</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_RW1OIdlLI4XgYqxgjP7Hw.jpeg" /></figure><p>Later on that Summer, while I was a postdoc at San Diego, Britton Smith, Jeff Oishi and I decided to take a few days to hack on yt out in the woods somewhere, inspired by the model of <a href="https://wiki.sagemath.org/Workshops">Sage Days</a>. We’d been using mercurial for version control for a while at this point, and it was here that we did a bunch of repository reorganization (getting rid of names like lagos and raven and enki for submodules in yt) and we also re-imported the entire history of yt from subversion into hg. We even posed for a picture at the event and hammed it up. Also, this is where Jeff introduced me to <a href="https://en.wikipedia.org/wiki/Parts_%26_Labor">Parts &amp; Labor</a>, which has remained a consistently effective work music routine. We also watched the greatest Mystery Science Theater 3000 <a href="https://www.youtube.com/watch?v=vmNZwJTp9nM">episode</a>. There is an easter egg that we snuck into the code base during this reorganization that, to my knowledge, has never been identified by anyone else.</p><p>In early 2011, we did this again, where we (expanding our ranks by one to include Cameron Hummels) headed up to Northern Michigan in the wintertime for a coding sprint. This time, rather than reorganizing the repository, we focused on building (from scratch!) a web-based <a href="https://en.wikipedia.org/wiki/Ext_JS">ExtJS</a> GUI for yt. I was so, so proud of this GUI. We even decided it would be “the last GUI for yt.” It turns out, this was not quite the case. I remain incredibly proud of what we built — it was modular, it did many things that people wanted and needed at the time, and I really enjoyed writing it. But, it was eclipsed by the truly amazing and groundbreaking work done by <a href="http://jupyter.org/">Jupyter</a>, and that’s just how things ought to be sometimes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*vsy27iylHqNbppUag1nTww.png" /><figcaption>I always thought of this as our “progressive rock album cover” picture</figcaption></figure><p>In August of 2011, John ZuHone wrote to me and Britton about holding a yt workshop at the FLASH center in Chicago. We put in a proposal to the NSF for workshop funding, and in January of 2012 we held the the first yt workshop. This was where I first got to know Nathan Goldbaum and Kacper Kowalik, two people I have the honor of working with at the University of Illinois, and who have become core to the development of yt — among other things, Kacper has essentially single-handedly built our testing infrastructure, and Nathan has been an incredibly devoted community member and developer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bCUKEvdx7ixa1FOdMNjy5A.png" /><figcaption>Cameron Hummels at the first yt workshop, showing off Reason and our WebGL GUI for exploring grid structures.</figcaption></figure><p>By this time, yt had started to feel more and more like a community. I remember feeling so grateful that people would hang out in the IRC channel, that we could just talk about things, and that people were interested in using and contributing to the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*MG2qI-idZFYGfAl2tqm-Kw.png" /><figcaption>We had a contest for a logo. This was Sam Skillman’s submission. I still love it.</figcaption></figure><p>One thing I don’t really talk about, though, is how much my interaction with yt as a community was shaped by people in my life. Friendships, like with those who formed its early development, were key to building out support structures and identifying how it could do really awesome things.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*WkgcabHi9TXl92HhbWkROA.png" /><figcaption>Our daughter, five days old and helping me with changeset <a href="https://bitbucket.org/yt_analysis/yt/commits/bd7b752446fa">bd7b752446fa</a></figcaption></figure><p>To be perfectly honest, however, I think that the relationship that has had the biggest impact on my interaction with yt and its community has been my relationship with my wife, Meghan. It has been through learning from her experiences working with people and with communities that I have learned about myself, and learned to understand and shape my relationship with the yt community. In the summer of 2014, we welcomed our first child. That summer was also when we moved to Illinois from New York, and when I was trying to complete work on “yt 3.0.” There are a lot of things about the yt-2.x to yt-3.0 transition I feel bad about; I can look at any number of design decisions that I made (or didn’t make) that have impeded it in a number of ways. I actually can’t really think about the yt-3.0 release without thinking about working on it while Ellie slept next to me in our home office.</p><p>I suppose it’s a common thing to see the flaws in our own work. As I look at some of the things that happened with yt-3.0, I think about things like the chunking system and how it could have been improved, or the octree indexing for particles which we’re trying really hard to remove, and I think about how much I wish I’d spent more time or done things better. I don’t want to give the impression is that I’m not proud of it, or that I wish I could take it back. Even though I can see all the problems with the work I’ve done, all the “I wish I’d…” bits, I cannot express how enormously proud I am of the work that the <a href="http://yt-project.org/about.html">people</a> in the <a href="http://yt-project.org/community.html">community</a> have done. It’s a bit odd to say that, to say I’m proud of something that others have done, but it’s true.</p><p>I am honored that I’ve gotten to spend the last 10 years of my life working on this project. I don’t really know where the next 10 years will take it, but I am really looking forward to it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c93b2f1cef8c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Astronomical Software in 2017 and Beyond]]></title>
            <link>https://medium.com/@matthewturk/astronomical-software-in-2017-and-beyond-ae1366181870?source=rss-3c8be61d760b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae1366181870</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[science]]></category>
            <category><![CDATA[academia]]></category>
            <category><![CDATA[astronomy]]></category>
            <category><![CDATA[scientific-software]]></category>
            <dc:creator><![CDATA[Matthew Turk]]></dc:creator>
            <pubDate>Fri, 13 Jan 2017 16:36:34 GMT</pubDate>
            <atom:updated>2017-01-13T16:36:34.326Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>At the end of 2016, I took on the role of Chair of the Working Group for Astronomical Software (WGAS) in the American Astronomical Society (<a href="http://aas.org/">AAS</a>), attempting to fill in the unfillable shoes of Frossie Economou. I’m honored to be asked to take on this role, and I hope I live up to the expectations of the society and its members.</p><p>Below, I’ve outlined a few of the things I want to prioritize in the WGAS; they can be summarized as the problems of recognition and domain specificity. Having these discussions occur in the context of an AAS-recognized working group provides the opportunity to leverage the membership of AAS and to present findings to the AAS Council, where they can help shape policy. I see the WGAS as an instrument of social change in our professional society.</p><p>I’ll say this again at the end, but I want to make sure this is up front: if you have an interested in how the professional society views and interacts with software, software developers, and how software factors into the research lifecycle, I invite you to engage with WGAS. You can do this by contacting me directly at matthewturk@gmail.com or by joining the <a href="https://groups.google.com/forum/#!forum/wgas-discuss">public discussion group I’ve created</a>.</p><p>This last week at AAS229, I had the opportunity to hear from many different people about their ideas on how software is and should be viewed in the AAS. In particular, I was able to speak at some length with Julie Steffen, Frank Timmes, Kelle Cruz, David Hogg and Erik Tollerud, and we spoke about the role that WGAS may play in the next few years for the AAS, especially as the Astro2020 review begins. I also sat in on the open portion of the AAS Council meeting, where I learned a considerable amount about how the council operates, how decisions are made, and its interaction with the society. I highly recommend attending one of these meetings.</p><h4>Where Are We?</h4><p>I’ll be honest: I was tempted to start this section with a sentence that breaks the record for most cliched, “Science is becoming increasingly software-driven.” As with many cliches, though, this is true.</p><p>Astronomers use software to drive telescopes, to take data, to <a href="http://iraf.noao.edu/">reduce that data</a>, to conduct subsequent <a href="http://astropy.org/">analysis of that data</a>, and even to <a href="https://github.com/lsst/firefly">share the results of their data</a>. On the computational side, astronomers use software to <a href="http://boxlib-codes.github.io/Castro/">run simulations</a>, <a href="https://bitbucket.org/gfcstanford/rockstar">analyze the results of those simulations</a>, and <a href="http://astroblend.com/">visualize the output</a>. Theorists use software as well, to explore analytical and <a href="https://sites.google.com/site/galacticusmodel/">semi-analytical results</a>.</p><p>And I’m sure I just missed some category or use of software. The point is, it’s everywhere, and it is used at essentially every stage of the research pipeline, even <a href="https://astroplan.readthedocs.io/en/latest/">before any data has been taken</a>.</p><p>Software is critical for the continued growth of astronomy as a scientific endeavor. This includes the sustenance of existing software, the development of new software, stewarding software as it grows through its lifecycle, and identifying strategies to improve efficiency of the field as a whole. Ivelina Momcheva and Erik Tollerud explore this in depth in <a href="https://arxiv.org/abs/1507.03989">their 2015 paper</a>.</p><p>Zero of those items occur in a vacuum. Software is not a raw commodity; software is an intellectual product created by <em>people</em>.</p><h4>People</h4><p>People are hard. They don’t really have <a href="https://en.wikipedia.org/wiki/Unit_testing">unit tests</a>, <a href="https://en.wikipedia.org/wiki/Continuous_integration">continuous integration</a> is expensive, <a href="https://en.wikipedia.org/wiki/Version_control">version control</a> is still an open issue, and they’re woefully susceptible to <a href="http://www.telegraph.co.uk/news/2016/11/29/donald-trumps-preposterous-tweets-distracting-us-enormous-conflicts/">denial of service attacks</a>.</p><p>I’ve spent a considerable amount of time in the last few years studying and participating in discussions about sustainability of scholarly software; groups such as <a href="http://wssspe.researchcomputing.org.uk/">WSSSPE</a>, <a href="http://www.numfocus.org/blog/numfocus-receives-grant-for-project-sustainability">NumFOCUS</a>, <a href="http://software.ac.uk/">SSI</a>, and many others have held workshops, collected position papers and organized scholarly discourse around this topic. While I am versed in this material, I won’t pretend to be an expert — but I do know the right people to ask.</p><p>Usually the discussions revolve around a few different points: sustainability (a term I use in an intentionally generic fashion here), funding, credit, and careers. All of these are somewhat intertwined, and often take on different meanings depending on the specific conversation, participants and so on that are having the discussion.</p><p>At some level, these questions can essentially <em>all</em> be reduced to the notion of recognizing software as an intellectual product in the scholarly discourse.</p><p>The WGAS has the opportunity to advocate for recognition of software as a primary intellectual product in the astronomical sciences.</p><h4>Recognition Cuts Both Ways</h4><p>Let’s imagine for a moment that credit is a zero-sum game. (<a href="https://medium.com/@matthewturk/the-royal-we-in-scientific-software-development-9deea495b3b6">It’s not.</a>) Imagine it as a pie. When you divide up credit for any given scientific discovery, you have to figure out who gets to have a piece of that <a href="https://frinkiac.com/meme/S10E05/1075523.jpg?b64lines=IEkgTUVBTiwgVEhFIFNDUklQVCBNSUdIVAogRVZFTiBXT1JLIElGIFlPVSBHT1QgUklECiBPRiBUSEUgVEFMS0lORyBQSUUu">pie</a>; do you give a piece of pie to the person who wrote the software, as well as the person who took the data? I believe that the answer is unequivocally yes; software is an intellectual contribution to this discovery.</p><p>This is a reductionist approach to thinking about the question, and furthermore it is damaging in that it approaches the research process as a <em>closed system</em>.</p><p>I posit that if the WGAS is successful in bringing about social change, we should envision this as not only “giving a slice of pie” to the software developers, but increasing the number and the <em>diversity</em> of those doing the software development.</p><p>Recognition of importance ensures that there is credit given for the work done. It also mandates that this work not be done by volunteer effort. This is critically important, as any time we rely on volunteer effort, on unpaid labor, we select <em>against </em>inclusivity and diversity. For a deep dive into this, I highly recommend Ashe Dryden’s post the <a href="https://www.ashedryden.com/blog/the-ethics-of-unpaid-labor-and-the-oss-community">Ethics of Unpaid Labor</a>.</p><p>This is a critical problem. If we do not recognize the intellectual contribution of software, we will not put into place systems to ensure that its development relies on volunteer effort. This has the dual effect of both <strong>exploiting</strong> those able to provide volunteer effort and <strong>selecting against</strong> those whose situations inhibit volunteer effort.</p><p>I believe that working with communities focused on sustainability to identify approaches and strategies to sustaining astronomical software and the people who write it is a critical goal for the WGAS and the society as a whole. Without thinking about the necessary social change, throwing funding is a stop-gap that serves to reinforce existing credit and reward structures.</p><h4>Next Steps</h4><p>I’ve identified a few top priority agenda items to get things moving.</p><ul><li>An open call for input, ideas, and discussion around a software-related white paper for the decadal review. This is something that we <em>absolutely</em> have to get right, and that means ensuring that viewpoints from a wide cross-section of the community.</li><li>Bidirectional communication: Part of the role of the WGAS is in giving presentations to the AAS Council on the current state and future directions, but I also believe we need to build a dialogue with the Society and its members, ensuring that they are kept apprised and asked for input on relevant issues. This includes people involved in pipeline development, infrastructure, observation, theory, and computational astronomy.</li></ul><p>If you are interested in participating in this discussion or the working group, please contact me directly at matthewturk@gmail.com, or join the <a href="https://groups.google.com/forum/#!forum/wgas-discuss">Google Group I have created for this purpose</a>.</p><p>This isn’t the end of the work — in fact, I would like to see a number of tasks (ranging in levels-of-ambition) accomplished through the WGAS. But I hope it’s a good start.</p><p><em>Thanks to Jeff Oishi and Gus Muench for comments on this post.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae1366181870" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Loneliness of the Computational Scientist]]></title>
            <link>https://medium.com/@matthewturk/the-loneliness-of-the-computational-scientist-a3ebd97e050c?source=rss-3c8be61d760b------2</link>
            <guid isPermaLink="false">https://medium.com/p/a3ebd97e050c</guid>
            <category><![CDATA[education]]></category>
            <category><![CDATA[science]]></category>
            <category><![CDATA[computational-science]]></category>
            <category><![CDATA[diversity-and-inclusion]]></category>
            <category><![CDATA[diversity]]></category>
            <dc:creator><![CDATA[Matthew Turk]]></dc:creator>
            <pubDate>Thu, 29 Dec 2016 16:24:46 GMT</pubDate>
            <atom:updated>2016-12-29T16:32:36.742Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/289/1*87fxLpgtlnzrezMAymzdiQ.png" /><figcaption>“Ringing” (red) around the true solution (blue)</figcaption></figure><p>One of the things I worked on in graduate school was how hydrogen atoms turned into hydrogen molecules, and how that affected how the first stars in the Universe formed. Solving the differential equations that described this process was a tricky business, and often led to “ringing” around the true solution by overshooting, or undershooting, and cyclically over-correcting as it tried to converge.</p><p>I think that some of the communities I circulate in are in danger of over-correcting. They started because people felt isolated, and sought connection with peers, but they’re teetering on the brink of implicit exclusion through homogeneity.</p><h4>Building Without Any Edge Pieces</h4><p>I started graduate school in the Fall of 2003. My graduate work was in computational astrophysics — I ran simulations of the formation of the first stars in the Universe. At the time, and today as well, the primary mechanisms of investigating the first stars are all mediated by conducting computer simulations.</p><p>Running simulations is an interesting experience. Even today, it’s like a window into a hybrid of time periods — at times, the code is highly modernized, utilizing advanced features of recent programming languages, and at other times it is time-tested code passed down like a set of revered documents.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*VuKW2Z6dBya-u8w8_xThBg.png" /><figcaption>A running simulation and some code to analyze the results</figcaption></figure><p>When I was in graduate school, “social coding” hadn’t quite become the buzzword it is now. There was communication over email, and there were some folks just a cubicle over that I could talk with, but when I was looking at a piece of code, it was just me and the code. Some of the work I did was writing new modules from scratch, but much of it was modifying or enhancing existing code. Sometimes that felt like receiving transmissions from the past, sometimes it just felt like trying to re-assemble a jigsaw puzzle someone else didn’t know they were constructing. (And then once they had gotten the bit of the picture they wanted, they pulled out all the edge pieces.)</p><p>This isn’t to say being a computational scientist is bad, or that the code is bad — it’s just how it was. It is a fundamentally <em>lonely</em> operation. My days were spent having a conversation with something that was simply<em> unable to converse back</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*dY28IYYt1b_0iuxtpxeDng.jpeg" /><figcaption>Here, Jeff and I worked on landscaping code together</figcaption></figure><p>But even if it could talk back, the reality of it is that in the field I was in, folks were generally expected to be <a href="https://en.wikipedia.org/wiki/Vertical_integration">vertically integrated stacks</a>. We collaborated within the group (“Help me out with this?”), and outside of the group (“Sure, use the simulation platform we built”), but for the <em>most</em> part, we still did most everything on our own. We were responsible for generating initial conditions, implementing whatever physics we were exploring, running the simulations, analyzing the results, and then writing up the paper.</p><h4>Stronger Together</h4><p>In <em>some</em> ways, things are different now.</p><p>We still have a lot of the same ways of communicating, even if they’re wrapped differently — chat, email, face-to-face, forums. But now people are using them a lot more, at least in the crowds I circulate in. At any given moment, there are a couple dozen folks on the <a href="http://yt-project.org/">yt</a> slack — and they don’t <em>just</em> talk about yt, but things related to computational astrophysics, things they’re interested in, things that might create new collaborations or even new friendships. I remember the dawning of this time, when these communities started forming; yt was a bit late to the game, but we found our way to IRC, to email lists, to in-person meetings.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O-HmbOIrHqSwptxauAb4sA.png" /><figcaption>Remember when CIA.vc still existed?</figcaption></figure><p>I’m increasingly starting to think that communities that start like this, where people come together for a particular <em>thing</em>, for a particular <em>task</em>, have the ability to grow and to expand. I started to realize this when I began to evaluate my relationship with the communities I frequent — what I expect from them, the interactions I have in them, and even the way that I rely on them. Even the communities that started for one purpose can expand, can meet additional needs.</p><p>When I want to know “Anybody know the latest work on synthetic observations of the <a href="https://en.wikipedia.org/wiki/Warm%E2%80%93hot_intergalactic_medium">WHIM</a>?” I know where to go, who to ask, and I don’t feel like I am disturbing them. If I am speculating about how to execute a complex version control maneuver, I know where to go. And people share information about new papers, upcoming conferences and events, and just idle chit-chatter. I have built social capital in these communities.</p><p>Even if researchers are still vertical stacks, maybe they can find other vertical stacks they can talk to. Having a space where tools, understanding and information can be shared is an enormous value for <em>everyone</em>.</p><h4>Overturn Power Structures</h4><p>When I was in college, I used to think about “interest-oriented” communities. Usually I lurked in these, but I’d follow forums about things that I was interested in — miniature gaming, science fiction shows, typesetting and font fandom, that sort of thing. The thing is, though, this type of self-selection has a tendency to lead to pretty homogeneous “communities.”</p><p>And with the communities that I want to be involved in now, that’s the type of tendency we need to defend against. I’ve just spent a thousand words talking about how things used to be worse, and how pleased I am that now, for <em>me</em>, they’re better. That is not enough. These communities can’t just be a transplant of power structures, providing support for the already-supported. For these communities to be a step forward, they must challenge the power structures that inspired their development.</p><p>We must diversify because it’s the right thing to do. Yes, pragmatically, <a href="https://www.scientificamerican.com/article/how-diversity-makes-us-smarter/">it</a> <a href="http://www.mckinsey.com/business-functions/organization/our-insights/why-diversity-matters">makes</a> <a href="https://insight.kellogg.northwestern.edu/article/better_decisions_through_diversity">us</a> <a href="https://www.ncwit.org/sites/default/files/resources/impactgenderdiversitytechbusinessperformance_print.pdf">more</a> <a href="http://www.usatoday.com/story/tech/columnist/2015/07/21/why-diversity-matters-your-tech-company/30419871/">effective</a>. But using that as motivation is worth challenging in depth, as in this <a href="https://modelviewculture.com/pieces/how-to-uphold-white-supremacy-by-focusing-on-diversity-and-inclusion">fascinating article</a> at Model View Culture; assimilation is not the same as liberation, and being in a truly diverse community means giving up dominance. And furthermore, it’s <em>hard</em>, especially with intersectional diversity (<a href="https://modelviewculture.com/pieces/intersectional-approaches-to-diversifying-the-tech-sector">MVC again</a>).</p><p>But, it’s the right thing to do.</p><p>If something doesn’t change, and change quickly, these communities that I am so happy about, that I feel such honor to see grow and form, will simply reinforce existing power structures. If they end up just being a place where I can hang out with people just like me, then the “value” they provide is not worth it. It will be an over-correction from <em>isolation</em> to <em>exclusion</em>.</p><h4>Do the Work</h4><p>Here’s my challenge to myself: expand. I challenge myself to help make my communities more diverse; I should do this not because it makes them better but because it is an <em>inherent moral obligation</em>. That means they will be uncomfortable at times; distinguishing inclusion from assimilation requires discomfort for the group that has traditionally been in power.</p><p>It’s time to be humble, to invite, to engage, to listen and to learn, and most importantly to experience that discomfort.</p><p><em>Thank you to Safia Abdalla, Nathan Goldbaum, Meghan Kirkpatrick, August Muench, and Greg Wilson for reading and providing feedback on a draft of this post.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a3ebd97e050c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Citations, credit, and the yt method paper]]></title>
            <link>https://medium.com/@matthewturk/citations-credit-and-the-yt-method-paper-1034e4080eb?source=rss-3c8be61d760b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1034e4080eb</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[yt-project]]></category>
            <category><![CDATA[scientific-software]]></category>
            <category><![CDATA[publishing]]></category>
            <category><![CDATA[academia]]></category>
            <dc:creator><![CDATA[Matthew Turk]]></dc:creator>
            <pubDate>Wed, 14 Dec 2016 19:15:54 GMT</pubDate>
            <atom:updated>2016-12-14T19:15:54.217Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p><em>This is an edited and somewhat rewritten version of an email I sent to the yt </em><a href="http://ytep.readthedocs.io/en/latest/YTEPs/YTEP-1776.html"><em>steering committee</em></a><em> a few months ago. At the time, I mentioned that I’d written something up about software citation (from the perspective of a project creator/developer) and some folks expressed interest, so I’ve edited it and put it here; the postscript at the end explains some actual next steps which are a bit removed from the idealistic next steps in the main body.</em></p><p><em>Additionally, when I wrote this piece, it felt like one of the more important things on my agenda. Since that time, it has languished in draft state as I couldn’t bring myself to finish it up; instead, since the second week of November I’ve mostly been descending into obsession over the fractally horrific nightmare from which it is impossible to wake.</em></p><p>A couple months ago, I posted an article that touched on <a href="https://medium.com/@matthewturk/the-royal-we-in-scientific-software-development-9deea495b3b6">some issues around credit</a> in software projects. I can’t get it off my mind. After an unexpected, extended conversation with one of the Data Curation Specialists at UIUC, Elizabeth Wickes, where she shared with me some of the intricacies of DataCite metadata and citation practices, I decided it was time to take some action. I’m going to frame this discussion in the context of <a href="http://yt-project.org/">yt</a>, since that’s the project that I’m the most deeply involved in, but there’s a possibility it’ll apply elsewhere.</p><p>In recent memory, there has been no shortage of discussion about how to handle citation of software in the scholarly record. Look no further than the extensive discussions at the FORCE11 <a href="https://www.force11.org/group/software-citation-working-group">Software Citation Working Group</a> (and the <a href="https://peerj.com/articles/cs-86/">affiliated paper</a>) or initiatives and journals such as <a href="http://openresearchsoftware.metajnl.com/">JORS</a>, <a href="http://joss.theoj.org/">JOSS</a>, <a href="http://wssspe.researchcomputing.org.uk/">WSSSPE</a>, <a href="https://impactstory.org/">ImpactStory</a>, <a href="http://depsy.org/">Depsy</a>, and so many others, to see the outstanding contributions both prescriptive and descriptive around citations and citation principles for software. Almost all of these revolve around the fundamental concept of identifying and entity-izing what constitutes a piece of “software.”</p><p>The approach we took with yt doesn’t predate <em>all</em> of these efforts, but it certainly predates my awareness of them. In 2010, a few of us wrote up a “method paper” that described the algorithms, motivation behind design decision, some things I thought were innovative or novel at the time, and so on, and this was published in early 2011. At the time, we had relatively few contributors to the yt codebase, and I decided to include seven individuals on the paper’s author list. (At present, of those seven, three remain on the <a href="http://ytep.readthedocs.org/en/latest/YTEPs/YTEP-1776.html">yt steering committee</a>.) In the nearly six years since that paper was published, it remains our primary method of citation, despite the fact that our community has grown to over 100 contributors. The number of data formats that yt supports has grown to several dozen, the entire underlying data system has been refactored, and we’ve expanded functionality in so many ways. And the reason we haven’t published a new paper is simple: it has not been pushed by the community leaders (including and especially me). The position that puts us in is that the definitive citation for yt includes a minority (by count <em>and</em> by volume of contribution) of the developers and community members.</p><p>This situation <em>needs</em> to be remedied. We want people to <em>be </em>recognized for their work, and to <em>feel</em> that they are recognized.</p><p>We identified a couple criteria for “fixing” the problem of credit for contributions to yt.</p><ul><li>Support our community members.</li><li>Don’t rely on an <em>intentionally</em> temporary solution. If we do this, let’s not do it in a way we already know we’ll have to redo.</li><li>Be a little aspirational. We can temper our goals with reality, but let’s also try to be a bit optimistic.</li></ul><p>How do we do this?</p><h3>Support the Community</h3><p>Academia is — at least, at present — built around a citation economy. The citation is a one-bit signal emitted by a paper or an author to indicate … well, to indicate one of a number of things. These signals get collected and drilled down into a couple numbers — citation count, h-index, etc. Despite their deeply problematic and reductionist nature, these metrics are used to measure things like impact, and in the case of citation targets that are proxies for software tools, they are used as a measure of the utilization of a piece of software. (Citing software itself is an interesting point I will return to below, but for our purposes I feel that without additional changes, it’s a distinction without a difference.)</p><p>The way that yt has been used up to the present, though, includes a dangerous breaking of symmetry. If someone hears, “Person A works on yt” it’s very easy to go to Person A’s “official” list of works and <em>not</em> see the yt method paper on that list. On the other hand, it’s also quite easy to go to the yt method paper and see the list of things its been used in. We’ve attempted to mitigate this asymmetry by building a “<a href="http://yt-project.org/members.html">membership</a>” system to recognize contributors to the project (both code and non-code), but this is not sufficient. The people who are a part of the community need some “official” recognition as well.</p><p>The primary developer community of yt is drawn from astronomy (although we have ambitions on broadening), which brings with it one of the greatest benefits possible: the <a href="http://adsabs.harvard.edu/">SAO/NASA Astrophysics Data Service</a> (ADS). This is <em>the</em> digital library for astrophysics; you can log on, search, and find everything. Most importantly for metrics fans, it also provides a <em>citation count</em>. If you search for an author, it lists the citation counts of each paper; when you’re on the page for a paper, it tells you how many times it has been cited. (Here’s the <a href="http://adsabs.harvard.edu/abs/2011ApJS..192....9T">yt method paper</a> page. Note that the Google Scholar page <a href="https://scholar.google.com/citations?view_op=view_citation&amp;hl=en&amp;user=QTmv2p0AAAAJ&amp;citation_for_view=QTmv2p0AAAAJ:9yKSN-GCB0IC">for the same</a> gives a slightly different citation count.)</p><p>In an ideal world, what we want is to be able to say, for every published paper that used yt, which <em>version</em> of the software was used — this is useful from the perspective of ensuring reproducible and replicable science, but for our purposes, the most important aspect of this clarity is that it describes <em>who contributed to that version</em>. In this ideal world (where, incidentally, they have <a href="https://en.wikipedia.org/wiki/Songs_from_the_Black_Hole">all</a> <a href="https://en.wikipedia.org/wiki/Smile_(The_Beach_Boys_album)">the</a> <a href="http://www.maximumfun.org/dead-pilots-society/episode-2-only-child-written-john-hodgman">best</a> <a href="http://io9.gizmodo.com/5569986/more-details-about-shane-carruths-next-mind-bending-film">stuff</a>) everyone would receive cumulative credit for their contributions — all papers that cite a version <em>or later</em> would show up in their citation count and metrics. As it stands, not only do most of the contributors to the yt ecosystem <em>not</em> get credit, but this preferentially hurts the more vulnerable members of the community: the early-stage researchers, such as graduate students and postdocs, and <em>especially</em> those who have provided <a href="https://www.ashedryden.com/blog/the-ethics-of-unpaid-labor-and-the-oss-community">“free” labor</a>.</p><p>So here is what we want: people to be added to a list of contributors, and for their metrics to <em>reflect </em>that. Goal identified.</p><h3>Avoid Stopgaps</h3><p>The obvious answer, which was suggested by a surprising number of people, was to simply write another method paper. Publish another one, add everybody who was an author, then suggest everybody just start citing that one instead of the old one.</p><p>This is a fine idea from the perspective of contributing to the scientific record; publishing a paper allows not just a new citation bucket, but it also facilitates communication about algorithms, implementation details, and motivation. This goes beyond the intellectual contributions of the implementation; in some ways, the process of describing and publishing a paper is a process of curation, of adding metadata, and of providing context for the code. Publishing a new method paper is <em>important</em>.</p><p>Unfortunately, it won’t “fix” the problem we’re trying to fix. All it does it kick it down the road, so that we can deal with it again in another couple years, assuming the project makes it that far.</p><p>The same is true of many software publishing systems — publishing a chunk of code and making <em>that</em> the citation bucket is not going to improve the situation unless we have some method for allowing others to get a part of that citation bucket. In fact, it might even be worse at this point: having a large set of authors on a new citation bucket, all of whom are getting credit, might be <em>more</em> of an impediment to distributing credit to newcomers than having a relatively small number of authors. The perceived marginal gain is very small, comparatively.</p><h3>A Brief Diversion into DOIs</h3><p>Just about everywhere I go, people talk about DOIs. DOIs are <a href="https://www.doi.org/">Digital Object Identifiers</a>; think of them as <a href="https://en.wikipedia.org/wiki/Digital_object_identifier">unique IDs that carry metadata</a>. These IDs are persistent, citable, and they carry an enormous about of information with them. For instance, through <a href="http://citation.crosscite.org/docs.html">some fun APIs</a> you can even get back information about relevant datasets, if that information is part of the record.</p><p>A few dangerous topics come up when DOIs are discussed, though. For starters, be wary when someone says that a getting DOI means that whatever it points to is suddenly, magically <em>permanent </em>or <em>published</em>. The second thing is that DOIs are valuable for citations, but they are only as valuable as the method by which citations are tracked. And the third danger, which I fall into myself, is that DOIs are viewed as adding <em>prestige</em> to an object, rather than a future-proof reference. What DOIs certainly do, however, is to provide a record that <em>this existed</em>, even if it doesn’t anymore, and for that to be remembered.</p><p>As an example, if I have a DOI for a dataset (issued by <a href="http://datacite.org/">DataCite</a>) and I cite that in my paper, that citation is only tracked if both the journal and the citation tracking agency register that information. If someone cites a DOI registered in DataCite, but that DOI either doesn’t show up in Google Scholar or ADS or isn’t tracked by the journal, it might as well have been a tree falling in a lonely forest. And, how DOIs are cited and formatted in journals takes on many different forms: do they exist in the narrative, in footnotes, in the bibliography?</p><p>This is important to keep in mind: in the practical world where we need to be true to our community members, and they only care about ADS-tracked or Scholar-tracked citations, it doesn’t really help matters too much to ask folks to throw citations into a void. And as of right now, I am told that the ADS and Google Scholar do not harvest the DataCite DOI metadata and data repositories.</p><p>One important note: the metadata for DOIs at DataCite also includes items such as relatedIdentifier, which can provide semantic information about relationships to other DOIs via attributes such as IsNewVersionOf and IsPreviousVersionOf. Parsing these for a canonical set of citations to a given item would require recursive calls to the metadata resolution API, which seems unlikely. There’s further discussion of this by the <a href="https://github.com/force11/force11-scwg/issues/157">FORCE11 SCWG</a> but I believe we need to have an approach that is flatter (fewer sets of recursive linkages) and that more directly addresses the issue of person-to-software linkages, rather than paper-to-software.</p><h3>We Can Aspire to More</h3><p>“But,” you say, “maybe the world isn’t ideal, and we should hope that it’ll get better?”</p><p>And, I agree!</p><p>The community is changing rapidly; for instance, in astronomy the American Astronomical Society has recently issued a statement about <a href="http://journals.aas.org/policy/software.html">papers relating to software</a>. This is great news!</p><p>But let’s take it a step further. Isn’t there something we can do, that meets all of these needs? That we can add new people to? That can track citations across all time? That is recognized by the places people refer to, so that hiring and tenure committees can see it?</p><p>Kinda seems like the answer is “no,” to be honest.</p><h3>So what do we do?</h3><p>I’m glad you asked that! After looking through all of our options, and that serendipitous conversation with <a href="http://orcid.org/0000-0003-0487-4437">Elizabeth</a> that I alluded to up at the top, we’ve identified a potential solution. It’s a solution that doesn’t quite pay off yet, but which seems like it <em>will</em>, eventually, and meet the needs we have identified. The DataCite metadata for a registered DOI includes the ability to expand the set of “contributors” for a given record, and updating the metadata is a distinct operation from updating the content. (More discussion of this notion of a group that changes over time can be found over at <a href="https://danielskatzblog.wordpress.com/2016/04/17/to-better-understand-research-communication-we-need-a-groid-group-object-identifier/">Dan Katz’s blog post</a>.)</p><p>Here is my proposal for how to distribute credit to yt contributors:</p><ol><li>Create a DOI for yt through our Library. Set the creator field of the DOI record to be “The yt project” and the landing page to be the <a href="http://yt-project.org/">yt homepage</a>.</li><li>Provide supplemental metadata: every contributor to the code base, the documentation, community. These will be listed under the “Contributors” metadata element. While this includes the option to specify a wide variety of roles (see also <a href="https://orcid.org/blog/2015/08/11/contributor-recognition-update-orcid-project-credit-and-contributorship-badges">Project CRediT</a>), we will likely not utilize these. These records can include <a href="http://orcid.org/">ORCID</a> IDs.</li><li>With a regular cadence, and in collaboration with the Library, update the Contributors metadata element.</li><li>Strongly encourage <em>all</em> citations of yt to be made to this DOI. (<em>But actually! See below!)</em></li></ol><p>This isn’t perfect. The DOI will be registered with DataCite; as I noted above, DataCite isn’t currently ingested by either Scholar or ADS. There’s good reason to think that this is going to change, some day, or that there will be alternate methods for measuring impact that <em>will</em> parse DataCite.</p><p>There are two different fields we can utilize in the DataCite metadata to encode information about individuals that have been a part of, and should receive credit for, the software. The first is the Creator field, and the second is the Contributor field. The Creator field is what is typically thought of as the “author” field, and is typically thought of as the “author.” But for a large community project, what should this field in fact be, and how can we future proof it? I would strongly encourage this field to simply be the name of the project itself; rather than electing one or a set of representatives, it makes more sense to have it be a neutral, community-focused name. The Contributor field, on the other hand, provides a natural destination for everyone who deserves credit for having <em>contributed</em>. This is where we should put names.</p><p>But, this brings up odd issue that the contributors field is <em>not</em> thought of the same way as the creator field; does that mean that the DOI record won’t show up when a search is conducted for a person who is only listed under contributor? I don’t know. But I don’t think it’s an unreasonable hope. And it still leaves an open problem: this intentional attempt to flatten the hierarchy of contributions may dilute credit across the community. I feel that, right now, the benefits of doing so outweigh the drawbacks. And, we’re doing this <em>manually</em>, in collaboration with experts in the field of data curation. With the shifting ecosystem of credit and citation, this will provide us with the opportunity to collaborate, identify and potentially even migrate the DOI itself to a better or emerging environment or metadata standard.</p><p>From a personal perspective, I’m convinced this is the right way to go. It’s simply unworkable, immoral, and negligent not to more broadly distribute credit among the community members who have propelled yt to its current state.</p><p>It’s simply <em>wrong</em> not to take a new path, and it’s a <em>wrongness</em> that hurts some more than others. So let’s do it, or let’s figure something else out, but let’s not let things stay where they are.</p><h4>Postscript: We Take a Few Steps Back</h4><p>I wrote this post largely in isolation, following on discussions among a number of people from the community and the yt steering committee. After sharing it, and asking for feedback, the point was made to me that there’s a big distance between where we <em>are</em> as a community and where we want <em>to be</em>. And because of that, we need to compromise, and maybe hedge our bets a little bit.</p><p>So we’re adding on a bullet point: we will be writing a new method paper, and reasonably soon, and as part of a transition, we’ll be requesting dual citations of the new method paper and of the software DOI. And then, once the technology has caught up (and it is likely to take longer than a standard postdoc job application cycle) we will revisit.</p><p>One of the harshest — and most useful — pieces of feedback I got was that the ideal that I pushed for in here is actually not really going to “get what we want,” which also included pointing out that it would be incredibly easy to “game.” That’s true. It’s not going to get what we want, and it will be very easy to “game,” but I think it’s still worth trying, so I want to keep that option open, and maybe even explore it.</p><p>But for now, on to the method paper!</p><p><em>Thanks to Britton Smith, Elizabeth Wickes, Daniel S. Katz, August Muench, Nathan Goldbaum, Carly Strasser and Heidi Imker for their comments, suggestions and guidance on a draft of this post.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1034e4080eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Foolishly Consistent Software Libraries]]></title>
            <link>https://medium.com/@matthewturk/foolishly-consistent-software-libraries-f67e1dc567d7?source=rss-3c8be61d760b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f67e1dc567d7</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[scientific-software]]></category>
            <category><![CDATA[yt-project]]></category>
            <category><![CDATA[academia]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Matthew Turk]]></dc:creator>
            <pubDate>Tue, 25 Oct 2016 16:59:54 GMT</pubDate>
            <atom:updated>2016-10-25T16:59:54.424Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p><a href="http://third-bit.com/">Greg Wilson</a> is fond of pointing out that most (or all) programming languages don’t undergo A/B testing for usability. Decisions about how to express computation aren’t evaluated at the same level as, say, usability inside a GUI, or studied with the same rigor as how to maximize clicks on an advertising-driven website. For people who are able to expend the effort to become familiar with, or even experts at, a given programming language or paradigm, this is not necessarily a show-stopping problem; once the initial effort to reach familiarity has been reached, there’s something of a valley of utilization. Once I’ve learned that whitespace delimits loops in Python, it becomes second nature; once I’ve learned the some of the idiosyncracies of Javascript, I can muddle my way through tasks in that language.</p><p>This is particularly relevant for individuals whose primary output isn’t in code or programming, but instead in the utilization of that code for another purpose. In domain sciences that rely heavily on computation, the measured impact of research is almost exclusively through byproducts (papers, results, posters, etc) of software development. This is true for undergrads, students, postdocs, and even professors. Impediments to “getting started” with a new language pose significant challenges to researchers that are earlier in their education or careers, and disproportionately so. While earlier-stage researchers may be equipped to learn new languages and paradigms rapidly, the distance between “starting” a project, picking up a new language or library, building the software, and then “finishing” the project by producing some scientific output, can seem especially large.</p><p>Frontloading a research project with frustration is a pretty harsh thing to do to somebody. And yet, it happens, over and over again. Hand somebody a piece of opaque, unfamiliar code and say “Get to it!”, or tell someone who has only ever studied Python that they need to pick up Haskell, or even suggest that someone construct a “web portal” to a piece of research software — the result is typically the same, with frontloaded frustrations that disproportionately affect the more vulnerable party in the relationship.</p><p>But that’s a bigger problem, one that I’ll <em>happily</em> leave to Greg to solve. I’ve been thinking lately about how this “lack of design” in programming languages intersects with the way we construct software <em>libraries</em>. More specifically, I’ve been wondering to what extent software developers, particularly in scholarly or scientific software, should embrace existing ecosystem-wide idioms (potentially in flagrant violation of usability concerns) or forge new paths that follow “best practices.”</p><p>Just how foolish a consistency should we seek when writing libraries to be used by students and colleagues?</p><p>I’ll give a concrete example: <a href="http://www.numpy.org/">NumPy</a>. In many — most, even — I adore NumPy and its syntax. Once I understood the basics of how NumPy thought about arrays, indices, and numbers, I was able to build so many useful things out of it. What I’ve never really done, though, is found a satisfying way to explain it, or to teach it. (I should note at this point that many others have; I’ve heard stellar reviews of NumPy tutorials and instruction from around the world. I’m merely saying that <em>I</em> have not yet found my footing with teaching it.) It’s from this standpoint that I begin to wonder, if I build a library that uses NumPy, that extends it, should everything in it be NumPy-like? If I find something about NumPy that is awkward, or that causes confusion (for instance, the reasoning for distinguishing between using array-methods and top-level functions) is that a flaw to paper over? Or in developing a library, should a new methodology be struck?</p><p>This isn’t an entirely hypothetical question. A few weeks ago, I instructed at a workshop called “<a href="http://yt-project.org/workshop2016/">Learn yt</a>” at the University of Illinois. This was an intensive, three days workshop featuring structured examples, worked data analysis tasks, visualization, and hands-on tutorials. (I was honored to work with Nathan Goldbaum and Jill Naiman in organizing it.) One of the things I featured in one of my first lectures was a new feature in the most recent release of <a href="http://yt-project.org/">yt</a>: the “numpy-ish” mode for <a href="http://yt-project.org/docs/3.3.1/analyzing/objects.html#slicing-syntax-for-selecting-data">selecting</a> and <a href="http://yt-project.org/docs/3.3.1/analyzing/objects.html#quickly-processing-data">operating</a> on data.</p><p>A bit over a year ago, there was a “<a href="https://bids.berkeley.edu/news/data-structures-data-science-workshop-exploring-common-data-structures-across-programming">Data Structure 4 Data Science</a>” workshop at the <a href="https://bids.berkeley.edu/">Berkeley Institute for Data Science</a> (BIDS). At this workshop, I learned about some syntactic sugar in libraries like xray (now <a href="http://xarray.pydata.org/en/stable/">xarray</a>), and I was inspired. For years in yt we’ve had “derived quantities” — things like “maximum value,” “total quantity” and so on. These were hidden behind a .quantities object, which abstracted out parallelism, irregular data, geometric and non-spatial selection, and so on. To access them, you would do something like data_obj.quantities.max_location(“density”). And to make a data object, you’d usually construct it out of something like a region or sphere or a slice.</p><p>What we ended up putting into yt had two pieces of functionality, both inspired by NumPy. The first was a RegionSelector, a little object that hung off a 3D dataset (or in yt parlance, a ds) that could accept slice syntax for selecting data inside the object. A slice has three components: the start, the stop, and the step. When the __getitem__ method in Python is called with a slice, it receives the slice object itself; if multiple are supplied (comma-separated) they will be provided in a tuple. We used that to build the RegionSelector. You could do things like:</p><p>ds.r[:,:,:]</p><p>to get everything in the dataset. Or, you could select by using unitless index-space coordinates with respect to the dataset edges:</p><p>ds.r[ 0.1:0.9, :, 0.4:0.45]</p><p>And since yt has units deeply embedded in its indexing system, we could even do this with unitful operations:</p><p>ds.r[ (10.0, “miles”):(20.0, “miles”), (31.3, “cm”):(49.4, “cm”), :]</p><p>The second piece of functionality that ended up in yt was a set of NumPy-like operations that operated on data objects, that in many ways could “mask” the usage of quantities, and make them a bit more obvious. For instance, we added .max() to an object, and it accepts a field to find the max of:</p><p>data_object.max(“density”)</p><p>And we implemented things like argmax, min, mean and so on, as well. And, I like this stuff. It felt like a more natural way to express data selection and manipulation operations. When I was teaching it, it felt appropriate.</p><p>But then, and I take the blame here, I started to continue to follow this down a path. If these syntactic improvements were good, could we extend them a bit further?</p><p>One of the things that folks love to do with yt is to take their irregular, non-uniform data, and then turn it into a regular grid of values. Given a left edge and a right edge, there’s an obvious free parameter: the number of cells in each dimension. This is an awful lot like how NumPy does <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.mgrid.html">mgri</a>d, which is one of my absolute favorite things that NumPy does. You can slice mgrid to get regularly-spaced values between bounds, and it works in multiple dimensions. You can construct an array like this:</p><p>arr = np.mgrid[0.1:0.9:0.01]</p><p>This will return an array starting at 0.1, ending at 0.9 (non-inclusive) and updating by 0.01. It’ll work in multiple dimensions, too, returning multiple arrays all organized consistently. But if you supply it a <em>complex</em> argument for the “step size” of the slice, instead of a real value, that will be the number of steps that the grid will take. (And the bounds become inclusive.) So you can instead do:</p><p>arr = np.mgrid[0.1:0.9:10j]</p><p>and the size of the returned array will be 10 elements. This isn’t necessarily obvious, though; and in fact, <a href="http://www.dictionary.com/browse/anecdata">anecdata</a> confirms that most people, upon seeing this for the first time, will have one of two immediate reactions: “I didd’t think mgrid would work any other way” or “What’s that j doing?” The j is the signifier of a complex value, which gets overloaded here, but there’s no obvious reason that this should be the case. It’s shorthand — convenient shorthand, but shorthand nonetheless — that takes advantage of a meaningless or invalid construction (“Complex step size?!”) to provide another simple yet useful means of expressing something.</p><p>So we implemented this in the RegionSelector object in yt; now, you can supply a complex argument for the step size, and it will know to return a regularized grid with that many elements. I can get my entire domain turned into a 256-on-a-side grid just by doing:</p><p>ds.r[::256j, ::256j, ::256j]</p><p>This is where things start to break down. The RegionSelector is now conceptually consistent with mgrid. But, mgrid is <em>intentionally</em> inconsistent with the rest of Python, using the “step size” part of a slice to communicate something other than the actual step size.</p><p>When I reached the part of the workshop where I wanted to teach this, which honestly was something I was really quite proud of, I realized: there are at least three layers of complexity here, and each one is going to have to be unpacked. If someone were coming from a position of familiarity with NumPy, of knowing not only that jas a numerical suffix means “complex” but that mgrid accepted complex numbers to indicate number of zones, they would be set up to understand what we’re doing. But, if they didn’t, they’d have to learn each of those concepts before proceeding to using the RegionSelector in this way. And that’s a barrier to entry, and one that disproportionately affects people who are new or earlier in their careers; these are the very people that are crucial to the success of a community-focused software project.</p><p>Where’s the dividing line between following a logical, internal consistency, which may be counter-intuitive for new learners, and developing a new method of expression? What is the buy-in cost that is too high to follow a consistent design, even if that design is non-intuitive? Who do we want to optimize for?</p><p>But really, the question I want answered: is there evidence that can help us guide our design, to help us understand when we should be designing for consistency? Is there evidence that suggests that internal consistency is more easily comprehended in some cases than others? This cost-benefit analysis is fascinating and troublesome to me; integrating into an ecosystem and emulating its norms can “jumpstart” the mental model for a software project.</p><p>But by breaking away from external influences, a new dialect can be built, a new mindset and mental model provided. How can library developers find the right balance between the two?</p><p>As for the “worked example” above, I’m still a bit torn. I really like using it, but if I’m the only one who ever does, is it really worth it?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f67e1dc567d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Royal “We” in Scientific Software Development]]></title>
            <link>https://medium.com/@matthewturk/the-royal-we-in-scientific-software-development-9deea495b3b6?source=rss-3c8be61d760b------2</link>
            <guid isPermaLink="false">https://medium.com/p/9deea495b3b6</guid>
            <category><![CDATA[academia]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[scientific-software]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[yt-project]]></category>
            <dc:creator><![CDATA[Matthew Turk]]></dc:creator>
            <pubDate>Thu, 21 Jul 2016 19:13:46 GMT</pubDate>
            <atom:updated>2016-07-21T19:13:46.087Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p><em>Or: A challenge to myself (and maybe others) to change how we represent community software development</em></p><p>There’s a delusion in academic software development: that there exist brilliant people who don’t need the help of others. This delusion says that these people operate in isolation, that they carry the sole responsibility for their projects, that they are pulling strings, architecting. This delusion says that the only valuable contribution is innate intelligence, that the “idea” is the only metric by which individuals can be valued.</p><p>This delusion is insidious not only because it is self-perpetuating, but because it so blatantly favors the people who are the face of the work and the public contributions that are easily measurable, like source code commits. And some of us benefit from that more than others.</p><p>I’m enormously fortunate. As part of my work, I have had the opportunity to engage my passions for problem solving, for communicating, for following my scientific curiosity, for pursuing my creative urges, for coding, for visualizing, and for getting to do it with some of the most brilliant, insightful, warm, kind and creative people I could ever hope to meet.</p><p>Some of these opportunities have come however, because I do work that is easy to assign credit and value to.</p><p>I’m proud of the work I have done. About ten years ago, I wrote the first line of code in what is now a reasonably (but not overwhelmingly) well-used piece of software in the astrophysical community called <a href="http://yt-project.org/">yt</a>.</p><p>In the time between then and now, there have been periods of time (and sections of the code) that I can largely take credit for the initial implementation, the design, and some of the debugging. And while I am proud of that work, there are numerous times when I have not contributed code, when I have not participated in the community, and there are many components — both modules and infrastructure — which did not come from me.</p><p>yt is both an application and a library, but much more the latter. It’s meant to be used to write scripts that conduct analysis or create visualizations, and to be extended to conduct more types of analysis and visualization. There are readers for data formats, indexing systems, derived product generation, analysis modules, visualization components, and many, many other components. Depending on the functionality they present and the level of abstraction at which they are found, they are of varying criticality to the overall software. Some, like “code frontends,” live at the top-most level, providing crucial functionality for individuals loading data, but which don’t have a large degree of interconnectedness. Others, like the array system, or the selection system, are deeper into the code base and are called more frequently. This does not make them more important.</p><p>Code is not the sole metric of a successful project. In fact, it might be one of the worst metrics. It’s a problematic metric in a lot of ways, but I would highlight two in particular: it’s incredibly reductionist (as well as difficult to measure accurately) and it favors far too strongly the “first movers” over the much broader collection of influences that guide and support a project. (For more on how this may disproportionately impact individuals from underrepresented and minoritized groups, see the incredible article “<a href="https://www.ashedryden.com/blog/the-ethics-of-unpaid-labor-and-the-oss-community">The Ethics of Unpaid Labor and the OSS Community</a>” by Ashe Dryden.)</p><p>The way individuals, particularly in science, engage with software does not start with a consummate reading of the code, or evaluation across many different technical metrics. It begins with discovery, hearing about software from a colleague, a competitor, from a website or a talk. This often leads to documentation, including advocacy and tutorials as well as both narrative and reference documentation. Often, installation or inspection come next, followed by following tutorials or examples, or interacting with a graphical interface. And this can then be followed up by engaging with the community, asking questions, suggesting or implementing changes, and perhaps even advocating in turn. In academia, many of these activities can be supported by grants or indirect funding, but oftentimes they are not — they are provided on a volunteer basis by peers. And amongst people developing or participating, there is often communication, personal and professional disputes to resolve, and even issues of governance and project direction.</p><p>If we only look at “who wrote this line of code,” we ignore all of these other aspects — aspects which are arguably far, far more important. People who took risks on unproven software, who advocated for it, who contributed ideas, bugs, corner cases, documentation, who instructed students and cited it in papers, and who supported it in so many difficult to quantify ways.</p><p>And even worse, if we delude ourselves that the technical merits of a project are typically tied to one or a handful of people, every other code contributor is immediately marginalized.</p><p>There are people in the <a href="http://yt-project.org/community.html">yt community</a> who simply do not get recognized for the incredible amount of work that they do. This work isn’t always in the form of code, although that does play a large role. It’s in their advocacy, their training, their devotion to producing something we can all be proud of, that I see their dedication.</p><p>This article didn’t come out of nowhere; in fact, I confess that I am writing this because I am trying to make amends for some recent failures. I was discussing this with someone recently, and they said something that I think is incredibly astute. It was in the context of a couple comments that I made that overplayed my contribution, where I bought into the idea that code was supreme. To be honest, I am intensely embarrassed. It is something I should have known, something I should have recognized, and something I should have worked against. Paraphrasing:</p><blockquote>“Like it or not, people look to you when they think of the project. As such, it falls on you to make it clear that we are not just helping you. You know what people think every time you say ‘we’ did this.”</blockquote><p>They’re right. And what’s more, when I don’t explicitly reject this perception, I am subtly reinforcing it. As the person who has this role, I have to elevate the perception of the contributions of others, because I’m the one who benefits when they aren’t elevated. It is inappropriate to let others think I am using the “royal we” when I talk about the code, and this requires actively addressing that perception.</p><p>If you’re reading this, and you are part of a collaboration around scientific software, I challenge you to think very carefully about how you present your involvement. Too often I have been cavalier in that presentation. I’ve allowed an implicit assumption of the audience that I am the responsible party to be unchallenged, if not reinforced. I’ve shown names, but not faces, or I’ve shown names without calling them out. And the people that have suffered as a result are the ones who are the most crucial to the community’s success. They are the people I consider myself grateful to work with, and I owe it to them to steward them as best I can.</p><p>Before you use the royal “we,” I challenge you to think about it. I challenge you to present your role explicitly and say what you have been involved with, rather than presenting it in an undifferentiated way. Perhaps most importantly, don’t function under the mistaken belief that credit is a zero-sum game, where giving it to others diminishes your own role.</p><p>I want to end by recognizing many of the contributors to yt who have contributed in so many different ways. yt has a model in place for recognizing contributions that go beyond code; individuals can be designated “members” of the project to indicate that they have been recognized by project peers as having made substantial contributions to the project. An alphabetical list of these people can be seen <a href="http://yt-project.org/members.html">on the website</a>, although even this does not tell the complete story. And I would like to take this time to say thank you to both the members of the project as well as everyone who has contributed time, thoughts, code or communication.</p><p><em>[Thank you to Britton Smith, who was instrumental in the development of the thoughts behind this essay, and in the development of the yt community as a whole. I’d also like to thank Tracy Teal, Carly Strasser, Titus Brown and Ethan White, who provided feedback on a draft of this article.]</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9deea495b3b6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>