Scholars' Lab

At our final official Praxis meeting, I shared an overview of my experience as project manager with the rest of the team, and I thought I would share some of those same reflections in a short series of blog posts.  This first post reflects on some of the more technical and organizational aspects of project management. 

  Early on, I read Sharon Leon’s piece about project management, and these reflections follow much of her conversation.  As Leon discusses, the PM is responsible for the delegation of roles and tasks, the allocation of resources, establishing a work plan and a time line, and developing a method for tracking progress and the completion of tasks.  In addition, the PM needs to be able to articulate the vision and goals of the project, distinguishing between primary deliverables and those that are secondary.  

Rather than deciding on a set of goals and then assigning people to different roles, in the case of Praxis, these processes happened in tandem.  As each of us gravitated toward certain roles, it became more clear which deliverables would become prioritized and which would be secondary.  To help keep myself focused, I drafted a very general project vision statement and, at Bethany’s suggestion, collected statements from the other Praxisers about their goals for the semester.  

This left me with the job of laying out the calendar and work plan for the semester.  As I blogged about earlier, this was a really daunting task for me given that I am still new to the DH world and did not have the skills to conceptualize how all the pieces fit together.  From that process, however, I have learned that PMs do not need to know every detail of how the project will go from the outset.  Rather than feel uncomfortable with my lack of knowledge, I started to see how I was surrounded by a team of knowledgeable consultants who could assist me in figuring out the relevant information needed to coordinate different aspects of our project. 

When it came to the calendar, I basically just worked backward.  I started by establishing our launch date.  Then, in conversation with Wayne and Bethany, I worked to figure out the approximate dates when each task needed completion.  Leon and others recommend that PMs work with team members to establish deadlines and goals rather than just dictating them.  While this is a good idea (and something which I plan to try again in my next PM gig), it didn’t work so well for Praxis—mostly due to the fact that all of us were novices and not really sure how much time various tasks required.  I did, however, collect information from everyone with regard to their commitments over the semester.  I wanted to know when people would be leaving for the summer, when they would be out of town for a significant period, and if there were other commitments that might take time away from Praxis.  That information helped me to set up the calendar and to know when people were most and least available throughout the last few months. 

Although we did not have to worry about financial resources or the allocation of equipment or software, I want to say something briefly about time and space.  One of our most important resources has been the graduate lounge.  Often our best work happened when we were in that shared spaced for a good chunk of time.  Although the design team had regular weekly meetings, the rest of us were rarely in the lounge collectively.  Rather, we came in one by one when our schedules allowed.  As the semester quieted down, we found more time to be in the lounge collectively.   I am happily in awe of the amount of work and progress that we accomplished in the last three weeks of Praxis.  Had I known how valuable that shared time and space would be, I would have done more to institute habits of collective work meetings early

To keep track of progress, we used the issues tracker in github.  Deciding what counted as a task or a milestone was also difficult initially.  Personally, I found that it helps to have the project broken down into small enough parts that you can actually track progress from week to week.  If tasks are too large, there is little to check off of the “to do” list until the project approaches completion.  In the end, each of our core deliverables became a milestone to which a list of issues (or tasks) were attached.   I will have more to say about the articulation of tasks in my next post.

[Cross-posted from my personal site]

I’m delighted to announce that our proposed roundtable on the Praxis Network has been accepted for the 2014 MLA Convention. Here are the details:

Session Proposal
How can humanities programs better equip students for a wider range of careers, without sacrificing the core values or approaches of the disciplines? While not new, the question becomes more urgent as public funding for the humanities shrinks and the proportion of contingent faculty grows. Rather than see these pressures as threats, however, many programs see in them an opportunity to develop vibrant programs that take a broader view of possible methodological approaches, research products, and desirable career outcomes.

The participants in this proposed roundtable are all members of the Praxis Network, a new international partnership of graduate and undergraduate programs that are making effective interventions in the traditional models of humanities pedagogy and research. They represent programs that are embarking upon collaborative, interdisciplinary, project-based approaches to humanities education.

The Praxis Network features graduate programs at the University of Virginia, Michigan State University, CUNY Graduate Center, University College London, and Duke University, as well as undergraduate programs at Hope College and Brock University. By bringing together a collection of diverse programs that all aspire to similar goals of increasing the effectiveness of humanities educational practices and making their methodologies more widely applicable, we hope to spark ideas among institutions that are exploring similar initiatives. Each roundtable participant will give brief remarks to introduce their program, leaving substantial time for broader discussion and questions.

The partnership is one of three complementary projects in the Scholarly Communication Institute’s latest work on rethinking graduate education. A recent SCI study on the level of career preparation provided by graduate programs makes it clear that most graduates and their employers find that they do not gain many of the skills that are important in their professional environments—such as collaboration, project management, and communication with varied audiences—through their graduate programs. The Praxis Network provides a closer look at select programs that have taken unusual and effective approaches to addressing some of the issues that the survey uncovered.

Beyond preparing students for a broader range of careers, the Praxis Network programs also provide excellent models for the relevance of humanities scholarship in a changing public landscape. With federal and state funding for higher education facing tremendous pressure, making humanities scholarship meaningful to a much broader audience is critical. Fortunately, scholarly work is becoming increasingly available to a broader and less specialized public, whether through open-access journals, via blogs and personal websites, or as standalone digital projects. The programs in the Praxis Network address these two trends by encouraging students to develop public-facing projects that are accessible to non-specialists, without sacrificing disciplinary rigor. In fact, the students’ research output shows that encouraging students to think critically about their intended audience helps them to better grasp not only what is appropriate for the general public, but also what matters to their academic peers.

