Alexey Zagalsky

Teaching Information Visualization

Mon, 08 Jan 2018 17:44:18 +0000

I see information visualization as one of the most fascinating and important areas, particularly useful for researchers and people who work with data. From cases like Charles Minard’s map of Napoleon’s campaign of 1812, and John Snow’s cholera outbreak map of London 1854, we can see examples how visual articulation of data can impact the world. If I were to teach an InfoVis course, I would use the following material and tools.

Books

I can’t think of a specific book that can serve as the course textbook. Hence, I’m recommending multiple sources of material.

One book that’s worth covering is Edward Tufte’s “The Visual Display of Quantitative Information” book. It focuses on comprehensible and usable design, concisely and clearly articulating core principles. It includes many good examples (including examples of poor design).

“Graphical excellence is the well-designed presentation of interesting data—a matter of substance, of statistics, and of design.”

— Edward R. Tufte”

Tamara Munzner’s book, “Visualization Analysis and Design”, does a great job in providing and framing the proper terminology for learning about and discussing InfoVis topics (Figure 2.1 of the book shows a summary of this framework). While, Tamara’s book would work great as a reference book, I don’t think it should be used as the only textbook.

Additional material that may be worth covering or providing as recommended reading: “Envisioning Information” by Edward Tufte, “Visual Thinking for Design” by Colin Ware, and “The Functional Art” by Alberto Cairo.
For aspects of interaction, the paper “Toward a Deeper Understanding of the Role of Interaction in Information Visualization” may serve as a helpful starting point (by Yi et al. 2007).

Additionally, I suggest taking a look at the interesting story of William Playfair, the inventor of the pie chart, the bar graph, and the line graph. Eugene Wei’s depiction of his job at Amazon as the first analyst in the strategic planning department is also worth reading.

An upcoming new book is “Fundamentals of Data Visualization” by Claus O. Wilke. The book seems to be quite comprehensive, fully accessible online, and is entirely written in R Markdown.

No matter what kind of data needs to be visualized, an important question to ask oneself is: are you communicating information, displaying an analysis, or exploring data? For instance, Scott Berinato described four types of visual communication (idea illustration, idea generation, visual discovery, and everyday dataviz). Even something as basic as a table can be improved—not by adding more visual cues, but by removing unnecessary visual clutter.

For more modern examples, the “Information is Beautiful” Awards website showcases interesting award winning examples. These projects were awarded for excellence and beauty in data visualizations.

Software and Tools

These are commonly used tools that I find useful:

Visualizations with R and R Studio (and packages like ggplot2). Related to visualizations in R, check out the book “Circular Visualization in R”
A list of 50 ggplot2 visualizations (with corresponding R code)
The D3.js library is a great JS library for creating visualizations. It’s commonly used and is very customizable. Related to D3, the books “D3.js in Action” by Elijah Meeks, and “Interactive Data Visualization for the Web” by Scott Murray, are exceptionally good (and very practical).
Tableau or Tableau Public
The data visualization catalogue, the data viz project, and Xenographics: for choosing the type of visualizations to use

Inspirational People in the Field

Hadley Wickham is a statistician from New Zealand who is currently Chief Scientist at RStudio. He has developed several notable and widely adopted R packages including ggplot2, plyr, dplyr, and reshape2.

David Robinson is the Chief Data Scientist at DataCamp (previously a data scientist at Stack Overflow), and the co-author with Julia Silge of the Tidytext package for R. He writes an awesome blog on data analysis and visualization.

Giorgia Lupi is an award winning information designer. I find her work to be inspirational and superb. I highly recommend her TED talk.

Nadieh Bremer is an award-winning data visualization designer, with an interesting background as an astronomer and a data scientist. Interestingly, she has shared a list of resources and a compilation of recommended books, with a short review and her thoughts on the usefulness of each book. If you wish to learn more about data visualization, I recommend checking it out.

I’d love to add additional material that can be of help to others. If you’ve taught or taken an InfoVis course—what material did you use or have found useful?

We also use this paper in our InfoVis course: https://t.co/oe4Ayqhj9j
— Sebastian Baltes (@s_baltes) January 10, 2018

P.S. I’d love to meet you on Twitter.

My Toolbox

Thu, 07 Sep 2017 20:44:18 +0000

As a researcher, I use a variety of software tools on a regular basis, and I’d like to share this list of tools here.

Writing and Collaborating on Papers

For writing papers, I use Sublime Text 3 with the LaTeXTools package installed. This allows me to edit and compile the document directly from ST3. I have the same setup with the Atom editor as well, and both work well.

