The course also covers the business side, teaching you how to distribute your music to major platforms and properly collect your royalties. By the end, you will have the practical knowledge needed to transform your creative ideas into a fully released, monetized product.

Here are the sections in this course:

• Introduction and Welcome

• Course Overview: Theory vs. Application

• Tools and Setup (FL Studio, Fabric, Samples)

• Sound Design Basics with Fabric

• Understanding Pre-processing vs. Post-processing

• Parallel Processing and Filters

• Alternative Tools: Using Vital

• Working with Samples as Building Blocks

• Building a Basic House Beat

• Mixing Theory: The Box Concept

• Practical Mixing Techniques in FL Studio

• Melody Creation and Music Theory

• Creating Motives and Variations

• Melodic Symmetry and Flow

• Music Distribution and Publishing Rights

• Application: Making a Bass House Track from Scratch

• reakdown: Baseline and Vocal Setup

• Breakdown: Adding Effects and Ambience

• Breakdown: Drum Progression

• Filling empty spaces using "Call and Response" synth melodies.

• Creating vocal ambience through pitch-shifting and reverse sampling.

• Designing the Main Drop: Combining drums and aggressive baselines.

• Advanced Bass Sequencing: Rhythm, variations, and groove.

• Using Automation: Adding reverb and pitch shifts for dynamic transitions.

• Buildup Techniques: Creating tension with filters and snare rolls.

• Song Arrangement: Copying sections and creating "Fake Drops" for variation.

• Final Mixdown: Leveling, EQ filtering, and stereo placement.

• Sidechaining: Using "ducking" effects to keep the kick and bass from clashing.

• Sub-bass Management: Separating low-end frequencies for club systems.

• Mastering: Utilizing limiters to achieve professional loudness without clipping.

• Export Settings: High-quality MP3 rendering for distribution.

• Song Distribution: Step-by-step guide to uploading through RouteNote.

• Strategic Release Planning: Choosing dates and managing store territories.

• Collecting Royalties: Using Monetunes to claim publishing and intellectual property rights.

• Final Encouragement and Closing Remarks.

Watch the full course on the freeCodeCamp.org YouTube channel (3-hour watch).

We just posted a course on the freeCodeCamp.org YouTube channel that will teach you essential guitar theory including the fretboard, the major scale and the triads. It was created by baritone guitarist, Alex Gordon Hi-Fi.

Here are the sections in this course:

• Introduction

• The Crux of Self-Contained Guitar

• This Notion of Practice - part 1

Chapter 1 - THE FRETBOARD

• The 12 Chromatic Notes

• Half Steps & Whole Steps

• Unisons & Octaves

• Paperwork - The Fretboard

• Fingerwork - The Fretboard

• Fretboard Summation

Chapter 2 - THE MAJOR SCALE

• The Major Scale Formula

• Paperwork - The Major Scale Formula

• Major Scale Intervals

• Paperwork - Major Scale Intervals

• Fingerwork - Major Scale Intervals

• Major Scale Fretboard Patterns

• Fingerwork - Major Scale Fretboard Patterns

• The 12 Major Scale Keys

• Major Scale Summation

Chapter 3 - THE TRIADS

• Triad Formulas

• Paperwork - Triad Formulas

• Chord Voicings - part 1 - Inversions

• Fingerwork - Inversions

• Chord Voicings - part 2 - Barre Chords

• Fingerwork - Barre Chords

• The Harmonized Major Scale

• Paperwork - The Harmonized Major Scale

• Fingerwork - The Harmonized Major Scale

• Chord Progressions

• Paperwork - Chord Progressions

• Fingerwork - Chord Progressions

• Triads Summation

• This Notion of Practice - part 2

Watch the full course below or on the freeCodeCamp.org YouTube channel (1-hour watch).

Course Overview

This course is structured to take you from the basics of music production to mastering your own tracks. Here's a breakdown of what you'll learn:

1. Introduction: Get an overview of the course and what to expect as you embark on your music production journey.

2. Chapter 1 - Instruments: Learn about the different instruments available in FL Studio and how to use them to create unique sounds.

3. Chapter 2 - Chords, Melody, Bass: Discover the fundamentals of music theory, including how to create chords, melodies, and bass lines that form the backbone of your tracks.

4. Chapter 3 - Playlist: Understand how to organize and arrange your music using the playlist feature in FL Studio.

5. Chapters 4/5 - Drums and FX: Explore the world of percussion and sound effects, learning how to add depth and rhythm to your music.

6. Chapter 6 - Structure: Learn how to structure your tracks to create engaging and dynamic compositions.

7. Chapter 7 - Mixing: Dive into the art of mixing, balancing different elements of your track to achieve a polished sound.

8. Chapter 8 - Automation: Discover how to use automation to add movement and interest to your music.

9. Chapter 9 - Mastering: Learn the final steps of music production, mastering your tracks to ensure they sound great on all playback systems.

10. Chapter 10 - The Final Chapter: Bring everything together and complete your first music production project.

Understanding FL Studio

FL Studio, also known as FruityLoops, is a powerful digital audio workstation (DAW) that is widely used by music producers around the world. It offers an intuitive interface and a wide range of features that make it ideal for beginners and professionals alike. Here’s a closer look at what makes FL Studio a great choice for music production:

• User-Friendly Interface: FL Studio's interface is designed to be easy to navigate, with a pattern-based music sequencer that allows you to create and edit music with ease.

• Unlimited Free Trial: One of the standout features of FL Studio is its unlimited free trial, which allows you to explore all its features without any time restrictions. This makes it an excellent choice for beginners who want to experiment with music production before committing to a purchase.

• Comprehensive Toolset: FL Studio comes equipped with a wide array of tools and plugins, including synthesizers, samplers, and effects processors, giving you everything you need to create professional-quality music.

• Versatility: Whether you're interested in electronic music, hip-hop, pop, or any other genre, FL Studio provides the flexibility to produce music in a variety of styles.

• Strong Community Support: With a large and active user community, FL Studio offers plenty of resources, tutorials, and forums where you can learn from other producers and share your own experiences.

Get Started Today

If you're ready to start your music production journey, this course is the perfect place to begin. Watch the full course on the freeCodeCamp.org YouTube channel.

Jessica found success in the extremely competitive field of classical music, playing the Oboe in orchestras, recording sessions, and even at major events such as the NFL awards on national television.

She started her own business – a sheet music e-commerce website. This not only helped her survive in the high cost of living city of Los Angeles – it also helped her learn web development.

During the pandemic, many of her performance and recording gigs were cancelled. This inspired her to dive much deeper into coding. She now works as a software engineer at freeCodeCamp, and has contributed substantially to freeCodeCamp's core curriculum. Also, her many freeCodeCamp tutorial articles have more than 400,000 readers each month.

During our conversation, Jessica talks about the insane pressure she faced as a musician, where standards are incredibly high. So many people want to be professional musicians, and there is so little money in the industry. Jessica was a rare case of finding success. But even that success could not dissuade her from diving into software development.

This is a long, intimate conversation with one of the sharpest minds behind freeCodeCamp.org. It was a blast talking with Jessica for more than two hours. I think you'll dig it.

Here are some timestamps in case you want to skip some our lengthy discussion about music education and the music industry:

• 0:00:00 My bass intro. See if you can guess this 1970 classic bassline.
• 0:01:00 Our discussion of Jessica's upbringing by a school teacher and single mom, and her journey into classical music
• 1:07:00 Jessica Learns to code and builds a profitable sheet music e-commerce business
• 1:35:00 Jessica's decision to go all in on software development
• 1:44:00 Contract work and thoughts on what caused recent tech layoffs

You can watch this interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. You can also listen to the podcast below, right in your browser:

Links we talk about during the interview:

• One of Jessica's articles - 40 JavaScript Projects for Beginners – Easy Ideas to Get Started Coding JS
• The Black Excellence Music Project, Jessica's first React project
• Danny Thompson freeCodeCamp Podcast interview
• Danny's LinkedIn course that Quincy mentions

We just published a course on the freeCodeCamp.org YouTube channel that will teach you how to use FL Studio to produce music.

Tristan Willcox developed this course. Tristan is a professional music producer with over 10,000 hours of experience in music production.

Our course is structured in an easy-to-follow manner, starting with the basics and gradually building up to more advanced topics. We cover everything from setting up the software to creating and arranging music, as well as mixing and mastering your tracks. Along the way, we'll be demonstrating various techniques and tips to help you get the most out of FL Studio.

In this course, you'll learn how to use the piano roll, the sequencer, and the synthesizers to create and edit music. We'll also be covering some of the more advanced features of the software, such as using effects and automation to add depth and complexity to your tracks.

Whether you're new to music production or looking to take your skills to the next level, this course is the perfect resource for learning how to use FL Studio.

This course is broken up into the following ten chapters:

• Chapter 1: Virtual Instruments
• Chapter 2: Melodies and Chords
• Chapter 3: Using Patterns
• Chapter 4: Using Samples
• Chapter 5: Layering and Arranging
• Chapter 6: Leveling
• Chapter 7: Adding to the song
• Chapter 8: Mixing + FX
• Chapter 9: Automation
• Chapter 10: Mastering + Exporting

Watch the full course below or on the freeCodeCamp.org YouTube channel (2-hour watch).

Everybody's different, but I believe that nearly all of us enjoy listening to music.

If you want to keep a local version of audio streams you often listen to, you'll need to download these files. Sometimes you'll also want to clip a portion of this audio file instead of having only the whole thing available.

You can develop a Python script to do exactly these things. You can also extend it with additional functionality if you'd like. And I'll show you how to do it in this tutorial.

A Note on Copyrights

If you've used the internet before, you're likely aware that copyright issues can make a lot of people upset – on both sides of a debate about how free content should be.

The very library we'll use has had its share of copyright troubles.

Thankfully, there is copyright-free material available for us to both enjoy and play with in our programs. So we'll use the royalty-free Beethoven's 4th Movement of the 9th Symphony audio piece in this tutorial.

This guide assumes you'll use the following methods to download copyright-free material as well. Don't use this information to infringe on any copyrights!

What We'll Do in This Tutorial

First we're going to install the basic dependency, FFMPEG. Then we'll install the youtube-dl library (which also works with Vimeo and many other platforms) to download audio from a YouTube URL and use it on Python code.

Next, we'll download the pydub library to trim audio files and implement this functionality in our code.

