J is an APL-like array programming language. It was developed in collaboration with Ken Iverson. The documentation online, especially the tutorials and educational material, is exemplary. This weekend I worked through the J primer. If you can ignore the rhapsodic evangelism for the language, then it’s a robust and thought-provoking introduction to a very different way of programming.

One of my motivations for learning something about J is to understand this article about a combinatorics problem with an application in music theory. Because arrays (and their generalization, n-dimensional matrices) are of fundamental importance in J, it is possible to write a very terse program to compute a twelve-tone matrix. Not a “for” loop in sight!

A post on the Google Research blog today announced

the open-sourcing of Embedding Projector, a web application for interactive visualization and analysis of high-dimensional data

Over the summer, I presented work (co-authored with Jaan Altosaar) on the application of word embedding models to a large–and admittedly noisy–corpus of classical music. It appears that word embedding models capture something about sequences of chords. Our work, and related recent work with a different dataset, shows that that major triads are somewhat evenly distributed through the embedding space, in their circle-of-fifths order.

For a project I am currently working on using the Processing programming language, I use the provided Table class to read in data from a flat CSV file.

The column names in this file have to match parameters specified elsewhere in the code. As a consquence, when validating the data from the file, I need access to the column names.

There is an undocumented private field in all instances of the Table object which contains the column names (when the flag to treat the first line of the file as column headers is flipped in the Table constructor).

This post is timely given RTE’s recent publication of their analysis of social media usage during the 2016 general election in Ireland, available here. It looks like they’ve partnered with the ADAPT Centre for Digital Content Technology to produce the Twitter data and Facebook for that content. It’s a pity that they:

1. don’t indicate the source of their data
2. don’t indicate on what basis were Tweets deemed to be about the election (was it simply the presence of the #ge16 hashtag?)
3. don’t indicate the basis for the topic codings
4. don’t mention the sentiment analyser algo (state of the art is still pretty far from robust, often missing e.g. sarcasm)
5. don’t indicate what consitutes a “mention” of a political party.

It would be great to take on each of these, but I only have time to examine the topics that were identified in online Twitter posts. Ranked by volume (presumably over tweets tagged with #ge16, but I don’t know) they are:

Last night, at the suggestion of a friend, I took a midi performance of the first movement of Beethoven’s Op. 2, No. 1 (a piano sonata in F minor) and squashed it all into the one octave. It’s a sort of pitch-class version of the movement, where each pitch-class is represented by a real pitch, bounded to a given octave of the piano. But there are twelve different ways to do this, since the “destination” octave could be bounded by twelve different pitch-classes. This is the offset parameter referred to in the playlist. Different offsets lend each flattening a slightly different character, due to the fact that different pitch classes will end up with different registers in each iteration. The code for this experiment is forthcoming. It was made possible with pretty-midi and pyfluidsynth.

Today I was working on getting as many YouTube comments out of the internets as was possible. I’m sure that my code has a long way to go, but here’s one speed-up that a naive first day out with multiprocessing and requests generated.

import requests
import multiprocessing

BASE_URI = 'http://placewherestuff.is/?q='

def internet_resource_getter(stuff_to_get):
  session = session.Session()
  stuff_got = []
  
  for thing in stuff_to_get:
    response = session.get(BASE_URI + thing)
    stuff_got.append(response.json())

  return stuff_got
  
stuff_that_needs_getting = ['a', 'b', 'c']

pool = multiprocessing.Pool(processes=3)
pool_outputs = pool.map(internet_resource_getter,
                        stuff_that_needs_getting)
pool.close()
pool.join()
print pool_outputs

It’s been while, again, since I’ve blogged. And I’m sort of concerned about how to fix that. Do I commit to a post a day? There’s a bit of pop pyschology floating around that you should never tell your goals to anyone. Doing so only gives you a dopamine dose of self-satisfaction that actually reduces your likelihood of completing the project. Why go for delayed gratification at all if you can get your hit of happy by telling all your friends what you plan to do.

See the GitHub repo here

I suck at Python. I write Python like I’m still 10 years old, programming in QBASIC. I don’t even need to be a good better programmer in my line of work (I’m a music student), but it’s something that I’ve wanted to work on for a while, and I know the only way to improve is to write, write, write.

I love iPython Notebook (a.k.a. Jupyter + Python 2 kernel) because it allows me to mess up, fix my mistakes, and run the code again. It also supports cells that contain prose, rendered from Markdown source, so it’s a perfect engine for blogging about the code that I intend to write, using the same tool I’m writing the code with.

1. Download this version (R2012b a.k.a. v80) of the Matlab Compiler Runtime.

2. Follow the instructions carefully and make sure to modify the LD_LIBRARY_PATH and XAPPLRESDIR environment variables appropriately. These changes can be made permanent in your shell startup profiles.

3. Trusty Tahr (14.04) doesn’t usually come with the right codecs in order for the Matlab Compiler Runtime to do its thing. These packages seemed to do the trick for me: ubuntu-restricted-extras, and then add the ppa ppa:mc3man/trusty-media which provides gstreamer0.10-ffmpeg

Allow me a little rant. I was reading this FastCo article about a Spotify webapp that seemed interesting to me. Here’s a screencap of the relevant part.

See the hyperlinked words “playlist tool”, underlined in yellow? You’d think that this would link to the webapp in question.

But no, it resolves to a category/tag-explorer page with the URI http://www.fastcompany.com/explore/playlist-tool.

What about “web app”? Nope: http://www.fastcompany.com/explore/web-app.

Does the article link to the tool at all? No.