Humanities programs have the opportunity to better serve their students as well as the public by examining our core values and rethinking the methods we use to teach them. Increased public engagement is not only valuable to general audiences, but also healthy for academic disciplines and for individual graduates. Still, a great deal of work remains before humanities departments will commonly evaluate their success through outcomes other than tenure-track job placement. For wide-scale change to be possible, programs must find it valuable to equip students for varied careers in universities, libraries, cultural heritage organizations, non-profits, government offices, and more.

The programs in the Praxis Network show the tremendous potential of encouraging students to approach humanistic inquiry in new ways as the discipline moves toward embracing increased collaboration, meaningful public engagement, and an ethos of openness and exploration. Bringing together representatives of each program in a roundtable discussion will provide a fruitful opportunity for others in the humanities community to learn about the developments, to ask questions relevant to the goals and directions of their own institutions, and to spark new ideas for growth and change.

Participant Bios
David F. Bell, co-director of the Duke PhD Lab in Digital Knowledge, is Professor of French Studies at Duke University. His research focuses on nineteenth-century French literature and culture, including urban space and technologies of communication. He also works on the concept of tact as a discursive strategy, and on the notion of debt in French literature. He is the co-editor of SubStance.

Matthew K. Gold directs the Digital Fellows program at the Graduate Center, City University of New York, and holds joint appointments there and at the New York City College of Technology. Gold is an Associate Professor of English at City Tech, while his roles at the Graduate Center include Director, CUNY Academic Commons; Advisor to the Provost for Master’s Programs and Digital Initiatives; and Acting Executive Officer, MA Program in Liberal Studies. Gold recently edited a collection of essays related to the digital humanities, titled Debates in Digital Humanities. Other projects include “Looking for Whitman”, a multi-campus experiment in digital pedagogy sponsored by two NEH Digital Humanities Start-Up Grants, Commons In A Box, funded by the Alfred P. Sloan Foundation, and JustPublics@365, funded by the Ford Foundation.

Kevin Kee is Canada Research Chair of Digital Humanities and Associate Professor in the Department of History and the Centre for Digital Humanities at Brock University, where he also directs the Interactive Arts and Science program. Kee’s research focuses on the intersection of history, computing, education, and game studies, with a particular interest in the use of computing for innovative expressions of culture and history. Part of his innovative approach includes a strong emphasis on partnerships across the university and with the broader community; his development of the business incubator nGen enables a deep level of crossover between the two.

Cecilia Márquez is a PhD student at the University of Virginia’s Corcoran Department of History, and is one of the 2012-2013 Praxis Fellows. She became interested in the digital humanities through the South Atlantic Studies Fellowship for the Public Humanities, funded by the Virginia Foundation for the Humanities. Márquez’s recent work focuses on the experience of Latina/os in the American South during the Civil Rights Movement. Her research interests include African American, Latina/o, and Gender and Sexuality Studies.

Kelli Massa earned her MSc in the Digital Humanities Program at University College London. As a graduate student in the UCL DH program, Massa had the opportunity to take a variety of stimulating courses connecting the humanities with digital technologies. Entering the program with a humanities background (MA in Literature), she focused primarily on the computer science side of the program and pursued an MSc. Her internship with JISC (Joint Information Systems Committee) sparked an interest in academic software sustainability and repositories, which she plan to research for her dissertation.

William Pannapacker is Professor of English at Hope College and directs the Mellon Scholars program. His research and teaching interests include American literature and culture and digital humanities. Pannapacker is also a columnist for the Chronicle of Higher Education and a contributor to The New York Times and Slate, where he writes about a range of issues related to higher education in the humanities.

Donnie Sackey is a PhD candidate in the Writing, Rhetoric, and American Cultures department at Michigan State University, and a 2012-2013 Cultural Heritage Informatics Initiative Graduate Fellow. Through his dissertation research on invasive species, Sackey explores the relationship between rhetoric and the environment, as well as ways in which creative applications of information and computing technologies can help map environments and subsequently allow for alternative levels of engagement.

Katina Rogers researches graduate education reform and career paths for humanities scholars in her capacity as Senior Research Specialist at the Scholarly Communication Institute. Rogers collaborated on the development of the Praxis Network website and conducted a study of career preparation in humanities graduate programs. She has given invited lectures on her work on graduate education reform and alternative academic career paths at New York University, Stanford University, and the University of Delaware, and her work has been written up in the Chronicle of Higher Education and Inside Higher Ed. She holds a PhD in Comparative Literature from the University of Colorado, Boulder. Effective September 2013, she will begin a new role as Managing Editor of MLA Commons.

[Cross-posted with dclure.org]

We’re pleased to announce Neatline 2.0-alpha2, a second developer-preview version that gets us one step closer to a stable 2.0 release! For now, this is still just an testing release aimed at engineers and other folks who want to experiment with the new set of features (for more information, check out the announcement for the first testing release). Grab the code here:

Neatline-2.0-alpha2 | NeatlineWaypoints-2.0-alpha2 | NeatlineSimile-2.0-alpha2

This revision fixes a couple of bugs and adds two new features that didn’t make it into the first preview release:

