Teaching with a document camera

How does an “old-school” document camera work for modern-day teaching? Remarkably well, I think. Here are some thoughts on my experience over the last few years.

The reason I got started with a document camera was because I felt the need for a more flexible setup for my classroom teaching. Conference presentations with limited time are better done with linear presentation tools, I think, since the slides help with the flow. But for classroom teaching, in which dialogue with students is at the forefront, such linear presentation tools do not give me the flexibility that I need.

Writing on a black/whiteboard could have been an option, but in many modern classrooms these have been replaced by projector screens. I also find that writing on a board is much more tricky than writing with pen on paper. So a document camera, which is essentially a modernized “overhead projector”, is a good solution.

After a little bit of research some years back, I ended up buying a Lumens Ladibug DC193. The reason I went for this one, was because it had the features I needed, combined with being the only nice-looking document camera I could find (aesthetics is important!). A nice feature is that it has a built-in light, which helps in creating a better image also when the room lighting is not very bright.

My Lumens Ladibug DC193 document camera is red and has a built-in light.

One very useful feature of the document camera, is the ability to connect my laptop to the HDMI input on the Ladibug, and then connect the Ladibug HDMI output to the screen. The built-in “video mixer” makes it possible to switch between the document camera and the computer screen. This is a feature I have been using much more than I expected, and allows me to change between slides shown on the PC, some hand-writing on paper, and showing parts of web pages.

When I first got the document camera, I thought that I was going to use the built-in recording functionality a lot. It is possible to connect a USB drive directly to the camera, and make recordings. Unfortunately, the video quality is not very good, and the audio quality from the built-in mono microphone is horrible.

One of the best things about a document camera is that it can be used for other things than just showing text on paper. This is particularly useful when I teach with small devices (instruments and electronics) that are difficult to see at a distance. Placing them on the table below the camera makes them appear large and clear on the screen. One challenge, however, is that the document camera is optimized for text on white paper. So I find that it is best to place a white paper sheet under what I want to show.

Things became a little more complicated when I started to teach in the MCT programme. Here all teaching is happening in the Portal, which connects the two campuses in Oslo and Trondheim. Here we use Zoom for the basic video communication, with a number of different computers connected to make it all work together. I was very happy to find that the Ladibug showed up as a regular “web camera” when I connected it to my PC with a USB cable. This makes it possible to connect and send it as a video source to one of the Zoom screens in our setup.

When teaching in the MCT Portal, I connect the Ladibug with USB to my PC, and then send the video to Zoom from my laptop.

The solution presented above works well in the Portal, where we already have a bunch of other cameras and computers that handle the rest of the communication. For streaming setups outside of the Portal I have previously shown how it is possible to connect the document camera to the Blackmagic web presenter, which allows for also connecting a regular video camera to the SDI input.

More recently I have also explored the use of a video mixer (Sony MCX-500), which allows for connecting more video cameras and microphones at once. Since the video mixer cannot be connected directly to a PC, it is necessary to also add in the Blackmagic web presenter in the mix. This makes for a quite large and complex setup. I used it for one remote lecture once, and even though it worked, it was not as streamlined as I hoped for. So I will need to find an easier solution in the future.

Exploring a more complex remote teaching setup, including a video mixer in addition to document camera and web presenter.

What is clear, however, is that a document camera is very useful for my teaching style. The Ladibug has served me well for some time, but I will soon start to look for a replacement. I particularly miss having full HD, better calibration of the image, as well as better recording functionality. I hope manufacturers are still developing this type of niche product, ideally also nice-looking ones!

Some tips and tricks when writing academic papers

I have been teaching the course Research Methods, Tools and Issues in our MCT programme this semester. The last class was an “open clinic” in which I answered questions about academic writing. Here is a summary of some of the things I answered, which may hopefully also be useful for others.

Formatting

Your academic exam paper is not the place to experiment with fancy layout and formatting. Some basic tips:

  • Template: Choose a conservative template (but not too old-school). Check that it is in A4, as templates using a North-American “letter” paper size looks weird when/if printed in A4.
  • Font: A serif font typically looks more serious than a sans-serif, so “Times New Roman” or something similar is the safest choice.
  • Paragraphs: There are different ways of formatting paragraphs. The two most common ones are: (1) indented first lines, (2) spaces between lines. The first type is the most common in professional type-setting and is what you see in books and academic journals. It is also the most space-conservative. Making spaces between lines is what most people do when they write on computers. Choose whichever type you want, but do not mix the two.

Writing

It is impossible to cover everything about academic writing here. But these are the things I usually comment on when I supervise:

  • Long sentences: It is better to write short and meaningful sentences than long and complex ones. Many students think that their text will look more academic if they make long sentences. The truth, however, is that it is much more pleasurable to read well-formed and meaningful sentences. The general rule of thumb is to include only one point in a sentence. If in doubt, start a new sentence. It also helps to read your text out loud. Whenever you feel that
  • Short sentences: Some students only write very short sentences. This is not good either, so find a balance.

