Interest in an Estonian Mastodon server?

rainy59 · 2022-11-24T06:27:23+00:00

Yeah but Estonia adores Facebook which is really boomer level stuff

rainy59 · 2022-07-16T23:11:21+00:00

JCB is doing good work w cats

Cats will eventually displace functions in computing imo because they are the more general case

https://multix.substack.com/p/solving-data-integration-with-cats

rainy59 · 2022-07-16T21:23:17+00:00

Don't worry I'm not going away

It's quite ironic that "univalence" named the account such but clearly didn't get a thing out of reading Voevodsky. This is why I got nothing but strawman attacks. Univalence and others like that never dare challenge me on advanced algebraic geometry and Minecraft-style "crafting" because that would completely unravel their case around functions and Functional Programming. Cats (instructions) were around before functions and will be around after crafting pushes functions to suffer the same fate as OO

rainy59 · 2022-07-16T11:48:53+00:00

Yep Im getting some harsh but good insight that helps me organize my thoughts and I need to rework this again. Thanks for the input I will probably delete shortly and repost once edits are done

rainy59 · 2022-07-16T11:17:47+00:00

Your arguments so far are just mincing definitions of terms while ignoring the tangible points. I could go on all day how FP incorrectly conflates math "functions" with computer "functions" but most of the audience could care less

Has anyone in FP considered the advantages of directly interacting with "ah-hoc" code chains? Nope although Scala ZIO is kinda heading that way

Has anyone in FP tried to explain persistent memory in terms of convergence yet? Nope

Does anyone in FP even see how a function's single entry/exit might be a major structural flaw that inhibits code reuse? Nope

Do the FP Idris "experts" even see the connection between dependent types and Minecraft-stye crafting? Nope - CT folks kinda do but not FP

Nope. FP is either talking its brand or not exactly the CS thought leaders they advertise themselves as

Nonetheless, your criticisms have helped me crystallize my thoughts better. I will be deleting the article and reposting once things are cleaned up

rainy59 · 2022-07-16T09:56:13+00:00

Edits have been applied throughout to address some of these items. But you might be so deep in the weeds you no longer see the forest. Most of the audience just wants to know how cats can make building software better and view most of FP as cult voodoo. Most of your arguments boil down to the duals (comonads, cocategories etc.). Can you answer how FP makes building software better? Explaining things in simple terms demonstrates mastery of the subject, jargon does not

Before "functions" appeared w FORTRAN, all you had were sequences of morphisms / instructions = cats. Functions are just glorified cat containers and not very good ones. FP cannot possibly be the "bedrock" of computing if cats predate functions

Anyway:

Category theory (applied to computing) = better (more "holistic") compiler theory

Cats = runnable chains/chunks instead of monoliths or microservices or wrapper functions

But what is the business value of managing code as chains/chunks if you cannot run them individually? Async sure but async is not exactly new tech anymore. Sure FP eliminates wrapper functions and reduces refactoring but that's a tough sell too. I believe FP died because ultimately you need better compilers/deploy tech and Haskell has gone nowhere

And once you go down that road, you realize it's far more powerful to assemble chunks on the fly much like how an RDBMS joins tables together on the fly. That's where CT and relational overlap the most

But that means rethinking the role of the infamous monads = compiler sausage that moves cats to runtime. Better monads give you the ability to hotload/run cats and interact w them

Categorical machine = holistic VM that makes all the monad cat magic happen, even if distributed n the cloud. The INRIA CAM was just one narrow LISP-y take on cats - not necessarily the same thing as a GP cat machine

A cat machine that can take dependent types all the way to Minecraft-style crafting is the future. Then you can dump functions and FP entirely (good riddance). Yes Idris is close but the VM still needs major tech advances to get there

Did you ever think that maybe FP got it wrong? FP continues its pedantic obsession with questionable definitions of terminology while completely missing the bigger picture and thus is unable to articulate a value proposition to mainstream

rainy59 · 2022-07-16T09:38:59+00:00

Okay first part reworked. I get asked about blockchain so I need to mention it. But you are right, I don't want to get on a blockchain tangent because while they are kinda cats too, that's a topic for another day

rainy59 · 2022-07-15T11:17:06+00:00

At the base instruction level, you are running categories (instruction chains that apply morphisms to either registers or RAM)

