Видео

How many?

@@melbournealtnet how many you got? 😏

Hi Rico, unfortunately, this was a few years ago now and I've been unable to get the code. I think you'd probably have some luck finding other samples with a bit of google though?

I've contacted the speaker to try to see if the code samples are online :)

I've contacted the speaker to try to see if the code samples are online :)

Both ways wil have identical perf

0, '0' or "" in this context are all literals, so they're compile time constants, meaning they won't have a perf impact. In real world code though, there could be a difference, so its a good point to make, thank you!

Abhishek Srivastava thanks, I was struggling for a good description of the video. Any suggestions?

There are only two hard problems in computer science naming things and cache invalidation. I suck at names and descriptions.

The third hard problem of computer science is how to get anything done with all of those meetings.

Ed Maphis mob programming can help with that!

Did Neil have code prepared in this talk? I will reach out to him

Yes, Neil confirmed there are samples in the Repo. You can follow along with that conversation here twitter.com/pjimmy/status/937077927178407936

Cool , thanks!

twitter.com/pjimmy/status/937077927178407936?s=20

Vũ Tô I know you posted this two years ago, but I think it’s worth clarifying. Simply getting back the same data type is insufficient to uphold the “laws” of a category. It must meet a stricter definition which is that the returned object must be structurally identical (including value). In this case, the only integer which satisfies this with `(+)` is zero. And none of the integers will satisfy it with `(+1)`. Another good example is the Functor. It has a `map` function which “maps” a second function over its contents, returning a new functor. But it’s not sufficient to match the types. Otherwise, `map` (for lists) could decide to reverse the list at the end, which still meets the type signature, but breaks the functor law that `map` should “preserve the structure” of the functor, including ordering. These rules that exist outside the type system are often included in what they call “properties” of categories. Naturally, many programmers want to verify that their own implementations satisfy the categorical laws, so they use “property-based testing” in order to prove what the type system cannot prove for them.

I say examples should be in Factor or Joy*. It's a better notation for composition: "c ∘ b ∘ a" is simply "a b c" ;-) But jokes aside, if anything, Javascript would be better than Haskell or C#. It's trying to present it in a language-agnostic and paradigm-agnostic way, precisely moving it away from Haskell, where it's almost a monopoly, and where you have enough material already. EDIT: (*) Oh, if Cat was still alive, that would be just perfect!

www.slideshare.net/kenbot/category-theory-for-beginners

Tomer Ben David The usual FP way is to have simple building blocks, and build more advanced things by recombining them with other things, not by adding features to them. You might implement this extra feature using something like a State monad, which could keep track of your status while still being a functor itself.

Tomer Ben David No; just because b.com page has a hyperlink to something, doesn't mean that a.com does. If we allow that, then any webpage has a hyperlink to pretty much everything on the internet! It's just a specific case of a graph; a graph A --> B --> C does not have an edge from A --> C. It's not a category unless all consecutive arrows A --> B --> C have a composite arrow A --> C, and all objects have an identity arrow.

Because they don't compose by rule. The fact that they might compose, does not satisfy the rules of category theory. Webpages are graph nodes at best. They are not composed by a set of rules that don't have any gaurantees related category theory. Categories compose by rules of math and logic only. "Webpages" cannot be PROVEN to compose in this way, because that kind of composibility is not a required part of the TCP/IP protocol.

William Ross Yes.

not necessarily. constants in .NET are bound at compile-time. readonly variables are bound at runtime (and can thus be lazy)

I think they are basicly read-onlys

Hey Rick, glad you liked the video. It's my understanding that its probably the theory that's the tricky bit here anyway. The implementation is just nice and neat in F#

Jimmy P yeah, the background was very good, just wanted to see some F# idioms as well...

Well watch this space because I believe there may be some more information coming on the topic. Right Andrew Browne?

Jimmy P will do, thx

Hey Rick, We are working on open sourcing much of our event sourcing code. Lots of activity happening at the moment but not much documentation or example code: github.com/adbrowne/eventful/tree/dev In the meantime this talk has a lot more code and might be of interest. It's another company doing event sourcing with F#: vimeo.com/109343720 Hope that helps.