Відео

Step one: delete Clojure. Step two: use a real language, like SQL.

So at 42:43 you’re saying slectRandom() and playRandomStrategy() are both “pure”, and that’s just referring to inputs and outputs, because the second relies on the first to function? So dependencies are ok in pure functions, it’s just that lack of side effects within it?

This made me realize i should just double down on Go - I appreciate the honesty. Getting away from the JVM is a blessing.

what’s cool about this functional programming demo here is that it did not stress higher order functions or composition at all. it was just about managing state which is the hard part of a system.

How has situation with Clojure techstack changed since then? I'd like to know!

Hi

Nitpicking, the term "pure" is used incorrectly. The extracted functions don't have side effects, which is only one of the requirements of purity. Some of them are not deterministic, which is also a requirement for functions to be marked as pure.

Love that man!

Amazing talk!

Great talk. Keeps it simple and gives one of the clearest, most pragmatic and easy to understand explanations of the key aspects of functional programming. I've done lots of React, some Haskell and I'm now learning Clojure for a new job. Made perfect sense to me.

58:00 - that's rather different. They just describe their API in data, then generate clients for it. It's similar to swagger. - That is very different to writing the program, the server itself as largely configuration driven. - and I think code is great, and if you try to put a lot in "configuration" at some point it will become much more work than it's worth. - Also, "configuration" is harder to write: usually zero intellisense, discoverability (+correctness) even harder than with just dynamic types ... - That being said, I really DO like configuration in VSCode - it has lots of intellisense etc. - It becomes a lot more usable then, but writing this for YOUR "dsl" becomes way, way more work again...

22:08 "...and deferring, well, well we'll get to deferring in a moment." LOL well played

hi, i think u lookin gud fam

I'm not clojure programmer, just started to look at it, but this talk was very cool, and refactoring imperative to FP style was great however you made couple of bugs during this process: - newScores() adds just 1, not bountyCard - report() should skip initial state, there are no lastBountyCard and lastPlayedCards values for initial state (and lastState is not defined) - endCondition should be flipped (using not or length == 0) (and lastState is not defined) anyway, it was cool and I wish you have couple more talks where you show how to "transition to FP", thanks!

2022 -- enter AWS-CDK -- the snake bytes its own tail: AWS Cloud Development Kit (CDK) accelerates cloud development using common programming languages to model your applications.

Thanks Tommi!!

Great refactoring! Also, pretty cool categorization of methods to avoid side-effects! 😄

Don't quite follow why he suggests that having global state is considered to be having side effects - if the closure of the system is well defined then it's just a matter of organisation.

This is a nice tutorial, thanks. Inspired from you I have also start create a clojure course on youtube checkout on my channel ua-cam.com/video/f9VBkTpr5uc/v-deo.html

I think this is a historical talk. Do you agree !?

10:00:50 OK, folks reinvented PHP

Big floppy maps and vectors become a mess over time. Prefer composable piecewise functions which generate what you need clearly and nest those. You'll get MUCH more power that way and you don't enter the brittle realm of copy/paste nonsense inherent in *only* pure data structures. And if your structure changes you'll adjust it in 1 place vs ALL over your code peppered with literal data representations. An unbound map literal is just a more advanced version of "magic number" in your program. ;; Clarity through composition shows intention (make-house ; Generates vector to hold rooms (make-room "foo") ; Generates {:room "name"} (make-room "bar")) ;; Better yet (make-house (make-room "foo" "bar" "baz" "qux")) ; make-room now multiple arity with & rest ;; Floppy garbage [{:room "foo"} {:room "bar"}] ; What does this represent? A house? An office? A prison? Nobody knows!

Great talk, thank you for walking us through that. Is there a bug in the recur function? The end condition looks like it would end on the first iteration. Also, the recursive call to recur() doesn't have the last two parameters. It's ok if there's a bug, I just want to make sure I'm understanding everything. Thank you again for all this information!

I wish I had cljs when I was doing ASM on Z80's and 8085's to control racks of equipment across RS232 UARTs 42+ years ago :) Nice work!

This talk is such a hidden gem, it's one of the very few I've got backed up locally just in case