1. A user-privileges system, which makes Neatline much easier to use in collaborative, multi-user settings like classrooms and workshops. In a lot of ways, this feature reflects an expanded focus for Neatline. During the first cycle of development last year, we were mainly focused on building a tool designed for individual scholars and students working on focused projects. In that setting – when just a handful of trusted collaborators are working on a project – it’s often not necessary to assign “ownership” to individual pieces of content to protect them from being changed or deleted by other users.

   Over the course of the last year, though, we’ve realized that there’s a lot of interest in using Neatline in a classroom setting, which introduces a new set of requirements. When 50 students are all building their own Neatline exhibits inside a single installation of Omeka, it would be easy for someone to accidentally edit or delete someone else’s work – there need to be guard rails to prevent users from modifying content that doesn’t belong to them.

   In Neatline 2.0-alpha2, we’ve added an ACL (access control list) that makes it possible to enforce a three-level user privileges system:

   • Admin and Super users can do everything – they can create, edit, and delete all Neatline exhibits and records, regardless of who they were originally created by.

   • Contributor users can add, edit, and delete their own exhibits, but can’t make changes to exhibits or records that they didn’t create.

   • Researcher users are denied all Neatline-related privileges – they can’t create, edit, or delete any Neatline exhibits or records.

   This is a simple approach, but we think it addresses most of the basic patterns for classroom use that we’ve encountered here at UVa and elsewhere. If students are working on individual projects, each can be given a separate “Contributor” account, which allows them to create and update their own exhibits, but blocks them from changing anyone else’s work. If students are working together in groups, each group can be assigned an individual “Contributor” account, which allows group members to update each other’s work, but prevents them from making changes other groups’ exhibits.

2. An exhibit-specific theming system that makes it possible to create completely custom “sub-themes” for individual Neatline exhibits. Before, it was possible to customize the layout and styling of the Neatline exhibit views by editing the Omeka theme, which would change the appearance of all the exhibits on the site. In many cases, though, individual exhibits have specific requirements. Depending on the content, it might be useful for different exhibits to have different page headers, typography, or viewport layouts; and it’s also really useful to be able to load exhibit-specific JavaScript files, which can be used to define custom interactions for individual exhibits.

   In this release, every aspect of an exhibit’s public view can be completely customized by adding an “exhibit theme” that sits inside of the regular Omeka theme. For example, if I have an exhibit called “Testing Exhibit” with a URL slug of testing-exhibit, I can define a custom theme for the exhibit by adding a directory in the public theme at neatline/exhibits/themes/testing-exhibit. With the directory in place, Neatline will automatically load any combination of custom assets:

   • If a template.php file is present in the directory, it will be used as the view template for the exhibit in place of the default show.php template that ships with Neatline.

   • All .js and .css files in the directory will be loaded in the public view. This makes it possible to break additional styling and JavaScript functionality across multiple files, which makes it easier to break complex customizations into smaller units.

   This gives the theme developer full control over the appearance and behavior of each individual exhibit, making it possible to build a extremely diverse collection of Neatline projects inside a single installation of Omeka.

Check out the change log for more details. And let us know what you think!

Thanks to Neatline Time user nancymou, we’ve addressed a bug in Neatline Time where fields added by other plugins to the advanced search form were not recognized by Neatline Time. (In nancymou’s case, the other plugin was Exhibit Builder.) So we’ve put together a bugfix release, version 1.1.3, that addresses this issue. Download Neatline Time 1.1.3 to upgrade.

We’re also wrapping up work on Neatline Time to make it compatible with Omeka 2.0. There isn’t a tagged version yet, but if you’re interested in trying it out (and sending us feedback), feel free to check out the `develop` branch from our Github repository. You can also download a zip of the develop branch; you’ll just need to rename the unzipped folder to “NeatlineTime”. If you do try it out, and run into any problems, feel free to add a ticket to our issue tracker. There’s also plenty of time to contribute a translation for Neatline Time, or any of the Neatline plugins!

Graduate Fellows Forum: Lydia Rodríguez

The Time Has Come: Ethnography, Gesture Research, and Digital Technology

Lydia Rodríguez
PhD Candidate, Department of Anthropology
Scholars’ Lab Fellow

Respondent
Dr. Eve Danziger
Associate Professor, Department of Anthropology
University of Virginia

Summary:

In Western societies, time is usually perceived as a linear progression of events, but not all cultures think about and experience time in this particular way. In this presentation I analyze the relationship among linguistic, conceptual, and cultural notions of time through ethnographic observation of spoken interactions in Chol, a Maya language spoken in Chiapas, Mexico. In particular, I describe how the concept of time is depicted in the spontaneous gestures which are produced in conversational exchanges among speakers of Chol Maya. I also discuss the role that digital technology has played in the collection and analysis of gestural data, and how digital tools can be used to complement and enhance traditional ethnographic research about temporal conceptualization.

  

As always, you can listen to (or subscribe to) our podcasts on the Scholars’ Lab blog, or on iTunesU.

[Cross-posted from dclure.org]

I ran into an interesting testing challenge yesterday. In Neatline, there are a couple of controller actions that need to spawn off asynchronous background processes to handle operations that are too long-running to cram inside of a regular request. For example, when the user imports Omeka items into an exhibit, Neatline needs to query a (potentially quite large) collection of Omeka items and insert a corresponding Neatline record for each of them.

Jobs extend Omeka_Job_AbstractJob and define a public perform method:

And can be dispatched asynchronously by getting the job_dispatcher out of the registry and passing the job name and parameters to sendLongRunning:

It’s easy enough to directly unit test the perform method on the job, but, since actual execution of the process is non-blocking, the jobs can’t be tested at the integration level in the ordinary manner. For example, I’d like to just dispatch a request with a mock item query, and check that the correct Neatline records were created. This can’t be asserted reliably, though, since there’s no guarantee that the job will have completed before the testing assertions are executed.

