Please Don't Learn Category Theory (2013)

http://jozefg.bitbucket.org/posts/2013-10-14-please-dont-learn-cat-theory.html

by psibi • 13 years ago

54 79 13 years ago

jozefg.bitbucket.org

Finally someone has the courage to tell the Truth about CT.

Next up: the idea that the notions of Monad, Functor, and Category (in whatever guise) are even needed or helpful to do strong FP.

cnlwsu• 13 years ago

I was able to be fairly effective (imho) in clojure/scala without knowing anything about fuzzyWuzzies, bananas, and cheerios. I felt learning about them becomes interesting though as you dig into the language more. Mostly as a curiosity thing... spend some time to "finally learn about monads" to see you've been using them the entire time.

tjr• 13 years ago

I like how he wrote a post a few days later, Learn You Some Category Theory:

http://jozefg.bitbucket.org/posts/2013-10-22-category-theory...

freyrs3• 13 years ago

Are they needed? No. Are they useful abstractions? Yes. Like most abstractions in Haskell the theory is always optional.

nbouscal6• 13 years ago

Strictly speaking very little is needed. You can write everything in assembly if you'd like. Helpful, though? There's absolutely no question. Type classes like those you mentioned make programs more concise, more understandable* , and more general. All of those are good things.

* Specifically, understandable to people who know the language and concepts. Trying to be understandable to everyone is a terrible idea. For example, Cucumber.

dllthomas8• 13 years ago

I regularly miss Monad as an abstraction in my C code and Functor in my C#. They're just plain helpful, FP or not. Needed? Probably not, though a case could be made that monad is sufficiently helpful to deserve that title for dealing with sanely ordering IO in a lazy language.

rtfeldman3• 13 years ago

the people who designed Haskell decided they weren’t going to pretend they didn’t use math

This is almost certainly the decision that has kept the most people from successfully learning Haskell.

If you write "Appendable", many programmers go "oh, okay, got it." If you write "Monoid", many programmers go "yeeeah, I don't know if I have time to learn all this."

This is either a perfectly acceptable cost of avoiding redefining the wheel, or a cautionary tale for future language developers, depending on your perspective.

anaphor2• 13 years ago

It's not really Appendable though, because e.g. you can write a Monoid instance for various number-y things like Sum and Product.

srl• 13 years ago

And you could write an Appendable instance for them as well, it would just fly in the face of what the word "append" means to most people. (Nitpick, of course.)

cscheid3• 13 years ago

But "Appendable" is a terrible way to describe what a monoid is. Some of the really cool tricks in the way abstractions in Haskell match mathematical notions come from extending the abstractions beyond what you would expect. For example, integers under sum are monoids; naturals under the maximum operation too. And so is the "over" operator from computer graphics. All of these find applicability as general monoids in Haskell, but you'd have a hard time calling them "Appendable". All of these just need a binary operation that's associative and with an identity element.

The same thing happens for functors and monads: their use come from the properties they respect. And if you accept that abstractions will be defined as a set, some operations, and some algebraic laws respected by those operations, well, then, you arrived at abstract algebra, and you might as well use the right terms.

yohanatan2• 13 years ago

I think Combinable is more appropriate as 'append' pertains to only one of many associative binary operations.

joe_the_user4• 13 years ago

Jeesh,

I have an MA in mathematics but without knowing category theory, it has been opaque to me till just now that the monoids discussed around Haskel are the same beast I briefly dealt with in abstract algebra. Indeed, only by looking up monoid and appendable did this become semi-evident.

The Haskellians don't even help you out enough to point towards ordinary abstract but instead send you all the way to category theory with sign-posts along the way.

The abstract structure monoid may not really be fully described by appendable but it's a leg-up. The objects in object-orientation get extended by convenience but the term object still helps the learner feel like they've got something concrete.

rtfeldman3• 13 years ago

Nevertheless, if you're a programmer with no particular exposure to that sort of math (which is to say, the overwhelming majority of programmers), saying "this function takes a Monoid" is as useful as saying "this function takes a Foogblort."

Saying "this function takes an Appendable" conveys useful information.

It's a matter of priorities. If your priority is using the correct mathematical term, you necessarily sacrifice clarity to newcomers. Hence, fewer newcomers.

...of course, not that Haskell as a language has ever strived to attract newcomers!

yongjik• 13 years ago

Kinda off-topic, but I also have to say "appendable" is a terrible choice. It would mean that those objects (or variables, or whatever) support efficient appending operation, which is usually not the case.

