is the the um the writing by hand um because you know you can you can certainly write by hand and write down facts you know as well um 00:30:36 and uh and so yeah but i but what i what i do hold is that it's way way harder to uh store a lot of facts in 00:30:49 you know an analog settle costin because there's no copy paste you actually have to write out the facts by hand and as a result of that i think there are more benefits over digital in that you 00:31:02 are writing down uh neuro imprinting you know facts onto your mind that you can later recall more rapidly and stuff and um i think that's a benefit

Once you've written the imperative library/util code once, your components are super slim and completely reactive/declarative. Wow.

this action is re-usable. Anytime you want a typewriter effect added to an element, you just import the function and apply it. So elegant.

One of the consequences (although arguably not the primary motivation) of DRY is that you tend to end up with chunks of complex code expressed once, with simpler code referencing it throughout the codebase. I can't speak for anyone else, but I consider it a win if I can reduce repetition and tuck it away in some framework or initialisation code. Having a single accessor definition for a commonly used accessor makes me happy - and the new Object class code can be tested to hell and back. The upshot is more beautiful, readable code.

For pluggability, an endpoint is split into a Protocol and an Adapter part. This separates generic logic from environment-dependent code.

Why is all this interaction code better? Two reasons: One, you can reuse the FindAccount interaction in other places, like your API controller or a Resque task. And two, if you want to change how accounts are found, you only have to change one place.

You can optionally compose the steps manually (great for reuse) and just make use of the Runner#call method.

What does this mean for our runner? They get simpler and allow for quick reuse! Let's see.

we get the benefit of isolating request specific logic without cramming it into a ActiveRecord model that will be used in multiple controllers/actions

If you are working in a large enterprise application, we have to create small components. Small components are much more flexible in terms of reusability and maintainability.

or just make our components non configurable and copy paste all their code for each usage variation.

Reusability: you can take advantage of many already built validations and you can easily promote your custom validations to reusable ones.

You may want to reuse a list of curated third party validators without having to take the time to learn the signature of each validator.

Yes, you cannot fully express a modern app through templates without sacrificing flexibility and code reusability.

Even if a component is rendered just once, your design will improve if rendering twice doesn’t break it.

In contrast, Javascript-made templates can be organised into components with nicely decomposed and DRY code that is more reusable and testable.

This has already forced me to forgo Svelte Material because I would like to add some actions to their components but I cannot and it does not make sense for them to cater to my specific use-case by baking random stuff into the library used by everyone.

I've committed to using Svelte, so I want to see it become highly adopted and not die or lose steam. For that, I believe we need to build up the ecosystem. Shared components, actions, transitions, etc. which make it easier for ourselves and others to build apps. I feel this will help Svelte continue to grow and will make it a better tool for our jobs. I see actions as one of the needed pieces to make this happen.

Actions aren't necessary, otherwise they would have been implemented from the start. But they do allow for easier code-reuse and better shared libraries without exploding/complicating the ecosystem.

I think hooks will be beneficial to the Svelte ecosystem, making sharing code for Svelte apps that solve common problems easier.

As an alternative I have written component specific wrappers rather than generic wrappers.

We should also allow passing unrecognised props to the rendered component. eg: tabindex might be required on some instances of a component, and not all. Why should developers have to add tabindex support to their components just that it may potentially be used

This would be a component that is meant to be styled by its parents, and it would make no logical sense to have every possible type of style available inside the Link component. If I wanted to turn one of these anchor tags into a button, another into a nav-link, and another into a footer link, I should be able to. There's no reason that there shouldn't be a feature to treat a component like a normal HTML element.

The key to successfully creating reusable components using both render props and scoped slots is being able to correctly separate behavior from presentation. Each time you create a new UI component, think “What is the core behavior of this component? Can I use this anywhere else?”