Відео

You could have solved it with something like ...(favcolor.value && { favcolor: favcolor.value } its shorter than what you had and easier to reason with than what you later developed. But yes its a nice discovery you made regarding reflection.

Not reflection. Also, the payload must be serialized, if sending via REST - remove null values during serialization.

I've been procrastinating to watch this whole video for a long time

I was so invested in this video only to discover the most basic and commonly used pattern for creating objects. No hate though, I liked the way you explained. It would help out beginners I guess. If you watch any beginner level tutorial about javascript objects, you will find this pattern being explained.

Nice [[]]

Huh, I thought this was just normal js object manipulation....

Just send everything and let the backend logic for favourite colour deal with the empty value - it has to check the value anyway.

Its called “spread operator” not “rest operator” 😄 sorry it started to annoy me a bit after you said it multiple times haha

Like 100

...opt('favoriteColor', favoriteColor) function opt(key, ref) { return ref.value ? { [key]: ref.value } : {} }

i dont feel people are arguing against abstractions, nor are the people who would be are saying they shouldn't exist at all. the argument they are trying to make is that *good* abstractions are not something which can be made on accident, and a bad abstraction will do more damage than a good one. needing to keep multiple ideas in your head as you move down abstraction layers is very hard to do, and can be the case when you move to abstract as much as you can. it is much more valuable to consider if it is actually going to improve the quality of your code outright. the misdirection will add overhead to your code, and replacing a one-liner with a different one-liner does not improve anything; it just adds misdirection. it is very hard to not make a lot of abstractions in OOP, and because of that you end up with, imo, a lot of bad abstractions. the methods you show in the video, like `getAdminUsers` or `getNonAdminUsers` dont make the code any more readable, they just redirect anyone trying to understand what is happening in the actual code, like maintainers, back to your method. there is a great video called "Object-Oreneted Programming is Good*', which is more aptly called 'How to write good procedual code' which covers this topic more in depth near the end. i agree with his video entirely, and my code quality has improved since. it's a good watch if you are at all interested in the oposing side. try everything!

I feel like a simpler way to solve this problem is to make a function that takes an object, and returns a new object with only the keys on it that are truthy. But I like the creativity!

What you're saying common sense. But common sense is not very common, even in developers.

It's one way of doing this and it's not completely wrong. However, I think you should utilize the undefined value as is instead of this additional logic. JSON.stringify removes undefined values from an object, so just run every object through JSON.stringify before sending to the server. This is the way axios handles for it, for example, and in my opinion it's the correct use case for undefined values. And you kind of need to stringify the request data anyways, since there is no concept of data types in the HTTP layer, it's just bytes being parsed on both ends. In fact, JSON doesn't even contain undefined value, and null should be used to represent an "empty" value. So tl;dr: prefer to use undefined to omit properties, null to represent empty values.

> if (user.admin === true) { user.onboarded = true } Only in JavaScript.

It's a good thing to learn something new.

Mixins are a similar idea

Hey man, thanks for sharing :) I love the idea of traits as a mechanism for composing behavior out of a bunch of small components, and your tiny implementation of them is awesome! I feel like we need more small but powerful extensions like this. However, do you worry about the tying of implementation details to interface? The interface of `CanVote` eseentially boils down to `['vote', 'mayVote']`, but that's never mentioned anywhere explicitly. Instead, the implementation is passed around directly. I'm not sure if or how this would actually manifest as a problem in practice, it just feels like it could become an issue. Also, small tip: you can use `Array.every()` instead of `Array.reduce()` to make the implementation slightly more succinct! Something like `const hasTrait = (obj, trait) => Object.keys(trait).every(name => typeof obj[name] === 'function')`.

I feel like undefined value should be returned and checked by the API (if the API your are dealing with is correctly setup) not by the client because you are doing work that should be done anyway by the server, so either you are doing twice the work, or the server can be corrupted by a malicious user. Anyway cool to see you are exploring the langage and you had fun!

Please zoom in on your text editor so that viewers can read what you're writing.

Yup. Tools in the box. Use the right tool for the job. Document the job. Everyone loves the construction analogy in software development, so don't use a screwdriver to drive nails and make sure you update the as-built blueprints if you deviate from the provided plans. There are too many developers who don't understand this basic concept and anything that is hard (abstraction, pointers and memory management, etc) is bad because why not.

I love that someone is talking about this. The transfer of information from one human to another is complicated and difficult and deserves more intentionality. I definitely agree that documentation needs to be more than a brief summary. And that need grows exponentially with the size of the company. More developers need to realize that documentation is part of the job too, not just writing code.

a take so based i'm going to have to be nicer to javascript programmers