Spelling and grammar

Whatever you do, ensure that your texts are not full of spelling mistakes. You should also reduce the number of grammatical errors. There are so many tools available to help you these days, so there is no excuse for not using them before you submit your final text.

Figures

Figures are nice, please include them! But when you do, always think about this:

  • Label: Figures should always have a figure name (“Figure 1”) followed by an explanation of what the figure is about (“This figure shows…”). Ideally, the figure text should be sufficient to understand what the figure aims at conveying of information. Many people (like myself) like to browse through papers and books quickly, and use the figures as a way to quickly navigate the content. Then it helps if the figure texts are self-explanatory.
  • Text size: Figures are often made in different software than where you write. This means that you typically do not have full control of their size in the final layout, hence the text inside of the figure may be too large and too big. As part of the final layout, you should try to make the text size similar to the text size of the main document within which the figure is placed.
  • Units, labels and legends: If you include graphs or other types of representations of numbers, it is critical to include information about what the axes mean and the units that you have used (“Time (s)”, “Number of people”, “Vertical position (mm)”). You should also have clearly marked legends (if relevant) to explain what the different lines in your figure are.
  • Simplify: You should always aim to remove unnecessary stuff from figures so that the most important things are what people see. This follows Tufte’s ideal of aspiring for a high “data-ink ratio”.

References

Adding references to your text, and including a bibliography at the end of your document, is the clearest sign that you are writing an academic paper.

  • Consistency: Ensure that all citations have an entry in the bibliography. Similarly, all entries in the bibliography should be referenced in the text.
  • Reference manager: Use a reference manager to keep track of everything. While it is not perfect, I generally recommend Zotero. It works on all platforms, has an online front-end, and integrates with many writing platforms.

Submission

  • PDF: If you are not asked to do otherwise, always submit a PDF file. This will ensure that both content and layout are preserved for the final reader. Submitting your “raw files” (.docx, .pages, .odt, etc.) is problematic for a number of reasons. First, they may not be readable by people on different platforms (.pages files only work on OSX, for example). Second, often such raw files contain the history of the file, which you may not want the end reader to see. This may be particularly important if you have been using track changes.
  • Good naming: Always give your file a useful name. If your exam is anonymous, include your candidate number in the file name. If not anonymous, include your last name. Your examiner will probably download a zip-folder with all submissions. Having a bunch of files with names such as “exam.pdf”, “submission.pdf”, etc., is annoying.
  • Supplementary files: It is often fine/useful/required to submit supplementary material. Then it is usually good to have a list at the end of your main document describing what you have chosen to include (for example, a list describing audio files). If you have many supplementary files, you should zip them down and give them a useful name. Again: remember that the reader will download your submission together with a bunch of other things. It is your job to make the read as pleasurable as possible.

General form

The standard “IMRAD” form of a paper looks like this:

  • Abstract
  • Introduction
    • Motivation (could include a rhetorical question/something catchy)
    • Research question(s)
    • (Hypotheses)
    • Definitions
    • Limitations / scope
    • Overview of the paper
  • Background (either chronological or topical)
  • Methods (be precise – explain what you did, how, etc)
  • Results
  • Discussion
  • Conclusion

Many interaction papers, and also “NIME-like” papers, have a form something like:

  • Abstract
  • Introduction
  • Background
  • Method
  • Design
  • Implementation
  • Evaluation / Discussion
  • Conclusion

Carpentries Train the Trainer

I have spent the two last days at a “Train the Trainers” workshop organized by the Carpentries project. Here I will summarize some thoughts on the workshop, and things that I will take with me for my own teaching practice.

The Carpentries

The Carpentries project comprises the Software Carpentry, Data Carpentry, and Library Carpentry communities, with a shared mission to teach foundational computational and data science skills to researchers. I have taken several Carpentries lessons over the last years, organized by volunteers here at the University of Oslo.

One of the best things about the Carpentry workshops, is that they are very practical. The idea is that you learn some concrete skills, in a hands-on manner. I also like that the workshops are very inclusive. Everyone can participate and in my experience you always find a mix of students, support staff, postdocs and faculty members. It is very rewarding to get acquainted to people outside your regular “bubble”, and it definitely creates a different learning environment than the normal student-oriented semester-long courses. I also think it is healthy for everyone to see professors struggle with the same things as everyone else.

Another great thing about the Carpentries is the focus on short, intensive workshops with a clear focus. This is an example of what I like to call micro-education, as opposed to our regular focus on semester-long courses and year-long degrees. In an ever-changing world, everyone needs to learn new things all the time. I don’t think universities (in general) do enough to meet this need.