Finally, we'll create some friendly user interface so we can reuse this script later without having to edit the code.

This will all be executed inside a main() function so we can separate functionality, implementation, and use.

How to Install the FFMPEG Package

This package is at the core of many multimedia programs (and all of the open-source ones I've used so far). We are going to need it for both of the Python libraries we'll install very soon.

How to Install on Linux

If you are on a Debian-based machine (such as Ubuntu or Kali), here's the command to install FFMPEG:

sudo apt-get install ffmpeg

If you are using other kinds of distributions, install instructions are here.

How to Install on Windows

First, install the Chocolatey Package Manager. Install instructions are here, I'll be waiting.

Once you've properly installed chocolatey (if you didn't have it already), download the package from an administrative instance of Powershell:

choco install ffmpeg

How to Install on Mac

If you don't have it already, install homebrew. Then, in a terminal:

brew install ffmpeg

How to Programmatically Download Audio from YouTube URLs

First of all, download the youtube-dl package from pip. It's one of the most starred on GitHub.

pip install youtube-dl

We're going to import this module and then declare a function that downloads the audio in mp3 format with reasonable quality from a YouTube URL.

import youtube_dl # client to many multimedia portals

# downloads yt_url to the same directory from which the script runs
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)

main()

The .download() method will gradually download the audio stream as a .webm file. Once it detects that the whole file is available, it will use ffmpeg to convert it to an MP3 audio file. This means that if something happens, say the internet connection goes down when the file is 90% downloaded, it'll resume download at 90% instead of from the beginning – pretty neat.

Note that if you already have the mp3 file downloaded, the download will restart and overwrite the file.

Run your Python script. The audio download for this interpretation of Beethoven's 4th Movement of the 9th Symphony should have a ~33 Mb MP3 file with the video's title available locally. It'll probably be somewhat slow, so go make yourself some tea.

As you can see, it is possible to pass optional parameters to youtube-dl (which will also be available as a standalone CLI program outside the script). One of its capabilities is downloading a series of videos from a playlist URL. If you are more interested, you can read their documentation. I'll keep usage more trivial throughout this tutorial.

How to Trim the Downloaded File

With the file downloaded, we're now going to arbitrarily slice it locally (you might have considered whether it is possible to simply download a clip from YouTube. All reliable methods I've found will essentially boil down to downloading the whole and then editing locally). For that we'll use the pydub library. You can install it like this:

pip install pydub

This is a pretty nice library that enables you to completely manipulate the audio, reducing or boosting volume at certain intervals, repeating clips, and so on. For now, we're just interested in trimming.

In order to trim our downloaded file, we'll have to get the filename of our newly downloaded MP3, convert the start and end points of our desired audio interval from 'hours:minutes:seconds' to milliseconds, and finally use pydub to slice our audio file.

How to get the file name

Unfortunately, the .download() method won't return our generated filename, which we also won't have access to since we're just passing the URL as a parameter. But we have Python and this is a fantastic tool.

We know that we are looking for an .mp3 file which was generated just before our file name lookup operation (Python is single-threaded and will execute code synchronously by default). We'll get the name of our most recent MP3 in the script directory, and that's gonna be our file.

We can perform this operation by listing all .mp3 files in the local directory, collecting their timestamps as integers (which means time in milliseconds counted from a given date in the past. This means that the higher the value, the further in time the file was created.), and getting the file with the highest value.

For this we'll need the modules glob to navigate the directory and os to get timestamp information, both available natively.

import glob
import os

def newest_mp3_filename():
    # lists all mp3s in local directory
    list_of_mp3s = glob.glob('./*.mp3')
    # returns mp3 with highest timestamp value
    return max(list_of_mp3s, key = os.path.getctime)

How to get HH:MM:SS as milliseconds

Once we slice our file, pydub will expect time intervals expressed in milliseconds. But for we humans, calculating the exact moment in milliseconds every time we want to trim a video would be pretty annoying, so we'll respectfully ask the computer to do it for us.

Our input is going to be a string in the HH:MM:SS format. This works well if we want to trim a video longer than one hour, but most of the time we'll just want to get the time interval from a minute:second interval to another. So we have to take this into consideration as well.

A millisecond is 1/1000 of a second, a minute is 60 seconds, and an hour is 60 minutes. So we have to get the value for hours, then for minutes, then for seconds, perform the millisecond conversion on each, and then sum the parts to reach the result.

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # if in HH:MM:SS format
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # MM:SS format
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # time point in miliseconds
    return hours + minutes + seconds

How to Get the Trimmed Audio

We'll now read our MP3 as a pydub object and slice our desired interval. The syntax is exactly the same as slicing operations on strings and arrays, but instead of an index for an element we'll use milliseconds for specific instants within the audio.

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
        # raise an error to immediately halt program execution
        raise Exception("No MP3 found in local directory.")
    # reads mp3 as a PyDub object
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Beginning trimming process for file ", mp3_filename, ".\n")
    print("Starting from ", initial, "...")
    if (len(final) > 0):
        print("...up to ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # t0 up to t1
    return sound[t0:] # t0 up to the end

How to Put it All Together

Alle Menschen werden Brüder,
Wo dein sanfter Flügel weilt.
-- Friedrich Schiller

In case you were wondering, the previous fragment translates to "All men shall become brothers, wherever your gentle wings hover". It's a fragment of Ode to Joy, a poem by Friedrich Schiller, which serves as most of the lyrics to the choral parts of the 4th Movement.

This is the most famous fragment of the most famous movement of the most famous Beethoven symphony. Whoever you are, whenever and however you were raised, you are very likely to recognize this piece.

We'll now put together what we have done. We'll download the audio from YouTube, slice the Ode to Joy choral (from 9:51 to 14:04), and save it as <filename> - TRIM.mp3.

If you have followed the tutorial correctly, update your main() function to execute each step in a way that'll leave you with the full MP3 and the trimmed version of it as files available in the directory you'll be running the script from. Don't forget to run the main() function at the end of the script.

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)
    initial = "9:51"
    final = "14:04"
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Process concluded successfully. Saving trimmed file as ", trimmed_filename)
    # saves file with newer filename
    trimmed_file.export(trimmed_filename, format="mp3")

How to Add User Interaction Directly from the CLI

For this part we'll need the sys Python module, which reads input passed from the command line (among other things). We'll simply update the variables in the main() function to read input from the CLI instead of the currently hard-coded data.

ARGV reads input sequentially as an array, starting from index 1 (0 represents the running Python script name). We'll set it up to read a URL as the first argument, then (optional) initial and final trimming instants.

import sys

