Video

I write variable names that are a whole paragraph

How about we let people name their variables however they want? What makes you qualified to go into people's houses and tell them how they should design their living room.

Having comments can make things harder to read. Now I have to read the comment and the code! Twice as much reading! So I use them sparingly.

depends on what you're building tbf

how do you make your animation for your video. I need that for presenting programming to my class.

12'th year pure-FP programmer debugging of your video: * It is not true that there is no state in FP; you confuse mutable state with state. In pure FP immutable state is carried through function arguments - which e.g. includes when you have an accumulator argument to `fold`. In functional reactive programming, you can even have state that is kept over time, and used to calculate the new result from a new event that shoots. * This previous point is also related to your confusion at 9:00, where you *state*: "it's funny that FP should be so different from OO". ... it's about immutable vs mutable state. * At 15:30 you say that pure FP is awful - which is obviously a skill/culture/language-issue. It's actually fantastic to write your whole core program logic in pure FP, and then push all IO to the edges of your program. This avoids most bugs at the core of the program, minimizes error-prone code, and you then know where to look for the bugs; the edges.

"Pure function programing where you can not mutate any state or have any side effects is kind of awful. The issue is it's fake. Computers fundamentally have state." "Pure functional programming is still mostly academic" Erlang bros be like: Say what? 😀

The biggest selling point of functional programming is OOP. Classes are simply state coupled to logic. The only reason you should ever write a class is if it increases cohesion. The problem with OOP is that it cannot help but encourage contriving reasons to do so, and thus it guarantees that your code with be incoherent.

I love monads because they are impossible to understand theoretically, but take a half second to understand what it's doing when you actually see one even if you have no clue how monads are supposed to work.

How is everyone doing fine with max 80 characters and having spaces between operators, properly descriptive variable names aswell as descriptive function names (wiht underscores have you) that take in a couple properly descriptive variables as arguments. Is every function call that returns to a variable like 4 line breaks long?

My friend in my comp sci class purposfully names everything as terribly as possible to make it as unreadable as possible. Its kinda funny but whenever they have a bug i cant really help 😭

In case anyone wonders the song in the start is -> Anatoly Boardman - Boy's Heart

As a mathematician, I frequently give my variables single letter name (or possibly "beta", or in Julia I can use β), and it makes life so much easier, because then it matches the equations. If I can write dS = +r*N*(1-N/c) - d*S - β*S*I/N then I know exactly what is going on. If I instead had to write rate_of_change_of_S = reproduction_rate * population_size * (1 - population_size / carrying_capacity) - mortality_rate * num_susceptibles - infection_coefficient * num_susceptibles * num_infectives / population_size that's so much harder to read and I'm much more likely to make a mistake.

On the ++i vs i++ debate, I agree that it doesn't really matter for performance, but I think their is an argument to be made for the entire project using the same one for consistency. And if you are going to do one, might as well do the one that is, at least in theory, a teeny tiny bit faster

beautiful and insightful. Thanks. How do you animate your videos by the way? Which tool do you use? Thanks in advance.

Me too

Glad to meet a fellow never nester.

unique_ptr isn't a big responsibility, because the ownership semantics imply that you just let the pointer fall out of scope and it gets freed. Whereas in old systems taking ownership did carry the responsibility to explicitly free. Figured I'd mention that, since people should totally embrace smart pointers.

Extraction and inversion are universal and the obvious main 2, but there's also opting for more concise features. I think it's reasonable to assume this is Java, and with that the containsKey check could be replaced by a computeIfAbsent. You might end up doing a redundant setName, but I'm just working with the example you gave. With computeIfAbsent you can declare a function to compute a field if one doesn't exist, then this returns the computed or present value for the key, kind of like a pull through cache. This really begins to shine when you use concurrent map types like ConcurrentHashMap, because these features work atomically. With a concurrent map implementation you'd still need to make sure that the map hasn't changed in between the containsKey and the put, but if you do a computeIfAbsent you can atomically check if the key exists and assign a value if there isn't one. This is really useful to avoid having to manage your own synchronization on concurrent maps, because most concurrent map types have granular locks which only lock a given bucket of the map at a time, whereas you only have the control to lock the entire map without coming up with an overly clever solution.

Recursion is a problem here: the function call depth will grow so fast as to exceed stack memory. Not a practical solution.

When trying to understand assembly source code, the only hope is the comments (and also a documentation). There are even people who disassemble binaries, then add comments on each line of the disassembly. So in my opinion, comments can be extremely useful. It's a way to understand what code does and how, and why. Code doesn't tell that you need perform some operation to avoid some problems. But comments might.