The job itself is non-blocking, but the job invocation in the controller code is blocking, and can be tested pretty easily by replacing the job_dispatcher with a testing double and spying on the sendLongRunning method. Since this is a pattern that needs to be implemented in more than one test, I started by adding a mockJobDispatcher method to the abstract test-case class that mocks the job dispatcher and injects it into the registry:

Then, in the test, we can just call this method to mock the dispatcher, assert that the dispatcher is expecting a call to sendLongRunning with the correct job and parameters, and then fire off a mock request to the controller action under test:

This is a pretty good solution, but not perfect: The integration test is really asserting an intermediate step in the implementation of the controller action, not the end result – it tests that the job was called with certain parameters, not the final effect of the request. This opens up the door to false positives. For example, in the future, I might make a breaking change to the public API of the Neatline_ImportItems. Assuming I’ve changed the job’s unit tests to assert against the new API, the test suite would pass even if I completely forget to update any of the job invocations, since the integration tests are just asserting the structure of the invocation, not the final effects.

I’ve encountered a version of this problem more than once, and I’ve never really found a good solution to it. Short of moving up to something like in-browser Selenium tests, or resorting to hacky execution pauses in the integration tests, has anyone ever come across a better way to do this?

This morning, Kiyonori Nagasaki noticed that one of the remote API’s used by the Neatline 1.x releases went offline, which had the effect of breaking exhibits that included the SIMILE Timeline widget. To fix this, we just posted a 1.1.3 maintenance release that patches up the timeline problem and also includes a couple of other improvements:

• Disabled animated opacity transitions on WMS tiles, which were causing performance problems in recent builds of Chrome;

• Fixed a bug that was causing the map not to focus correctly when a record is selected that has a default focus position/zoom, but no vector geometry.

Download Neatline 1.1.3.

Meanwhile, lots of activity on the Neatline 2.0 front – we’re almost done with a second alpha release, which gets us one step closer to a stable 2.0 release, which will include the migration to update existing installations from the 1.x series.

Stay posted!

[Cross-posted with dclure.org]

Neatline 2.0 makes it possible to work with really large collections of records – as many as about 1,000,000 in a single exhibit. This level of scalability is liberating, but it also introduces a whole new set of interesting content management challenges. If the map can display millions of records, it also needs utilities to effectively manage content at that scale.

This often involves a shift from working with individual records to working with groups of records. When there are a million records on the map, it’s pretty unlikely that you’ll want to change the color of just one of them. More likely, that record will exist as part of a large grouping of related records (eg, “democratic precincts,” or “photographs from 1945″), all of which should share a certain set of attributes. There needs to slice and dice records into overlapping clusters of related records, and then apply bulk updates to the individual clusters.

Really, this is a familiar problem – it’s structurally identical to the task of styling web pages with CSS, which makes it possible to address groupings of elements with “selectors” and apply key-value styling rules to the groups. Inspired by projects like Mike Migurski’s Cascadenick, Neatline 2.0 makes it possible to use a Neatline-inflected dialect of CSS to update groups of records linked together with “tags,” which can be applied in any combination to the individual records.

Neatline Stylesheet Basics

Imagine you’re plotting results from the last four presidential elections. You load in a big collection of 800,000 records (200k precincts for each of the four elections), each representing an individual polling place with a point on the map. Each point is scaled to represent the number of ballots cast at that location, and shared red or blue according to which party won more votes. In this case, there are really seven different nested and overlapping taxonomies in the data. All of the records are precincts, but each falls into one of the our election seasons – 2000, 2004, 2008, or 2012. And each precinct went either democrat or republican, regardless of which election cycle it belongs to. Each record can be tagged with some combination of these tags:

Each of the groupings needs to share a specific set of attributes – and also not share some attributes that need to be assigned separate values on individual records. For example, all of the precincts – regardless of date or party – should share the same basic fill-opacity and stroke-width styles. All records in each of the groupings for the four election seasons need to share the same after-date and before-date visibility settings so that the records phase in and out of visibility in unison. And all republican and democratic records should share the same shares of red and blue. Meanwhile, none of the groupings should define a standard point-radius style, which is used on a per-record basis to encode the number of ballots cast at that location.

Neatline-inflected CSS makes it easy to model these relationships. To start, I’ll define some basic styles for the top-level precinct tag, which is applied to all the records in the exhibit:

Now, when I click “Save,” Neatline instantaneously updates the stroke-width and fill-opacity styles on all records tagged with precinct:

Next, I’ll set the before-date and after-date properties for each of the for election season tags, which ensure that the four batches of records phase in and out of visibility in unison as the timeline is scrolled back and forth:

Now, when I open up any individual record, the before-date and after-date fields will be updated with new values depending on which election the record belongs to:

Last, I’ll define the coloring rules for the two political parties. First, the Democrats:

Click “Save,” and all democratic precincts update with the new color:

Auto-updating stylesheet values

So far, we’ve just been entering hard-coded values into the stylesheet. This often makes sense for properties that have inherently semantic values (eg, dates). For other attributes, though (namely colors), it’s much harder to reason in the abstract about what value you want. For example, I know that I want the republican precincts to be “red,” but I don’t know off-hand that #ff0000 is the specific hexadecimal value that I want to use. It makes more sense to open up the edit form for an individual record and use the color pickers for the “Fill Color” field to find a color that looks good.