(Sorry, I couldn't get over the fact that appending a character to a string (or a list) is O(N) operation in Haskell.)

Now, if you named them "prependable", then maybe...

dllthomas8• 13 years ago

"Max 3 <> Max 5" isn't really appending or prepending, though.

codeflo5• 13 years ago

I also think that there's a clash of naming conventions going on. Programmers are used to name types for their values are, as in "4 is an Int", or even abstractly, "4 is Serializable". Haskell conforms to this convention with type and class names like "Int", "String", or "Num". But classes with names like Monoid don't conform to that, as 4 is not "a Monoid". The set of integers with + is a monoid, but that's a property of the type itself, not of its values. (Edit: And don't get me started about "IO". What's "an IO" even supposed to be?)

Chattered• 13 years ago

And similarly, the list [1,2,3,4] is not a monad, and that's why "flatmappable" isn't a sensible alternative to "monad", as Bracha recently suggested.

Though some have argued that this confusion indicates a hole in our vocabulary:

http://blog.plover.com/prog/haskell/monad-terminology.html

nbouscal6• 13 years ago

You noted a pattern in how programmers name types, and then complain that the naming of a type class doesn't conform to that pattern. Of course 4 isn't a Monoid, rather, Sum is a Monoid.

As for IO, the best way to read it would be as an "IO action", which is what much of the literature refers to it as. Yes, this isn't trivial to understand, but IO in Haskell isn't trivial, and you can avoid the formalism if needed until once you understand things a bit better.

Perseids• 13 years ago

And maybe it is a tale promoting more theoretical computer science in the education of programmers. For example monoids should be familiar because the states of a minimal DFAs are essentially the elements of the syntactic monoid [1] of the accepted language and the transition function is essentially the monoid operation.

[1] https://en.wikipedia.org/wiki/Syntactic_monoid

chongli2• 13 years ago

The problem with analogies is that they only work in one direction on the abstract<->concrete spectrum. It's perfectly fine to talk about lists under the append operation as an example of a monoid. It makes no sense whatsoever to try to reverse that relationship because not all monoids have anything remotely analogous to appending.

This principle applies to pretty much all ways of categorizing objects. We can say that dogs are an example of mammals but to turn around and call all mammals "doglikes" or "doggables" would be silly.

runT1ME• 13 years ago

Appendable is more akin to a semi-group than a monoid though, no?

rtfeldman3• 13 years ago

Yes, but the point stands. :)

dllthomas8• 13 years ago

Yes, "appendable" to me doesn't imply the existence of an identity.

Dewie2• 13 years ago

If this is all it takes to turn people away, then I would say that the problem is that those people have an irrational fear of mathematics. At that level, it's not about having a tool that is too abstract or difficult, or not being gifted at abstract thinking; it's about those people having a conditioned knee-jerk reaction to math-sounding things.

Mathematics is hard, at least for me, but I have accepted that I have to get over my preconceived notions and at least try to look beyond the jargon. And these are mere names, not "let's cook up an ad-hoc notation and heavily overload and abuse it in places because 'the meaning is obvious from the context'...". this is only a question about choosing name A, or name B. I can't imagine it will get any harder by choosing either of them.

At least Haskell clearly states, with it's esoteric naming; "what you are about to get into is quite strange, and quite different from anything you've probably encountered in programming before." And if they can't look beyond scary-sounding words, maybe that kind of programming is not for them - and in that case, it's good that they found out straight away - or maybe they need to work on their own phobias.

lmm3• 13 years ago

You need the words to be able to use Haskell. There are too many of them to learn otherwise. I have a similar experience with scalaz, where I tend to only spot useful things in the library after I've reimplemented them, because they don't have names that let me find them based on what they do.

