Name: アダム・ギーゼによる作曲機能を用いた作曲｜JSConf Budapest 2019 (Composing music with composed functions by Adam Giese | JSConf Budapest 2019)
Uploaded: 2021-01-14T10:25:51.000Z
Duration: 21 min 34 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

Everybody hope everyone's having a great time at J s.

Confident a pest that my name is Adam GC.

I'm Adam GC Dev on Twitter and before I was a software engineer, I did attend school for music, specifically music composition, and I was always drawn to the analytical thinking aspect of music theory and perhaps surprising nobody.

I had a tough time finding a job in music, and so I went into programming, which I had some experience with.

And years later, when I started toe learn a functional programming, I found that the same itch was scratched regarding the analytical thinking.

So when I started Thio try to get back into music as a hobby, I decided to use functional pro programming.

So here's my introduction to programming my introduction to functional programming from a musical perspective.

My answer is its programming, with functions just like object only into programs are oriented around objects.

Functions are the building block of functional programming, but that naturally leads to the next question.

The non functional programming definition might be something like a sequence of commands attracted into a reusable unit.

But a more functional definition is a relationship between a set of inputs and outputs, and this is sometimes refer to as a pure function, and it comes from the mathematical definition of a function.

And these so called pure functions are the building block of functional programming.

Well, there's two main aspects given the same arguments in it will return the same value.

That means it shouldn't rely on anything outside of itself, such as a random number generator or the current time or a read from the database.

It also means it shouldn't affect anything outside of its return value, such as manipulating the Dom or writing to a database.

And together this makes the function referential.

This means that AH, function call with the same parameters can be replaced by its return value.

So here we're defining middle C with a name and an active an increment octave.

It takes a note and it returns a new note, with the active in corrected by one in high sea.

Here is the result of that pure function.

Play here is a function that is an impure function because it has a side effect.

You can pass on either high C or in current active middle C, and I'll have the same effect because of the referential transparency of the incurring octave function.

So we decided to learn functional programming, remove all side effects and now your program is useless is important to note that side effects are not bad.

Don manipulation or playing music are all side effects.

They are not bad, but they are unpredictable and they are harder to test.

So you so you need to use your impure functions carefully and predictably.

So now that we know what functional programming is and what a function is, what are some tools?

One of the main ones is a mutability, and that's the idea that a very bold state cannot be modified after creation.

Why would you like to tie one arm behind your back?

There's some advantages of the mutability, such as it's less for your brain to track.

And if your brain has to keep track of what state A current variables in its Maur time that your brain is working on that and not spending on the rest of your program, it also mutability prevents unintentional side effects.

You accidentally changing a variable in the function can be a really hard bug to track down, and it preserves state.

I like to think of it as your bank account balance.

When you sign into your bank account, you don't just see your single balance.

You see your current balance, which is derived from the starting balance, and then the withdrawals and deposits.

Another technique of functional programming is higher order functions, and that's a function that either accepts an argument.

Ah, a function as an argument or returns of function.

You might be thinking this is something along the lines off, but he's an example that might help.

Tone Js is a framework that's built on top of the Web audio, a p I, and playing out here is a higher order function.

It accepts a note and it returns a function play middle.

See, here is the result of that that function being called with C four at event listener here except a function as an argument.

So at event, listener and play note are both higher order play note because the returns of function and at event listener because it accepts a function now manipulating raises an important part of all paradigms and functional programming has a lot of really great tools for dealing with a raise.

And there's two concepts that we already covered that are important.

The higher order functions because each of these methods, except a function and immune ability, because each of these methods that I'm mentioning ah will return a new value rather than manipulating the current one.

So a raid at Filter it accepts a function that's run against every element.

That function receives the element the index in the array, and it returns a subset of the original rain.

So we define a melody and we did find a function is high, which takes a note and returns a Boolean.

If that value is equal to or above middle C, it is considered high, otherwise it is considered low.

So high notes is the melody filtered to is high and we get only the elements that return a truth e value.

So here we have our unfiltered reality, and when we filter to just the high notes, you read a map except the function that's run against every element as well.

It also accepts the element index and array within that that function.

But rather than returning a subset of the original ray, it returns in array of the same length with new values.

So we have our melody here and we have our increment octave function, and then we map our melody to include the active, and now we have the a copy of the array.

But with each note implemented by one active with a high multi and the last one I'll cover today is a raid at reduce and all right I reduced.

Also, accept the function that's run against every element.

But in addition to the accumulator, I think in the addition to the element index and array, it also accept an accumulator value, and it will return the total accumulated value after passing through every element and in some languages.

This is known as fold and accumulate, and it is a more generic tool than filter or map.

I often hear that reduce takes an array and returns a single value, and this is true.

But I don't consider it to be a terribly useful distinction because all functions and job script or turn a single value s so I like to think of it as a generic utility function that can return any type.

Um, in fact, you can write, filter or map using a reduce, or it can return a single string or a single interred herb.

So I find the best way to learn reduce is really by ah, by example.

So here we're defining this melody with no names and length.

Then we have our two length function that is going to be passed to reduce.

Total is the accumulator and note is the array element, and then the function adds the total to the value of the notes length so length are the reduced except of function and an initial value.

And then the rich value is the end accumulation.

So starting with the initial value of zero we go through and each notes length, it's added to the total zero pa's 00.1 to 5 0.25 plus 0.1 to 5 this 50.25 point +375 until we get to the total length of 1.6 to 5 seconds.

So here, with our melody way, get 1.6 to 5 seconds.

All right, now that we're done with a raise, partial application is an incredibly useful tool for writing reusable and generic functions, and it is sickening to preset or fix some of the arguments of a function.

It takes a direction either up or down an interval such as a major third or a minor seventh and you know which will be transposed.

A major third is a function that is a partially applied transposed we set up, and we set major third, but we wait to receive the note.

So here, when passing in C four up major third will return an E four or a B flat, too will return a D three and there is a way in Stage one of the TC 39.

There's a, uh, there is a syntax for native partial application that will let you two personally apply.

Um, partially apply arguments to a function by using the question mark for what you don't want to apply so down.

Minor Seventh can be a partially pie transposed by leaving the note as a question mark.

So here we can map these partially applied functions to an array of notes and hear the transposition or up a major third, or transposed down a minor seventh.

So partial application is a great tool for writing reusable functions that are partially applied.

But the rial bread and butter ah, functional programming is composition, and composition is a technique to combine multiple functions into a new function.

So here we're gonna take a note name and we will return the frequency.

So we have a function converting a note name to a frequency, for example, in the input of a four would return a number of fourth pretty, which is the frequency and hurts of in a four de tune up will be defined a function to multiply by a small percentage, so input of 440 hurts would return 444.4 and then compose here, takes two functions and calls them from right to left so get detained.

Frequency is a function that is created by composing D Turn up and frequency.

So in input of a four would return 444.4.

And there's a pipeline operator that's currently in stage one of the TC 39 suspect as well.

That would allow for easier function composition through piping.

字幕リスト動画再生

アダム・ギーゼによる作曲機能を用いた作曲｜JSConf Budapest 2019 (Composing music with composed functions by Adam Giese | JSConf Budapest 2019)

perspective

technique

consider

manipulate