This PR replaces nested require statements in files in vendor/postcss with import declarations, so that they can be properly resolved at build time.

there's a major problem with all of this instantaneous communication:  It doesn't leave time to think.

And now it won't let me edit my comment. (I always find that time limit for editing annoying.)

Once again, this isn’t good or bad, it’s just the most efficient way to create something that is similar to something else

The only "issue" it has is that its unfamiliar. People have been working with HTML for years and are comfortable with it. That's basically the only reason that people find it more readable. If you make an effort to spend sometime with hyperscript, it becomes as familiar and readable as jsx.

Moreover, React team even removed the “highlight updates” feature from dev tools because people used to obsessively haunt wasted renders with no reasoning behind it

The perdurantist view is that an individual has distinct temporal parts throughout its existence.

I’d still be interested in Svelte making things easier so I’ve opened a feature request for Reactive statement cleanup functions.

I'm not sure I understand the problem, everything you are describing is already possible.

30-min pre-incubation of inhibitors and BTK

As programmers, we’re kind of inherently built to want the ABSOLUTE BEST HIGHEST FIDELITY FORMATS OF ALL TIME. Like dammit, I need the timestamp down to the micromillinanosecond for every cheeseburger that gets added to my bespoke Watch-The-BK-Throne app. If I do not have this exact knowledge to the millisecond of when I consumed this BBQ Bacon WHOPPER® Sandwich From Burger King® I may die.

Unfortunately people lack the the time to invest to really understand those things

Over time Adam, Surplus' creator, had less and less time to spend on the project and I decided to take my own shot.

Although I also work with solid in my day job at inrupt, I wrote this guide in my spare time.

“Yes. My objection is, that your proposal obliges us to wait.”

But when you’re using Svelte within a larger Rails app, you probably already have a CSS system in place and there’s no reason to change that. You can just use the same CSS classes as you do elsewhere in your app, and everything will be fine.

Svelte will not offer a generic way to support style customizing via contextual class overrides (as we'd do it in plain HTML). Instead we'll invent something new that is entirely different. If a child component is provided and does not anticipate some contextual usage scenario (style wise) you'd need to copy it or hack around that via :global hacks.

Explicit interfaces are preferable, even if it places greater demand on library authors to design both their components and their style interfaces with these things in mind.

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.

The point of the feature is to not rely on the third-party author of the child component to add a prop for every action under the sun. Rather, they could just mark a recipient for actions on the component (assuming there is a viable target element), and then consumers of the library could extend the component using whatever actions they desire.

Your LazyLoad image is now inextensible. What if you want to add a class? Perhaps the author of LazyLoad thought of that and sets className onto the <img>. But will the author consider everything? Perhaps if we get {...state} attributes.

You'll have to create a new component that brings in the functionality of both. TooltipButton, TooltipLink, Link, and TooltipRoutedLink. We're starting to get a lot of components to handle a bit of added functionality.

For the tooltip example, if you had a whole bunch of tooltips on different elements, it would be annoying to have different event listeners and "should it be shown" variables for each one.

Perhaps at that point we're better off settling on a way to pass components through as parameters? <!-- App.html --> <Outer contents={Inner}/> <!-- Outer.html --> <div> <div>Something</div> <[contents] foo='bar'/> </div>

I would hope for it to come with React-like behavior where I could pass in a string (like div or a) and have it show up as a normal div/a element when the child component used it.

Use case: Wrapper components that need to render an element (e.g. because they attach event listeners). You'd probably use a <div> there by default but there may be places where this is not desirable for semantic reasons (e.g. in lists).

const components = { Label, Tree, Menu };

The lack of spread continues to be a big pain for me, adding lots of difficult-to-maintain cruft in my components. Having to maintain a list of all possible attributes that I might ever need to pass through a component is causing me a lot of friction in my most composable components.

cross-validation is sometimes not valid for time series models

The feature is highly likely to be implemented, the API and implementation are the only real topics of discussion right now.

Three tests to prove a small piece of behavior. Although it might seem overkill for such a small feature, these tests are quick to write—that is, once you know how to write them

(At the point at which it does make sense to turn this into a separate Tooltip.svelte component, the extraction is a completely mechanical process that could even be automated by tooling.)

6to5 attempted to ship a quick and dirty TDZ static checking feature but had to retract it immediately afterwards due to various bugs in the algorithm.

Sometimes answering a single question can be very time consuming (such as setting up a benchmark), but discussions tend to stall out if concerns don't get thoroughly addressed.

For example, you might want to use the browser’s knowledge of the user’s current time zone to group a collection of elements by date.

I have a theory that time scarcity is also linked to something I'll call time scatteredness. This happens when you really have no idea how long it takes us to complete tasks, and this skews how much time you think you have or need.

it’s a wise idea to begin tracking your time in order to get a more realistic handle on how long specific projects and tasks take you. That’ll override your optimism bias and keep your expectations for your own productivity in check.

Pushing a deadline back once is one thing. Needing to do it over and over again will make it appear as if you don’t know how to manage your own workload.

GTD strategies

19th century

late 1700s

3,000 years ago

back much further

possibly oldest

1896

goes back more than 2,000 years to the Han Dynasty

ancient times

prehistory

ancient

19th century

mid 20th century

over 5,000 years

oldest known group of dogs in existence today

17th-century

1920s

since ancient times

1930s

1539

1200 BC

medieval

ancient

4,000 years

thousands of years

from at least the 1600s

mid- to late 19th century

13th-century

1800s

early 1800s

since the Middle Ages

17th century

hundreds of years ago

since the time of Charlemagne

the 15th century