def main():
    if (not len(sys.argv) > 1):
        print("Please insert a multimedia-platform URL supported by youtube-dl as your first argument.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # exit if no instants as args
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Process concluded successfully. Saving trimmed file as ", trimmed_filename)
    # saves file with newer filename
    trimmed_file.export(trimmed_filename, format="mp3")

Run the file to test it. Remember to update the script name to the same one that's on your machine.

python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04

Final Script

This is the final version with everything put together. Note that the comments on modules are related only to what we're using them for and that the main() function is being invoked at the last line.

import youtube_dl # client to download from many multimedia portals
import glob # directory operations
import os # interface to os-provided info on files
import sys # interface to command line
from pydub import AudioSegment # only audio operations

def newest_mp3_filename():
    # lists all mp3s in local directory
    list_of_mp3s = glob.glob('./*.mp3')
    # returns mp3 with highest timestamp value
    return max(list_of_mp3s, key = os.path.getctime)

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # if in HH:MM:SS format
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # MM:SS format
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # time point in miliseconds
    return hours + minutes + seconds

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
        # raise an error to immediately halt program execution
        raise Exception("No MP3 found in local directory.")
    # reads mp3 as a PyDub object
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Beginning trimming process for file ", mp3_filename, ".\n")
    print("Starting from ", initial, "...")
    if (len(final) > 0):
        print("...up to ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # t0 up to t1
    return sound[t0:] # t0 up to the end



# downloads yt_url to the same directory from which the script runs
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    if (not len(sys.argv) > 1):
        print("Please insert a multimedia-platform URL supported by youtube-dl as your first argument.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # exit if no instants as args
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Process concluded successfully. Saving trimmed file as ", trimmed_filename)
    # saves file with newer filename
    trimmed_file.export(trimmed_filename, format="mp3")

# example usage:
# python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04
main()

Suggested Exercises

1. Detect whether the first input is a valid URL or not. Take a look at Python RegEx if you don't know where to start.
2. Detect whether the second and third inputs are in the valid format (hours:minutes:seconds OR minutes:seconds).
3. Add an option to rename the MP3 file directly from the CLI. Remember that ARGV arguments are executed in order.
4. Refactor this script in order to interact with its functionality using a GUI. Can be either a web or local app, your choice.

Final Considerations

I hope you'll have fun with this project and put it to good use.

Remember that making a living as an artist is pretty hard, especially for the majority without corporate backing. Remember to support the artists whose work you enjoy whenever you can and also remember to support open-source software.

In this reference guide, I'll be sharing a variety of different playlists, radio stations, and videos that you can listen to while coding. Whether you're a beginner or an experienced programmer, you will find something to listen to.

So put on your headphones and get to work!

Coding music on Spotify

One of my favorite ways to listen to music while working is through Spotify. If you're not familiar with Spotify, it's a music streaming service that you can use for free (with ads) or for a monthly fee (no ads).

I like using Spotify because it has a huge selection of songs and albums, and you can create your own playlists. Plus, if you have the paid version, you can download songs and listen to them offline.

If you're looking for some good coding music, here are a few Spotify playlists:

• Lofi Beats
• Electronic Music for Coding: Fast Programming Instrumentals for Concentration
• Coding Mode
• Lofi Hip Hop Music - Beats to Relax/Study by Lofi Girl
• Deep Focus
• Electronic Focus
• House Focus

Music for programming on YouTube

YouTube is another great resource for finding music to listen to while programming. In fact, there are entire channels dedicated to that kind of music.

Here are a few productivity/programming/concentration music channels on YouTube:

• Chill Music Lab
• Filfar
• Lofi Ghostie
• Lofi Geek
• Lofi Girl
• Greenred Productions
• Productivity Music by Evan Carmichael
• Fluidified

There are also many 24/7 coding music lives. Let me share with you some YouTube queries to find them:

• 24/7 coding
• 24/7 lofi
• Programming music
• Coffee music
• Focus music

Music for coding on TwitchTV

TwitchTV is a live streaming video platform where you can watch people play video games, listen to music, and more. There is a lot of great content that you can watch and listen to while coding.

Here are a few music channels on TwitchTV:

• LeekBeats
• KuboMusic
• SixtySevenRadio
• SpinninRecords

On this platform, some streamers like to create virtual offices. Most of the time, they are streaming in the "Just Chatting" or "Software and Game Development" sections. You can launch their streaming in the background, work with them and listen to good music.

It can be motivating when you're working alone at home and need to have the feeling of working with someone. Some of these streamers are even doing Pomodoro Sessions that you can follow to get your code done and improve your focus.

Web radio broadcasting music for developers

If you're looking for something a little more low-key, you can try listening to radio dedicated for developers. There are a few stations that play nothing but programming music.

Here are a few of them:

• Code radio by freeCodeCamp
• musicForProgramming();
• X-Team Radio
• Lofi Cafe

Wrapping up

Thank you for reading this article. I hope these links will be helpful and motivate you in your day-to-day developer work. Keep coding, and keep hustling.

I regularly deliver content about web development, personal growth as a developer, and my journey as an aspiring digital nomad and remote software engineer. If you don't want to miss them, I invite you to follow me on Twitter.

If you dig it, subscribe to my new music channel and leave a comment with feedback or your favorite track.

I am currently uploading this to Spotify.

How I Made The Learn to Code RPG Soundtrack

The Funk of the 70s.
The Jazz of the 80s.
The Hip Hop of the 90s.

I was a lover of music. But I never really learned how to play.

That changed 3 months into the pandemic. I bought an electric bass. I clocked several hundred hours in Rocksmith practicing the bass lines of Nathan East, Bootsy Collins, and Andy Rourke from The Smiths.

Bootsy Collins, the legendary bassist for both Parliament and James Brown

For theory, I made heavy use of Musician YouTube, including Rick Beato and Adam Neely, and most importantly Paul Del Bello.

I also got guidance from two musicians in the freeCodeCamp community: Lawrence Yeo (AKA Trebles and Blues) and Devin Lane (AKA Gentle Return). Check out their tunes.

Before long I came to realize that almost any piece of music could potentially sound good with nothing more than drums, bass, and a piano. But I didn't want to find a drummer or a pianist, so I set out to learn how to play those instruments myself.

My gear – a Fender Precision bass, Roland Octopad, and M-Audio midi controller

I started by learning to read music, doing ear training, memorizing the circle of fifths – all the things I presume you learn in music school. But I quickly abandoned that in favor of just sitting down and writing songs.

I bought a $100 midi controller and a $200 copy of Logic Pro, then got to work learning how to compose chords and melodies, and play to a metronome.

It took about 6 months, but I recorded dozens of instrumental tracks, 10 of which made it into the first release of Learn to Code RPG. I am working on several more songs with similar tempos and instrumentation for future expansions to the game.

How do you make your keyboard sounds?

I build my synth patches using Logic's built-in Alchemy additive synth and its analog synth. I also use some of Logic's stock pianos, electric pianos, organs, and its celesta.

What do you use for drums?

I play a heavily modified Logic producer drum kit on a Roland Octopad. I use heavy muting and very few plugins. I'm going for a dry, crisp 1970s sound.

You may notice that I only use the kick, snare, ride, and hi-hat. That is all that the 70s greats like Clyde Stubblefield and Gregory Coleman needed to build grooves. So I imposed that constraint upon myself. (I find that reasonable constraints can accelerate the creative process.)

Rather than playing the classic 70s breakbeats, I attempt to weave my own around the song's bass line.

What is that kick drum sound?

A booming house music kick layered on top of a clicky death metal kick.

What is that bass sound?

The bass you hear on the Learn to Code RPG soundtrack is a fattened-up analog synth sound with some delay and distortion. I can't quite play bass tight enough for studio-grade recordings, and rather than chopping it my playing, I just played on a keyboard. I EQ the bass at 40 Hz to make room room for the kick, and so it still sounds OK on a phone's speakers.

Can I use your music in my videos / on my live stream?

DM me on Twitter and we can discuss this.

Can you play my tech conference / roller skating rink / art opening?

That sounds like a blast. DM me on Twitter.

Thanks for reading about my music. I never thought I'd discover a new all-consuming passion at age 40. But it has been a blast. And I am just getting started. If I am lucky, I will still have 40 years left in me to learn music and create work I am proud of.

This tutorial is relevant even if your application doesn't use Python - for example, you are building a game in Unity and C# which doesn't have robust libraries for onset detection.

If that is the case, you may export the detected onset timestamps to a text file to read into your engine of choice.

If you prefer a video tutorial to an article, here's the video version of this tutorial.

Applications of Music Onset Detection

I came across this music onset detection technique when I was building a rhythm game and wanted a way to automatically generate beat maps for any song.

Check out the end of this article for my open-source rhythm game and my step-by-step course on how I built it.

My rhythm game showcase

Besides building a rhythm game, this technique has a lot of other applications.

For example, detecting onsets is usually the first step in music information retrieval and analysis.

Another example could be that we are building a game in which there are combat scenes. We may detect the onsets in the BGM and spawn an enemy at every onset. This can create a unique pacing in our game.

I'll demonstrate how to detect music onsets using two different Python packages for audio signal processing, Aubio and librosa. Both packages detect onsets pretty accurately. The small difference is that librosa works for the OGG format while Aubio doesn't.

How to Set up the Development Environment

We will be installing our packages in a virtual environment.

In the command line, we create a virtual environment named python-aubio-librosa as follows. -m stands for module.

$ python3 -m venv python-aubio-librosa

Then we activate the virtual environment:

$ . python-aubio-librosa/bin/activate

Note that if you try to activate the environment using the following command, you will get an error:

$ ./python-aubio-librosa/bin/activate
-bash: ./python-aubio-librosa/bin/activate: Permission denied

Once your environment is activated, the name of the environment will show in parentheses:

(python-aubio-librosa) $ ...

We can check that if we invoke python or pip, the invoked programs will be those in our virtual environment instead of the system-level ones.

If we haven't activated our environment, the output will point to the system-level programs.

$ which python
/usr/bin/python
$ which pip
/usr/local/bin/pip

Once we have activated our environment, the output will point to the local ones.

(python-aubio-librosa) $ which python
/Users/USERNAME/Desktop/python-aubio-librosa/bin/python
(python-aubio-librosa) $ which pip
/Users/USERNAME/Desktop/python-aubio-librosa/bin/pip

How to Install and Use Aubio

We will install Aubio via pip:

(python-aubio-librosa) $ pip install aubio

The function that we will use to generate a list of onset timestamps as floating point numbers in seconds is as follows. This function comes from Aubio's official documentations, so we can just use it without learning about the nitty-gritty details (like FFT, Fast-Fourier Transformations) in audio signal processing.

from aubio import source, onset

def get_onset_times(file_path):
    window_size = 1024 # FFT size
    hop_size = window_size // 4

    sample_rate = 0
    src_func = source(file_path, sample_rate, hop_size)
    sample_rate = src_func.samplerate
    onset_func = onset('default', window_size, hop_size)

    duration = float(src_func.duration) / src_func.samplerate

    onset_times = [] # seconds
    while True: # read frames
        samples, num_frames_read = src_func()
        if onset_func(samples):
            onset_time = onset_func.get_last_s()
            if onset_time < duration:
                onset_times.append(onset_time)
            else:
                break
        if num_frames_read < hop_size:
            break

    return onset_times

Then, we write a main function that takes in the path to an audio file, and outputs the onset timestamps to a file, keeping the first four decimal places in each float, one float per line.

def main():
    file_path = '../game/audio/my-music.mp3'
    onset_times = get_onset_times(file_path)
    # remove extension, .mp3, .wav etc.
    file_name_no_extension, _ = os.path.splitext(file_path)
    output_name = file_name_no_extension + '.beatmap.txt'
    with open(output_name, 'wt') as f:
        f.write('\n'.join(['%.4f' % onset_time for onset_time in onset_times]))

Let's invoke the script from the command line. Aubio might raise a warning about accuracy but my experimentation shows that Aubio is still pretty accurate.

(python-aubio-librosa) $ python generate_beatmap_aubio.py 
[mp3 @ 0x7fe671031e00] Estimating duration from bitrate, this may be inaccurate

An example output file would look like below. For a short 15-second music clip, Aubio detected 26 onsets. These are the timestamps that we can use for our application.

An example output file consisting of onset timestamps

And that's it for Aubio.

How to Install and Use Librosa

Similar to Aubio, we will install librosa also via pip:

(python-aubio-librosa) $ pip install librosa

Compared to Aubio, librosa's library methods are easier to use. librosa.load returns a NumPy array x and a sampling rate sr, which we pass to librosa.onset.onset_detect to get a list of onset frames.

Finally we convert onset frames into onset timestamps, and write each timestamp to an output file like we did for Aubio.

import librosa

def main():
    file_path = '../game/audio/my-music.ogg'
    x, sr = librosa.load(file_path)
    onset_frames = librosa.onset.onset_detect(x, sr=sr, wait=1, pre_avg=1, post_avg=1, pre_max=1, post_max=1)
    onset_times = librosa.frames_to_time(onset_frames)
    # remove extension, .mp3, .wav etc.
    file_name_no_extension, _ = os.path.splitext(file_path)
    output_name = file_name_no_extension + '.beatmap.txt'
    with open(output_name, 'wt') as f:
        f.write('\n'.join(['%.4f' % onset_time for onset_time in onset_times]))

The output file will be in the same format as shown above for Aubio.

Conclusion

Thanks for reading and I hope you are ready to apply this onset detection technique to your next project. 🎶

As a recap of the differences between Aubio and Librosa, both detect onsets pretty accurately based on my experimentation.

Aubio is more restricted in terms of audio file formats: it raises a warning about accuracy for MP3 files and doesn't handle OGG files.

On the flip side, Librosa is able to handle most common audio file formats: MP3, OGG, FLAC, and M4A. Librosa's library interface is also easier to use than Aubio's, especially for those of us who aren't pros in signal processing.

Check out the resources below if you'd like to learn more or get inspired for your next project!

Resources

You can check out the code used in this tutorial on my GitHub or watch the video version of this tutorial on YouTube.

If you are interested in building a rhythm game, check out my open-source one built in Python on GitHub and my Udemy course in which we will build the game from the ground up.

If you'd like to know whether the course is for you, check out my course promotional video on YouTube and free sample lectures on Udemy.

My YouTube channel also features other fun project tutorials like building a Discord AI Chatbot, and, a series of coding interview crash courses I'm developing. Hope to see you there!

Well, as a professional oboist, I have noticed a lot of parallels between studying music and studying programming.

Both require a lot of focus, discipline, and perseverance to become great.

Here are some examples of how my musical training helps me stay focused in learning how to code.

Just Get it Done

_Photo by [Unsplash](https://unsplash.com/@gpthree?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">George Pagan III / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

Back in college, there were times I wasn't prepared for my lessons, rehearsals, or exams.

Instead of taking ownership for my lack of preparation I would make excuses like,

“I was busy studying for a music theory test and that’s why I couldn’t prepare for my lesson.”

or

“I have a big audition coming up so I was busy preparing for that.”

No matter what excuse I had in the moment for being unprepared, my oboe professor never bought it. He always believed there was enough time in the day to practice, study, and have a little bit of a social life.

So, he would often drop that famous NIKE slogan, "Just Do It."

I would always get a little laugh about it, but he was making a valid point.

As a self-taught programmer, there are so many distractions around you all the time. It is very easy for thoughts to come into your head like,

“I really should do some more algorithm practice, but maybe tomorrow.”

or

“I really should get started on that new project but I am really busy.”

Most people in life do not have 24 hours of uninterrupted free time to do whatever we want. There will always be something that comes up and we just have to deal with it.

The harsh reality is that we have to stay disciplined to get our work done so we can become better programmers.

So when you are about to make another excuse for procrastination remember to get it done anyway!

Practice Makes Perfect - Or Does it?

_Photo by [Unsplash](https://unsplash.com/@samthewam24?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Samuel Sianipar / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

We have all heard the saying, “Practice makes Perfect”.

Well, that is not entirely true.

My oboe professor in college would always dismiss this phrase and instead tell us “Practice Makes Permanent”.

Whenever I was trying to learn a new piece, I would get frustrated that it wasn’t getting any better. No matter how many times I practiced, it was still a mess.

But I learned early on that just showing up and practicing is not enough. You have to practice smart.

So I learned how to break things down into small chunks, slow down the metronome and work on that passage until it was right.

Once I changed my practicing habits, I started to become a much better musician.

In learning how to code, rushing through a course is not going to make you a better programmer. In some cases, you might develop some bad habits that will be tough to break later on.

It is better to tackle one problem at a time and work through it slowly than rush through all of them.

If you practice smart, then the concepts will start to make more sense.

Consistency is Key

_Photo by [Unsplash](https://unsplash.com/@xps?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">XPS / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

I was one of those kids that started piano at age 7 and was really into it for the first few years.

But once I started working on harder pieces, I just lost the motivation to practice.

I was very sporadic with my practicing habits, and as a result I wasn’t getting any better. My lessons ended up being a complete waste because we were just going over the same things week after week.

With all of the hype around learning how to code at home, a lot of people dive in with an initial excitement. They will go through tutorials and build small projects from class.

But as the months go by, people start to lose motivation.

They start to code less often and eventually lose interest and quit.

In learning how to code, you have to come up with a consistent schedule or else you will never become a programmer.

You will always be stuck struggling with the fundamentals and never be able to build more complex projects.

You don’t have to put in 12 hours a day to be successful. Build a schedule that works for you.

If you only have 2 hours a day to dedicate to learning, then stick with that.

But repeating a cycle of doing 8 hours one day and then taking two weeks off will just lead to lack of progress.

Consistency is the key to learning something well.

Practice what you don’t know

_Photo by [Unsplash](https://unsplash.com/@surface?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Surface / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

During my junior year of college, our wind ensemble conductor told us something that has stuck with me ever since.

He said, “Have the courage to practice what you don’t know.”

Most of us wanted to practice music that we knew sounded good in the practice room. It was probably a way for us to feel good and stroke our egos a little bit.

But, my conductor was right.

If you don’t challenge yourself and work on your weaknesses then you will never grow as a musician.

There is so much to learn when you are just starting out as a beginner programmer. It is really tempting to only focus on the things you enjoy.

It makes sense that you want to feel good about yourself and show off what you know. But that doesn’t give you the excuse to ignore what you are bad at.

If you know you are bad at algorithms, don’t ignore them. Make extra time to work on them so they become easier to solve.

Or maybe you are struggling with recursion. It is not going to go away just because you don’t like it.

Even though it is difficult in the moment, you have to have the discipline to sit down and learn what you need to learn.

I hope you enjoyed this article. If you want to learn more about me, follow me on twitter @codergirl1991

Happy coding!

Most developers I know listen to music while they code. When the meetings are over, the headphones come out.

And devs aren’t alone. According to a study Spotify conducted in 2014, 61% of people listen to music while they work — mostly to stay focused, and to drown out surrounding noise.

So in 2018, freeCodeCamp.org created a music live stream on our YouTube channel called Code Radio.

And now we've gone a step further: we've moved Code Radio off of YouTube and onto our own fast, data-efficient internet radio station.

Choosing the tunes

We made a couple critical decisions early on:

1. There would be no advertisements. This wasn’t a hard decision, since we don’t have ads anywhere on freeCodeCamp.org or our YouTube channel, anyway.
2. The genre would be instrumental downtempo music, which is relaxing and non-distracting. My grad school classmates and I had listened to thousands of hours of this type of music while studying and hadn’t gotten bored of it yet. So it seemed like a safe bet for a coding live stream as well.

Fortunately, I knew a prolific musician in the freeCodeCamp community.

Lawrence hanging out in LA (photo by Leah Perrino)

Lawrence Yeo — also known as Trebles and Blues — is a DJ and music producer in Los Angeles. His work encompasses many genres: American soul, jazz, Brazilian funk, and even Korean folk music. The common root that connects all these influences together is hip hop — blending percussive elements and sampling techniques to create a wide variety of instrumental works.

In addition to his work as a musician, Lawrence enjoys programming. Among other things, he built his own website for his music.

Lawrence hand-curated Code Radio's more than 1,250 songs.

Lawrence working on some new grooves (Photo by Joannza Lo)

Making Code Radio fast and accessible

Now you can listen to Code Radio on your phone. It is now extremely data-efficient. The website itself loads fast, and the music starts playing almost immediately.

If you open Code Radio on your phone, you can switch between apps and the music will keep playing. You can even lock your phone and continue listening, and have the ability to stop and start the music from your headphones or lock screen.

And if your phone has limited data, you can kick the bitrate down to 64kbps to cut Code Radio's data usage in half.

Again, here's a link to Code Radio

Be sure to bookmark Code Radio and come back. We'll continue to expand and refine the playlist, and add additional features. You can tweet about Code Radio using the #CodeRadio hashtag.

Enjoy the tunes, and happy coding!

Over the past year, Code Radio had grown to be one of the largest music streams on YouTube. People played it in their coffee shops and co-working spaces. Wherever people coded, the familiar groove of Code Radio could be heard not too far off in the distance.

In the past 28 days alone, developers listened to Code Radio for more than 14 million minutes. (That's the equivalent of a whopping 27 years of jamming out and coding.)

The Fall

One of the 1,250+ songs on Code Radio contained a short audio sample from an anime that played over a beat at the end of a song.

It turned out that a Japanese media company - through a series of acquisitions - happened to own the rights to that anime. And they used some sort of automated system to trawl YouTube and identify streams that had any samples from their vast catalog of intellectual property.

One of those streams was Code Radio. And on Wednesday morning, their system filed an automated takedown request to YouTube.

Just like that, the stereos in 1,000 cafes, offices, and hackerspaces around the world fell silent. Our Code Radio stream was replaced with this message from YouTube:

We immediately contacted YouTube support. This had to be a mistake.

The customer service reps we talked to were friendly. But they didn't know how to fix it. They didn't even know how we could regain access our channel's streaming controls. Instead they said they "would look into it and get back to us."

(As of Monday afternoon, we have yet to hear back from them.)

So in the depths of this confusion - in a sea of tweets and emails from dedicated Code Radio listeners asking what was happening - I came to see the truth: Code Radio needed a new home - a home where a single questionable automated takedown request couldn't wipe it from existence.

Code Radio also rises

"Why do we fall, Mr. Wayne? So we can learn to pick ourselves back up." - Alfred in Batman Begins

Ah - a self-hosted Code Radio! There would be several benefits:

1. Watching YouTube uses a lot of data. Many people have limited data plans. If we self-host Code Radio, we could just serve the MP3 files themselves, rather than a video stream. We could even offer a data-light version of the music at a lower bitrate.
2. YouTube is blocked in a lot of countries where freeCodeCamp is popular - including China. A self-hosted version of Code Radio would be available to everyone, anywhere in the world.
3. With YouTube, you have to keep the YouTube app open or the music will stop playing (unless you pay them US $12 per month for YouTube Premium). A self-hosted Code Radio could continue playing in the background on your phone - even when you switch applications or lock your phone.
4. With a self-hosted version, we could build Code Radio mobile apps, Alexa skills so you can easily listen to Code Radio on an Amazon Echo - the sky is the limit.

But how would we implement a self-hosted version? Wouldn't it be expensive to serve 14 million minutes of audio each month. That's a lot of data.

Building Code Radio

It turns out that the internet radio community is quite active. We immediately found an awesome open source self-hosted internet radio project called AzuraCast.

I reached out to the project maintainer through Twitter, and within minutes, we had him on a call with us. He was a former terrestrial radio guy. He brought us up to speed on the internet radio tooling ecosystem.

Yes - streaming digital audio to people around the world is a lot more expensive than just serving our coding curriculum data. But with some additional donations from supporters, we should be able to swing it.

With AzuraCast, plus some additional relay tools, we could run a self-hosted internet radio station at our previous scale for less than US $100 per month.

Side note: If you aren't a supporter yet, we would welcome your support. Every little bit helps: https://donate.freecodecamp.org - And yes, we accept one-time donations, crypto, employer donation matching, and more: https://donate.freecodecamp.org/other-ways-to-donate/)

Code Radio is live. Help us load-test it and give us feedback.

You can start listening to Code Radio right now: Listen to Code Radio

We are working on a lot of additional features that we'll roll out over the next few days:

• bitrate controls (so you can save your mobile data by listening at 64 kbps)
• some form of chat - preferably with existing forum accounts and forum moderators
• a chatbot (maybe Nightbot again)
• hotkeys
• a better mobile experience
• bringing back the classic Saron Yitbarek Code Radio animation

I would like to thank @abdolsa, @beaucarnes, @raisedadead, @askmp, @scissorsneedfoodtoo, and of course Code Radio DJ and curator Lawrence Yeo AKA Trebles and Blues. They all pulled together and within 24 hours helped get this prototype up and running.

YouTube da real MVP

In all seriousness, I would also like to thank YouTube. Through their own bumbling, they inadvertently forced us to take a step back and look into the possibility of self-hosting Code Radio.

We will continue to post in-depth coding tutorials and free programming courses on YouTube. We don't hold their own incompetence against them. We are grateful they exist and provide the infrastructure for nonprofits like ours to serve HD video to 1 Million+ subscribers for free.

This is just the latest chapter in our community's gradual move off of proprietary platforms like Medium and Facebook, and over onto our own tools like Developer News and this forum.

Thanks for reading, thanks for listening, and happy coding!

Introduction

SoundCloud is a music and podcast streaming platform for listening to millions of authentic tracks. They have a really interactive interface for playing / listening to the tracks.

The most important feature in their interface is showing the progress of the track based on its frequency waveform. This helps the users to identify the nature of it.

They also have a blog post which describes how to use the waveform based on its image. It is hard to use the same techniques to generate the waveform in a React Native app. Their Waveform.js SDK translates a waveform into floating points to render on an HTML5 canvas and is currently no longer operational.

In this article we’ll discuss how to use the same waveform for our React Native apps.

Why Should I use SoundCloud’s Waveforms?

_Image Credits — [KnowYourMeme](https://knowyourmeme.com/photos/1269398-arthurs-headphones" rel="noopener" target="blank" title=")

• The SoundCloud’s waveform looks more impressive than the old boring way of showing the progress bar.
• The pre-loaded waveform will give the user an idea of the different frequencies present in the song.
• It is also much easier to show the buffered track percentage on a waveform rather than showing it on a blank progress bar.

Let’s learn more about SoundCloud’s Waveforms

_Image Credits — [Backstage Blog by SoundCloud Developers](http://img.svbtle.com/inline_leemartin_24131769094098_raw.png" rel="noopener" target="blank" title=")

The SoundCloud provides a waveform_url in its tracks API.

• Each track has its own unique waveform_url .
• The waveform_url contains a link to the image hoisted over the cloud.

Example — https://w1.sndcdn.com/PP3Eb34ToNki_m.png

_Image Credits — [SoundCloud’s waveform for the track “Megadeth — Sweating Bullets” by mauriciohaensch](https://w1.sndcdn.com/PP3Eb34ToNki_m.png" rel="noopener" target="blank" title=")

As of now, every argument is static hence it is unusable in this current state. Therefore we need to re-create the waveform based on it using React Native’s containers in order to have access to the touch events, styles etc.

Getting Started

_Image Credits — [ImgFlip](https://imgflip.com/memegenerator/4081988/What-if-i-told-you" rel="noopener" target="blank" title=")

Here is a list of stuff that you will need:

• d3-scale
• d3-array

First, we need the sampling of the waveform. The trick is to replace .png with .json for the waveform_url . A GET call to it would give us a response object that contains

• width (Width of the waveform)
• height (Height of the waveform)
• samples (Array)

For more info, you can try out the following link https://w1.sndcdn.com/PP3Eb34ToNki_m.json.

Dive into the code

_Image Credits — [Unsplash](https://images.unsplash.com/photo-1466477234737-8a3b3faed8c3?ixlib=rb-0.3.5&s=919a7e046d85dc25ac72f4c3070228b6&auto=format&fit=crop&w=800&q=60" rel="noopener" target="blank" title=")

Add a Custom SoundCloudWave Component

function percentPlayed (time, totalDuration) {
 return  Number(time) / (Number(totalDuration) / 1000)
}

<SoundCloudWave
  waveformUrl={waveform_url}
  height={50}
  width={width}
  percentPlayable={percentPlayed(bufferedTime, totalDuration)} 
  percentPlayed={percentPlayed(currentTime, totalDuration)}
  setTime={this.setTime}
/>

It would be better to create a custom SoundCloudWave component that can be used in multiple places as required. Here are the required props:

• waveformUrl — The URL object to the waveform (accessible through the Tracks API)
• height — Height of the waveform
• width — Width of the waveform component
• percentPlayable — The duration of the track buffered in seconds
• percentPlayed — The duration of the track played in seconds
• setTime — The callback handler to change the current track time.

Get the samples

fetch(waveformUrl.replace('png', 'json'))
  .then(res => res.json())
  .then(json => {
    this.setState({
      waveform: json,
      waveformUrl
    })
  });

Get the samples by using a simple GET API call and store the result in the state.

Create a Waveform Component

import { mean } from 'd3-array';

const ACTIVE = '#FF1844',
  INACTIVE = '#424056',
  ACTIVE_PLAYABLE = '#1b1b26'

const ACTIVE_INVERSE = '#4F1224',
  ACTIVE_PLAYABLE_INVERSE = '#131116',
  INACTIVE_INVERSE = '#1C1A27'

function getColor(
    bars,
    bar,
    percentPlayed,
    percentPlayable,
    inverse
) {
  if(bar/bars.length < percentPlayed) {
    return inverse ? ACTIVE : ACTIVE_INVERSE
  } else if(bar/bars.length < percentPlayable) {
    return inverse ? ACTIVE_PLAYABLE : ACTIVE_PLAYABLE_INVERSE
  } else {
    return inverse ? INACTIVE : INACTIVE_INVERSE
  }
}

const Waveform =
  (
   {
     waveform,
     height,
     width,
     setTime,
     percentPlayed,
     percentPlayable,
     inverse
   }
  ) => 
  {
    const scaleLinearHeight = scaleLinear().domain([0, waveform.height]).range([0, height]);
    const chunks = _.chunk(waveform.samples, waveform.width/((width - 60)/3))
      return (
        <View style={[{
          height,
          width,
          justifyContent: 'center',
          flexDirection: 'row',
         },
         inverse && {
          transform: [
            { rotateX: '180deg' },
            { rotateY: '0deg'},
          ]
         }
        ]}>
         {chunks.map((chunk, i) => (
           <TouchableOpacity key={i} onPress={() => {
             setTime(i)
           }}>
            <View style={{
              backgroundColor: getColor
               (
                 chunks,
                 i,
                 percentPlayed,
                 percentPlayable,
                 inverse
               ),
              width: 2,
              marginRight: 1,
              height: scaleLinearHeight(mean(chunk))
             }}
            />
          </TouchableOpacity>
         ))}
        </View>
      )
  }

The Waveform Component works as follows:

• The Chunks split the samples object based on the width that the user wants to render on the screen.
• The Chunks are then mapped into a Touchable event. The styles as width:2 and height: scaleLinearHeight(mean(chunk)). This generates the mean from the d3-array.
• The backgroundColor is being passed as a method with different parameters to the getColor method. This will then determine the color to return based on the conditions set.
• The Touchable onPress event will call the custom handler passed into it, to set the new seek time of the track.

Now this stateless component can be rendered to your child component as:

render() {
  const {height, width} = this.props
  const { waveform } = this.state
  if (!waveform) return null;
  return (
     <View style={{flex: 1, justifyContent: 'center'}}>
       <Waveform
         waveform={waveform}
         height={height}
         width={width}
         setTime={this.setTime}
         percentPlayed={this.props.percent}
         percentPlayable={this.props.percentPlayable}
         inverse
       />
       <Waveform
         waveform={waveform}
         height={height}
         width={width}
         setTime={this.setTime}
         percentPlayed={this.props.percent}
         percentPlayable={this.props.percentPlayable}
         inverse={false}
       />
     </View>
    )
}

Here one of the waveform component is original and one inverted as in the SoundCloud’s player.

Conclusion

Here are the links to the react-native-soundcloud-waveform

• Github
• npm

I’ve also made an app in react-native — MetalCloud for Metal Music fans where you can see the above component at work.

Here are the links:

• IOS
• Android

Thanks for reading. If you liked this article, show your support by clapping to share with other people on Medium.

More of the cool stuff can be found on my StackOverflow and GitHub profiles.

Follow me on LinkedIn, Medium, Twitter for further update new articles.

It was 4 years ago when I had the idea to replicate the Apple® Siri wave-form (introduced with the iPhone 4S) in the browser using pure Javascript.

During the last month, I updated this library by doing a lot of refactoring using ES6 features and reviewed the build process using RollupJS. Now I’ve decided to share what I've learned during this process and the math behind this library.

To get an idea what the output will be, visit the live example; the whole codebase is here.

Additionally, you can download all plots drawn in this article in GCX (OSX Grapher format): default.gcx and ios9.gcx.

The classic wave style

Classic style

Initially, this library only had the classic wave-form style that all of you remember using in iOS 7 and iOS 8.

It’s no hard task to replicate this simple wave-form, only a bit of math and basic concepts of the Canvas API.

Siri wave-form in iOS 7/8

You’re probably thinking that the wave-form is a modification of the Sine math equation, and you're right…well, almost right.

Before starting to code, we’ve got to find our linear equation that will be simply applied afterwards. My favourite plot editor is Grapher; you can find it in any OSX installation under _Applications > Utilities > Graphe_r.app.

We start by drawing the well known:

Plot for y = sin(x)

Perfecto! Now, let’s add some parameters (Amplitude [A], Time coordinate[t] and Spatial frequency [k]) that will be useful later (Read more here: https://en.wikipedia.org/wiki/Wave).

Now we have to “attenuate” this function on plot boundaries, so that for |x| >; 2, the y values tends to 0. Let’s draw separately an equation g(x) that has these characteristics.

This seems to be a good equation to start with. Let’s add some parameters here too to smooth the curve for our purposes:

Now, by multiplying our f(x, …) and g(x, …), and by setting precise parameters to the other static values, we obtain something like this.

• A = 0.9 set the amplitude of the wave to max Y = A
• k = 8 set the spatial frequency and we obtain “more peaks” in the range [-2, 2]
• t = -π/2 set the phase translation so that f(0, …) = 1
• K = 4 set the factor for the “attenuation equation” so that the final equation is y = 0 when |x| ≥ 2

It looks good! ?

Now, if you notice on the original wave we have other sub-waves that will give a lower value for the amplitude. Let’s draw them for A = {0.8, 0.6, 0.4, 0.2, -0.2, -0.4, -0.6, -0.8}

In the final canvas composition the sub-waves will be drawn with a decreasing opacity tending to 0.

Basic code concepts

What do we do now with this equation?

We use the equation to obtain the Y value for an input X.

Basically, by using a simple for loop from -2 to 2, (the plot boundaries in this case), we have to draw point by point the equation on the canvas using the beginPath and lineTo API.

const ctx = canvas.getContext('2d');

ctx.beginPath();ctx.strokeStyle = 'white';

for (let i = -2; i <= 2; i += 0.01) {   const x = _xpos(i);   const y = _ypos(i);   ctx.lineTo(x, y);}

ctx.stroke();

Probably this pseudo-code will clear up these ideas. We still have to implement our _xpos and _ypos functions.

But… hey, what is 0.01⁉️ That value represents how many pixels you move forward in each iteration before reaching the right plot boundary… but what is the correct value?

If you use a really small value (<0.01), you’ll get an insanely precise rendering of the graph but your performance will decrease because you’ll get too many iterations.

Instead, if you use a really big value (> 0.1) your graph will lose precision and you’ll notice this instantly.

Plot drawn with precision = 0.2

You can see that the final code is actually similar to the pseudo-code: https://github.com/kopiro/siriwave/blob/master/src/curve.js#L25

Implement _xpos(i)

You may argue that if we’re drawing the plot by incrementing the x, then _xpos may simply return the input argument.

This is almost correct, but our plot is always drawn from -B to B (B = Boundary = 2).

So, to draw on the canvas via pixel coordinates, we must translate -B to 0, and B to 1 (simple transposition of [-B, B] to [0,1]); then multiply [0,1] and the canvas width (w).

_xpos(i) = w * [ (i + B) / 2B ]

https://github.com/kopiro/siriwave/blob/master/src/curve.js#L19

Implement _ypos

To implement _ypos, we should simply write our equation obtained before (closely).

const K = 4;const FREQ = 6;

function _attFn(x) {   return Math.pow(K / (K + Math.pow(x, K)), K);}

function _ypos(i) {   return Math.sin(FREQ * i - phase) *       _attFn(i) *       canvasHeight *      globalAmplitude *       (1 / attenuation);}

Let’s clarify some parameters.

• canvasHeight is Canvas height expressed in PX
• i is our input value (the x)
• phase is the most important parameter, let’s discuss it later
• globalAmplitude is a static parameter that represents the amplitude of the total wave (composed by sub-waves)
• attenuation is a static parameter that changes for each line and represents the amplitude of a wave

https://github.com/kopiro/siriwave/blob/master/src/curve.js#L24

Phase

Now let’s discuss about the phase variable: it is the first changing variable over time, because it simulates the wave movement.

What does it mean? It means that for each animation frame, our base controller should increment this value. But to avoid this value throwing a buffer overflow, let’s modulo it with 2π (since Math.sin dominio is already modulo 2π).

phase = (phase + (Math.PI / 2) * speed) % (2 * Math.PI);

We multiply speed and Math.PI so that with speed = 1 we have the maximum speed (why? because sin(0) = 0, sin(π/2) = 1, sin(π) = 0, … ?)

Finalizing

Now that we have all code to draw a single line, we define a configuration array to draw all sub-waves, and then cycle over them.

return [   { attenuation: -2, lineWidth: 1.0, opacity: 0.1 },   { attenuation: -6, lineWidth: 1.0, opacity: 0.2 },   { attenuation: 4, lineWidth: 1.0, opacity: 0.4 },   { attenuation: 2, lineWidth: 1.0, opacity: 0.6},

   // basic line   { attenuation: 1, lineWidth: 1.5, opacity: 1.0},];

https://github.com/kopiro/siriwave/blob/master/src/siriwave.js#L190

The iOS 9+ style

GIF of SiriwaveJS iOS9+

Now things start to get complicated. The style introduced with iOS 9 is really complex and the reverse engineering to simulate it it’s not easy at all! I’m not fully satisfied of the final result, but I’ll continue to improve it until I get the desired result.

As previously done, let’s start to obtain the linear equations of the waves.

Original Siri iOS 9+ wave-form

As you can notice:

• we have three different specular equations with different colours (green, blue, red)
• a single wave seems to be a sum of sine equations with different parameters
• all other colours are a composition of these three base colours
• there is a straight line at the plot boundaries

By picking again our previous equations, let’s define a more complex equation that involves translation. We start by defining again our attenuation equation:

Now, define h(x, A, k, t) function, that is the sine function multiplied for attenuation function, in its absolute value:

We now have a powerful tool.

With h(x), we can now create the final wave-form by summing different h(x) with different parameters involving different amplitudes, frequency and translations. For example, let’s define the red curve by putting random values.

If we do the same with a green and blue curve, this is the result:

This is not quite perfect, but it could work.

To obtain the specular version, just multiply everything by -1.

In the coding side, the approach is the same, we have only a more complex equation for _ypos.

const K = 4;const NO_OF_CURVES = 3;

// This parameters should be generated randomlyconst widths = [ 0.4, 0.6, 0.3 ];const offsets = [ 1, 4, -3 ];const amplitudes = [ 0.5, 0.7, 0.2 ];const phases = [ 0, 0, 0 ];

function _globalAttFn(x) {   return Math.pow(K / (K + Math.pow(x, 2)), K);}

function _ypos(i) {   let y = 0;   for (let ci = 0; ci < NO_OF_CURVES; ci++) {      const t = offsets[ci];      const k = 1 / widths[ci];      const x = (i * k) - t;            y += Math.abs(         amplitudes[ci] *          Math.sin(x - phases[ci]) *          _globalAttFn(x)      );   }

   y = y / NO_OF_CURVES;   return canvasHeightMax * globalAmplitude * y;}

There’s nothing complex here. The only thing that changed is that we cycle NO_OF_CURVES times over all pseudo-random parameters and we sum all y values.

Before multiplying it for canvasHeightMax and globalAmplitude that give us the absolute PX coordinate of the canvas, we divide it for NO_OF_CURVES so that y is always ≤ 1.

https://github.com/kopiro/siriwave/blob/master/src/ios9curve.js#L103

Composite operation

One thing that actually matters here is the globalCompositeOperation mode to set in the Canvas. If you notice, in the original controller, when there’s a overlap of 2+ colors, they’re actually mixed in a standard way.

The default is set to source-over, but the result is poor, even with an opacity set.

composite operation: source-over

You can see all examples of vary globalCompositeOperation here: https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation

By setting globalCompositeOperation to “ligther”, you notice that the intersection of the colours is nearest to the original.

Composite operation: lighter

Build with RollupJS

Before refactoring everything, I wasn’t satisfied at all with the codebase: old prototype-like classes, a single Javascript file for everything, no uglify/minify and no build at all.

Using the new ES6 feature like native classes, spread operators and lambda functions, I was able to clean everything, split files, and decrease lines of unnecessary code.

Furthermore, I used RollupJS to create a transpiled and minified build in various formats.

Since this is a browser-only library, I decided to create two builds: an UMD (Universal Module Definition) build that you can use directly by importing the script or by using CDN, and another one as an ESM module.

The UMD module is built with this configuration:

{   input: 'src/siriwave.js',   output: {      file: pkg.unpkg,      name: pkg.amdName,      format: 'umd'    },    plugins: [       resolve(),       commonjs(),       babel({ exclude: 'node_modules/**' }),    ]}

An additional minified UMD module is built with this configuration:

{   input: 'src/siriwave.js',   output: {      file: pkg.unpkg.replace('.js', '.min.js'),      name: pkg.amdName,      format: 'umd'    },    plugins: [       resolve(),       commonjs(),       babel({ exclude: 'node_modules/**' }),       uglify()]}

Benefiting of UnPKG service, you can find the final build on this URL served by a CDN: https://unpkg.com/siriwave/dist/siriwave.min.js

This is the “old style Javascript way” — you can just import your script and then refer in your code by using SiriWave global object.

To provide a more elegant and modern way, I also built an ESM module with this configuration:

{    input: ‘src/siriwave.js’,   output: {       file: pkg.module,       format: ‘esm’   },    plugins: [       babel({ exclude: ‘node_modules/**’ })   ]}

We clearly don’t want the resolve or commonjs RollupJS plugins because the developer transplier will resolve dependencies for us.

You can find the final RollupJS configuration here: https://github.com/kopiro/siriwave/blob/master/rollup.config.js

Watch and Hot code reload

Using RollupJS, you can also take advantage of rollup-plugin-livereload and rollup-plugin-serve plugins to provide a better way to work on scripts.

Basically, you just add these plugins when you’re in “developer” mode:

import livereload from 'rollup-plugin-livereload';import serve from 'rollup-plugin-serve';

if (process.env.NODE_ENV !== 'production') { additional_plugins.push(  serve({   open: true,   contentBase: '.'  }) ); additional_plugins.push(  livereload({   watch: 'dist'  }) );}

We finish by adding these lines into the package.json:

"module": "dist/siriwave.m.js","jsnext:main": "dist/siriwave.m.js","unpkg": "dist/siriwave.js","amdName": "SiriWave","scripts": {   "build": "NODE_ENV=production rollup -c",   "dev": "rollup -c -w"},

Let’s clarify some parameters:

• module / jsnext:main: path of dist ESM module
• unpkg: path of dist UMD module
• amdName: name of the global object in UMD module

Thanks a lot RollupJS!

Hope that you find this article interesting, see you soon! ?

Each artist has their own unique musical styles. From Ed Sheeran who devotes his life to the acoustic guitar, to Drake who masters the art of rapping. From Adele who can belt some crazy high notes on her pop ballads, to Kygo who creates EDM magic on his DJ set. Music is about creativity, originality, inspiration, and feelings, and it is the perfect gateway to connect people across differences.

Spotify is the largest music streaming service available. With more than 35 million songs and 170 million monthly active users, it is the ideal platform for musicians to reach their audience. On the app, music can be browsed or searched via various parameters — such as artists, album, genre, playlist, or record label. Users can create, edit, and share playlists, share tracks on social media, and make playlists with other users.

Additionally, Spotify launched a variety of interesting playlists tailor-made for its users, of which I most admire these three:

• Discover Weekly: a weekly generated playlist (updated on Mondays) that brings users two hours of custom-made music recommendations, mixing a user’s personal taste with songs enjoyed by similar listeners.
• Release Radar: a personalized playlist that allows users to stay up-to-date on new music released by artists they listen to the most.
• Daily Mix: a series of playlists that have “near endless playback” and mixes the user’s favorite tracks with new, recommended songs.

I recently discovered the ‘This Is” playlist series. One of Spotify’s best original features, “This Is” delivers on a major promise of the streaming revolution — the canonization and preservation of great artists’ repertoires for future generations to discover and appreciate.

Each one is dedicated to a different legendary artist, chronicling the high points of iconic discographies. “This is: Kanye West”. “This is: Maroon 5”. “This is: Elton John”. Spotify has provided a shortcut, giving us curated lists of the greatest songs from the greatest artists.

What we’ll cover here

The purpose of this project is to analyze the music that different artists on Spotify produce. The focus will be placed on disentangling the musical taste of 50 different artists from a wide range of genres. Throughout the process, I also identify different clusters of artists that share a similar musical style.

For the study, I will access the Spotify Web API, which provides data from the Spotify music catalog. This can be accessed via standard HTTPS requests to an API endpoint.

The Spotify API provides, among other things, track information for each song, including audio statistics such as danceability, instrumentalness, or tempo. Each feature measures an aspect of a song. Detailed information on how each feature is calculated can be found in the Spotify API Website. The code snippets in this article might be a bit tricky to understand, especially for data beginners, so bear with me.

Here’s a quick summary of my approach:

• Get the data from Spotify API.
• Process the data to extract audio features for each artist.
• Visualize the data using D3.js.
• Apply k-means clustering to separate the artists into different groups.
• Analyze each feature for all the artists.

Let’s now retrieve the audio feature information from “This Is” Playlists of 50 different artists on Spotify.

_Source: [https://blog.prototypr.io/have-you-heard-about-the-spotify-web-api-8e8d1dac9eaf](https://blog.prototypr.io/have-you-heard-about-the-spotify-web-api-8e8d1dac9eaf" rel="noopener" target="blank" title=")

Getting data

The first step was registering my application in the API Website and getting the keys (Client ID and Client Secret) for future requests.

The Spotify Web API has different URIs (Uniform Resource Identifiers) to access playlists, artists, or tracks information. Consequently, the process of getting data must be divided into two key steps:

• get the “This Is” Playlist Series for multiple musicians.
• get the audio features for each artist’s Playlist tracks.

Web API credentials

First, I created two variables for the Client ID and the Client Secret credentials.

spotifyKey <- "YOUR CLIEND ID"spotifySecret <- "YOUR CLIENT SECRET"

After that, I requested an access token in order to authorize my app to retrieve and manage Spotify data.

library(Rspotify)library(httr)library(jsonlite)spotifyEndpoint <- oauth_endpoint(NULL, "https://accounts.spotify.com/authorize","https://accounts.spotify.com/api/token")

spotifyToken <- spotifyOAuth("Spotify Analysis", spotifyKey, spotifySecret)

“This Is” Playlist Series

The first step was to pull the artists’ “This Is” series is to get the URIs for each one. Here are the 50 musicians I have chosen, using their popularity, modernity, and diversity as the main criteria:

• Pop: Taylor Swift, Ariana Grande, Shawn Mendes, Maroon 5, Adele, Justin Bieber, Ed Sheeran, Justin Timberlake, Charlie Puth, John Mayer, Lorde, Fifth Harmony, Lana Del Rey, James Arthur, Zara Larsson, Pentatonix.
• Hip-Hop / Rap: Kendrick Lamar, Post Malone, Drake, Kanye West, Eminem, Future, 50 Cent, Lil Wayne, Wiz Khalifa, Snoop Dogg, Macklemore, Jay-Z.
• R & B: Bruno Mars, Beyonce, Enrique Iglesias, Stevie Wonder, John Legend, Alicia Keys, Usher, Rihanna.
• EDM / House: Kygo, The Chainsmokers, Avicii, Marshmello, Calvin Harris, Martin Garrix.
• Rock: Coldplay, Elton John, One Republic, The Script, Jason Mraz.
• Jazz: Frank Sinatra, Michael Buble, Norah Jones.

_Source: [http://www.thedrum.com/news/2017/11/29/spotify-wraps-up-2017-making-humorous-goals-2018-using-its-data-and-artists](http://www.thedrum.com/news/2017/11/29/spotify-wraps-up-2017-making-humorous-goals-2018-using-its-data-and-artists" rel="noopener" target="blank" title=")

I basically went to each musician’s individual playlist, copied the URIs, stored each URI in a .csv file, and imported the .csv files into R.

library(readr)

playlistURI <- read.csv("this-is-playlist-URI.csv", header = T, sep = ";")

With each Playlist URI, I applied the getPlaylistSongs from the “RSpotify” package, and stored the Playlist information in an empty data.frame.

# Empty dataframePlaylistSongs <- data.frame(PlaylistID = character(),                            Musician = character(),                            tracks = character(),                            id = character(),                            popularity = integer(),                            artist = character(),                            artistId = character(),                            album = character(),                            albumId = character(),                            stringsAsFactors=FALSE)

# Getting each playlistfor (i in 1:nrow(playlistURI)) {  i <- cbind(PlaylistID = as.factor(playlistURI[i,2]),             Musician = as.factor(playlistURI[i,1]),             getPlaylistSongs("spotify",                              playlistid = as.factor(playlistURI[i,2]),                              token=spotifyToken))  PlaylistSongs <- rbind(PlaylistSongs, i)}

Audio features

First, I wrote a formula (getFeatures) that extracts the audio features for any specific ID stored as a vector.

getFeatures <- function (vector_id, token) {  link <- httr::GET(paste0("https://api.spotify.com/v1/audio-features/?ids=",   vector_id), httr::config(token = token))  list <- httr::content(link)  return(list)}

Next, I included getFeatures in another formula (get_features). The latter formula extracts the audio features for the track ID’s vector, and returns them in a data.frame.

get_features <- function (x) {  getFeatures2 <- getFeatures(vector_id = x, token = spotifyToken)  features_output <- do.call(rbind, lapply(getFeatures2$audio_features, data.frame, stringsAsFactors=FALSE))}

Using the formula created above, I was able to extract the audio features for each track. In order to do so, I needed a vector containing each track ID. The rate limit for the Spotify API is 100 tracks, so I decided to create a vector with track IDs for each musician.

Next, I applied the get_features formula to each vector, obtaining the audio features for each musician.

After that, I merged each musician’s audio features data.frame into a new one, all_features. It contains the audio features for all the tracks in every musician’s “This Is” Playlist.

library(gdata)

all_features <- combine(TaylorSwift,ArianaGrande,KendrickLamar,ShawnMendes,Maroon5,PostMalone,Kygo,TheChainsmokers,Adele,Drake,JustinBieber,Coldplay,KanyeWest,BrunoMars,EdSheeran,Eminem,Beyonce,Avicii,Marshmello,CalvinHarris,JustinTimberlake,FrankSinatra,CharliePuth,MichaelBuble,MartinGarrix,EnriqueIglesias,JohnMayer,Future,EltonJohn,FiftyCent,Lorde,LilWayne,WizKhalifa,FifthHarmony,LanaDelRay,NorahJones,JamesArthur,OneRepublic,TheScript,StevieWonder,JasonMraz,JohnLegend,Pentatonix,AliciaKeys,Usher,SnoopDogg,Macklemore,ZaraLarsson,JayZ,Rihanna)

Finally, I computed the mean of each musician’s audio features using the aggregate function. The resulting data.frame contains the audio features for each musician, expressed as the mean of the tracks in their respective playlists.

mean_features <- aggregate(all_features[, c(1:11,17)], list(all_features$source), mean)

names(mean_features) <- c("Musician", "danceability", "energy", "key", "loudness", "mode", "speechiness", "acousticness", "instrumentalness", "liveness", "valence", "tempo", "duration_ms")

The image below shows a subset of the mean_features data.frame, for your reference.

Audio features description

The description of each feature from the Spotify Web API Guidance can be found below:

• Danceability: describes the suitability of a track for dancing. This is based on a combination of musical elements including tempo, rhythm stability, beat strength, and overall regularity. A value of 0.0 is least danceable and 1.0 is most danceable.
• Energy: a measure from 0.0 to 1.0, and represents a perceptual measure of intensity and activity. Typically, energetic tracks feel fast, loud, and noisy. For example, death metal has high energy, while a Bach prelude scores low on the scale. Perceptual features contributing to this attribute include dynamic range, perceived loudness, timbre, onset rate, and general entropy.
• Key: the key the track is in. Integers map to pitches using standard Pitch Class notation. E.g. 0 = C, 1 = C♯/D♭, 2 = D, and so on.
• Loudness: the overall loudness of a track in decibels (dB). Loudness values are averaged across the entire track and are useful for comparing the relative loudness of tracks. Loudness is the quality of a sound that is the primary psychological correlate of physical strength (amplitude). Values typical range between -60 and 0 db.
• Mode: indicates the modality (major or minor) of a track, the type of scale from which its melodic content is derived. Major is represented by 1 and minor is 0.
• Speechiness: Speechiness detects the presence of spoken words in a track. The more exclusively speech-like the recording (e.g. talk show, audio book, poetry), the closer to 1.0 the attribute value. Values above 0.66 describe tracks that are probably made entirely of spoken words. Values between 0.33 and 0.66 describe tracks that may contain both music and speech, either in sections or layered, including such cases as rap music. Values below 0.33 most likely represent instrumental music and other non-speech-like tracks.
• Acousticness: a confidence measure from 0.0 to 1.0 of whether the track is acoustic. 1.0 represents high confidence that the track is acoustic.
• Instrumentalness: predicts whether a track contains no vocals. “Ooh” and “aah” sounds are treated as instrumental in this context. Rap or spoken word tracks are clearly “vocal”. The closer the instrumentalness value is to 1.0, the greater likelihood the track contains no vocal content. Values above 0.5 are intended to represent instrumental tracks, but confidence is higher as the value approaches 1.0.
• Liveness: detects the presence of an audience in the recording. Higher liveness values represent an increased probability that the track was performed live. A value above 0.8 provides strong likelihood that the track is live.
• Valence: a measure from 0.0 to 1.0 describing the musical positiveness conveyed by a track. Tracks with high valence sound more positive (for example happy, cheerful, euphoric), while tracks with low valence sound more negative (for example sad, depressed, angry).
• Tempo: the overall estimated tempo of a track in beats per minute (BPM). In musical terminology, tempo is the speed or pace of a given piece, and derives directly from the average beat duration.
• Duration_ms: the duration of the track in milliseconds.

_Source: [https://www.engadget.com/2018/02/05/spotify-recommendation-tech-nelson-custom-playlists/](https://www.engadget.com/2018/02/05/spotify-recommendation-tech-nelson-custom-playlists/" rel="noopener" target="blank" title=")

Data Visualization

Radar charts

A radar chart is useful to compare the musical vibes of these musicians in a more visual way. The first visualization is an R implementation of the radar chart from the chart.js JavaScript library, and evaluates the audio features for ten selected musicians.

In order to plot, I normalized the key, loudness, tempo, and duration_ms values to be from 0 to 1. This helps to make the chart more clear and readable.

mean_features_norm <- cbind(mean_features[1], apply(mean_features[-1],2, function(x){(x-min(x))/diff(range(x))}))

Okay, let’s plot these interactive radar charts in batches of ten musicians. Each chart displays data set labels when you hover over each radial line, showing the value for the selected feature. The code below details the process of making the radar chart for the first batch of ten musicians. The code for the other four batches has been omitted, but the radar charts are displayed.

Batch 1: Taylor Swift, Ariana Grande, Kendrick Lamar, Shawn Mendes, Maroon 5, Post Malone, Kygo, The Chainsmokers, Adele, Drake

Batch 2: Justin Bieber, Coldplay, Kanye West, Bruno Mars, Ed Sheeran, Eminem, Beyonce, Avicii, Marshmello, Calvin Harris

Batch 3: Justin Timberlake, Frank Sinatra, Charlie Puth, Michael Buble, Martin Garrix, Enrique Iglesias, John Mayer, Future, Elton John, 50 Cent

Batch 4: Lorde, Lil Wayne, Wiz Khalifa, Fifth Harmony, Lana Del Rey, Norah Jones, James Arthur, One Republic, The Script, Stevie Wonder

Batch 5: Jason Mraz, John Legend, Pentatonix, Alicia Keys, Usher, Snoop Dogg, Macklemore, Zara Larsson, Jay-Z, Rihanna

Cluster Analysis

Another way to find out the differences between these musicians in their musical repertoire is by grouping them in clusters. The general idea of a clustering algorithm is to divide a given dataset into multiple groups on the basis of similarity in the data.

In this case, musicians will be grouped in different clusters according to their music preferences. Rather than defining groups before looking at the data, clustering allows me to find and analyze the musician groupings that have formed organically.

Prior to clustering data, it is important to rescale the numeric variables of the dataset. Since I have mixed numerical data, where each audio feature is different from another and has different measurements, running the scale function (aka z-standardizing them) is a good practice to give equal weight to them. After that, I kept the musicians as the row names to be able to show them as labels in the plot.

scaled.features <- scale(mean_features[-1])rownames(scaled.features) <- mean_features$Musician

I applied the K-Means Clustering method, which is one of the most popular techniques of unsupervised statistical learning methods. It is used for unlabeled data. The algorithm finds groups in the data, with the number of groups represented by the variable K. The algorithm works iteratively to assign each data point to one of K groups based on the variables that are provided. Data points are clustered based on similarity.

In this instance, I chose K = 6 — the clusters can be formed based on the six different genres I used when choosing the artists (Pop, Hip-Hop, R&B, EDM, Rock, and Jazz).

After I applied the K-Means algorithm for each musician, I can plot a two-dimensional view of the data. In the first plot, the x-axis and y-axis correspond to the first and second principal components respectively. The eigenvectors (represented by red arrows) indicate the directional influence each variable has on the principal components.

Let’s have a look at the clusters that result from applying the K-Means algorithm to my dataset.

As you can see in the graph above, the x-axis is PC1 (30.24%) and the y-axis is PC2 (16.54%). These are the first two principal components. The PCA graph shows that PC1 separates artists by loudness/energy vs acoustic/mellowness, while PC2 appears to separate artists on a scale of valence vs key, tempo and instrumentalness.

Because my data is multivariate, it is tedious to inspect all the many bivariate scatterplots. Instead, a single “summarizing” scatterplot is more convenient. The scatterplot of the first two principal components which were derived from the data has been shown in the graph. The percentage, likewise, is the variance explained by each component of the overall variability: the 1st component captured 30.24% and the 2nd component captured 16.54% of the information about the multivariate data.

If you’re interested to learn more about the math behind this algorithm, I recommend that you brush up on Principal Component Analysis.

Let’s see which artists belong to which clusters:

k_means$cluster

I have also plotted another radar chart containing the features for each cluster. It is useful to compare the attributes of the songs that each cluster creates.

Cluster 1 contains four artists: Coldplay, Avicii, Marshmello, and Martin Garrix. Their music is mostly performed live and instrumental, usually loud and full of energy with high tempo. This is not too surprising, as three of the four artists perform EDM / House music, and Coldplay is known for their live concerts.

Cluster 2 contains 2 artists: Frank Sinatra and Norah Jones (any jazz fans out there?). Their music scores high on acousticness and the Major scale mode. However, they score low in all the remaining attributes. Typical Jazz tunes.

Cluster 3 contains ten artists: Post Malone, Kygo, The Chainsmokers, Adele, Lorde, Lana Del Rey, James Arthur, One Republic, John Legend, and Alicia Keys. This cluster scores average in mostly all the attributes. This suggests that this group of artists is well-balanced and versatile with style and creation, hence the diversity of genres presented in this cluster (EDM, Pop, R&B).

Cluster 4 contains 15 artists: Ariana Grande, Maroon 5, Drake, Justin Bieber, Bruno Mars, Calvin Harris, Charlie Puth, Enrique Iglesias, Future, Wiz Khalifa, Fifth Harmony, Usher, Macklemore, Zara Larsson, and Rihanna. Their music is danceable, loud, high-tempo, and energetic. This group has the presence of many young mainstream artists in the Pop and Hip-Hop genres.

Cluster 5 contains 10 artists: Taylor Swift, Shawn Mendes, Ed Sheeran, Michael Buble, John Mayer, Elton John, The Script, Stevie Wonder, Jason Mraz, and Pentatonix. This is my favorite group! Taylor Swift? Ed Sheeran? John Mayer? Jason Mraz? Elton John? I guess I listen to a lot of singer-songwriter artists. Their music is mostly in the Major scale, while achieving perfect balance (average score) in all other attributes.

Cluster 6 contains nine artists: Kendrick Lamar, Kanye West, Eminem, Beyonce, Justin Timberlake, 50 Cent, Lil Wayne, Snoop Dogg, and Jay-Z. You already see the trend here: seven of them are Rappers, and even Beyonce and JT regularly collaborate with rappers. Their songs have high number of spoken words and speech-like sections, are long in duration, and often performed live. Any better description of rap music?

Analysis by feature

The following charts show the values for each feature for every musician. The code below details the process for making the danceability diverging bar plot. The code for the other features has been omitted, but each feature’s plot is displayed subsequently.

Danceability

If you want to bust the moves and impress your crush, try listen to more of Future, Drake, Wiz Khalifa, Snoop Doog, and Eminem. On the other hand, don’t even attempt to dance to Frank Sinatra or Lana Del Rey’s tunes.

Energy

You’re a fairly energetic person if you listen to lots of Marhsmello, Calvin Harris, Enrique Iglesias, Martin Garrix, Eminem, Jay-Z. The opposite is true if you’re a fan of Frank Sinatra and Norah Jones.

Loudness

The Loudness ranking is almost the same as the Energy one.

Speechiness

All the Rap fans out there: what’s your favorite songs from Kendrick Lamar? or 50 Cent? or Jay-Z? Hmm, I’m surprised Eminem does not rank higher, as I personally think that he’s the GOAT of all rappers.

Acousticness

Acousticness is the exact opposite of Loudness and Energy. Mr. Sinatra and Mrs. Jones released some powerful acoustic tracks throughout their careers.

Instrumentalness

EDM for the win! Martin Garrix, Avicii, and Marshmello produce tracks that contain almost no vocals.

Liveness

So who are the 5 artists who performed the most live audio recordings? Jason Mraz, Coldplay, Martin Garrix, Kanye West, and Kendrick Lamar, in that order.

Valence

Valence is the feature that describes musical positiveness conveyed by a track. Music by Bruno Mars, Stevie Wonder, and Enrique Iglesias are very positive, while music by Lana Del Rey, Coldplay, and Martin Garrix sound quite negative.

Tempo

Future, Marshmello, and Wiz Khalifa are kings of speed. They produce tracks with the highest tempo in beats per minute. And Snoop Dogg, lol? He tends to take some time to utter his magic words.

Duration

Last but not least, songs by Justin Timberlake, followed by Elton John and Eminem, are, sometimes excruciatingly, long. In contrast, Frank Sinatra, Zara Larsson, and Pentatonix favor shorter music.

Conclusion

Whoa, I had a lot of fun doing this analysis and visualization project on Spotify data. Who could have thought that James Arthur and Post Malone are in the same cluster? Or Kendrick Lamar is the speediest rapper in the game? Or that Marshmello would beat Martin Garrix in producing energetic tracks?

Anyway, you can view the complete R Markdown, separate R code for processing and visualizing data, and the original dataset in my GitHub repository here. From my own perspective, R is much better in data visualization than Python, with the likes of libraries such as ggplot and plot.ly. I highly encourage you to give R a try!

— —

If you enjoyed this piece, I’d love it if you hit the clap button ? so others might stumble upon it. You can find my own code on GitHub, and more of my writing and projects at https://jameskle.com/. _You can also follow me on Twitter, email me directly or find me on LinkedIn. Sign up for my newsletter to receive my latest thoughts on data science, machine learning, and artificial intelligence right at your inbox!_