And even for styles that can be reasoned about in the abstract, it’s often easier and more intuitive to use the auto-previewing functionality on one of the record forms to tinker around with different values. Once you’ve decided on a new setting, though, it’s annoying to have to manually propagate the value back into the stylesheets so that all of the record’s siblings stay in sync – you’d have to copy the value, close the form, open up the stylesheet, find the right rule, and paste in the new value. To avoid this, Neatline also automatically updates the stylesheet when individual record values are changed, and immediately pushes out the new value to all of the record’s siblings.

Let’s go back to the election results. For the republican precincts, instead of pasting in a specific hex value for the fill-color style, we’ll just “register” fill-color as being one of the properties controlled by the republican tag by listing the style and assigning it a value of auto:

When I click “Save,” nothing happens, since a value isn’t defined. Now, though, I can just open up any of the individual republican records, choose a shade of red, and save the record. Since we activated the fill-color style for the republican tag, Neatline automatically updates all of the other republican records just as if we had set the value directly on the stylesheet:

And now, when I go back to the stylesheet, the fill-color rule under democrat is automatically updated with the value that we just set in the record form:

This also works for styles that already have concrete values. For example, say I change my mind and want to tweak the shade of blue used for democratic precincts. I can just open up any of the individual democrat-tagged records, pick a new value with the color picker, and save the record. Again, Neatline automatically replaces the old value on the stylesheet and propagates the change to all of the other democratic precincts.

The following was co-authored and co-hacked with Claire.

Claire and I went to the Arduino Hackday hosted by the Scholars’ Lab on Friday. We had no idea what we were getting into, which made it all the more fun. Jeremy brought in a bunch of Arduino kits of all shapes and sizes, and various people went to work to see what they could make out of them.

First Claire and I got a blinking light to work. From there we decided to skip several chapters to make a little music player using a piezo speaker component. At that point we went off the map, dreaming big and working off the page. We started out working with this schematic, but we wanted to expand things a little.

I apologize in advance for whatever vocabulary gap there might be in the discussion below; it was my first time coding in C.

For one, this set-up only uses a single octave major scale. We opened things up by expanding the range of tones the speaker could play, including both a chromatic scale and adding an extra octave. One difficulty here was in the way that way that accidentals would be read by the board. At first we tried to use standard notation – f sharp would be represented by f#. But the code finds the notes in the melody by reading character by character through an array. So when the computer sees “cc#”, it processes it as two ‘c’s and one nonsense syllable that it can’t process. There is probably a more elegant solution, but we got around this by associating the accidentals with new characters entirely

C#/Db             =>       l

D#/Eb              =>       m

F#/Gb              =>       n

G#/Ab             =>       o

A#/Bb             =>       p

Next, we added an extra octave. To extend the range, we hard coded frequencies for the new notes according to the formula given by the original Arduino code:

timeHigh = period / 2 = 1 / (2 * toneFrequency)

We probably could have done this in a more dynamic way. Or, as Eric and Ronda showed, we could have just downloaded a tone library to do this for us. They were jamming out to the Star Wars theme while we were still trying to get things working.  But eventually, we were able to program in the opening of “Mary Had a Little Lamb,” Mozart’s Lacrimosa, John Coltrane’s “26-2,” and “Somewhere Over the Rainbow.”

Here is where things got really ambitious, we came up with the idea to incorporate a RGB LED light that would change colors each time there was a note change in “Somewhere Over the Rainbow.” Rainbow lights for a song about rainbows.

To get the light working we worked off a slightly modified version of this schematic, mashed in with the piezo tutiorial. With some quick help from Eric, we modified the light arrangement so that each generates a random RGB combination. We then synchronized this with the rhythm of the melody.

In terms of the actual circuitry, we just split the digital signal so that it went out to two different parts of the bread board simultaneously and then fed information to both pins. Later we added a volume knob to reduce the maddening noise. You can see attached photos below, though you’ll have to meet us halfway with our diagram of the breadboard.

A later, unsuccessful attempt to key each frequency to a particular color resulted in a light that got brighter or darker depending on the note. I think with a little more time I could fix that by hard coding particular RGB values to particular frequencies, but we were trying to do it dynamically by converting the frequency directly into an intensity value.

Behold our final product!

// Piezo speaker connected to pins int speakerPin = 6; // RGB LED leads connected to PWM pins const int RED_LED_PIN = 9; const int GREEN_LED_PIN = 10; const int BLUE_LED_PIN = 11; // Used to store the current intensity level of the individual LEDs int redIntensity = 0; int greenIntensity = 0; int blueIntensity = 0; char notes[] = {"cCbgabccaag "}; // a space represents a rest int length = sizeof(notes); // the number of notes int beats[] = {4,4,2,1,1,2,4,1,1,1,4,1}; int tempo = 300; void playTone(int tone, int duration) { for (long i = 0; i < duration * 1000L; i += tone * 2) { digitalWrite(speakerPin, HIGH); delayMicroseconds(tone); digitalWrite(speakerPin, LOW); delayMicroseconds(tone); } } void playNote(char note, int duration) { char names[] = { 'c', 'l', 'd', 'm','e', 'f', 'n', 'g', 'o','a', 'p', 'b', 'C', 'L', 'D', 'M', 'E', 'F', 'N', 'G', 'O', 'A', 'P', 'B' }; int tones[] = { 1915, 1805, 1700, 1608, 1519, 1432, 1351, 1275, 1205, 1136, 1073, 1014, 956, 903, 850, 804, 760, 716, 676, 638, 603, 568, 478 }; // play the tone corresponding to the note name for (int i = 0; i < sizeof(names); i++) { if (names[i] == note) { playTone(tones[i], duration); } } } void setup() { pinMode(speakerPin, OUTPUT); } void loop() { for (int i = 0; i < length; i++) { if (notes[i] == ' ') { delay(beats[i] * tempo); // rest } else { playNote(notes[i], beats[i] * tempo); greenIntensity = 255 * rand(); redIntensity = 255 * rand(); blueIntensity = 255 * rand(); analogWrite(GREEN_LED_PIN, greenIntensity); analogWrite(RED_LED_PIN, redIntensity); analogWrite(BLUE_LED_PIN, blueIntensity); delay(beats[i]); } // pause between notes delay(tempo / 2); } }

