I found the talk frustratingly vague. After all the hard work of setting up categories/operads in an example, the talk moved on without using them to do anything interesting.
I found the talk frustratingly vague. After all the hard work of setting up categories/operads in an example, the talk moved on without using them to do anything interesting.
I don't know if the video itself maybe fails to properly point out uses of category theory.
My opinion on the matter is that if you do want to use mathematics in your everyday work, the main applications will come from the mathematics you know the best. So, whether you are interested in category theory or not will also influence whether you use it. Many of the concepts in category theory can be done instead in algebra and analysis, but it is the spirit of unification that inspires people to study category theory. A lot of functional programmers are delighted when they learn about axioms such as associativity (since you can prove thing about your program) but the concept is much older than category theory. So you can just know associativity if you are not really interested in category theory and that will already take you far.
[1] M. Johnson and R. Rosebrugh, Fibrations and universal view updatability, Theoretical Computer Science 388.1, 2007, 109–129.
When we do logical deduction, we have facts and rules. We can apply rules to facts to get more facts. More specifically, formal logic is built from situations where we have some fact P, some rule P => Q, and some conclusion Q.
In a category, we have objects and arrows. We can imagine arrows as mapping one object to another, or sending one object to another. We might have objects P and Q, and an arrow f : P -> Q relating them.
The connection continues. We can take multiple rules in logic and apply them sequentially, building a proof tree; we can take multiple arrows in a category and compose them sequentially, building a path. In some logics, there is an idea of ex falso quodlibet, or from the false fact, anything can be proven; similarly, in some categories, there are initial objects, which come with arrows from the initial object to every other object.
Just like how logical formalism eventually removed the possibility that logic is non-mathematical, category theory removes the possibility that logic is unstructured. Logic is actually incredibly highly structured, and those structures happen to coincide with structures in other parts of maths and physics.
I've seen some vaguely cool stuff done with Category theory in Haskell, e.g.: composable tree parsing and traversal, but I've never seen anyone actually use any of this stuff to make a deliverable piece of software that is notably better than what developers can readily produce using traditional procedural languages.
I mean sure, I suppose it would be nice if the C# team added some sort of category theoretically "pure" tree processing sub-language akin to some bastard child of LINQ and XSLT, but... meh. I don't think it would see a lot of use in practice.
The traditional approaches weren't just stymied by this problem, BTW; the other developers wanted to go shopping for off-the-shelf components which transform XML to PNG, as if that would get us the specific katamorphism we desired.
The nature of your everyday work will inform what you can do with category theory. I personally use category theory to design programming languages; it's something for which category theory gives a turn-the-key recipe:
* Pick some objects of interest
* Define a relatively free Cartesian closed category whose objects include your objects of interest
* Enrich the category with interesting arrows
* Extract a combinator basis
The MarshallB programming language [0] is a good example of this recipe in action.
Also, from my perspective, the exact real arithmetic isn't super-interesting because it's not new; Turing was doing this sort of thing when he first got access to computers. Legend has that one of Turing's first recreational programs was computation of zeros of the Riemann zeta function, and ever since, there's been a tradition of exploring exact real arithmetic with computers and programming languages. MarshallB is one more incremental step forward in a big research programme of overcoming the inconvenient fact that we can't test real numbers for interesting properties with computers alone.
At no point have I advocated only category theory. Categories are always composed of some collection of arrows (and objects, but I prefer object-free presentations!), and those arrows are always homogeneous, if not homoousios, composed of a single substance. We can study that substance on its own. Perhaps an analogy to materials science would be appropriate. We ought to study both each building material, be it sets, vector spaces, relations, graphs, or type theories; but also the architectural principles used to make buildings, like abstract algebra and category theory.
I can't share the details of the program with you, but hopefully this helps. Wikipedia has more information and an example at [0].
The point is (probably, maybe) that nothing in programming is intuitive; all the abstractions have to be learned for a first time somewhere. A lot of math education is about cataloguing common patterns, naming them and providing an environment where students can check if they have internalised the obvious pattern or not.
This allows incremental building of knowledge between different people. So for example if someone is trying to build a Something with [Property Z] and person B points out "this is a [mathematical object X] therefore [theory Y] says the Something won't have [Property Z]" then the builder can understand the implications immediately and abandon the effort, or identify what needs to change to make the Something not an [object X]. Saves a lot of discussion, enables a lot of coordinating. You can ask an expert to check your work for [Object X]s if you never quite got confident in the concept.
A bit like how an engineer might look over another's design and say "the tensile stresses on that beam will be huge!" and the designer will be able to make a lot of assessments in an instant that would need a good half hour if the concept of tensile stresses wasn't part of a common language and the mistake-finder had to explain stress & strain from first principles.
So yeah; a lot of it probably is trivial but it saves hours of discussion and explaining out in the real world. And there is benefit in moving the explaining up early where it is dealt with in a 30:1 classroom setting and it doesn't slow down design work.
The GP asked for nontrivial insights from applied category theory, not a recipe for use in everyday problems. I do not think every insight immediately leads to basic recipes that are used in day to day tasks. I haven't digested enough if the papers in the field yet to have a good answer for the GP, but I think you are not asking a fair question of a field as young as ACT.
One possibility I can imagine is that in a highly compositional language like Haskell, where structural patterns could be factored out as libraries, identifying patterns in a new problem means that you can now just use the library to take care of the structural “boilerplate” when writing code to solve the new problem, and focus purely on the domain-specific tidbits... in a sense allowing maximal code-reuse and convenience. It’s not Luke one couldn’t have solved the problem without categories — it’s just that there’s less “design pattern” boilerplate and correctness guarantees. I guess this is what it means to “make the trivial into trivially trivial” :-)
Tho approach is then not very useful when you’re interested in solving only a single problem. But if you want to solve many problems, then this approach gives HUGE leverage towards reducing incidental complexity in code, and should be particularly useful when designing frameworks/libraries/DSLs/etc for maximal reuse.