unrecoverable errors vs recoverable errors. I love it.

I get what you are going for and would argue that you miss the point. First of all you are right in that "thou shall not repeat business logic", it is a fair and accurate point. But abstraction is not just creating functions, it is also about encapsulating things inside objects and using inheritance. On some level, encapsulating things makes some sense, it will enforce some boundaries and avoid traps. However encapsulating things too much or before the needs arise is just as bad as not having encapsulation, that is why a lot of people including me are pushing back on abstraction and especially OOP. The point of fighting abstraction is that you may also never change the admin check or realize that you actually have 5 levels of permission for the user. Trying to predict futur use case before knowing them fully may lead you to create abstractions that are more complex than they need to be or that are just not correct for the use case. Either way you end up in a spot where you need to fight the abstractions that were created because they don't account for the specific thing you need. A recent example from my work is using a big library to receive messages. They have an abstract class for the support of communication and function exposed such as read that is blocking and a function poll that is non blocking. For performance reasons, we would need the poll or read to be blocking (ie get the message as soon as it arrives) but also not just block indefinitely to be able to exit the program gracefully. What happened is the creators didn't thing of that and didn't provide a way of doing this. So now you either change their abstraction or find out by digging into their abstraction that in the end they always use posix sockets and just get a hold on those and block poll with timeout on those. In the end, the abstraction was wrong and the cost of modifying it was high for something that was trivial, and that's the problem, abstraction is not a replacement for dumb straight forward code that does what you need, it is a tool to make dumb staight forward code easier to write/read and understand.

I fell into a similar hole fairly recently when creating my own Result type. Semantic differences between errors can be expressed in much simpler ways that don't attempt to radically diverge from the standard way things are handled in JS. Extending the Error class achieves this handily, but given that you an throw anything in JS, you're not limited to just throwing errors (although that somewhat betrays the notion of writing "idiomatic" JS). Unsurprisingly, a good number of other languages have multiple ways to handle "errors," where some are arguably more aligned with this than others. Go has multiple return values for error handling, but also has panic and recover statements for unusual/extreme cases. Erlang/Elixir's exceptions aren't particularly unusual, but handling them is usually done at higher levels by supervisors, and is therefore reserved for something "unexpected" or generally unable to be handled, otherwise you just return error tuples and handle them with pattern matching. Rust has panics (that are technically recoverable) that are a much more severe form of runtime exceptions and Result types that you pass around for more intelligent handling. Haskell and OCaml are much like a middle ground between Elixir and Rust, with Exception and Option types, but unlike the BEAM languages, exceptions don't usually propagate as far and aren't used as often. After using my JS Result type for awhile, I got tired of dealing with it, though. It's nice to know that I'm handling something that can error when using JSDoc/TS, but it gets really tedious when I have to wrap every single IO operation or external dependency that could possibly fail. The second someone else touches the codebase, there's also no guarantee that the convention will be strictly followed unless I watch PRs like a hawk. Betraying the convention of a language really hampers productivity and the ease in which someone else can pick up where you left off, in my experience. It's probably a better idea to pick a different language with built-ins that cater to this idea than to try and force it into an ecosystem and runtime that isn't particularly friendly to it.

cool

you consistently have L takes on your channel - shows that you have never worked in the industry before (in any meaninful capacity). I wish you luck.

You can do it more simply with function submit() { const payload = Object.fromEntries( Object.entries({ name, email, favoriteColor }) .filter(([_, ref]) => ref?.value != null) .map(([key, ref]) => [key, ref.value]) ); post(payload); } Some of the utility libraries like Lodash/Underscore.js also give you access to a `mapValues` type utility function that does the same as above, but more efficiently and less code on your part. `zip`/`unzip` are also functions in these utility libraries that help a lot with this kind of object transformation and go tegether well with `fromEntries` / `toEntries`.

Love that you're learning and having fun :) this video made my brain hurt though ... this is a tutorial on what _not_ to do. Especially using reflection for something that can be solved with a standard. Clever code != Good Code. Bad habits all over the place.

Nice tip, though this makes me wonder how many people have read a book about javascript

Since undefined is not a valid JSON value, when it is serialized and sent to the server, the key should disappear (try JSON.stringify({"hello": null, "world": undefined})). Also you can simplify your code, return { [r]: r.value }

i would always submit all values even when null/undefined

Great observations, but I disagree with the proposed solution. Its not about docs, but about tests! Those are real world examples with schema, application, edge cases, short description. Tests must be consistent with code, docs just supposed to be. When I want to quickly catch-up how something works, I'm always looking for tests. So don't waste time on docs, write good tests!

