The probably most evident aspect of their productions (especially when talking about Flying Lotus) is the use of sidechain compression. Piloted from the kickdrum or the bass, the compressor pulls up and down the volume of the melodic samples and hihats; this makes their volume oscillate rhytmically, and it brings a very groovy feeling to the hats. One of the most savage users of sidechain compression (well, in another context) is Benny Benassi, but let’s not talk about him now.

The second aspect is the swing of the rhythm, something that is not possible to do on many sequencers or at least it is not encouraged. I have been thinking for a while that this effect was achieved by using samples that matched the tempo in a loose way, and by recording the hit notes with a keyboard/drum pad without quantization, but then I realized that there might be something more. It’s actually possible (in Logic, for instance)  to extract the groove from a sequence of 8 or 16 notes and apply it to other notes as a quantization template. On the net there are some groove packs, like the MPC grooves for Logic and the DNA grooves (commercially sold). However, it’s quite simple to create grooves by hand or even import them from a Recycle file. Once I got the trick, I started to hear swing in many productions, and I realized that this technique is used by some big names but still unknown to many. Wikipedia even talks about the existence of a genre called Schaffel music, that is however nothing really interesting for my ears. There are several interesting research papers dealing with the swing, seen from a technical point of view, such as [one] and [two].  So now you can go and happily try to steal the feeling of your favourite drummer.  

Another trick quite commonly used are the LFOs applied on the hand claps’ starting time to make them sound in a way more realistic, but still fake.

The rest of the game is done by little or no use at all of the delay and the reverb, fat bass lines (often analog synths) and, of course, constant crate digging to get the best samples. I still doubt about the everywhere-claimed MPC feeling, but in this case the limited features of the (not anymore) white monster might help to keep the things simple and limit the sense of omnipotence of who’s behind the EQ.

The first tests I made have been done in Ruby, as it has been my language of choice since half a year. The ruby port of Processing takes advantage of JRuby, which allows to run Ruby code over the Java Virtual Machine. JRuby gives the possibility of using the standard Java API, and it increases the speed of the code compared to the native interpreter. It was a bit tricky to get the external libraries to work,  so I will try to summarize the steps that need to be taken.
The external libraries should be downloaded and unpacked to the folder “ruby-processing/library/library_name”.
Loading them should be done in the following way:

class Foo < Processing::App
  load_java_library "minim"
  include_package "ddf.minim"
  include_package "ddf.minim.analysis"

This is the equivalent of the original Java code:

import ddf.minim.*;
import ddf.minim.analysis.*;
class Foo {

Implementing an interface would be something like:

class Bar
  include_package "ddf.minim.AudioListener"
  def initialize(beat, source)

Where in Java it was:

class Bar implements AudioListener
{
  Bar(BeatDetect beat, AudioPlayer source)
 

I have been using the Minim library to analyze a sound with beat-detection and FFT analysis, here is a screenshot of the result, hopefully I’ll have something more interesting to show soon.