Name: カテゴリー理論１．モチベーションと哲学 (Category Theory 1.1: Motivation and Philosophy)
Uploaded: 2021-01-14T06:43:56.000Z
Duration: 46 min 46 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

Alright, welcome to category theory lectures

Is everyone a programmer, or are there people who are not programmers?

If you're not a programmer, please raise your hand

Okay, thats means, like, you don't write any programs? > I kind of learn as a hobby

okay and how many people here have some little bit of knowledge of Haskell, okay

Oh Lots, that's, that's, excellent because I might be giving some examples mostly

just like you know, declarations, functions or something like that

I'll explain everything but it's it's good to have a little bit of

understanding. So I'm not really teaching a programming language, it will be about

category theory and category theory is like this most abstract, or well maybe

almost the most abstract part of mathematics, right

what does it have to do with programming, right?

they finished learning math at college and now they

are really happy now "for the rest of my life I will not have to touch it"

"I hate math" and so on, and you guys here come for, I dunno, punishment?

Why do you think category theory might be important?

What do you think, do we do functional programming?

Is category theory only relevant to functional programming or other branches

of programming would maybe profit from it too?

Have you heard of functors, who's heard of functors?

Uh huh, a few. That's good, that means i can actually explain stuff and you won't be totally

so I came to category theory through a long long twisted road

ok when I started programming I started programming in assembly language

the lowest possible level, right, where you actually tell the computer exactly what to do

right down to "grab this thing from memory, put it into the register, use it as an

"address and then jump" and so on so this is very precisely telling the computer

what to do right this is this is a very imperative way of programming we start

with this most imperative approach to programming and then sort of we drag

this this approach to programming throughout our lives right and like we

have to unlearn at some point. And this approach to programming sort of in

computer science is related to Turing machines. A Turing machine is this kind of

very primitive machine, it just stamps stuff on a paper tape, right

there is no high-level programming there it's just like this is

the assembly language "read this number, put it back on tape, erase something from

the tape" and so on so this is this one approach towards programming

by the way, all these approaches to programming were invented before there were even

computers, right and then there's the other approach to programming this came

from mathematics the lambda calculus right, Alonzo Church and these guys

and that was like "what is possible to compute, right,

"how things can be actually executed in some way, transforming things", right

so these approaches to programming are not very practical

although people write programs in assembly language and it's possible but

they don't really scale, so this is why we came out with languages that offer higher levels of abstraction,

and so the next level abstraction was procedural programming

what's characteristic of procedural programming is that you divide a big

problem into procedures and each procedure has its name, has a

not necessarily, maybe it's just for side effects and so on, but because you

chop up your work into smaller pieces and you can like deal with bigger

problems right so this this kind of abstracting of things really helped in

in programming, right and then next people came up with this

idea of object-oriented programming right and that's even more abstract now you

have stuff that you are hiding inside objects and then you can compose these

objects right and once you program an object you don't have to look

inside the object you can forget about the implementation right and and and

just look at the surface of the object which is the interface and then you can

combine these objects without looking inside and you know you have the bigger picture

and then you combine them into bigger objects and so you can see that there is

a a certain idea there, right? and so it's a very important idea that if you

want to deal with more complex problems you have to be able to

chop the bigger problem into smaller problems, right,

solve them separately and then combine the solutions together

And there is a name for this, this is called composability, right.

So composability is something that really helps us in programming.

What else helps us in programming? Abstraction, "abstraction" that comes from

from a Greek word that means more or less the same as "subtraction", right which

means "getting rid of details". If you want to hide details, you don't want them or you wanna say

"these things, they differ in some small details but for me they are the same"

"I don't care about the details" so, an object is in object-oriented programming

is something that hides the details, abstracts over some details right, and there are even these

abstract data types that just expose the interface and you're not supposed to

so when I first learned object-oriented programming I thought "this is like the best thing since sliced bread"

and I was a big proponent of object-oriented programming and together with this idea

of abstracting things and and and composing things comes the idea of

reusabillity right so if i have these blocks that I have chopped up and

implemented, right, maybe I can rearrange them in different ways so once I

implemented something maybe I will use it in another problem to solve

another problem I will have these building blocks, I will have lots of building

blocks that hide their complexity and I will just juggle them and put them

in new constellations, right? so it seemed to me like this is really the promise of

object-oriented programming, I'm buying it! and I started programming object-oriented way

using C++ and I became pretty good at C++ I think, you know, I wrote a lot of C++ code

and well it turns out that there is something wrong with this

object-oriented approach and it became more and more painfully obvious when people started

writing concurrent code and parallel code, ok, so concurrency does not mix very well with

object-oriented programming. Why doesn't it? Because objects hide implementation

and they hide exactly the wrong thing, which makes them not composable, ok?

They hide two things that are very important:

They hide mutation – they mutate some state inside, right? And we don't know about it, they hide it

字幕リスト動画再生

カテゴリー理論１．モチベーションと哲学 (Category Theory 1.1: Motivation and Philosophy)

stuff

awkward

approach

essentially