Own practice

Inspired by some of the Carpentries courses I had participated in, I decided to develop a carpentry-inspired course myself: Quantitative Video analysis for Qualitative Research. This short workshop is intended as a tutorial for the Musical Gestures Toolbox for Matlab, and was developed with the Carpentries template.

The course material template is but one thing of the Carpentries. There is also a teaching philosophy that I wanted to learn more about. So when I was challenged (and inspired) to become a certified instructor myself, I decided to sign up for the instructor training.

Online instructor training

I am more than averagely interested in new learning methods, so I was curious to see how the Carpentries instructor training was carried out. For the training we were around 20 learners from around the world and two instructors. One of the instructors, Lex Nederbragt, is working at UiO, and he had secured that the six of us that were taken the training from Oslo where gathered in one room on campus. Such a mix of on-campus and off-campus learners is an interesting challenge in itself. Having a sizeable minority of learners being physically co-located creates a different group dynamic than if everyone had been sitting separately.

The video communication was run on Zoom, a platform I have become very acquainted with through the MCT master’s programme. As opposed to Skype, Hangouts, and similar, Zoom consistently works reliably on all platforms (including Ubuntu), and it has great support for handling changing hardware. I have been adding/removing sound cards, headsets, cameras, etc. during Zoom sessions without any issues. Most other solutions would crash or require restarts to make this work.

Another nice thing about Zoom is that allows for creating breakout rooms, which means that a larger group can be split into sub-groups for local discussion. The instructors used this very effectively during the training, splitting us up in smaller groups for exercises throughout the days. The only challenge here was for the six of us sitting physically together. We had to also split up and move into different rooms for these exercises. It worked fine, but it is interesting to reflect on the different experience the Oslo group had from the online participants. Personally I connected primarily with the local Oslo people, and did not interact at all with any of the online participants. I think it might have worked better for the whole group if everyone had been sitting separately. That way we could all have collaborated more easily.

Take-aways

Some of the most interesting things I picked up during the training:

Mental models: It is important to identify the different mental models that learners may use for any given task. These can be used as the starting point for developing better formative assessment, such as creating good wrong answers to multiple choice tests. Rather than just making randomly wrong answers, they should be based on different mental models that one may assume that the learners may have.

Developing skill: Carpentries embrace the Dreyfus model of skill acquisition and the need to move upwards through Bloom’s taxonomy. While I generally agree with this, I often like to start on top of the Bloom pyramid. In my experience, having people feel that they “master” a tool quickly often help in making them interested in learning more about the underlying concepts. Not everyone wants to become software engineers, most people just want to learn enough to solve their problem.

Concept maps: This is a tool to help develop a complete lesson through drawing a picture of someone’s mental model of a domain: facts are bubbles, and connections are labelled arcs. It is particularly important to explain what the relationship is. Planning how different parts of a course is interconnected is very important, but is something that many of us don’t spend enough time on, I think.

Teach as a learner: This is related to using the mindset of a learner when teaching. Acknowledging your faults as a teacher may be a good strategy for helping students learn more themselves.

Never teach alone: I fully agree with this one. Teaching together helps identify learners that struggle with something, and it is a good way to develop better teaching practice with a colleague. The challenge, of course, is that we usually don’t have the resources available for two teachers for most university courses.

Teach slowly: the live coding strategy employed at Carpentries is an effective way of slowing down the teacher, and makes it easier to follow along.

Make and solve errors: live coding also means that errors will have to be handled on the fly by the instructor. There is a lot of learning involved in seeing someone else troubleshoot code, so this should be embraced. I have been live coding as a teacher for more than a decade now, so I am very used to it. But I still remember how challenging it was to get started with all the realtime, public error-handling in the beginning.

Code of conduct: The Carpentries are very conserned about being an inclusive community. Thus the code of conduct is easily available on the web pages, and it is also explicitly mentioned at the beginning of lectures. I think this is something that should be embraced more generally in teaching.

Feedback strategies: There is a very structured approach to feedback in Carpentries:

  • Feedback is delivered in the form of pre-workshop and post-workshop questionnaires. This is useful to learn about the learners’ skills before the course, but also to follow their progression from beginning to end.
  • Minute cards are used before lunch with the focus on writing down one positive thing and something that could be improved.
  • 1up-1down evaluations are used to receive oral feedback from each of the learners.

Stick-it notes: We didn’t use it during the instructor training, but the use of stick-it notes is another “feature” of Carpentries. When carrying out tasks, learners put a yellow stick-it on their laptop when they are done, and put a read if they have questions. This is an efficient way of ensuring that people are on track or have problems.

Summing up

