Home/ Questions/Q 8621473
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-12T06:49:42+00:00

I am writing an app to record drum tablature (specifically for a sampler ).

  • 0

I am writing an app to record drum tablature (specifically for a sampler). I am following the conventions of the sampler which are:

  1. A Sequence is 1 or more Tracks. A Sequence can be quantized (break the measure up into equal parts).

  2. A Track is an instrument or sound that will be played at certain parts of a measure. Each Track is broken up into parts. The number of parts is determined by the quantization of the Sequence. As an example, if the quantization is set to 1/16, the array will have length of 16. Each element of the array then stores whether or not the sound should play at that step in the Sequence.

Naturally, I have one object to represent a Sequence. It has an attribute called tracks which is an array of Track objects. A Track object has an array attribute that is in equal length to the quantization of the Sequence.

I am suffering major analysis paralysis and am unable to determine What is a clean way for all Track objects belonging to a specific Sequence to know when the quantization has changed so it can update its own internal array?

Or

How should the Track object know what to set its array length to without coupling the Sequence object?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    If every track must belong to one and only one sequence, then they are coupled by nature. Reflecting that coupling in implementation is not a problem (except perhaps for unit tests).

    Since the sequence initiates this change, I would recommend a publicly-accessible method on the Sequence object that sets the quantization for the sequence as a whole, and then iterates through the sequence’s tracks to set their quantization. Sequence.setQuantization() would be publicly accessible, Track.setQuantization() should not be.

    To ensure that the coupling is maintained, I’d also limit the ability to create Track objects to a factory method on Sequence (eg: addTrack()).

    That opens up the question of independently unit testing Track and Sequence. One way to do this is to create these objects as interfaces, and then have a single implementation of each with hooks for testing code. That leads to its own ugliness, probably including a SequenceFactory, but only you can decide how much purity you need.

    • 0