I can go up to 5 deep, but wont be happy with it and will try to denest it into 3 deep or 2 deep.

Bad programmer don't think the code they are writing from the point of view of "how hard is this going to be to understand for the person that come after me".

You should try assembly. It's not a problem in assembly. Also there are languages where this problem does not occur very often, like Prolog or Haskell.

"There Shall Be No State" Anarchists 🤝Functional programmers

That is why i hate reading data science books and frameworks after 15 years being a software engineer...most of the time naming and consistency are so terrible there ((( And i fed up seeing (and actually trying to change) BaseSomething, StandardSomething, DefaultSomething type names. Thank you for highlighting such an important topics! PS. I would add one more rule: fields/local variables should be nouns and functions/methods should be verbs :)

I think there's an exception to this and it's when you make code that'll be used by other, for example if you create a compiler, the compiled version of the code should be as optimal as possible so that the user won't lose process time on something he didn't do

Linis Torvalds has a saying about how any code that reaches three levels of nesting has a high likelihood that it needs to be refactored or pulled out into a separate function. I generally agree with this

this has to be the most awesome video on dependency injection ever made. Please make a course or playlist on DI and design patterns and how to solve problems using DI and the Design patterns.

This channel is a joke.

I hate doxygen

I have no CS background and had a Casio instead of a TI calculator when I was in school. I've tried to pick up programming over the past several years but don't understand anything unless it has parentheses.

FP scratches that itch when you don't really need a formally declared method/function but have a lot of very specific stuff to quickly get done. It's creating several quick "do some stuff with some things" bit of logic, almost like macros, that you can pass around (in languages that support it). Once you grok the concept, it opens up your world to intelligently break complex tasks down into simpler ones with less keystrokes and less code clutter. The problem is it's not nearly as readable and followable as more traditional code. You could arguably say it's an order of magnitude more complex to follow and read along with than non-functional programming. In 20+ years of professional software development as a .NET developer, other than things like Predicates (in Linq .Where) and arguably Projection (Linq .Select), you pretty much never see FP in production code. I've floated the idea by teammates from various companies in the past and nearly all of them have poo-pooed the idea of using FP in prod code, to the point they would probably reject any PR's including it.

I think that this is really going to depend on the language. If you're doing any serious shell scripting, comments are invaluable - sure you *can* sit through and work out what a long piped expression means, but far easier for the author to at least briefly explain it, especially given how arcane shell commands are. If you write a regex, you had better comment on at the very least what the intention of the regex is, and I have had no issue with taking multiple lines of comments to explain a complex regex before. Comments guard against folks who don't write readable code - I'd much rather have unreadable code with comments than without.

My argument for naming things *Interface is that it makes code review a ton easier. Having worked on teams where younger developers are inclined to just type against whatever concrete type they're using at the time rather using an interface, having all interfaces in "Interface" makes it a lot easier when scanning code to say "Hey, maybe you should use an interface here"

3:00 hahah

No no no. Why would you remove intent? Comments get compiled out anyways. Sorry comments are required where I'm concerned.

whole recreation of loops in functional is what recursion is.

This was so good, more videos like this please!

2:04 there’s an advantage to it when trying to hide code on another’s device

I agree with the "don't name things single letters names", with the caveat that for certain functions which are abstract math (abstract in the sense of not being tied to a specific problem domain), like for instance "divides", it can make sense to call the parameters x and y, because the inputs are just abstract values. Though in this case you could also say dividee and divider or something like that, I suppose

i'm sorry, but i believe in snake case supremacy

Sometimes it's better to repeat yourself in the code, rather than overabstracting things and dive into "abstraction hell". Just make your program do something interesting first, and than you may think about restructuring and abstracting code pieces.

Please keep making more videos !

Please keep making more videos !

Just don't nest your code too much. It's a pain in the ass to go through the codes 😂

there is also second rule, function no longer than 20 lines of code

I feel like this is a mostly pretty good perspective, while also I think its kinda strawmanning the FP community a touch. A core thing I think needs to be pointed out is functional programming is never actually about eliminating state, its about controlling it. Even in Haskell when all your state is in monads and theoretically pure or whatever, it is still state. The point is just that by tightly controlling state you get lovely guarantees - I think of it as the guarantee that you will never be hit by gotchas in the vein of 'oh yeah, python default argument elements are mutable'. And in terms of pure FP conflicting with the fact that computers are stateful? Yep, very much. The whole point is trying to write your code in a way that's easier to reason about, and trusting that a compiler can work out how to make that work on real hardware.

The comment can lie, outdated document too.

Elegant code. Is beautiful. The title. Has flaw in its title. Beauty and flaw. Go hand in hand.