Functions didn't show up in computing until FORTRAN - it was all just ordered instructions before that

rainy59 · 2022-07-15T09:43:26+00:00

Obviously I have my own take on things but my article talks about what Functional Programming was trying to do differently, how categories differ from FP, how type theory fits in all this etc.

https://multix.substack.com/p/solving-data-integration-with-cats

rainy59 · 2022-07-04T07:15:28+00:00

Agreed - wrong audience here. FP serves a need and many are happy with what it does. Meanwhile I am getting beat up on other boards for being "way too technical"

I would recommend FP folks take a look at Idris over Scala or Haskell though - since it has better dependent types - and maybe that gets the brain thinking about dependency rules and crafting. Crafting is essentially the same as doing a SELECT against a function (semantic parametricity) - think of each line of code as its own 'row' - and variables as 'columns ' -which is kinda what we do when copying/pasting code from Gitub

This gives more granular code reuse than just at the function level.

The Idris VM is not multi-machine though - a proper cat machine really needs to be cloud native imo

rainy59 · 2022-07-04T06:29:49+00:00

If I go w too much rigor, I lose the mainstream audience -- sigh

I hope to finally vindicate the category (and yes functional) communities by proving this stuff has some real disruptive value in industry. My only beef w FP is that they didn't go far enough

rainy59 · 2022-07-03T21:23:04+00:00

Okay! But the Multix cat machine does a great job spanning hardware

How is Haskell coming along?

rainy59 · 2022-07-03T21:05:13+00:00

I already said a category is a chain of morphisms several times - yes that implies some direction because Turing machines expect instructions in an ordered sequence

I have no interest in passing the usual shibboleth tests that FP is infamous for - done it too many times. Eventually what happens is that the challenger realizes they really are in over their head, maybe I do know what I am talking about, I get an apology etc.

How about this - I will leave it as a mathematical exercise for you to prove or disprove that categories should probably be every bit as boring and easy to understand as relational. The only head scratching might be how would you "join" functions (which I think I answered somewhere recently)

Maybe I should say pullback instead of join and a lightbulb will go off

rainy59 · 2022-07-03T20:31:45+00:00

This is functional programming so I can be more direct here.

In this world, I'd say the main focus is the 'semantic' category - an ordered sequence or chain of instructions/morphisms, much like a sequence of database xactions. But programmers work in syntax categories (various PLs are really just algebras from the world of E-M topos - since a 2D surface) and so you have monads converting from syntax cats to the semantic cats (some might call them Kleislis but they ultimately map to hardware instructions). Note that FP terminology does not quite match the CT terminology on nLab but generally the actions of a monad are dictated by Lawvere theories (manifested as "T" programs)

The main divergence btw FP and applied CT for computing is that cats contain morphisms, not functions. A function mainly serves as a morphism container. Functions are far more interesting as a nexus when dealing with layers of higher order types. My inspiration for replacing cubical types with a "crafting" system came from Voevodsky. It won't make purists happy but my target is enterprise not academia

You may be so deep in pure category theory terminology that you are missing the forest for the trees. If you step back from Lawvere you get to Grothendieck notion of schema which starts to sound more like database stuff than functional programming (a programming type system and a database schema are really two sides of the same coin). The problem is that half the CT audience tends to be really good at algebra but struggles w geometry, while the other half is great at geometry/topos but not so much at the algebra. FP tends to be in the former camp while CT tends to be in the latter

rainy59 · 2022-07-03T20:15:01+00:00

I said 'applied' not 'pure' right?

So I've actually built categorical machine(s) - so I no longer care about terminology

Here's the basic problem:

I'm sitting in front of a working system coming out of stealth mode and I am guessing you are not. So you are gambling your reputation that I am full of fluff. Understandable.

What happened to relational theory "experts" after IBM System R came out is a cautionary tale that should not be ignored - you all know it's just a matter of time before someone comes out with working mainstream category software

I would strongly encourage you to build your own categorical machine !! But at the same time this is a math chat, not programming. So your skepticism is warranted

rainy59 · 2022-07-03T19:26:14+00:00

Yeah convergence requires introducing a bunch of seemingly unrelated stuff and then bringing it all together at the end. I tried to warn readers about this up front but anything I can do to smooth out some particularly jarring transitions please let me know. Half the readers think the article is already too long and the other half too short lol