For collaborating on papers, I prefer to use GitHub and host the source files (e.g., tex,bib) in a repository dedicated for the paper. I believe this gives each co-author the freedom to choose and set up their own work environment and tools (as opposed to something like ShareLaTeX).

Typically when starting to work on a paper, we use Google Docs to draft out an outline for the paper and reach an agreement on the direction of the paper. The commenting mechanism on Google Docs works well and supports brainstorming.

Other tools I typically use:

LatexDiff, a command line tool, for generating visual diffs between compiled documents. Useful when outlining changes to reviewers between revisions. Similarly, Git-LatexDiff aims to generate a diff and simplify the process even further
AbstractFormater for formating text. Very useful, especially for paper submissions
BibTex normalizer for cleaning up the bibtex file
doi2bib.org
EZProxy plugin for accessing academic papers from outside of the university’s network
Octobox for managing GitHub notifications
Draft: a writing tool that I find helpful in overcoming writer’s block

Zenodo: for sharing data from our studies (e.g., replication package)
arXiv: for preprints or papers that are not archived elsewhere

English Prose

Grammarly: is an English-language writing aid for the browser
Proselint: works well with text and markdown files in Sublime Text and Visual Studio Code (no Latex support though)
Write-good: a prose linter extension for developers

Team Communication

Slack: most of our group’s communication happens on Slack, though we may switch to Mattermost later this year
Keybase: it’s like a combination between Slack and Dropbox, that also leverages cryptography.
Skype: video calls when we’re not co-located
Email

Schedule and Time Tracking

Google Calendar: we share a group calendar to coordinate our schedule

Keeping Up To Date