All in all it was very interesting to take part in the instructor training. I have been doing many different types of teacher training over the years, but this one was by far the most practical and hands-on. As such, it fits nicely into the Carpentry philosophy: provide hands-on tools for real-world problems.

I am looking forwards to developing and running my own Carpentry-courses in the coming years, and I am also quite sure that I will use several of these methods in other teaching as well.

NIME publication: “NIME Prototyping in Teams: A Participatory Approach to Teaching Physical Computing”

The MCT master’s programme has been running for a year now, and everyone involved has learned a lot. In parallel to the development of the programme, and teaching it, we are also running the research project SALTO. Here the idea is to systematically reflect on our educational practice, which again will feed back into better development of the MCT programme.

One outcome of the SALTO project, is a paper that we presented at the NIME conference in Porto Alegre this week:

Xambó, Anna, Sigurd Saue, Alexander Refsum Jensenius, Robin Støckert, and Øyvind Brandtsegg. “NIME Prototyping in Teams: A Participatory Approach to Teaching Physical Computing.” In Proceedings of the International Conference on New Interfaces for Musical Expression. Porto Alegre, 2019.

MCT at NIME
Anna Xambó presents the paper “NIME Prototyping in Teams: A Participatory Approach to Teaching Physical Computing” at NIME 2019.

Abstract:

In this paper, we present a workshop of physical computing applied to NIME design based on science, technology, engineering, arts, and mathematics (STEAM) education. The workshop is designed for master students with multidisciplinary backgrounds. They are encouraged to work in teams from two university campuses remotely connected through a portal space. The components of the workshop are prototyping, music improvisation and reflective practice. We report the results of this course, which show a positive impact on the students on their intention to continue in STEM fields. We also present the challenges and lessons learned on how to improve the teaching and delivery of hybrid technologies in an interdisciplinary context across two locations, with the aim of satisfying both beginners and experts. We conclude with a broader discussion on how these new pedagogical perspectives can improve NIME-related courses.

Testing reveal.js for teaching

I was at NTNU in Trondheim today, teaching a workshop on motion capture methodologies for the students in the Choreomundus master’s programme. This is an Erasmus Mundus Joint Master Degree (EMJMD) investigating dance and other movement systems (ritual practices, martial arts, games and physical theatre) as intangible cultural heritage. I am really impressed by this programme! It was a very nice and friendly group of students from all over the world, and they are experiencing a truly unique education run by the 4 partner universities. This is an even more complex organisational structure than the MCT programme that I am involved in myself.

In addition to running a workshop with the Qualisys motion capture system that they have (similar to the one in our fourMs Lab at RITMO), I was asked to also present an introduction to motion capture in general, and also some video-based methods. I have made the more technically oriented tutorial Quantitative Video analysis for Qualitative Research, which is describing how to use the Musical Gestures Toolbox for Matlab. Since Matlab was outside the scope of this session, I decided to create a non-technical presentation focusing more on the concepts.

Most of my recent presentations have been made in Google Presentation, a tool that really shows the potential of web-based applications (yes, I think it has matured to a point where we can actually talk about an application in the browser). The big benefit of using a web-based presentation solution, is that I can share links to the presentation both before and after it was held, and I avoid all the hassle of issues with moving large video files around, etc.

Even though Google Presentation has been working fine, I would prefer moving to an open source solution. I have for a long time also wanted to try out markdown-based presentation solutions, since I use markdown for most of my other writing. I have tried out a few different solutions, but haven’t really found anything that worked smoothly enough. Many of the solutions add too much complexity to the way you need to write your markdown code, which then removes some of the weightlessness of this approach. The easiest and most nice-looking solution so far seems to be reveal.js, but I haven’t really found a way to integrate it into my workflow.

Parallel to my presentation experimentation, I have also been exploring Jupyter Notebook for analysis. The nice thing about this approach, is that you can write cells of code that can be evaluated on the fly, and be shown seamlessly in the browser. This is great for developing code, sharing code, teaching code, and also for moving towards more Open Research practices.

One cool thing I discovered, is that Jupyter Notebook has built-in support for reveal.js! This means that you can just export your complete notebook as a nice presentation. This is definitely something I am going to explore more with my coding tutorials, but for today’s workshop I ended up using it with only markdown code.

I created three notebooks, one for each topic I was talking about, and exported them as presentations:

A really cool feature in reveal.js, is the ability to move in two dimensions. That means that you can keep track of the main sections of the presentation horizontally, while filling in with more content vertically. Hitting the escape button, it is possible to “zoom” out, and look at the entire presentation, as shown below:

The overview mode in reveal.js presentations.

The tricky part of using Jupyter Notebook for plain markdown presentations, is that you need to make individual cell blocks for each part of the presentation. This works, but it would make even more sense if I had some python code in between. That is for next time, though.