So, are we all programmers here?

所以，在座的都是工程師嗎？

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 well that's good enough

好的，這樣夠好了

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

好的，這邊有多少人有些Haskell的經驗 好的，哇

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

可能幾乎是數學最抽象的部份

so the question is why are we here?

所以問題是，我們為什麼在這裡？

what does it have to do with programming, right?

是啊，這和寫程式有什麼關係呢？

and a lot of programmers they hate math

而且很多程式設計師討厭數學

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?

其它寫程式的方式？

is there something more to offer?

它能提供更多嗎？

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

你們聽過函子嗎，誰聽過函子？

yeah, and who knows what functors are?

好，那誰知道函子是什麼？

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

啊哈，有一些。 這很好，這代表我可以真的解釋些概念而你不會完全在

repeating what you already know

重複你已經會的

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

數學，即lambda演算，阿隆佐·邱奇和那些人

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

問「什麼是可計算的？」

"thinking about mathematics in terms of

「以東西會怎麼樣被實際被執行，變換，來

"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

分割程很多程序且每個程序都有名字、有

certain number of arguments

一定數量的參數

maybe it returns a value sometimes right

或者它可能傳回一個值，恩

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

只暴露介面的抽象資料型態而你不應該

know how they are implemented right?

知道它們是怎麼被實作的是吧

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

物件導向達到的承諾，我服了這套！我開始用 C++ 以物件導向的方式寫程式

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

然後我的 C++ 變得很強，我想。你知道的，我寫了很多 C++

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

它們隱藏了改寫──它們改寫了某些內部狀態，對吧？而且我們不知道，它們隱藏了它

They don't say "I'm mutating something".

它們並不說它們改寫了什麼

And sharing these pointers right – they share data and they often share data between

還有分享──它們使用指標對吧，他們分享資料而且經常

each other you know between themselves they share data

在彼此之間分享。你知道的，在它們之間分享資料

And mixing, sharing and mutation has a name

然後分享、改變並混合 有個名字

It's called a data race, ok?

它被稱為資料競奪，好嗎？

So what the objects in object-oriented programming are abstracting over is the data races

所以物件導向中的物件對資料競奪進行抽象

and you are not supposed to abstract over data races

但你不該這麼做

because then when you start combining these objects you get data races for free, right.

因為一旦你開始組合它們，你就會有資料競奪

and it turns out that for some reason we don't like data races, ok?

而且因為某些原因我們不喜歡資料競奪

and so once you realize that you think

一旦你頓悟後你開始想

"okay, I know how to avoid data races, right, I'm going I'm going to use locks

「好，現在我知道怎麼避免資料競奪，我要使用數據鎖」

"and I'm going to hide locks too because I want to abstract over it"

而且我將也要隱藏它們因為我想要抽象於它們

so like in java where every object has its own lock, right?

所以像在Java裡所有物件都有它們自己的數據鎖對吧？

and unfortunately locks don't compose either, right.

不幸的是數據鎖也無法被組合

That's the problem with locks. I'm not going to talk about this too much

這是數據鎖的問題。我不再談更多

because that is like a different course about concurrent programming but I'm

因為這可以開另一堂並行編程的課程

just mentioning it that this kind of raising the levels of abstraction

我只蜻蜓點水：你必須特別注意這類抽象

you have to be careful what you're abstracting over

對什麼進行了抽象

what are the things that you are subtracting, throwing away and not exposing, right?

你減去、扔掉了什麼並不暴露它們？

So the next level of abstraction that came after that, well actually it came before

所以下一階段的抽象是，噢它其實更早出現

that but people realised that, "Hey, maybe we have to dig it out

但人們體會到「嘿，我們可能要重新找到它

"and start using this functional programming" when you abstract things into functions

並開始使用所謂「函數式編程」把東西抽象成函數

and especially in Haskell when, you know,

而且函數，特別是在Haskell裡面，你知道的

in a functional language you don't have mutations so you don't have this problem

在函數式語言裡你不需要可變變數所以你不會有

of hiding data races, and then you also have ways of composing

隱藏資料競奪的問題，然後你也有把

data structures into bigger data structures and that's also because everything is

資料結構組合成更大的資料結構的方法，也因為所有東西都是

immutable so you can safely compose and decompose things.

不可變的所以你可以安全組合和分解資料

Now every time I learned a new language I wanted to find where the boundaries of this language are

每次我學習一個新語言，我都想尋找語言的界線

like, "what are the hardest things to do in this language?", right?

例如，「這個語言最難做到什麼」？

So for instance in C++, right, what are the highest levels of abstraction that you can get?

例如在 C++ 中，你能達到的最高抽象是什麼？

Template metaprogramming, right? So I was really fascinated by template metaprogramming

模板元編程，是吧？我著迷於模板元編程

and I started reading these books about template metaprogramming

我開始閱讀了這些關於模板元編程的書

and was like "Wow, I would have never come up with these ideas, they are so complex", right?

那就像是「哇，我永遠想不出這些點子，他們太複雜了」，是吧？

So it turns out that these are very simple ideas

事實上它們是很單純的點子

it's just that the language is so awkward in expressing them

只是被用一個雞掰的語言表達

So I learned a little bit of Haskell and I said "Ok this huge template that was so complicated,

所以我學了些Haskell然後說「好，這些巨大的模板太複雜了

that's one line of code in Haskell", right? So there are languages in which

那只不過是一行Haskell。」對吧？所以存在某些

there was like a jump in the level of abstraction and made it much easier to

在抽象層級上大躍進的語言，它們讓

program at a higher level of abstraction, right.

你在更高抽象上寫程式簡單得多

And in every language you know there is this group of people who are writing

在每個語言中你都知道有一群人撰寫著

libraries right and they always stretch the language they always go to the highest