Very helpful. Thank you very much

Thanks

This perfectly demonstrates how to tease the pure out of the impure, the thing I want programmers who haven't seen it to see. Thanks for taking the time to showcase it.

57:50 is just mind blowing

It's Amazing! Thanks for your work!

This is superb..

(❤️)

Great talk. Here's my takeaway from it Process of making code more functional (eliminating impure code) 1. move all impure stuff to the top (the top component or a top function that calls everything else) 2. refactor out pure code from the top func 3. reorganize all mutable states into one (global) state object. 4. A dispatch function to return a new state (instead of mutating) 5. [Extra] instead of keeping a mutable state object, use a states array to keep all intermediary states. The top function is just a function to turn out states. 6. [Extra] use recursion to eliminate loop and mutation of state

I like how he deferred defining the defer technique. Lmao, very clever.

For those who need a more detailed explanation of the GOPS: ua-cam.com/video/WUTc1AF3a0I/v-deo.html

Fantastic talk. Thank you very much.

"After overcoming a fear of brackets..." Is this a rational or irrational fear? Haskell doesn't need as many brackets, after all. Is the opening parenthesis really necessary? Can we replace the end parentheses by something simpler?

Wow I think it's the first time I really get what functional programming is all about. I still can't get fully on board with the recursions, the accumulation of function calls and the accumulation of useless state variables though. A question to UA-cam's functional programmers out there, would it be possible to specify, instead of state_k = f(state_k-1) something like state_k = f(state_k-1) and by the way store state_k where state_k-1 was because I don't need it anymore?

Your valuable content deserves a better microphone ! ✌🏻

Question: did Smalltalk programmers realize all of this eons ago?

22:14 “Minimize, concentrate and defer. What’s defer? Well, we’ll get to that in a moment.” Why am I the only one who thinks that was totally hilarious!? XD. (Great talk, BTW.)

Been said many times already but this is by far the best talk I've seen explaining functional programming. Thank you so much Rafal!

But Clojure is a lisp! You can make a data-driven DSL in a lisp by putting a quote mark before any lisp expression. It seems unfair to lump both lisp and Ruby meta-programming with JS fluent API style. Both are quite different by culture and appearance from JS where the fluent style is basically a way of working around the lack of good meta-programming features.

Have you looked into etoys on pi. A smalltalk. You can attach a cam and gpuio support. Cool thing is that you can modify it to your needs, and very shrinkable. PhysicalSpace wise it's not bad

The meta programming system mentioned around @55:10 is this one: www.jetbrains.com/mps/ It allows defining different projections for the same source code

@22:35 is a very good advice about error messages

What is the point of this talk? You don't talk much about native Clojure library for deep learning, which does not exist (Cortex is still in early phase and has not seen a release since Oct 2017). If you rely heavily on Python libraries using a wrapper, why not just use Python? When you develop a piece of software you have to think about long term maintainability. How many Clojure developers would you find compared to Python developers? You need to show us what Clojure offers in the machine learning space that is not available in other languages. One of the zens of Python is "Readability counts." Compare that to 17:39, you could as well write in Assembly.

Wonderful talk. The big take-away for me was the three idiomatic "pillars" of functional code that was talked about: Minimize, Concentrate and Defer. I'll be remembering those. I think it's important to point out that the final functional code you ended up with could still organized in an OO style - that is, organize the functions with the data they operate on (methods), and make the methods pure. In fact, I think if you're forced to work in an OO language (like Java), favoring a 'functional-OO' style is still beneficial for all the reasons outlined in this talk.

What I'm not clear on is how the method table is implemented (in clojure's standard multimethods) in terms of namespaces and loading/unloading. Is the method table located in the same namespace where the defmulti is located? i.e. when a defmethod is encountered (e.g. in a different namespace), what happens? It's possible to use defmulti and defmethods all in the same namespace, but that seemed to defeat part of the purpose of the potential modularity being gained, at least, comparing to how generics are used in SICP. Haven't seen much explanation of this (mainly about clojure's implementation of multimethods, i.e. the starting point for this talk). Nice talk though. Feel it's important to get exactly how clojure does it clear first, before going more complex.

Such a great talk !