[Cross-posted with dclure.org]

It’s here! After much hard work, we’re delighted to announce the first alpha release of Neatline 2.0, which migrates the codebase to Omeka 2.0 and adds lots of exciting new things. For now, this is just an initial testing release aimed at developers and other brave folks who want to tinker around with the new set of features and help us work out the kinks. Notably, this build doesn’t yet include the migration to upgrade existing exhibits from the 1.1.x series, which we’ll ship with the first stable release in the next couple weeks once we’ve had a chance to field test the new code.

45 minutes of Neatline 2.0 alpha testing, compressed to 90 seconds, set to Chopin.

In the interest of modularity (more on this later), the set of features that was bundled together in the original version of Neatline has been split into three separate plugins:

• Neatline – The core map-making toolkit and content management system.
• NeatlineWaypoints – A list of sortable waypoints, the new version of the vertical “Item Browser” panel from the 1.x series.
• NeatlineSimile – The SIMILE Timeline widget.

Just unpack the .zip archives, copy the folders into the /plugins directory in your Omeka 2.x installation, and install the plugins in the Omeka admin. For more detailed information, head over to the Neatline 2.0-alpha1 Installation Wiki, and take a look at the change log for a more complete list of changes and additions.

We’re really excited about this code. Since releasing the first version last summer, we’ve gotten a huge amount of incredibly helpful feedback from users, much of which has been directly incorporated into the new release. We’ve also added a carefully-selected set of new features that opens up the door to some really interesting new approaches to geospatial (and completely non-geospatial) annotation. It’s a leaner, faster, more focused, more reliable, and generally more capable piece of software – we’re excited to start building projects with it!

Some of the additions and changes:

• Real-time spatial querying, which makes it possible to create really large exhibits – as many as about 1,000,000 records on a single map;

• A total rewrite of the front-end application in Backbone.js and Marionette that provides a more minimal, streamlined, and responsive environment for creating and publishing exhibits;

• An interactive “stylesheet” system (inspired by projects like Mike Migurski’s Cascadenick), that makes it possible to use a dialect of CSS – built directly into the editing environment – to synchronize large batches of records;

• The ability to import high-fidelity SVG illustrations created in specialized vector editing tools like Adobe Illustrator and Inkscape;

• The ability to add custom base layers, which, among other things, makes it possible to annotate completely non-spatial entities – paintings, photographs, documents, and anything else that can be captured as an image;

• A revamped import-from-Omeka workflow that makes it easier to link Neatline records to Omeka items and batch-import large collections of items;

• A flexible programming API and “sub-plugin” system that makes it easy for developers to extend the core feature set with custom functionality for specific projects – everything from simple JavaScript widgets (legends, sliders, scrollers, etc.) up to really deep modifications that extend the core data model and add completely new interactions.

Over the course of the next two weeks, I’ll be writing in much more detail about some of the new features. In the meantime – let us know what you think! We’re going to be pushing out a series of alpha releases in pretty rapid succession over the course of the next couple weeks, and we’re really keen to get feedback about the new features before cutting off a stable 2.0 release. If you find a bug, or think of a feature that you’d like to see included, be sure to file a report on the issue tracker.

[cross-posted from nowviskie.org]

This week marks the release of a new version of Prism, a web-based tool for “crowdsourcing interpretation,” constructed over the course of two academic years by two separate cohorts of graduate fellows in our Praxis Program at the Scholars’ Lab.

Praxis fellows are humanities and social science grad students across a variety of departments at UVa, who come to our library-based lab for an intensive, team-based, hands-on experience in digital humanities project-work, covering as many aspects of DH practice as our practiced Scholars’ Lab staff can convey. (By the end of the year, our fellows have negotiated a project charter; learned to create and appreciate robust ontologies and database designs; programmed or at least hacked around in Ruby and Javascript/CoffeeScript; raised up a Rails scaffold and become competent in HTML/CSS; managed the versioning of open source code in GitHub and deployed staging and production instances of a project; made design decisions and analyzed and drawn conclusions about user-experience aspects of a real-world project; communicated the value of their work and grown more comfortable sharing it in iterations and open-access venues; honed their skills at speaking across disciplinary and professional lines; learned hard project-management lessons; expanded their contacts in the DH world; engaged in conversations about funding, academic personnel, professionalization, and broadened career paths for scholars; and had fun and survived it all.)

Where our 2011-12 cohort of Praxis fellows laid the groundwork (resurrecting an old SpecLab game that evolved into the finest bit of vaporware never to be produced by the humanities computing community at UVa, and creating a multilingual, prototype system that allowed multiple readers to mark up a pre-set list of texts according to a shared vocabularly), our 2012-13 team had the opportunity to refine the concept into a usable, open-ended tool. Thanks to their work, it’s easy to create a Prism account (including by logging in via existing services) and launch your own markup games, by uploading texts and defining the facets available to readers for the kind of blunt-force, collaborative annotation Prism allows. Users now have a catalogue of texts they’ve added to the system or participated in marking up, and can get a sense of the evolving, shared reading of those texts through two visualization modes — one new (showing a quantified breakdown of crowdsourced readings), and one (showing the affective frequency of reader agreement) refined. Best of all, Prism has become lovely and light. A design refresh and attention to ease-of-entry should make it an attractive tool for classroom use, and for experimentation and play.