程式庫，他們總是延展著可能性

possible abstraction level and they and they hack, right? They hack at it

他們一路向上至最高的抽象層級。他們、他們是「駭客」。對吧？他們駭程式

as much as possible. So I thought "Okay I don't like hacking, I just wanted to

直至極限。所以我想，「好我不想駭程式，我只是想

"use a language that allows me to express myself at a high level of

使用一個讓我能在更高層次抽象上表達自己的語言

"abstraction and that lets me express new ideas that are much more interesting"

而且它讓我表達有趣得多的新點子」

you know, like, with template metaprogramming right you express this

你知道的，像模板元編程能讓你表達

idea that you might have lots of data structures that only differ by the type

一堆只差在它們包裝型別的資料結構這樣的點子

that they hide. Like you can a vector of integers and vector of

像你能有一個整數的列表和

booleans right? And there's just so much code to share, so if you abstract over the

一個布林值的列表對吧？而且它們之間有好多的共通代碼，所以如果你抽象於

data type that you are storing there, if you forget about it,

你儲存的資料型別，如果你忘了它

hide it, abstract over it, you can write code, abstract code, and in

隱藏它、對它進行抽象，你能撰寫代碼、抽象代碼

C++ you do this with templates right. And you get something new, you

在C++裡你用模板進行這樣的事情，對吧。豻且你得到了一些新的東西，你獲得了

program at a higher level – a higher abstraction level because you

在更高層次──更高抽象層次──寫程式的能力因為

disregard some of the details, so that was great.

你忽略了某些細節，而那真的很棒

Now it turns out that once I learned Haskell

再後來，我發現在學了Haskell後

(I'm still learning Haskell to some extent)

（某種程度上我還在學習Haskell）

I found out there are things in Haskell that are at these boundaries of abstraction

我發現Haskell中有某些東西在抽象的極限上

that, like, there are people who are working on this frontier of Haskell, right?

像有些人在Haskell的最前線努力對吧？

There are certain very abstract things that are unfortunately a little bit awkward to express in Haskell

有某些非常抽象的東西很可惜的有點難在Haskell中被表達

and then there is this barrier to abstraction even in Haskell right?

所以甚至在Haskell裡都有抽象程度上的障礙，對吧？

I mean if you've seen some libraries that were written by Edward Kmett

我的意思是如果你看過某些Edward Kmett編寫的程式庫

you realise that they are extremely hard to understand what was the thought process, right?

你會發現它們之中的思路非常難被理解吧？

And the secret is very simple – Category Theory.

而這之中的秘密很單純：範疇論

Edward Kmett knows Category Theory, and he just takes this stuff from

Edward Kmett 懂範疇論，他只是把東西從

Category Theory, he reads these mathematical papers and he just

範疇論搬來，他讀那些數學論文

translates them into Haskell and when you translate stuff from Category

並把它翻譯成Haskell。如果你從範疇論

theory to Haskell you lose a lot of abstraction, you make it more concrete

翻譯到Haskell，你喪失了很多抽象，你讓它變得更具體

Haskell has one category built-in and you are

Haskell有一個內建的範疇且你是在

restricting yourself to this particular category.

把自己限制在這個範疇

You can create other categories in Haskell and model them, but that becomes

你能在Haskell中創建其它範疇並對它們建模

awkward and that becomes sort of like template metaprogramming you know within

但那變得不方便且有點像在Haskell中進行你所知道的模板元編程──

Haskell – not exactly the same mechanism but the the level of

並非經由完全一樣的機制，但

difficulty in expressing these ideas in Haskell is as big as template

在Haskell中表達這些點子的難度和

metaprogramming in C++.

在C++進行模板元編程一樣高

So Category Theory is this higher-level language above Haskell, above

所以範疇論是個Haskell之上的更高階語言

functional programming, above ML,

在函數式編程之上，在ML

Haskell, Scala, and so on

Haskell, Scala...等等之上

C++, assembly, it's a higher-level language, okay? It's not a practical

像 C++ ，組合語言。它是更高階層的語言好嗎？他並不是一個

language that we can write code in, but it's a language.

我們可以在之中寫實際程式的語言，但它是個語言

So just like people who write these horrible metaprogramming template libraries in C++

所以就像在C++中撰寫恐怖模板元編程程式庫的人們一樣

they can only do this because they learned a little bit of Haskell.

只因為他們學了些Haskell而能做到這些

and they know what some constructs in Haskell are and how to do

而且他們知道 Haskell 中的某些構造是什麼而且要怎麼做──

things – how to implement algorithms on immutable data structures right

怎麼在不可變資料結構正確實作演算法

they know how to do this because they learned it from Haskell

他們知道怎麼做因為他們從Haskell學了這些

and they just translated into this horrible template programming language.

然後他們僅把它翻譯成這糟糕的模板程式語言

Fine right? And it works and people are using it, the same way that if you're

是吧？它行得通且人們正在使用它們。同樣的道理

a functional programmer you can take these ideas from category theory,

如果你是個函數式工程師，你可以從範疇論擷取這些點子

these very very abstract ideas and translate it into this kind of awkward language called

把這些非常非常抽象的點子翻譯成這樣不便的程式語言

Haskell, right? Now from looking from from categorical perspective Haskell

名為Haskell，對吧？現在從範疇論角度看

becomes this ugly language just like looking from Haskell C++ becomes this

Haskell變成了這個非常醜陋的語言一如從Haskell看C++變成這個

ugly language, right? But at least you know it's an executable language, its a

醜陋的語言，是吧？但至少你知道它是個可被執行的語言

language in which we can write programs. And of course these ideas when they

在它之中我們能寫程式。而且當然這些點子在

percolate from category theory down to Haskell they can also percolate then