(Possibly the only benefit of a previous company that wouldn't let me use scalaz was that, in reimplementing it myself, I got to give the typeclasses sensible names like "CanFlatMap")

orlandob• 13 years ago

Linkbait trash.

"Don't do this thing everybody says you should do. But I do and I like it."

Aqwis• 13 years ago

That's a very dishonest summary of the article. What he's actually saying is this:

"Don't do this thing everybody says you should do, except if you're actually interested in the math."

andrewflnr• 13 years ago

Then he really should have titled it, "You don't need to learn category theory", not the imperative "don't...". As it is, this is a textbook case of linkbait: choosing a dramatic title to get clicks.

jfarmer2• 13 years ago

The problem with being a programmer and learning category theory is two-fold.

First, category theory is very abstract. Indeed, mathematicians often jokingly refer to category theory as "abstract nonsense." The story goes that Norman Steenrod, one of the creators of category theory, coined this term himself. So, category theory can be abstract even for mathematicians.

Second, the "stuff" that category theory was built to abstract is highly mathematical and foreign to virtually every programmer who doesn't have a math background. What's worse, the bits of category theory that Haskell uses most frequently are typically not the bits of category theory that mathematicians use most frequently.

When you put these together, it's very hard to connect the dots between "category theory", "category theory as Haskell uses it," and "Haskell as a typical Haskell programmer uses it." To build up to the bits of category theory that Haskell uses requires understanding things like categories, morphisms, functors, adjoint functors, natural transformations, adjunctions, and commutative diagrams, to name seven. Trying to understand these without understanding their (inherently mathematical) motivations would be a tiny nightmare — they'd feel like a bunch of disjoint facts and diagrams that are supposed to mean who-knows-what.

And even if you get there, the categorial nature of monads in Haskell is not exactly apparent on the surface. Haskell exposes more programmer-friendly interfaces like "bind" that take some effort to translate into the language of category theory.

A major motivator in the development of category theory, for example, was as a tool to explore the relationship between topological spaces and groups, a field of mathematics called algebraic topology (http://en.wikipedia.org/wiki/Algebraic_topology).

Fasebook2• 13 years ago

What a ridiculous assertion. Category Theory and Chomsky Hierarchy are two easy to understand and key theories of Computer Science. If you don't have any understanding of these, you're not a professional programmer. Maybe it's "even abstract for mathematicians" should be "too abstract for detail oriented math nerds, but pretty easy to comprehend at a basic level"

jfarmer2• 13 years ago

I'm not sure what the Chomsky Hierarchy has to do with what we're talking about, but re: category theory, there's a difference between "understanding" and "familiarity."

I agree that the definition of a category is not a hard thing to learn. However, can you give me, say, three non-trivial examples of categories you'd expect a "professional programmer" to know? How about three non-trivial examples of functors?

If understanding category theory is a pre-requisite for being a professional programmer then 95% of the people I know who get paid to program aren't "professional programmers.

You're just being silly. Or trolling. Probably trolling.

haberman2• 13 years ago

I don't think the Chomsky hierarchy is very useful for Computer Science, except the distinction between regular and context-free languages (which is extremely useful).

"Context-sentitive language" in the Chomsky hierarchy is not the same as what a programmer means when they say a language is context-sensitive. In programming languages, "context-sensitive" nearly always refers to semantic context-sensitivity (for example, the set of symbols that are defined at this point and their types), not the syntactic context-sensitivity described by the Chomsky hierarchy. For example, none of the context-sensitivity described on this page has anything to do with Chomsky context-sensitivity: http://eli.thegreenplace.net/2007/11/24/the-context-sensitiv...

I can't think of a single case where Chomsky type-0 or type-1 grammars are relevant to any practical concept in computer science. And due to overloading of the term "context-sensitive" learning about the Chomsky hierarchy can be actively misleading unless you are aware of this distinction.

anaphor2• 13 years ago

Others have explained why the Chomsky Hierarchy isn't particularly useful to people working on designing or implementing languages. What IS useful and which developed around the same time as Chomsky's theories is BNF notation: https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_Form

tel• 13 years ago

While the origin of category theory can indeed be described that way, and while the formalisms are weighty to anyone not familiar with mathematics style proofs, the notions should not be too hard to someone with good FP background. Especially typed FP.

The real problem is more a question of why should someone learn it to begin with. Category theory will inform you that pairs are also called products and they're somehow the best kind of product-like thing. Big deal?

I don't have a really great answer to this question yet besides CT is like taking an X-Ray to computer languages and really asking "what does this mean?" Getting to see how a CCC develops into a programming language with sensible notions of computation, dynamics, simplicity is incredible and will end debate about language semantics.

That and dualization. Once that's in your head you don't want to go back.

drblast2• 13 years ago

I always feel like I'm at least seven or eight layers removed from anything I can relate to when I read about category theory.

I'll think, "Hey, let me check this out on Wikipedia..." and I'm six linked articles deep trying to understand the first paragraph of the original article, and I'm no closer to anything concrete.

It's obvious at that point that the "top-down" approach is the wrong way to go and that really the only way to develop an understand this is to take a class, or buy a book that may or may not be more tractable than Wikipedia.

At that point, I'll consider that there are many other languages that are supposedly esoteric that I've never had a problem grasping, and that I know of few advantages that Haskell offers over, say, F#, for doing things I need to do. And even though I've written some parsers in Haskell and it was a generally nice experience, I just don't have time to learn category theory from the ground up.

I also realize I really, really need to understand how my tools work from cradle to grave or I'm deeply unsatisfied.

At that point I abandon Haskell as a curiosity and go on with the rest of my life.

dllthomas8• 13 years ago

Like the article here states, though, you don't need to learn category theory to learn Haskell. Most math is useful in driving intuition and insight, and Category Theory is no different in that respect, but learning Haskell (in particular enough to use it and write normal applications and libraries, not necessarily create the neatest cutting-edge type-trickery libraries - some of which are amazing) requires much more of a concrete "here's how you use these things" than any knowledge of Category Theory.

chongli2• 13 years ago

The real problem, if you ask me, is that we've all gone through elementary and secondary school working with all kinds of mathematical objects without learning their proper names. Every kid ought to be told what semigroups, monoids, groups and rings are shortly after learning addition and multiplication.

j2kun• 13 years ago

If you're interested in more of a bottom-up approach, I have a series of articles on my blog explaining category theory with the programmer's perspective in mind (though I do assume you know a little bit of higher maths; sets and functions, mostly). See the section titled "Computational Category Theory" on this page: http://jeremykun.com/main-content/

I've let the series sort of fall to the wayside recently as I focused on other content, but there's enough to get you up to a categorical understanding of map, fold, and filter (and a mathematical justification for why fold is the "most" universal one of the three)

Dewie2• 13 years ago

I always feel like I'm at least seven or eight layers removed from anything I can relate to when I read about category theory.

I'll think, "Hey, let me check this out on Wikipedia..." and I'm six linked articles deep trying to understand the first paragraph of the original article, and I'm no closer to anything concrete.

I feel like that with most Wikipedia math articles.

guard-of-terra• 13 years ago

With such a great number of people around me dabbling in Category Theory, I'm not sure it's worthwhile anyway. I don't like crowded areas. Maybe learn something useful but less hot - cryptography perhaps?

KirinDave• 13 years ago

Are you too cool for category theory?

Fashion is a terrible reason to learn math, or to decide against learning it. Don't be a hipster.

badman_ting• 13 years ago

Makes sense if your goal is to use some particular language (in this case Haskell). But a lot of us don't necessarily need yet another programming language, whereas adding to our theoretical knowledge can be beneficial no matter what environment we're programming in.

saosebastiao• 13 years ago

I call mega-exponential-factorial-to-the-n-bullshit. I tried doing exactly that. You can't learn Haskell beyond superficial hello world apps without learning what a monad or functor are, because there aren't any substantial teaching materials that don't force you to understand it in order to continue learning, and all the common libraries require you to know how to use them because they are undocumented and have no examples.

Can you use Haskell without understanding how those things work? Sure...if by "use" you mean you are limited to copied and pasted code snippets without an ability to understand what your code is doing, with the slightest change causing unintelligible compile errors.

nilkn• 13 years ago

My impression of the article was not that you don't need to know what monads and functors are, but rather that you don't need to understand them on the level of category theory. I think that's a true statement, if your interest is in simply writing software in Haskell and not in breaking new ground in the Haskell community (like writing the lens library itself).

nbouscal6• 13 years ago

You have to learn what Monad and Functor are, but you do not by any means need to learn what a monad is, or what a functor is. To put it another way, you need to learn the Haskell type classes that have those names, but you do not need to learn the category theoretical constructs from which those names were taken. I believe this was the entire point of the article. The Haskell type classes are actually not too hard to learn at all, if you give it a bit of effort.

tene• 13 years ago

There's a significant difference between a wide understanding of category theory in general and understanding what a monad or a functor is used for in haskell. They're just type classes, nothing special. There's not all that much more to know about them besides their definition.

I rather disagree that they are undocumented and have no examples. Section 6.3.6 in the haskell report 2010 defines the type class and provides examples: http://www.haskell.org/onlinereport/haskell2010/haskellch6.h...

See also, the typeclassopedia, which walks through a simple definition, many examples, and discusses general intuition: http://www.haskell.org/haskellwiki/Typeclassopedia#Monad

Perhaps I've misunderstood you, and maybe you mean that common libraries are undocumented and have no examples? That certainly hasn't been my experience; most libraries I've run into have plenty of documentation for me. Can you give me some examples?

Yes, I agree that trying to write haskell without being able to understand simple type classes would be very difficult and confusing, but I disagree with what I understand the implied point to be, perhaps you could clarify this for me? I understand you to be saying here that you expect to be able to proficiently use a language with negligible understanding of how data types work in the language, or the common data types defined in the standard library? That sounds like nonsense to me, so I suspect I'm confused here; can you be a bit more explicit in your criticisms here?

rschmitty• 13 years ago

Side note from this submission is that I did learned you can host html like github

https://confluence.atlassian.com/display/BITBUCKET/Publishin...

Nifty!

tikhonj• 13 years ago

A bit of a link-baity title. It's not that you shouldn't learn category theory, it's that you don't have to. Even if you want to program in Haskell.

But is it worth learning on its own? Probably. At least the basics are. You'll get more insight into the design of languages like Haskell and ML and acquire a bunch of new abstractions which have a very good "power-to-weight" ration: that is, abstractions which are surprisingly general and expressive but also simple. The compromise, of course, is that these abstractions are really abstract--they do not admit good concrete explanations. At first, thinking about this sort of abstraction is difficult, but they become extremely powerful and convenient once you get used to them.

Category theory also helps people design libraries. In a sense, category theory is focused on composition, which is obviously integral to writing good code. Additionally, some extremely useful constructs--like prisms from the lens library--were discovered largely thanks to category theory.

Finally, category theory gives you a new perspective on programming. I find this very valuable because it gives me more than one way to think about whatever I'm working on. It's useful in the same way Curry-Howard is useful--in fact, there's a very natural extension of Curry-Howard to include categories with certain structure.

So yeah: please don't feel you have to learn category theory, but consider learning it anyway.

joe_the_user4• 13 years ago

But the alternative he proposes actually sounds more daunting than learning category theory: "In fact, try substituting

    Monad    -> FuzzyWuzzy
    Functor  -> Banana
    Category -> Cheerios"

Sure, uh, all the other languages I've learned involved using opaque labels whose meaning I had to infer over time. No, that approach is for something like esthetic theory. All the languages I've learned used pretty concrete intuitive terms for their constructs, even the terms weren't really accurate. Having to manipulate a construct without the slightest hint to qualities sounds just maddening.

Learning a programming language is hard enough that I think the learner needs terms that suggest they're dealing with something concrete even if they're not.

axman62• 13 years ago

Then try

    Monad -> Sequenced
    Functor -> Mapable
    Category -> ... I don't know, I don't use it much (not that it doesn't have a nice understandable alternative name, I just don't know it)

Monad and Functor are really quite simple classes to understand, and Tony Morris' 20 intermediate exercises listed in the article helped me greatly when trying to understand the concepts.

I've been a haskell programmer for 6 years, and feel I know about zero cetrgory theory. It's never seemed to hurt me (except when Edward Kmett pipes up in IRC and I don't understand a word after that =)

jfoutz• 13 years ago

I like the abstractions that _do not leak_.

ekidd2• 13 years ago

This is a nice, short article which basically says, "You don't actually need to go learn a bunch of category theory if you want to learn Haskell, so please don't stress about it." Despite the title, it's not any kind of general argument that no programmer should learn category theory.

Category theory is a strange branch of math—it's almost entirely definitions, with only a handful of interesting theorems. As far as I've been able to understand, category theory is a very abstract analogy between very different branches of math: abstract algebra, topology, mathematical logic and (here's the interesting part) the lambda calculus, via Cartesian closed categories.

This analogy has interesting payoffs, especially for programming language designers and people trying to do seriously weird stuff. For example, let's imagine you have a value of type A, a function from type A to type B, and another function from B to C. But if you squint at these types right, it's the same as a logical system where A is given, A implies B, and B implies C. Now, it turns out we have automated theorem proving software that can take statements like this and figure out how to get from A to C (even in much more complicated situations). And it turns out the analogy between types and logic is sufficiently strong that you can actually use a theorem prover to write certain kinds of programs without any human intervention, given nothing but the type signatures of your functions.

And this is not the only clever analogy lurking here: My favorite is the way that probability distributions can be mapped onto the lambda calculus.

So, no, you don't need to know all this math to write Haskell programs. (Although some library authors are a little nuts, generally in a good way.) And yes, category theory is a weird branch of scarily-abstract math without many theorems, and Haskell only uses certain corners of category theory. Still, there are times when category theory will allow you to see how far-flung branches of math can be mapped tidily onto the lambda calculus. And that should be of interest to Lisp developers, at least.

Please Don't Learn Category Theory (2013)

Related Stories