Please try it out and let our students know what you think. (They are Claire Maiers, Sociology; Brandon Walsh, English; Gwen Nally, Philosophy; Cecilia Marquez, History; Chris Peck, Music; and Shane Lin, History — emerging scholars and scholar-practitioners to watch!) We would be especially interested in pedagogical applications of Prism. And, since next year’s Praxis cohort — soon to be announced — will be moving on to a new project (reviving and re-thinking another SpecLab classic, the Ivanhoe Game), we also encourage developers to send pull requests for bug fixes and new features. Much remains possible with the “crowdsourcing interpretation” concept at the heart of Prism, which one early reviewer called “potentially the beginning of a new research field.” Further visualizations? Image-based or non-textual approaches to collaborative markup? Computational linguistic analysis based on comparison of crowdsourced readings to larger corpora? The sky is the limit.

For now, we’re just enjoying the way the new, bright, child-like design for Prism matches the current mood in the Scholars’ Lab grad lounge: “Look! We made this!”

After many months of brainstorming, debating, dreaming big, getting down to business, panicking, refocusing, programming, and fine tuning, Prism is here!

It has been a great journey, and I think my fellow Praxers would agree when I say that we have learned a lot.  Not only have we been introduced to the world of DH and received hands-on training in things like HTML, CSS, Ruby on Rails, database construction, and a smidge of JavaScript and Coffee Script, but we have also learned a great deal about working in a team environment and collaboration.

Although I plan to share some of the lessons learned throughout this year with you all in a subsequent blog post, I thought I would take this opportunity to tell you about what we have done with Prism this year.

Oauth:  With the new Prism, users are able to sign in through a variety of options.  We have retained the ability for users to create their own account on Prism.  However, users can also sign in through existing accounts with Facebook, Google, and Mozilla Persona.   Props go out to Brandon who tackled OmniAuth early on in the semester and then stuck with it despite many unforeseen hurdles!

Redesign:  From the beginning of our meetings, we discussed creating an online environment that was playful and would invite users to explore and participate.  In tandem with our vision of playfulness, we wanted to design the site with special attention to the user interface.  We pictured a site where the design itself would direct users on how to interact and lead them through the workflow from Prism creation to visualization in a streamlined manner.  Manifesting this vision fell to Gwen and Cecilia, and they have done a remarkable job creating a beautiful and functional site.

Database Refactoring: On perhaps a less glamorous note, Brandon and Shane (or “Brane” as I call them) have refactored the database for Prism.  This refactoring was crucial to some of the improvements we’ve made to visualizations, allowing for user uploads, and will hopefully allow for others to build upon our code more easily.

User Uploads: Thanks to Shane and Brandon, Prism now also provides the ability for users to upload their own texts to the site.  Our hope is that this contribution allows for Prism to be deployed in a variety of classroom and scholarly settings.  As users create a new Prism, they have the option to either make their Prism public and available to anyone for highlighting or they can choose to make an unlisted Prism.  Unlisted Prisms are not listed in the Browse page, allowing users to limit participation to desired audiences.  I encourage you to check this feature out for yourself!

A New Visualization:  This version of Prism also includes a second option for visualizing collaborative interpretation, the Winning Facet Visualization, developed by Chris.  This option allows users to see a combination of all the facet categories at once.  In addition, users can interact with the pie chart to see the exact break down of user highlights by category.

There are many other smaller improvements that I have not listed here, so go take a look at Prism and experience it for yourself!

Before I sign off, I want to give a shout out to the SLab faculty and staff.  They invested many hours in our team and rescued each of us from a precipice of panic or frustration more than once this year.  None of this would have been possible without them.  I will have more to say on that later, but for now, I will just say THANKS!

Graduate Fellows Forum: David Flaherty
Mapping the British Vision of Empire in 1731

David Flaherty
PhD Candidate, Corcoran Department of History
Scholars’ Lab Fellow 2012-2013

Respondent:
Dr. S. Max Edelson
Associate Professor, Corcoran Department of History
University of Virginia

Summary:
The British Board of Trade, a bureaucratic body responsible for overseeing the 18th-century Atlantic colonies, had a broad geographic vision of the British Atlantic based on their extensive communication with colonies from Newfoundland to Honduras. This project maps the Board’s correspondence for a single year, showing which points on the map it received information about and where those letters came from, in an attempt to illustrate that vision.

As always, you can listen to (or subscribe to) our podcasts on the Scholars’ Lab blog, or on iTunesU.

The biggest issue that I have faced with my work with the Praxis Program has to do with how I judge the difficulty of the tasks before me. I have proven to be singularly inadequate at distinguishing quick fixes with a large payoff from larger problems that would yield only small utility. This issue surfaced early on, when I boldly suggested that I could implement Omniauth in a week. Two and a half months later I am still trying to get it to work: the Omniauth code structure works more generally, but each authentication service is its own unique little snowflake, different from all the other snowflakes in the code breaking eccentricities that it brings to the table. We had to jettison Twitter early on because it would not return user emails, which are central to the way that Devise handles logins. Facebook worked on local rails servers, but something whacky is happening on staging (and in deployment, for that matter) so that it throws a redirect uri failure at us that did not appear before. I feel as though I could have pounded away at these problems for ages and gotten nowhere.

