2017 YOW West: "Does Smelly Code Also Sound Bad?"
•Download as PPTX, PDF•
1 like•101 views
This is a demonstration of a code quality analysis tool that doesn’t visualise the metrics – it “audiolises” them. The concepts of poor code having smell and colour (usually red) is commonly accepted, but what about appealing to our sense of hearing as well as eyes and nose? Aeolian is an open source tool (written by the author) that generates MIDI music from code quality metrics, which begs the question: What does poor quality code sound like? Justin Beiber’s latest? A Phillip Glass soundtrack? A Phil Spector wall of sound cacophony? Modern Jazz? Likewise, what does good quality code sound like? Mozart? White noise? How do commonly accepted musical concepts (keys, tempo, verse, chorus) apply when illustrating code quality. The author (an amateur musician and long time producer of smelly code) will talk through the concepts of Aeolian and provide plenty of examples of how you can map code quality to music. This will be a light hearted talk and no knowledge of music theory is needed.
More Related Content
Similar to 2017 YOW West: "Does Smelly Code Also Sound Bad?"
Similar to 2017 YOW West: "Does Smelly Code Also Sound Bad?" (18)
More from Andy Marks
More from Andy Marks (16)
Recently uploaded
Recently uploaded (20)
2017 YOW West: "Does Smelly Code Also Sound Bad?"
- 3. @andee_marks Agenda Music Theory Redux Aeolian Design Choices (& examples)
- 4. @andee_marks A Music Theory Primer Notes Tempo KeysOctave
- 5. @andee_marks github.com/andeemarks/aeolian “the aeolian tonic chord is the submediant minor triad” Java One note per line of code Make good quality code pleasant to listen to Make poor quality code unpleasant to listen to
- 7. @andee_marks Aeolian/Hello World public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World!"); } } X:1 T:HelloWorld.metrics C:AEOLIAN M:4/4 L:1/8 Q:1/4=140 K:C %%MIDI gchord c | "C"E c b E, E, E, | X:1 T:HelloWorld.metrics C:AEOLIAN M:4/4 L:1/8 Q:1/4=140 K:C %%MIDI gchord c | "C"E c b E, E, E, | ⇨
- 8. @andee_marks ABC Notation X:1 T:HelloWorld.metrics C:AEOLIAN M:4/4 L:1/8 Q:1/4=140 K:C %%MIDI gchord c | "C"E c b E, E, E, | Notes Tempo Keys ⇨ Octave
- 10. @andee_marks Design Choices #1/Notes Notes <module name="LineLength"> (cond (< line-length 10) (note-from-octave octave-1 line-length) (<= 10 line-length 39) (note-from-octave octave-2 line-length) (<= 40 line-length 79) (note-from-octave octave-3 line-length) ... ⇨
- 11. @andee_marks Design Choices #2/Tempo Tempo (+ (* 20 complexity) default-tempo) <module name="CyclomaticComplexity"> ⇨
- 12. @andee_marks Design Choices #3/Key Keys ⇨ <module name="SimianCheck"> (if (< duplication-percentage 10) (set-major-key) (set-minor-key)))
- 13. @andee_marks Design Choices #4/Instruments Instruments ⇨ (if (not (= current-author (get-author))) (instrument-for current-author)
- 14. @andee_marks Design Choices #5/Lyrics Lyrics (if (not (= current-source-file (get-source-file))) (lyrics-for current-source-file)
- 16. @andee_marks Design Choices/Unresolved Volume ⇨ Stereo Length Note length Comments /** **/ Editor integration
- 19. @andee_marks if (is_smelly?(code)) { set_build_light(“red”); } else { set_build_light(“green”); } if (is_smelly?(code)) { play “What Does The Fox Say (Ylvis)”; } else { play “The Blue Danube (Strauss)”; } Audio indicators
Editor's Notes
- Can I just start by saying “isn’t it good that we’re tackling the BIG issues here at YOW?” From Mars Exploration to the Meaning of Life to the ultimate question of our time really: Does Smelly Code Also Sound Bad? Still, I guess it beats more conversations around microservices… so 2015 right!?! So I work at ThoughtWorks and this talk is about two concepts which are near and dear to my heart, but it’s also a demonstration of some software that I inflicted upon this world from a hack day back in 2015, which we’ll get to.
- So what brings me here today? Well I have a more than a passing interest in both code quality and music quality. I’ve worked as a professional programmer for the best part of my career, producing lots of code of various degrees of quality, depending on my capabilities and external circumstances but I’m also a very strictly non-professional musician who produces music of various degrees of quality… again, depending on my capabilities an external circumstances such as how much I’ve had to drink before playing and whether the guitarists keeps standing on my instrument lead. [TX] I play bass with a bunch of colleages from ThoughtWorks in a band, so in the grand tradition of bass playing, here’s a picture of me being obscured by the more important members of our band. But it was a couple of moments like this which inevitably push me towards writing the software I’ll be talking about today - moments of sitting on conference audiences watching speakers talk about geek-y stuff that really interests them. [TX] Moment 1 was seeing Sau Sheng Cheong, who ran the R&D group for Hewlett Packard in Singapore talk at the RedDotRuby Conf in Singapore in 2012. Sau Sheng had written a nice little Ruby DSL for producing WAV files from Ruby which, because it produced lots of squawks and chirps during the presentation was a really interesting deviation from the other talks at the conf. [TX] Moment 2 leading to today and still the most enjoyable conference talk I’ve ever seen is stumbling onto this man - Andrew Sorensen - presenting at YOW 2013. It was one of those moments of the schedule where there was no clear winner as to which talk I most wanted to go to and the talk blurbs didn’t really reveal too much so I mentally flipped a coin and when to see Andrew. His talk “Programming in Time” was about the live coding community, a movement where programming musicians - or musical programmers - will write code to produce music in a live setting. Much of his talk was a live demo of him producing music using Extemporare, a lisp-based DSL of his own devising. And to me, it was astonishing to watch someone hack away at what looked like Clojure in Emacs and have beautiful atmospheric music come out the other end. More than anything, it was that experience which has resulted in me standing here today, TW Hack day
- [TX] Ultimately what I’m going to demonstrate is a method for mapping code quality to sound… dare I say music, although possibly not music as you know it. [TX] Along the way we’ll talk a bit about music theory (but not too much - after all, I’m a bass player so by definition I’m not going to have too much to say on this matter), various code metrics and how to make music sound bad… which is possibly a cue for another bass player joke as well come to think of it. [TX] And there’ll be lots of audio examples of good and bad code as well.
- Which brings us to my little primer on music theory - and I’ve really limited this to what you need to know to understand how Aeolian works. [TX] Firstly, we have the concept of music notes, which - if you remember back to your first introduction to music theory at school, consist of pitch and duration light a quarter note C, or an eighth note A sharp. [TX] Next we have the meter of the song which dictates how many notes you’ll hear in each measure and [TX] Next we have the tempo of the song, telling us how many of the fundamental notes will be played each minute [TX] And finally the key of the song, which gives some guidance to note selection and suggests the overall mood of the song, specifically with major keys sounding upbeat and happy whilst minor keys sound more menacing and sombre. There’s a whole lot more to music theory than just these concepts, but this should be enough to get you through to the end of this presentation.
- So let’s take Aeolian for a spin around the block and see what it can do. That’s where you can find it should you want to play by yourself at home. There are a small number of dependencies which are listed in the Readme. One big limitation is that it’s only capable of evaluating Java source code at the moment: Why Java? I hear you ask. Well, the snarky person in me says that that’s where all the smelly code in the world lives, but the truth is far more mundane than that… Java is a static language which makes lexical analysis for code quality easier than some of my preferred languages and I know Checkstyle quite well, which is what I use to derive my sense of code quality. And what’s in the name “aeolian”? Well, it’s a term from a more advanced level of music theory than I covered before but a common definition is “the aeolian tonic chord is the submediant minor triad”. TO be honest, I’m not sure if that’s a common definition or not, but it sounds so much like a functional programmer saying that a monad is “a monoid in the category of endofunctors” that I couldn’t resist… and hello to all my Haskell friends out there :-)
- And here’s how it all hangs together [TX] We start with a bunch of script-y magic clone-ing a specified repo and running Checkstyle over it [TX] Checkstyle is running a bunch of specific metric checks and producing a load of customised file output [TX] The same Bash scripts pass the generated Checkstyle output files into a Clojure program which does most of the hard lifting of producing the music, using a textual, reasonably readable format called ABC Notation. [TX] A program called abc2midi does exactly what the name suggest - MIDI standing for Musical Instrument Device Interface, a very common standard for the exchange of electronic music information [TX] And timidity in this case plays the resultant MIDI file
- So what does our old friend Hello World sound like via Aeolian? [DEMO] I know, I know - it’s overwhelming isn’t it? I get that reaction a lot :-) Unfortunately, Hello World is nowhere near smelly enough or long enough to produce something worthy of our ears, although I will show you the ABC Notation it generated.[TX] [TX] It’s really only the last line that plays the music and for those who are interested, that a directive to play a A minor chord and underneath that play an E, then a C, then a B (all as quarter notes), then a quarter note rest.
- L: Default note length (if unspecified) [TX] [TX] [TX] [TX]
- And because this demo is about rendering an abstract representation of an aspect of our code, we should quickly talk about the way most of us do this now, which has been via our good friend, the Delcom build light or it’s close cousins. We’ve probably all used or seen these in use, green means the CI build is good, red means the CI build is bad, flashing might mean it’s building or some nether state like that… the point is that these ubiquotous lights show us a very binary moment in time representation of what they are measuring. All of which is perfectly good, but it’s interesting to compare the matter-of-fact nature of a red/green build light versus the more fine grained opportunities a musical score can give you.
- When you think about the logic behind a build light, it’s really incredibly basic and something like this [TX]. Normally the notion of “smelly” also involves the tests passing as well as code quality, but it’s really not much more complex than this… which means if we wanted to, we could certainly take the same approach to turning code quality into music [TX], but that’s kind of cheating. Although I have to admit this sort of approach would lead to some great heated conversations within delivery teams as to what song should represent green versus red :-) No, nothing so simple for us in creating an audio version of our code quality - we’re programmers and we never take a simple solution when an overly complex one will do, do we?!? Because with complete control over the generation of our notes, we can create something which is not so much a song as it is a soundtrack for our code quality. And soundtracks differ from the Westernised version of songs in that they tend to be far more linear and progressive nature and lean heavily on the music to set the tone and tell the story rather than the lyrics and repeated elements like choruses.