Nice exploration. But over time you come to a realization that simpler is better, especially when you're working in teams. The abstraction you just made is not easily understandable and that might come to bite you in the future. Happens to me sometimes. That doesn't mean you stop doing that. Do it, you're mastering the language.

Just [r]: r.value wouldn’t work? [r] takes the name of the r variable and it can be used as an object key here

js without typescript is the enemy

This seems a lot like the concept of Errors As Values. Have you ever programmed with that paradigm? I agree a lot with you that thinking about your code in terms of a happy path and an unhappy path with the possiblity of invalid state is an absolutely fantastic way to model problems and code and I really like the way you have put it. If you haven't already, then I would suggest you try working in a language with 'Maybe' and or 'Error' types such as Rust, Go, Haskell, Ocaml or others. I think they are an absolutely brilliant way to write clear and correct code, with features such as Rusts "?" operator making the use of them often quite concise too.

I would disagree with you on a subjective point: The most important usage for abstraction is not avoiding copy+paste coding or even making it so a single change to the definition is propagated to all the callsites. Instead I would say that the most important usage for abstraction is about giving a clear and concise name to a block of code. It's an ability you don't have otherwise. When you think about abstraction like this, you still will want to abstract things even if the code isn't being reused in any way.

Also you have error in your opt function, it should return {[name]: value.value} in your case.

You overcomplicate things. all you can do is set your value, in your case "favoriteColor" to a value or "undefined". When you do your post request with "JSON.stringify" it remove undefined values from object. That's all. So you can do: {name: name.value, email: email.value, favoriteColor: favoriteColor.value || undefined} And if you need more checks, like validation, then turn it into ternary operator and add your conditions, for example: {name: name.value, email: email.value, favoriteColor: favoriteColor.value && /^#[0-9a-fA-F]{3,8}$/.test(favoriteColor.value) ? favoriteColor.value : undefined}

I think this is very helpful in large code bases where you work with other devs. I use assert() a lot and I don't likethrowing errors, so I mostly return some kind of result, it doesn't always have to be an object with a message, sometimes a simple false in case something went wrong is enough. When we do this, we lose an advantage of errors though which is bubbling including a stack trace. results don't bubble, you gotta do it manually whereas exceptions bubble automatically and include a lot of information. So in some cases, using exceptions is simply better. as always it depends

Have you tried Elixir? It handles errors similar to Go but has glorious pattern matching to more easily handle the returned value depending on if it has an error or not

ThePrimeagen is a big advocate for this concept, and he's mentioned many times that he uses asserts a lot, basically to catch bugs. If you can assert that a function or code module is being used as intended, you can greatly reduce a lot of bugs. I had actually used assert at work to ensure that a certain node module is never imported unless our application was started with a certain flag in the config, because if the module was loaded when that flag wasn't enabled, many other issues would occur. My coworker who reviewed my code wasn't a fan of the fact that we are basically defending the code against ourselves and suggested I remove it. I listened to their suggestion, but funnily enough, I accidentally added code that imported that module as part of another change they requested, and I introduced a bug in our software. If only the assert were still present, I would have caught it... Just thought I'd share a relevant story, I'm a huge fan of this kind of defensive programming, especially since it's so easy to compile asserts out of the binary for production builds, in many languages, so there's no performance downgrades. Subscribed via RSS!

also I think you should rename referp to attempt as that conveys the right meaning. referp makes me think you mean Refer "P" to X which conveys no further meaning about what P is or what it's for

14:06 In this scenario it's easier to just do "if ( i <= 0 ) return 0;" No need for excess calls and/or exceptions that add unnecessary bloat. But yeah I get what you're saying, it's why I named my "errors" as messages instead. If it's a message then it's not necessarily an unacceptable state, just one that needs to be handled.

Great video friend! To be honest, I hate functional programming. In my experience, the smarter a person who writes in a functional style is, the unmantenable their code is. I worked for several companies on scala, and as a rule there was always a smart productive developer who created code that just drove me crazy. In the last team, it reached the point of complete absurdity, they used code generation, and macros and the project simply could not get build on my working mac, the build required more RAM than my computer could give (no memory settings helped). As a result, I joined a team that rewrote everything they did in java in less than six months.

Interesting point, and I'm 100% pro good documentation. However, as an old coder, I know that this problem was solved a long time ago with Classes. If these vague raw objects were instances of "User" with a method called "isAdmin" and no public "admin boolean" then, boom, no problemo! The main issue is that it's trending to vilanize OOP so people are reinventing the wheel with what they think is functional programming.

I am so glad to hear someone actually talking about good software engineering rather than the over used OOP bullshit.

Love this video, a video on OOP would be great also