Twitter + Buffer: following research-related people and products. I try to keep the number of people I follow at a manageable number (~150)
TweetDeck: catching up with conference/event tweets
Google Scholar updates and alerts
HackerNews
Feedly: to keep up with blogs (e.g., http://blog.ieeesoftware.org/) and tech news
Podcast Addict: I subscribe to helpful and related podcasts (e.g., effortreport.libsyn.com, changingacademiclife.com, and changelog.com/rfc)
YouTube: following research-related people and channels

Knowledge Management and To-Dos

GitHub + Markdown files
Google Keep
Trello

Presentation Slides

Google Slides: for creating slides. I also use Google slides as a brainstorming tool when starting to design a study/paper
Speaker Deck: for sharing my slides
Pexels / Unspalsh / Pixabay / unDraw / ManyPixels

Posters

In the past I used PowerPoint to create conference posters, but I’m trying to switch to Inkscape

Collecting Data from Surveys and Interviews

Google Forms: for conducting surveys
Open Broadcaster Software (OBS): for recording interviews. The benefit of using OBS is that it works with any communication channel (Skype, Google Hangouts, etc…)

Data Analysis

Google Sheets and R Studio: for data exploration and analysis
RQDA: for qualitative data analysis (coding, memoing, generating themes)
Tidyverse: a set of packages for data science with R
DataGrip: when data-mining large SQL data sets

Creating Visualizations

Some visualizations (especially graphs) we create with R and R Studio
Draw.io: for diagrams and flowcharts
The data visualization catalogue and the data viz project: for choosing the type of visualizations to use
D3 library: great library for visualizations, very customizable
Tableau Public

Coding Tools / IDEs

Visual Studio Code: I recently started using it for learning React, and I really like it, reminds me a lot of Sublime Text
Eclipse: for Java
PyCharm: for Python
WebStorm
Sublime Text 3: for coding in Go
DataGrip: for exploring SQL databases
Robomongo: for exploring MongoDB databases
Docker
Insomnia: for working with REST APIs (better than Postman)
Heroku: for deploying projects
RegExr: for forming and testing regular expressions

App / Tool Design

Balsamiq: for low-fidelity mockups
InVision: for interaction design
UX Check: for identifying usability issues using Neilsen’s heuristic evaluation

Creating Video Demos

Shotcut: cross-platform video editing (works great in combination with OBS).

User Analytics

Website

Jekyll + GitHub pages: for my own personal website
Ghost: for our group’s website

Passwords

KeePassXC + chromeIPass: for storing and managing my passwords
Free OTP + YubiKey 4: for two-factor authentication

Backup

Duplicity: for encrypted local and remote backups

Running a Research Seminar

TinyLetter: for managing the seminar’s mailing list
GitHub Pages: for sharing seminar info and schedule

Course Teaching and Learning Management System

GitHub: I use GitHub for course material hosting and student assignment submission
GitHub Classroom

Tools I wish I could use, but they’re Mac-only

Sketch: for high-fidelity design
Screen Flow: for creating and editing app videos and tutorials
Origami Studio: for mobile interaction design
OmniGraffle: for diagrams and visualizations

What tools do you use?
Any recommendations for other tools I should try?

P.S. I’d love to meet you on Twitter.

Must-Reads for Doing Qualitative Research in SE

Wed, 19 Apr 2017 17:44:18 +0000

What papers and books would you consider as must-reads for software engineering researchers, especially for researchers that do qualitative studies? Here is my list of readings that I feel are important, seminal, or fundamental for conducting, communicating, and understanding software engineering research. In my opinion, each one of these provides important aspects.

In no particular order:

Methodology Matters: Doing research in the Behavioral and Social Sciences
by Joseph E. Mcgrath
Selecting Empirical Methods for Software Engineering Research
by Steve Easterbrook et al.
Preliminary Guidelines for Empirical Research in Software Engineering
by Barbara A. Kitchenham et al.
Qualitative Methods in Empirical Studies of Software Engineering
by Carolyn B. Seaman
Research Design: Qualitative, Quantitative, and Mixed Methods Approaches (4th edition)
by John W. Creswell
Case Study Research in Software Engineering: Guidelines and Examples
by Per Runeson et al.
Views on Internal and External Validity in Empirical Software Engineering
by Janet Siegmund et al.
‘Unsatisfactory Saturation’: A Critical Exploration of the Notion of Saturated Sample Sizes in Qualitative Research
by Michelle O’Reilly and Nicola Parker
The Truth, The Whole Truth, and Nothing But the Truth: A Pragmatic Guide to Assessing Empirical Evaluations
by Stephen M. Blackburn et al.

More specific aspects in qualitative research:

Constructing Grounded Theory (2nd edition)
by Kathy Charmaz
Grounded Theory in Software Engineering Research: A Critical Review and Guidelines
by Klaas-Jan Stol et al.
Developing a Grounded Theory to Explain the Practices of Self-Organizing Agile Teams
by Rashina Hoda et al.
Building Theories in Software Engineering
by Dag I.K. Sjøberg et al.
HCI, Natural Science and Design: A Framework for Triangulation Across Disciplines by Wendy E. Mackay and Anne-Laure Fayard
The Role of Ethnographic Studies in Empirical Software Engineering
by Helen Sharp et al.
Taxonomies in Software Engineering: A Systematic Mapping Study and a Revised Taxonomy Development Method
by Muhammad Usman et al.
Counting in Qualitative Research: Why to Conduct it, When to Avoid it, and When to Closet it
by David R. Hannah and Brenda A. Lautsch

There are many other recommended papers and books (too many to fit in a single blog post), so I tried to list the papers that should apply to most researchers. Have I forgotten to mention an important paper? Please let me know.

What papers or books do you feel are must-reads?
What would you recommend to new software engineering grad students?

P.S. I’d love to meet you on Twitter.

Operations and Speed in Startups

Tue, 07 Feb 2017 21:44:18 +0000

In the challenging and demanding world of startups, you may find yourself working hard for many hours, feeling busy but actually accomplishing little and barely “moving the needle”. Operations is not about the hours spent, but on how you work and which things you choose to work on. Many people see two dimensions here: Strategy and Execution. For early stage startups, execution is more about speed, while the strategy is about quality. Speed increases your chance of success and gives you more opportunities for learning before you run out of resources.

Moving the needle: making a noticeable (and measurable) difference in helping users.

It’s very common to find yourself working on many things that don’t “move the needle”, so to speak (e.g., refactoring, improving architecture, long-term improvements), but actually this can be a critical mistake for early stage startups (pre-seed, round A). It’s important to focus on doing things that “move the needle”.

“So often people are working hard at the wrong thing. Working on the right thing is probably more important than working hard.”

— Caterina Fake, Flickr co-founder

Consider the unit of execution you aim for (e.g., 1 week, 2 weeks, 1 month) — how often will you do something that moves the needle? This will dictate your work and decision making. A good rule of thumb, is to aim for the company to do something that moves the needle at least once a week or once every two weeks (in fact, ideally, each team member should contribute something that moves the needle in that time frame). If this doesn’t happen, there may be a problem with your strategy or with specific a team member.

Startups tackle big problems, but it’s very hard to tackle the whole problem. Typically, these big problems consist of many smaller things — so choosing what to focus on is critical. Equally important is to be able to gauge your speed.

Tools and Practices that Help with Speed

Culture of shipping.
Infrastructure that supports continuous deployment and shipping.
Efficient decision making process: Sometimes people believe they have to do more research on a topic, that they don’t have enough input, or that they need to reach an agreement or consensus in the team, eventually ending up delaying their decisions. In most cases it’s better to make a decision and change your mind later than to not make a decision. Jeff Bezos describes this perfectly in his annual shareholder’s letter.
Focus: Work on the most important thing first. Break down the most important thing to its basic layers and focus on the most important component.
Delegation and ownership: Allow people on your team to make decisions without the need to seek agreement with everyone.

“Most decisions should probably be made with somewhere around 70% of the information you wish you had. If you wait for 90%, in most cases, you’re probably being slow. Plus, either way, you need to be good at quickly recognizing and correcting bad decisions.”

— Jeff Bezos, CEO of Amazon

These insights are based on a podcast discussion by Eytan Levit and David Katz (original podcast is in Hebrew). I initially summarized these insights to share with students in my Startup Programming course, and later decided to share it here, too.

Setting up a Go Development Environment with Sublime Text

Wed, 28 Sep 2016 22:44:18 +0000

I really love the Go programming language, it feels like a mix of the best of Java and Python put together. But I found that setting a Go development environment can be slightly tricky, mostly in figuring out how to set up the proper path variables.

Here, I provide a short guide on how to set up a Go development environment with Sublime Text 3 on Ubuntu/Linux. I hope it saves you (and my future-self) time when installing, updating, or re-installing the development environment.

Installing / Updating Go

If you’re updating a previously installed Go version, you must first delete the older one:

sudo rm -r /usr/local/go

Download the latest version of Go archive from https://golang.org/dl/ and extract it:

sudo tar -C /usr/local -xzf go1.7.1.linux-amd64.tar.gz

Note: some people use the Go version manager (GVM) to install and set up Go, a tool similar to NVM which I highly recommend for Node.js, but for Go I prefer to set up everything myself.

Next, set the PATH environment variables by adding the following to .bashrc:

export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go

Here I use home/alexeyza/go as my workspace (which is $HOME/go), but feel free to change it according to your preference.

And, create your workspace:

mkdir -p ~/go/src/github.com/alexeyza

Setting up Sublime Text

Sublime text is my editor of choice for many things, and I highly recommend it for Go. If you don’t have it installed, start by installing Sublime Text 3, and installing the Package Control plugin.

Install GoSublime through package control (CTRL+Shift+P). It’s a Sublime Text plugin that provides Go code completion and other IDE-like features.

Next, set up the PATH environment variables for Sublime Text. This setting has slightly changed over time (which is why you may find different instruction variations online), but my current set up works with the following settings in Preferences -> Package Settings -> GoSublime -> Settings-User.
Make sure the GOPATH matches the path configured earlier.

{
    "env": {
        "GOPATH": "$HOME/go",
        "GOROOT": "/usr/local/go"
    }
}

Now, save and restart Sublime Text. When you first restart Sublime Text after installing GoSublime, it may take a few seconds to install and set up MarGo.

Building and Running Go code

You can build, compile, and run your code directly from Sublime Text. Use CTRL+B or CTRL+9 like so:

For additional help, type # help in the Sublime Text console.

Useful Go Plugins

Popular Go plugins that work well with GoSublime are GoOracle, GoImports, and GoDoc.

You can install them with:

go get -u golang.org/x/tools/cmd/oracle
go get -u golang.org/x/tools/cmd/goimports
go get -u golang.org/x/tools/cmd/godoc

Read more here on how to configure these plugins to work with GoSublime.

Programming with Go

A great starting point is the Introduction to Programming in Go book by Caleb Doxsey, and the JustForFunc: Programming in Go channel on YouTube.

Update: An Up and Coming Go IDE

There is a new and cool looking Go IDE, Gogland, created by Jetbrains (the company behind the awesome IntelliJ and PyCharm). Check out the early build on their website.

Getting Started with Node.js

Mon, 28 Sep 2015 20:21:02 +0000

The Node.js project and its community have undergone major changes in recent years, among which is the forking of the project (and perhaps the community itself). This situation causes confusion for newcomers, who find themselves with compatibility issues and difficulties in setting up a working and up-to-date environment.

In this post, I show how to get the recent version of Node.js on a Linux OS in an easy way.

What is Node.JS?

Node.js is an event-driven I/O server-side (backend) JavaScript environment based on Chrome’s V8 JavaScript engine. It is considered a very popular backend environment, and it uses NPM, the best package manager in my opinion (however, we’ll leave the discussion on what makes NPM so good for a different post).

At some point, Node.js was forked into two projects: Node.js and IO.js, causing compatibility issues and disputes in the community. While recently, these projects have been merged back with Node v4.x.

However, not everyone have caught on with the recent changes (which at some point should be a thing of the past). My OS of choice, Ubuntu, only supports Node.js 0.12.7 through the official repositories. Where version 0.12.7 is the latest stable version prior to the forking of the project. Thus, the best way to get the current version of Node.js on Linux is through NVM.

Removing the older version of Node

First, create a backup list of the previously globally installed NPM packages:

npm ls -gp > node_packages.txt

If you installed Node.js through apt-get, uninstall by using the following:

sudo apt-get remove nodejs

Additionally, your home folder may contain a .npm folder that can be removed (since NVM will use its own path for NPM packages).

Installing Node.js with NVM

Grab the latest copy of NVM (you may need to sudo apt-get install curl first):

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.27.1/install.sh | bash

Update NVM to latest version:

cd ~/.nvm
git pull origin master

Then restart your terminal window, and install the latest Node version:

nvm install stable

or if you want a specific version (e.g., version 4.1.1):

nvm install 4.1.1

And tell NVM which version of Node you want to use (when a specific version is needed):

nvm use 4.1.1

Define a default version, so that you don’t have to pick a Node version each time you start your terminal. This will activate the specified version each time the terminal starts, and it will do it silently.

nvm alias default stable

And lastly, check the installed version of Node:

node --version

When updating to a newer version:

nvm ls
nvm install stable
nvm ls
nvm uninstall 4.1.1

If later on you encounter errors with installing packages globaly, make sure your NODE_PATH is defined. You can do so by adding the following to ~/.bashrc or ~/.zshrc:

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm

export NODE_PATH=$NODE_PATH:/home/alexeyza/.nvm/versions/node/v4.1.1/lib/node_modules

If there are any issues loading the selected node version, make sure the above lines are at the bottom part of ~/.bashrc (the order matters).

The above steps are mostly based on a Stack Overflow answer and the NVM docs, with minor changes to make it more sustainable for future updates. If you prefer to install a system-wide Node.js with NVM, please follow this guide.

Embracing Participatory Culture in Education

Thu, 10 Sep 2015 18:41:54 +0000

GitHub is on the brink of growing from a platform for software projects, and into a mainstream collaboration platform for other domains as well. An unexpected area where GitHub’s collaborative workflow holds the potential to bring groundbreaking changes is education and learning. In fact, educators have already begun to use GitHub to support teaching and learning. In some cases using it to replace certain aspects of the traditional learning management systems (e.g., Blackboard, Moodle), while in other cases gaining new benefits and capabilities.

“It’s always about timing. If it’s too soon, no one understands. If it’s too late, everyone’s forgotten.”

— Anna Wintour

Beyond Software Development

GitHub is a popular Web-based social code sharing service that utilizes the Git distributed version control system. The software development community has embraced GitHub as an essential platform for managing their software projects. After just seven years, GitHub has 9 million registered users, and about 20 million unregistered visitors. Similarly, tools such as BitBucket and GitLab gain popularity in hosting software projects. More importantly, GitHub is far more than a code repository, it is a social meeting place, that supports communities of practice and fosters collaboration. People use it as a virtual meeting place, that supports discussions, and allows everyone to maintain awareness.

However, GitHub is not just for software development. We believe it is similar to other tools that are built for developers (e.g., Wiki, Stack Overflow), but end up being adopted by other knowledge workers. Early adopters use GitHub to compose music, to share recipes, and even for legal documents. For example, Stefan Wehrmeyer, a German software developer and activist has posted the German federal government’s laws and regulations to GitHub. Allowing anyone to track changes, see who made the changes, and why. Thus, not only providing traceability of the changes, but with the use of GitHub’s diff functionality showing what exactly has been changed. Similarly, the US federal code and the French civil code have been published to GitHub as well.

In addition to these marvelous uses, GitHub is used for educational purposes.

Our Study

My fellow researchers and I studied How and Why educators use GitHub. As a first phase, we searched for resources (such as blog posts and discussion groups) that described the personal experiences of educators using GitHub to support learning or teaching.

Next, we interviewed 15 educators that have used GitHub, including one of the blog authors from the previous phase. We were able to thoroughly investigate the usefulness and potential of GitHub in education. We then proceeded to interview John Britton, a representative from GitHub, in order to gain insights into GitHub’s perspective.

And finally, we conducted a follow-up survey to get feedback on our interpretation of the interview findings.

Why Educators Use GitHub

Traditional learning management systems (LMS) are a pain point for many educators (including myself). The basic purpose of these systems is to allow educators to share course material with the students, and to host student assignments. However, in reality, we end up using a combination of LMSs, and external services, while somehow most of the communication happens over email.

On top of that, access to the course material or the assignments is limited to current students only. Which doesn’t include students who completed the course and want to reuse the material, other educators, or industry people who may share their own experience. This is not a hypothetical situation, I’ve seen this happen first hand, more than once (both as a student and as an educator).

GitHub may not solve all these problems, but our study reveals extraordinary benefits to educators who used it.

By using GitHub, educators can share and collaborate on course material. When a fellow educator wants to teach a similar course, all that she needs to do is fork the original course on GitHub. And if she improves it, other educators are aware of the changes and can integrate them back to their courses as well.

“Some of the material is shared with the world and some of it is shared with other instructors of other universities…We’re versioning all of it.”

— CS professor from University of California at Berkeley

Furthermore, one of the interviewees shared the following unexpected situation:

“I think the repository has something like 200 stars on GitHub right now and as far as I can tell most of those stars are from people who didn’t take the course.”

— CS instructor from Harvard University

Suddenly, the course grows beyond the classroom, allowing the exchange of ideas and knowledge among students and external people (e.g., practitioners and experts from the industry).

Transparency of Activity

Using GitHub as a submission platform also makes it easier for educators to monitor student progress, activity, and participation. GitHub has numerous features that support transparency of student activities, e.g., graphs and the news-feed that aggregates all the activity in one place.

“[As an educator] you really see the full history of how the document comes into being, including all the discussions, the former versions. I can monitor who’s active, working in certain teams, which is also handy, practical.”

— CS professor from Delft University of Technology

Encourage Participation

By using GitHub educators were able to encourage participation. In one case, the instructor used student logs as material for discussion in class. Another example was where students submitted an issue followed by a Pull-Request, mechanisms that are usually used to discuss bugs or code changes, in order to change a deadline.

“Last year, I introduced a number of deadlines in between, and the time of the deadline was always Friday evening. And the students didn’t like it, so they opened an issue on GitHub - “Can we move it?”. So I said, I’m open to suggestions, please discuss it. Everyone responded to that issue on GitHub, and then at the end I said “based on the discussion, it is going to be on Sunday”. And then I asked the student who initiated this discussion “Please, open a Pull Request where you provide the fix to the assignment, so the Friday now changed to Sunday”. And that worked really nicely.”

— CS professor from Delft University of Technology

Industry Relevance

Educators also use GitHub to provide their students with industry relevant skills and tools.

“This is very much what people use these days in [statistics], and so I actually consider it a completely valid pedagogical goal in and of itself. And the fact that it makes our work together easier is a beautiful byproduct.”

— Statistics professor from University of British Colombia

Furthermore, GitHub can also be used as a portfolio showcasing the student’s work. It is common for employers to evaluate candidates based on their existing projects and activity on GitHub.

Incidental Benefits

There are incidental benefits as well. Educators mentioned the ease of use, where you don’t have to use complex university systems, instead you can use your existing tools and just “push the changes”. Additionally, GitHub provides free academic licenses, both at the “student level” and at the “organization level”.

How Educators Use GitHub

With course material hosted on GitHub, students (or other educators) can discuss and suggest corrections to the material with the use of Pull-Requests or issues. For example, in a course I taught, students submitted corrections to the material by using pull requests. We didn’t require them to do so, and it was not part of the grade - they did it on their own. Some educators even give extra credit for accepted pull requests. This is a game changer benefit of using a system like GitHub - it improves quality and encourages collaboration, benefiting everyone.

Additionally, educators use GitHub as a submission platform. And there are two main ways to do it. One is more similar to the traditional LMS, where you create a separate repository per student, and it’s private. The second way is having a single repository for the assignment, and the students will fork or branch it. This way all of the students can see each others work, allowing them to collaborate and build on the work of others.

Not Quite Ready for Prime-time, Yet

Our study uncovered how educators use GitHub to support learning and teaching, while extending or even replacing traditional LMSs. However, the implications of our findings go beyond GitHub itself. The emergence of GitHub’s workflow within education is transforming the traditional e-learning model and will better support socio-collaborative learning environments of the future. I would also like to strongly recommend reading GitHub for the rest of us by Jon Udell.

It should be mentioned that GitHub was not designed as an LMS, and even though it can be used as such, there are several challenges involved. The main challenges are the lack of a shared knowledge base of suggested and best practices, and the barriers to entry educators face (i.e., an understanding of Git is required).

“To get the most out of GitHub, you need to understand Git… if you use it the right way it is simple, but somehow with Git you end up with conflicts, and if you don’t understand it, it’s magic!”

— CS professor from Delft University of Technology

Planning to Use GitHub? Here’s What You Should Do

Privacy is not all or nothing. GitHub allows for various visibility levels, depending on how you set up the repository. Make sure to explore these possibilities.

Use Markdown when possible. A plain text file format will enable you to take advantage of the diff and line-commenting functionalities. And Markdown’s markup language is very simple to learn, while supporting stylized documents.

Share your experience, and learn how others use GitHub. We, as a community, need your help in contributing to and shaping a shared knowledge base.

Learn Git’s workflow. Understanding Git’s workflow (commits, branches, conflicts) will give you a better understanding how GitHub works and how it can be best used.

Be creative. There are additional ways to enhance the teaching and learning experience. For instance, some educators use Travis CI for automated assignment grading.

Have you used or plan to use GitHub to support teaching or learning? What was the biggest challenge for you? What recommendations do you have for other educators? Please comment below.

P.S. I’d love to meet you on Twitter.

Published Research

Additional details on this study can be found in our paper that was presented at the CSCW 2015 conference, with the slides available online as well. We are extremely grateful to all the interview and survey participants.

I would also like to thank Margaret-Anne Storey, Leif Singer, and Maryi Arciniegas Méndez for providing feedback on early versions of this post.

This post has been shared on the CHISEL group’s blog, The Winnower, and on Storybench.

Command Line Fun

Wed, 02 Sep 2015 22:42:19 +0000

I recently discovered a superb podcast on startups (in Hebrew). And, I wanted to download the episodes, so that I can listen to it when I commute to work. The podcast homepage has a page for each episode, with a download link at the bottom.

However, instead of downloading each episode manually, I decided to find an easier way, with the use of the command line. And to make it more interesting, I wanted to accomplish this with a single command line.

wget -q -O - "$@" http://simplecast.fm/podcasts/173/rss | grep -o "http://.*.mp3" | xargs wget

The first part brings the content, in quiet mode, to allow piping into grep. The second part extracts the episode file names and paths, in my case they are all mp3 files. And the last part downloads all the files. I used the RSS feed instead of the podcast homepage as a way to have all the content in a single file.

I wonder, can this be done with a single wget command?

BTW, a useful tool for experimenting with regular expressions is RegExr.

5 Tips for Successfully Meeting People at Academic Conferences

Fri, 06 Feb 2015 19:34:07 +0000

As a Ph.D. student, I have the opportunity to attend many cool conferences and co-located events (e.g., ICSE, CSCW, ICSME). However, beyond visiting beautiful places around the world (Switzerland, India, Canada, and Italy soon), I really enjoy meeting and connecting with people. In my experience, most people I’ve met at conferences were really great, super nice, and were very happy to talk to me, even though they didn’t actually know me or had any immediate outcome in mind. In this post I provide pointers—especially intended for new grad students—for meeting people at conferences.

1. Stop “Networking” and Just Meet People

At one of the conferences I attended recently, I was approached by another Ph.D. student. After he introduced himself, he allowed me to introduce myself, and then asked about my research topic. After describing my research topic, he politely left. The problem here, in my opinion, was that except getting to know my name and my research topic, we didn’t actually have a real conversation. And to be honest, the encounter didn’t leave enough of an impression and in the future, it would be hard for me to remember meeting him.

My main takeaway is that you should not focus on networking at conferences. I feel this is one the biggest mistakes people do, as they approach networking in a technical and goal oriented manner (saying things like “I have to talk to 50 strangers at this conference”). The goal should not be to (shallowly) meet X people in Y amount of time. Instead I suggest to genuinely be interested in meeting and connecting with other people. Have a proper conversation - you may never know where this conversation will go. I have had many amazing conversations (not necessarily research related) with people I just met, people who later became my colleagues or dear friends.

2. Don’t Be Afraid to Approach People

A good way to meet people, especially for new students, is through an introduction. An introduction can be done either by your supervisor, one of your colleagues, or one of the newly met people. However, since not all supervisors might do this, you should introduce yourself. If you already have some experience and know the community, make sure to help newcomers.

A very common way to meet people at conferences is to just approach them. I suggest the following: Start by introducing yourself, and get to know their name and where they come from (you can use the conference-issued name tags). Next, ask if they are presenting or have presented a paper at the conference. If they have a paper, you can ask them to tell you about the paper. If not, you can ask about their research interests. If you attended their talk, you should definitely mention that, and use their presentation as a way to start a conversation. Notice that this is not a script, but rather suggested guidelines to start a conversation.

Remember that the main point of conferences is meeting people from your research area. This means that everyone has a common goal, so there is no reason to be afraid to approach people! Most are probably anxious as well, and would be thankful for a conversation.

“Students are sometimes afraid to talk to professors, but they shouldn’t be. Many professors are very approachable. Some may be busy, so if they seem distracted don’t take it personally. On the other hand, some students only approach well-known people, rather than being open to meeting anyone.”

— Margaret-Anne Storey

When attending conferences, I recommend taking part in the various social events (official and unofficial). Most conferences will arrange a least a few organized social events: a dinner, a banquet, a hike, a bicycle trip, etc. However, there are also unofficial social meetings, such as groups of people gathering together for dinner. Attending these events will allow you to better connect with and get to know various people. Besides, these events are extremely fun (and usually lead to memorable moments).

Following and participating in the discussions happening on Twitter is another good way to get to know people in the community, and its research themes. The basic information on Twitter can allow you to know the names and faces of some of the people, and make it easier to approach them. In some cases, Twitter may also be used for coordinating social gatherings (e.g., when a group is organizing to go for dinner). However, using Twitter should not be a replacement for meeting people face-to-face.

Most conferences nowadays have a presence on Twitter, and often people are live-tweeting during the conference. Using the conference or event hashtags (e.g., #icse14, #icsme14) and tools like TweetDeck are a very convenient way to track all the related tweets.

5. Don’t Be Afraid of Lack of Experience

A common fear among newcomers is the lack of experience in research or in published papers. However, this should not be an issue at all. The research community is very welcoming, and the people you’ll meet will most likely give you some suggestions and guidelines. Moreover, they probably had similar challenges before and know how you feel. Don’t hesitate to be open about your lack of experience or the fact that you are a newcomer (e.g., a new student). Remember to be yourself.

“One thing that worked very well for me at ICSE 2011 was that I knew in advance which cool people would be there. I was interested in and impressed by their research, and made it a point to try to meet and talk to them. When you’re interested in what someone does it’s also much easier to come up with questions to ask them. This leads to much better conversations.”

— Leif Singer

I hope you’ll find this post useful. If you see me at a conference, please come by and say hello. Also, a recommended book is “How to Win Friends and Influence People” by Dale Carnegie.

How was your own experience with meeting people at conferences? Do you have a cool story where something happened only because you pushed yourself out there?

P.S. I’d love to meet you on Twitter.

Alexey Zagalsky

Teaching Information Visualization

Books

Software and Tools

Inspirational People in the Field

My Toolbox

Writing and Collaborating on Papers

Preprints and Study Data Sharing

English Prose

Team Communication

Schedule and Time Tracking

Keeping Up To Date

Knowledge Management and To-Dos

Presentation Slides

Posters

Collecting Data from Surveys and Interviews

Data Analysis

Creating Visualizations

Coding Tools / IDEs

App / Tool Design

Creating Video Demos

User Analytics

Website

Passwords

Backup

Running a Research Seminar

Course Teaching and Learning Management System

Tools I wish I could use, but they’re Mac-only

Must-Reads for Doing Qualitative Research in SE

More specific aspects in qualitative research:

Operations and Speed in Startups

Tools and Practices that Help with Speed

Setting up a Go Development Environment with Sublime Text

Installing / Updating Go

Setting up Sublime Text

Building and Running Go code

Useful Go Plugins

Programming with Go

Update: An Up and Coming Go IDE

Getting Started with Node.js

What is Node.JS?

Removing the older version of Node

Installing Node.js with NVM

Embracing Participatory Culture in Education

Beyond Software Development

Our Study

Why Educators Use GitHub

Reuse and Sharing of Knowledge

Transparency of Activity

Encourage Participation

Industry Relevance

Incidental Benefits

How Educators Use GitHub

Not Quite Ready for Prime-time, Yet

Planning to Use GitHub? Here’s What You Should Do

Published Research

Command Line Fun

5 Tips for Successfully Meeting People at Academic Conferences

1. Stop “Networking” and Just Meet People

2. Don’t Be Afraid to Approach People

3. Attend Social Events, Not Just The Conference

4. Take Advantage of Social Media

5. Don’t Be Afraid of Lack of Experience