But for every task like Omniauth there have been other jobs that seemed large but turned out to be much easier than expected. I implemented a destroy function on prisms last week in just a couple of hours (Shane had already provided a lot of the scaffolding on an older database setup), which meant that I also had to implement user roles and permissions using cancan. Cancan felt like a bigger job than it wound up being, and the whole thing seems to be working in the feature branch now. Now a user can delete a prism that they have uploaded. Great success!

I think this ability to distinguish between large and small tasks is something that can only come with time and experience. We Praxers may be unable to tell how much work a particular feature will require, but the SLab team has been incredibly helpful in that regard. Where we see mountains, they see molehills, and vice versa. And when you get right down to it, Prism seemed like the biggest mountain of all a couple months ago. Prism felt like an insurmountable task until last week when everything came together in a flurry of productivity. I am impressed with what we have done.

Now, without warning, a couple of inspirational climbing videos.

Scholars’ Lab Speaker Series: Alan Liu
4Humanities: Values, Strategies, Technologies for Humanities Advocacy in the Digital Age

In April, Dr. Alan Liu, Professor in the Department of English at the University of California, Santa Barbara, spoke about ways in which the skills and resources of the DH community can help advocate for the humanities.

 

Summary:
Alan Liu will present an informal talk exploring such issues as assessing values and narrative frames for communicating the worth of the humanities. He will also brainstorm next-generation methods for using digital/networked technologies to create material for public view of scholars’ normal research and teaching work.

As always, you can listen to (or subscribe to) our podcasts on the Scholars’ Lab blog, or on iTunesU.

Digital Humanities Speaker Series: Alan Liu & Rama Hoetlein
The History of Thought as Networked Community: The RoSE Prototype

In March, Dr. Alan Liu, Professor in the Department of English at University of California, Santa Barbara,
and Rama Hoetzlein, Project Scientist, spoke about their work developing the RoSE Prototype.

Summary:
What if bibliographies of past authors and works could be modeled as a dynamic, evolving society linked to today’s scholars and students? What if scholars and students could add data about biographical, historical, and intellectual relationships to the bibliographical entries, thus using present-day crowdsourcing to make more socially meaningful the crowds of history? And what if visualizations could help us actively “storyboard” intellectual movements and not just spectate them? Alan Liu and Rama Hoetzlein present the conceptual framework and some of the discoveries and challenges of the RoSE Research-oriented Social Environment (in beta at the conclusion of a NEH Digital Humanities Start-up grant).

The Digital Humanities Speaker Series is co-sponsored by IATH, SHANTI, and the Scholars’ Lab.

As always, you can listen to (or subscribe to) our podcasts on the Scholars’ Lab blog, or on iTunesU.

This week Cecilia and took a few hours and completed one of our goals for this semester: creating a tutorial video for using Prism.   Not only did this turn out to be surprisingly fun (due mostly to Cecilia’s amazing antics), but it also added a few more skills to the list of things we have learned through Praxis.

First—though this might seem trivial– we got to draw upon out teaching skills, devising a plan for how to teach someone to use Prism in under three minutes.  I authored the tutorial, and thanks to some great ad lib from Cecilia, I think the tutorial manages to capture the playful attitude with which we have approached our work and which we hope Prism engenders.

In addition, we learned how to use the iShowU HD software program.  Admittedly, this is a very user-friendly program which allows you to record an area on your screen as a video.  Still, it has left us with one more skill which we can confidently claim for our own.

And finally, and perhaps most importantly, we got to use this awesome microphone.   Need I say more?

The launch of Prism is just around the corner.  In the mean time, check out our tutorial here!

Here is a bunch of photos from our most recent team meeting!

     

This past week we started a soft (internal) launch of the new Prism so we could begin to work out all of the kinks. This of course meant that we spent a lot of time together working out last minute concerns.  This was a really different “finals” type experience than the one I am currently experiencing.  Finals in graduate school basically means that I find a quiet place and don’t leave until all of the papers have been written.  This crunch time collaboration felt exciting, dynamic, and fun.  It made me realize how much I have come to value the teamwork time that I get in Praxis each week.  Grad school can be isolating and socializing can feel like a distraction.  What was great about Praxis was that we were able to come together weekly in a work-related activity but really enjoy each other’s company.

I have always known that I’m a social worker but this experience has confirmed that in order to be successful in my graduate career I will have to build a team of people around me who are willing and able to support me.  I am also increasingly thinking about what type of alt-ac careers would allow me to keep this team experience central to my work life.  I’m going to miss these weekly work/hang sessions.

Graduate Fellows Forum: Joanna Swafford
Victorian Songs and Digital Tools: Facilitating Sound Studies Scholarship

Joanna Swafford
PhD Candidate, Department of English
Scholars’ Lab Fellow 2012-2013

Respondent
Dr. Herbert Tucker
John C. Coleman Professor of English
University of Virginia

Summary:
Although sound studies and interdisciplinary music and poetry scholarship have increased over the last decade, scholars have not had the digital tools necessary to make their auditory arguments accessible to a wider audience. This talk will present two tools built by Scholars’ Lab Fellow Joanna Swafford that will help change that: Songs of the Victorians, an archive and analysis of parlor and art song settings of Victorian poems, and Augmented Notes, a tool that will let scholars build their own interdisciplinary websites like Songs of the Victorians.

As always, you can listen to (or subscribe to) our podcasts on the Scholars’ Lab blog, or on iTunesU.