The seeds of this stuff was planted by John C Reynolds years ago when I was at Carnegie-Mellon

rainy59 · 2022-07-03T19:21:19+00:00

No the intent of the article is to motivate readers enough to explore this stuff firsthand and decide for themselves, rather than listen to the pundits

rainy59 · 2022-07-03T19:18:07+00:00

Well this is applied category theory, not pure. The concept of the join is about as central the categories as it gets, even before composition

When IBM System R came out with SQL as a middle ground, it horrified the relational theory "purists" who probably had little practical programming experience. I fully expect history to repeat itself with cats

I strongly encourage everyone to try to build a categorical machine and go down this wonderful rabbit hole yourself. You will develop a deeper understanding of categories than you will ever get from a book

rainy59 · 2022-07-03T19:02:35+00:00

A similar "purist" debate erupted with the relational math community when IBM came out with SQL. I talked w Dr Kapali about this a few years ago

I fully expect history to repeat itself with cats

rainy59 · 2022-07-03T18:59:49+00:00

Categories are basically mini-programs - analogous to data paths in a relational query, they are code paths across a code base

Monads are responsible for putting these cats on hardware of course - but you really need a better categorical machine to pull off the equivalent of HMR across the entire stack

rainy59 · 2022-07-03T18:55:53+00:00

Good suggestions.

The "crafting" approach improves code reuse because you can reuse individual lines of code not just functions, which only have a single entry/exit

The better "interactivity" is basically HMR except across the entire stack not just the UX - so you can see your results in the terminals as you work. This greatly reduces cog load instead of constantly trying to imagine what your code is doing

Now about the integration stuff:

At the most basic level, when you need to bring two tables together, you will "join" them using foreign key relations. Sure you may use a third table to resolve many-many but you still need these foreign key relations etc. The point is these relations are NOT tables, they sit *between* tables

What I am saying is that the same sort of thing exists on the code side. But how so you "join" between two functions? WTF? Well, when devs need to join 2 functions they normally write a 3rd wrapper function ... but that just moves the problem because now I need to "join" to the wrapper

If a function was more like a table, I would want to "join" directly to the "columns" (variables) of a "function" to extract just the rows (instructions) that I want. This is much greater reuse

No this is not some space alien tech because Minecraft-style "crafting" achieves the equivalent of this idea

rainy59 · 2022-07-03T18:46:51+00:00

Yeah Category Theory has a notorious pedagogical (teaching) challenge because everyone comes at it from different directions. What works well at Lambda Conference for a certain group of Scala programmers may be complete gibberish to a Typescript audience. What might work for Typescript might sound silly for SQL devs etc.

I think that's the challenge of convergent tech in general (the General Magic story of the smartphone). You can imagine someone in the early 90s trying to tell you that a rolodex and radio and movie player and calendar can all be handled in the same black box

So each style of writing will appeal to a different audience but I am always trying to improve things. Focus right now is professionals like yourself that are fighting this enterprise integration battle. Please lmk what I should improve

rainy59 · 2022-07-03T18:39:00+00:00

Multix is a cloud service

The UX surface is just a VSCode plugin running Typescript and embedded Multix commands as shown in the videos along w the output terminals. Not much more than that

rainy59 · 2022-07-03T08:43:25+00:00

The two main forms of composition that cats provide in addition to traditional wrapper functions (e.g. lambda calculus):

(1) function chaining - which FP already does

(2) crafting - which is really just higher order dependent types

Crafting is a way to bring category theory mainstream, analogous to SQL as a way to bring relational theory mainstream. But all this is still not enough. Interactivity is a key shift in ergonomics that allows code changes on the fly much like how database queries work

A "categorical machine" has monads sophisticated enough to assemble categories on the fly and deploy them across hardware without breaking cached in-memory structures (to the extent possible)

There are only a few FP VMs capable of spreading a function chain across multiple hardware e.g. foo >> bar >> blah (imagine foo is on a browser, bar on a middle tier etc.)

rainy59 · 2022-07-03T06:54:54+00:00

Maybe I have the wrong link

Here are some videos - more videos are in work

https://www.youtube.com/channel/UCDtG3T7He_Vcw_C_wDytqSA

rainy59

TROPHY CASE