DEV Community: Aravind Mohandas

Formalizing Konnakol using Haskell - GSoC '22

Aravind Mohandas — Tue, 06 Sep 2022 11:37:04 +0000

Project Description
Phase 1
Phase 2
Challenges and Learnings
Future Work
Blogs
Link to Code

Project Description

The major aim of the project was to create a system which could formalize the rules of Konnakol. The system developed was then integrated with Tidal Cycles.

This project was done with Haskell, under the mentorship of Alex McLean.

Phase 1

The first part of the project was to develop a system which could formalize the rules of Konnakol, validate as well as generate Konnakol compositions. The system was also capacitated to generate diagrams based on the compositions (sample diagrams can be found here. All code for this phase has been published as a Haskell package named konnakol.

Compositions generated can be converted for use in Tidal Cycles. We obtained audio samples that could be used from Arthur Carabott, and hence could listen to compositions. One can listen to sample compositions here.

The code written during Phase 1 can be found here.

Phase 2

The second part of the project was to try modify Tidal Cycles so that it could deal with beat-wise compositions. We were able to develop a sequence datatype in Tidal Cycles, and define alternative function definitions for many functions that are used by patterns.

The code written in this regard can be found here. My contributions focused on designing, implementing and integrating the Sequence module with the help of the Context module.

Challenges and Learnings

The major challenge that I faced initially was understanding the logic within the code that was written by other contributors. Since this was my first time contributing to an open source project, it took me some time to get familiar with the overall process.

I would say that the Google Summer of Code has introduced me to the world of open source and given me the joy of being a part of something huge. I have evolved to become a better programmer in the last 16 weeks, and look forward to continue contributing.

Future Work

After coming up with the Sequence datatype, we have decided to try rewrite Tidal from scratch, removing redundancies and adding precise documentation.

The work done in this direction can be found here.

Blogs

For full details on the above, please see the development blogs:

Part 0 - Before Official Coding period
Part 1 - Weeks 1 - 4
Part 2 - Weeks 5 - 8
Part 3 - Weels 9 - 12

Link to Code

Adding sequences to Tidal Cycles and listening to Konnakol - GSoC '22 Update 3

Aravind Mohandas — Sat, 03 Sep 2022 05:45:25 +0000

As the official coding period of the Google Summer of Code 2022 come to an end, I will be talking about the progress that I have made since the last blog post. I shall also talk about how I fared against my own expectations, major learnings and what I plan to do after the Official Coding Period ends.

Generating Konnakol using Tidal Cycles

In the previous blog post, I had talked about generating audio samples using Konnakol in Tidal Cycles. I spent a few days ironing out the finer details of this audio generation, by having functions to figure out the ideal speed at which compositions need to be generated, and fixing missing audio samples.

Now, one can listen to a Konnakol composition, with a few extra sounds and effects by using just a few lines of code as follows:

do
  resetCycles
  d1 $ jux rev $ fast 2 $ (tidalK Chaturasra thriputa Chaturasra (mkStdGen 23)) # gain 2

d2 $ sound "bd sd <bd ~> [sd sd sd]" # gain 1.2

d5 $ sound "arpy(<3 5>, 8)" # gain 1.2

One thing that should be noted here is that changing the value under mkStdGen entirely changes the composition that is generated. Hence, this offers a great range of variety Konnakol compositions, and two different values will most probably give two entirely different compositions.

I then had the privilege of presenting my progress in front of the Tidal Cycles community on the 11th of August 2022. The response was encouraging, and there were several suggestions on how to make it better. One of the suggestions was first enumerating syllables during generation of compositions, and then using these enumerations to generate the same pattern but
for different set of audio samples. I was instantly hooked to the idea, and spent the next couple days to get it to work.

Now, if you use the following code, you will get a Konnakol composition along with an enumerated composition on the piano.

do
  resetCycles
  d1 $ fast 2 $ numK Tisra rupaka Khanda (mkStdGen 12123) "lydian"  # sound "superpiano" # legato 3
  d2 $ fast 2 $  tidalK Tisra rupaka Khanda (mkStdGen 12123) # gain 3

I have tried recording a couple such samples, one can find these samples in the Konnakol repository.

Adding Sequences to Konnakol

After I was done with the Konnakol part of my project, the next (and final) objective was to develop a system within Tidal Cycles to deal with beat-wise composition. Currently Tidal Cycles is cycle-based, and a pattern in Tidal is a function of time, instead of a sequence of beats.

After a lot of brainstorming, my mentor (Alex McLean) and I decided to create a new datatype called Sequence, which would be able to deal with sequences.

data Sequence a = Atom Rational a
                | Gap Rational
                | Sequence [Sequence a]
                | Stack [Sequence a]
              deriving (Show, Eq)

The recursive tree-like structure of a sequence would allow one to have sequences within sequences. For representing aligned sequences, we have the Stack [Sequence a], which actually consists of a list of sequences with the same duration. The idea was to describe functions for sequences which had the same type signatures as the ones for patterns.

In order to do this, the first major problem that we had to solve was to develop functions which could align sequences(This would play a significant role in applying sequences of functions to sequences). To align sequences, we found there were multiple possible ways, somewhat similar to aligning text (read more about the various possible strategies here).

So, the first step in defining functions for sequences was defining the various alignment methods. In total, 9 different alignment methods were defined. After this, the instances of Functor, Applicative Functor, and Monad were defined for Sequences. A general method was also defined to apply a sequence of functions to a sequence. A couple of methods were also defined to help simplify a sequence of sequences, and to remove redundant values (such as a Gap 0).

After doing all this groundwork, the next objective was to start picking functions defined for patterns, and to define them with respect to sequences. Functions such as fast and slow were easy to implement, whereas functions such as euclid, iter and every took some brainstorming, since there was the initial challenge of understanding what their implementation would mean for a sequence.

As I kept adding on to and expanding sequences, we worked on creating a way to handle function calls with the same name for sequences as well as patterns. A method was also defined which could convert a sequence into a pattern (for now, it is a one-way street, but we might try to get it done the other way pretty soon).

All this modification was performed in Tidal-1.9.0, which then threw some errors when I tried to get it build on Windows. This helped us discover that there actually was a bug for Windows users, which was then resolved. However, the dependencies of Tidal-1.9.0 had a lot of conflicts with Konnakol, and so I defined a Konnakol program within the Tidal package, which contained all the necessary function for generating compositions.

Hence, the current system is capacitated to deal with sequences as well as patterns, and is capable of producing audio output as well. One can try implementing more than a handful of functions on sequences, and the results are often quite surprising, depending on the alignment strategy that has been chosen.

Future work on Tidal Cycles

Over the last 12 weeks, I was able to accomplish everything (and maybe a bit more) that I had initially proposed. The overall process of coming up with creative and efficient solutions to challenging problems has helped me evolve as a programmer.

The Official Coding period of the Google Summer of Code might be coming to a close, but it surely does not mark the end of my contribution to Tidal Cycles. I absolutely loved the community and the challenging problems that I encountered here.

The next thing that we are planning to do is rewriting Tidal to accommodate sequences and patterns (which we're planning to rename to signals), in a way that removes a lot of redundancy. We have already begun our work on this (repository has been linked below), and one can read more about the ideas that we have for this here.

References

To view the Konnakol repository, visit here.

To view all the progress that has been made on Sequences, visit this branch.

To view the exciting rewrite of Tidal, visit here.

Visualising Konnakol Compositions - GSoC '22 Update 2

Aravind Mohandas — Tue, 26 Jul 2022 06:05:18 +0000

It has been 6 weeks since the official coding period started for the Google Summer of Code '22. The last three weeks have been interesting as well as hectic . There were multiple new concepts to learn, hundreds of lines of code to go through and understand, and an attempt to get to that one elusive final plan which will decide how my next 6 weeks shall go.

Visualizing Compositions

After fixing a few minor bugs in the generations of Korvais and Mohras, the next step was developing methods to visualize compositions. This meant going through the Diagrams package, and discovering methods to visualize compositions in a grid-like structure.

The first idea that I had in visualizing Korvais was that I would represent the phrases in a color, and the gaps in another. Each row would represent a new rhythmic cycle. As I developed functions for the same, I realized that it would be better if I had a gradient as well instead of just a single color. Phrases would have a decreasing gradient, where the rate of decline would depend on the length of the phrase. The same would hold true for gaps, albeit with an increasing gradient. Another great idea, which was recommended by my mentor, Alex McLean, was to have a header which would help one understand where the beats would land.

An example generation for a normal numerical pattern is as follows:

Another such visualization for a Korvai is as follows:

These were custom compositions that were provided as a list of phrases and gaps. The next step was in getting the system to compose as well as visualize compositions in one go. One such Korvai that the system has composed is given below:

Visualizing Mohras proved to be a completely different ballgame. Unlike Korvais, gaps were not a characteristic feature here. Hence, I decided to use the fundamental structure, i.e., the separation of a Mohra into components as the deciding feature.

One such Mohra generated by the system has been given below:

The final step that I wanted to figure out was the representation of compositions which have changing time signatures. This required generating diagrams where the length of the individual components would vary.

The earlier composition visualized in two different time signatures is given below:

Another numerical pattern which used 4 different time signatures is given below:

At this point, I was interested to find out how it would be to overlap cycles over themselves to see what the resultant color would be. I accomplished this using circular wedges. Phrases would add a positive value to the resultant color, while gaps would add a negative value. Such a visualization is given below:

Once I was done with the diagrams part, all that was left was to create a package and upload it on hackage. The package has been linked below:

konnakol: Formalising the rules of Konnakol, an Indian percussional art form.

hackage.haskell.org

Listening to Konnakol

After visualizing Konnakol compositions, the next thing on the list was to listen to Konnakol compositions. Fortunately, we came across an amazing collection of Mridangam samples by Arthur Carabott, who recorded these with the help of Mridangam artist Harishankar V Menon. They were kind enough to grant us permission to use the audio samples in our project.

To use the samples along with compositions generated by the system, I had to define methods which would convert these compositions into mini notation, as well as a suitable value by which the compositions needed to be slowed down so they would attain optimal tempo. Once I did this, it was only a matter of installing the konnakol package, importing it in tidal and live coding Konnakol!!

The audio generation code has been written in such a way that anyone with a basic understanding of Konnakol would be able to generate a Mohra or a Korvai with just a single line of code. For example, to generate a Mohra one would only have to type in

d1 $ (tidalM Khanda rupaka Khanda (mkStdGen 112))

To make it sound better, one case use other available functions and audio samples in Tidal Cycles. One such example is given below:

do
  resetCycles
  d1 $ jux (fast 2) $ (tidalK Chaturasra thriputa Chaturasra (mkStdGen 112232)) # gain 1.3

d2 $ sound "bd sd ~ sd" # gain 1

d5 $ sound "arpy(<3 5>, 8)" # gain 1.1

Sample audios generated can be found in the code repository, linked at the end of the document.

What Next?

The main aim for the second half of the project is to develop a system within TidalCycles, which would be able to handle sequences. I would also be working on

To view the code developed, as well as a detailed description of Konnakol, visit:

tidalcycles / konnakol-gsoc

Repository for Konnakol experiments during GSOC 2022

GSOC Konnakol

Repository of experiments performed as a part of the Google Summer of Code 2022.

Contributer : Aravind Mohandas Mentor: Alex McLean

To read more about Konnakol visit here

To understand the datatypes and functions used, visit here

To look at sample diagrams generated, visit here

To launch a code and make music: Visualising Konnakol Compositions - GSoC '22 Update 2. (NB: load audiofiles with SC's startup file to hear sound)

Audio Samples

Mridangam samples (c) Arthur Carabott, distributed under a CC-BY-SA license https://creativecommons.org/licenses/by-sa/4.0/, performed by Harishankar V Menon.

View on GitHub

Audio Samples

Mridangam samples (c) Arthur Carabott, distributed under a CC-BY-SA license https://creativecommons.org/licenses/by-sa/4.0/, performed by Harishankar V Menon.

Konnakol Compositions using Haskell - GSoC '22 Update 1

Aravind Mohandas — Sat, 02 Jul 2022 06:47:48 +0000

Since it has been 3 weeks since the Official Coding Period started at the Google Summer of Code '22, I thought it would be ideal to write about my experience so far in developing a system to formalize Konnakol compositions using Haskell. I shall talk about the features that I have developed so far, the major roadblocks I faced, and the way ahead.

The Pre-Coding Phase

The Community bonding period began as soon as the contributors for GSoC '22 were announced. I was introduced to the TidalCycles community, and the GSoC '22 Haskell community. I met my mentor Alex McLean, and we chalked out the project timeline in greater detail.

Although I had a basic understanding of Haskell, I thought this period would be ideal to learn the language in greater detail. Since I had only learned Object Oriented Programming Languages till then, it took some time to get used to Haskell. I referred to "Learn You a Haskell For Greater Good" by Miran Lipovača, and as my understanding of Haskell improved, I started getting a detailed idea of how my project can be structured.

During this period, I also went through research papers on Konnakol in an attempt to find a formal document on the rules followed. On failing to do so, I approached Vidwan Sri H.S. Sudhindra, an Indian Classical Percussionist, and he was kind enough to help me identify the rules that would be necessary for implementing my project.

The next step was to go through the documentation of TidalCycles as well as Diagrams (a Haskell package which I would be using soon to visualize compositions). I also went through a series of videos on TidalCyles by my mentor. This helped provide a clearer image on how I should structure my datatypes, so that future integration with TidalCycles would be easier.

As I ended my community bonding period, I had gone through tons of documentation, research papers and videos, and was itching to start coding.

The Coding Period

Since I finished my objectives for the community bonding period early, I thought I would get a head start for the coding period. I felt I had done enough groundwork to start building up.

I started by defining datatypes for components of Konnakol such as Thala, Jati, Gati and the syllables to be used. I then defined the Suladi Sapta Thala System, and a method to show thalas using the conventional symbols. Next was development of the necessary methods and datatypes for the user to enter a composition which has varying gatis, and methods for displaying them in the proper jathi notation. This is immensely helpful for beginners in Konnakol as they could enter a composition and see exactly where each of the syllables land. A simple example of the same has been provided with along with the function call used. Here KalaCh is used to change the Gati (or the time signature) of the composition. The phrases are entered along with the speed at which they are to be recited.

The next step was to develop methods to generate a Mohra for a given thala, and to facilitate this, methods were created to generate phrases for a particular length. This method uses a random value to generate a phrase for the given length. This method, along with methods to partition the given thala into sections, are used to generate a mohra. Then the getRepresentation method is called on the same, and the user gets a custom Mohra along with its representation.

Another composition which can be composed it the Korvai. Since the structure of the Korvai is more complex than that of the Mohra, set comprehensions in Haskell were used to create subsets of the overall count which follow some pattern (such as arithmetic or geometric progressions). A similar procedure to Mohra generation was followed to obtain representation.

Users can now just run main, enter the jati, the thala and the gati, followed by a 1 if they desire to generate a Mohra and any other digit otherwise. Sample generations are provided below. Here a "-" denoted a gap in statements. "^" are used to separate beats, "|", "O" and "U" are used to denote the components of a thala, and "||" the beginning of the next cycle of the thala.

Another method was developed (along with the necessary datatypes), with which the user can enter his composition as numbers and see whether the composition is valid with respect to its total count. This method was further developed to check whether custom Korvais are valid.

What Next ?

The next step in the project is to develop methods to visualize custom compositions. A grid like structure will be used here, and this will help understand the structure of certain compositions. Post this, the system developed will be integrated with TidalCycles.

To view the code developed for the project, visit

tidalcycles / konnakol-gsoc

Repository for Konnakol experiments during GSOC 2022

gsoc-konnakol

Repository for Konnakol experiments during GSOC 2022

View on GitHub

Formalizing Konnakol using Haskell @ GSoC '22

Aravind Mohandas — Fri, 10 Jun 2022 05:30:55 +0000

Konnakol, in South Indian Carnatic music, is the art of performing percussion syllables vocally. It is the recitation of Solkattu – the vocal syllables related to the sounds of the Mridangam, a major percussion instrument in Carnatic Music. Recognized as an art form of principle study, Konnakol is also a medium used by Carnatic musicians to convey rhythmic ideas to each other.

However, notwithstanding its importance in Carnatic music, there have not been any successful attempts in creating a system which could formalise the conventional rules of Konnakol and check whether a given rhythmic pattern fits into a fixed set of rhythmic cycles or not. Such a pattern forms a partition of the total length of the rhythmic cycles.

This project aims to formalize Korvai (cadence) and Koraippu (starting with a longer pattern and progressively performing shorter patterns) and Mohra, three main aspects of Konnakol. The system developed will be able to formalize pre-existing compositions, as well as check whether a given composition follows the conventional rules of Konnakol. This system can then be used to generate new patterns, which could, further on, be compared to one another to find the most complex ones.

The project also aims to display valid compositions using the Jathi notation, as well as use a grid design to visualize the patterns generated, where syllables of different lengths and the gaps between syllables will be displayed using different colors. This will facilitate understanding of the patterns among the partition that this composition has formed. The system developed will be integrated with the
"Tidal Cycles” software, so that users may include Konnakol in their compositions as well. The documentation and the visualization tools provided will help TidalCyclists with no prior knowledge to develop a basic understanding about Konnakol.

To read more about the project and to follow progress, you can visit the Google Summer of Code Project Page

Google Summer of Code

summerofcode.withgoogle.com

DEV Community: Aravind Mohandas

Formalizing Konnakol using Haskell - GSoC '22

Contents

Project Description

Phase 1

Phase 2

Challenges and Learnings

Future Work

Blogs

Link to Code

Adding sequences to Tidal Cycles and listening to Konnakol - GSoC '22 Update 3

Generating Konnakol using Tidal Cycles

Adding Sequences to Konnakol

Future work on Tidal Cycles

References

Visualising Konnakol Compositions - GSoC '22 Update 2

Visualizing Compositions

konnakol: Formalising the rules of Konnakol, an Indian percussional art form.

Listening to Konnakol

What Next?

tidalcycles / konnakol-gsoc

Repository for Konnakol experiments during GSOC 2022

GSOC Konnakol

Audio Samples

Audio Samples

Konnakol Compositions using Haskell - GSoC '22 Update 1

The Pre-Coding Phase

The Coding Period

What Next ?

tidalcycles / konnakol-gsoc

Repository for Konnakol experiments during GSOC 2022

gsoc-konnakol

Formalizing Konnakol using Haskell @ GSoC '22

Google Summer of Code