But library users are more numerous, and so their needs are more important.

remember that the needs of the many outweigh the needs of the few

small modules allow library authors to become lazy. Why include that six-line helper function when you can do a one-line `require`?

These are all things that make your life as a library author easier.

possibly making it harder for them to appreciate how severe the discoverability issues are for the rest of us.

I think I know why: it’s because the small modules philosophy favours library authors (like Sindre) at the ultimate expense of library users.

What I believe should happen is the Svelte compiler should, when a promise is passed to onMount, realise that a promise has been passed, and await the result of the function to be used as the onDestroy function. i.e, it should behave the exact same way for an async function as it does for a non-async function (if this is possible)

answered

Also Svelte is so great because developer do not need to worry about class names conflict, except of passing (global) classes to component (sic!).

Thank you, but this answers the question and means I will be unable to use svelte.

The problem with working around the current limitations of Svelte style (:global, svelte:head, external styles or various wild card selectors) is that the API is uglier, bigger, harder to explain AND it loses one of the best features of Svelte IMO - contextual style encapsulation. I can understand that CSS classes are a bit uncontrollable, but this type of blocking will just push developers to work around it and create worse solutions.

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.

The main rationale for this PR is that, in my hones opinion, Svelte needs a way to support style overrides in an intuitive and close to plain HTML/CSS way. What I regard as intuitive is: Looking at how customizing of styles is being done when applying a typical CSS component framework, and making that possible with Svelte.

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.

For my point of view, and I've been annoyingly consistent in this for as long as people have been asking for this feature or something like it, style encapsulation is one of the core principles of Svelte's component model and this feature fundamentally breaks that. It would be too easy for people to use this feature and it would definitely get abused removing the style safety that Svelte previously provided.

This is a framework and it comes with certain opinions about how things should be done, this isn't unique to Svelte. And before we can decide whether or not we will allow certain behaviour or encourage it with better ergonomics, we have to have a conversation about whether or not we should be doing things that way. You can't separate the can from the should in an opinionated framework. We want to make building UIs simpler, for sure, but also safer we don't want to add ease of use at the expense of component encapsulation, there has to be a balance

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.

I like use. But we would still need a noun to reference them by in the docs or libraries.

one problem with 'behavior' is that's the terminology we use to describe all of a component's encapsulated logic — methods, transitions, etc.

<LazyLoad component="img" data-src="giant-photo.jpg" class="my-cool-image" />

<LazyLoad> <img data-src='giant-photo.jpg'/> </LazyLoad>

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.

I'm just pushing on the "is this really a good idea" front

You must: reference each element you are extending using refs or an id add code in your oncreate and ondestroy for each element you are extending, which could become quite a lot if you have a lot of elements needing extension (anchors, form inputs, etc.)

This is where hooks/behaviors are a good idea. They clean up your component code a lot. Also, it helps a ton since you don't get create/destroy events for elements that are inside {{#if}} and {{#each}}. That could become very burdensome to try and add/remove functionality with elements as they are added/removed within a component.

While there is some precedence in other frameworks for using as, the word doesn't fit well. Since you are adding functionality to elements I like the word add better (and it only has 1 more character).

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>

But some sort of official way to do that in the language would make this nicer - and would mean I would have to worry less about destroying components when their parent is destroyed, which I'm certainly not being vigilant about in my code.

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.

On the other hand, we could impose restrictions to the feature in order to avoid these hard paths.

I'll work on a preliminary PR (which I expect will need some love from maintainers, sorry!)

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.

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 };

LOD was defined as <x>bi + ksbi, where <x>bi equals the mean of the no-template controls, sbi is s.d. of no-template controls and k = 2.479 (99% confidence interval)

yet when I thought of my beloved Elizabeth, of her tears and endless sorrow, when she should find her lover so barbarously snatched from her, tears, the first I had shed for many months, streamed from my eyes,

They might even hate each other; the creature who already lived loathed his own deformity, and might he not conceive a greater abhorrence for it when it came before his eyes in the female form? She also might turn with disgust from him to the superior beauty of man; she might quit him, and he be again alone, exasperated by the fresh provocation of being deserted by one of his own species.

There arethree different organizations responding to the flood

As I got near the shore, the clouds gathered black, and the rain came down, drifting in great white sheets of water before the wind. I heard the thunder of the sea on the sand-bank at the mouth of the bay

I don’t want to force my opinion on you

“The Last Rose of Summer”

the gentlemen who make a business and a living out of writing books

React Aria separates the behavior and accessibility implementation for many common UI components out into React Hooks, which enables them to be reused easily between design systems. You remain in complete control over the rendering and styling aspects of your components, but get most of the behavior, accessibility, and internationalization support for free.

This leads to web developers at every company needing to rebuild every control from scratch. This represents millions of dollars of investment for each company to duplicate work that many other companies are also doing.

Modern view libraries like React allow teams to build and maintain these components more easily than ever before, but it is still extraordinarily difficult to do so in a fully accessible way with interactions that work across many types of devices.

Yup, which was released six years ago, is obviously a more popular choice at this time. Zod is smaller in size, probably because it doesn’t have as many APIs as Yup, but it’s sure to grow as more features are developed.

If I - knew what his plan was, if I knew what Peter was doing, if I just - (he stops, cuts himself off) Can I? [The low rumble of the Archivist’s static begins to sound in the background. The Archivist makes a few sounds of effort, which begin to grow both louder and more ragged.] [Then the high-pitched static that resembles microphone static layers itself on top with its strange, musical, near-angelic quality, and it becomes clear that the Archivist is putting a lot of effort into this Beholding, and that, as in “Heavy Goods,” it is not clear how much of this he is in control of.] [He continues to struggle through the process, and as he does, the distinct squeaky static of Peter Lukas begins to fade in as well.] [There’s a sound that’s difficult to place, could possibly be some things knocked off of the Archivist’s desk, but which could also be the sound of a door opening. The Archivist groans.] [Then all at once, the static all fades out; the Archivist begins to regain his breath.]

style tags don't currently need to be taught outside of 'this is scoped and safe'.

But what we should ask is "can we do better than the others".

What we don't want to happen is to bless an approach that inverts this control, allowing an arbitrary parent to impact the inner-workings of a component.

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.

I understand what you're getting at, but we shouldn't miss out on useful features just because a few developers will abuse it...

The custom code "fills in the blanks" for the framework, such as supplying a table of menu items and registering a code subroutine for each item

in traditional programming, the custom code that expresses the purpose of the program calls into reusable libraries to take care of generic tasks, but with inversion of control, it is the framework that calls into the custom, or task-specific, code.

There is interactive state as well. What about modals that come up because something is clicked? What is the active tab? Is this menu open or closed? What scroll position are they at? There are infinite permutations of this. Imagine a warning bar that shows up seven seconds after the user logs in to warn user about their expired credit card which contains a custom styled select menu which can be in an open or closed state, but only on the user settings page.

Remember the timing thing? We might think of timing as one generic form of state. There are countless other things that could be state related. Is the user logged in or not? What plan are they on? Is their credit card expired thus showing some kind of special message? Do situational things like time/date/geolocation change state? What about real-time data? Stuff from an API?

It gets worse when you're working on a team. No-one dares touch styles authored by someone else, because it's often unclear what they're doing, what markup they apply to, and what disasters will unfold if you remove them. The consequence of all this is the append-only stylesheet. There's no way of knowing which code can safely be removed, so it's common to undo some existing style with another, more specific style — even on relatively small projects.

It’s become increasingly common to divide code into components, rather than by file type. React, for example, allows for the collocation of a components markup and JavaScript. In Svelte, this is taken one logical step further: the Javascript, markup and styling for a component can all exist together in a single `.svelte`​ file

Tree of Life

The old mydata and the new mydata are actually the same physical object (only the object’s internal value changed)

I think it'd be nice to find a solution where it's a lot easier to mix React and Svelte components like this, but unfortunately I think that's out of the scope of this library.

React is an isomorphic/universal framework. That means that there is a virtual representation of the UI component tree, and that is separate from the actual rendering that it outputs in the browser.

Chapter 12Tuples

Chapter 10Lists

Chapter 8Strings

loss of Silesia

Thus, Confucius meditated upon water; and the Confucian Xunzi later attempted to systematize the relationship between water’s various forms and people’s moral qualities. This assumption of a correspondence between the principles which inform both water and human conduct was not limited to the Confucians; it was generally assumed in all early philosophical texts. Nor was the imagery the provenance of any particular school. For example, water which moves forward without force, giving life to everything, is described in Xunzi as ‘wuwei’ (without action) or (doing nothing) a term that is particularly associated with Daoism.

First class TypeScript support means that both of these two systems do a good job of handling TypeScript code.

Looking forward to the upcoming property management trends, there will be a wider range of opportunities, some big economic and social shifts, and a set of new technological trends upping the future of housing market sales numbers across the world.

The moral hazard of gameplay is basically a mismatch between what your goals are and what you’re incentivizing.

Chickering and Gamson (1987), forexample, suggested seven principles were central to suchteaching: encouraging faculty/student contact, developing reci-procity and cooperation among students, using active learningstrategies, offering rapid feedback, emphasizing time on task,communicating high expectations, and respecting diversetalents and ways of learning.

we assessed the learner-centeredness of 109 syllabi sampled from Project Syllabus

what may be nice here would be to allow the user to specify an event to run validation with, and to remove it from the exported handleChange. This way handleChange is responsible exclusively for updating the value in the store, and actions are responsible for updating the error state.

Argentina Argentina Brazil Peru Colombia Uruguay Chile Mexico EN

require 'minitest/autorun' class BugTest < Minitest::Test

Turns out, there’s a dedicated “Individual Account Appeal Form” where they ask you a list of privacy-touching mandatory questions, progressively shifting the Overton window

In the real world — the time to pay off technical debt is scarce — in most of the time fueled by the fear of the unknown. The management loves to milk the cow but not to change the litter. The developers on another hand avoid modernizing legacy code — to avoid trouble in case anything breaks.

First, let’s figure out how you’re going to pay for it. If you don’t have insurance (or even if you do), there are resources available to you at no cost. Consider looking into Federally Qualified Health Centers, community-based centers that offer care including mental health and substance use services

The coronavirus pandemic has created a paradox in mental health care: Widespread social distancing means that more people are in need of support for anxiety and depression, and that more of those resources are harder to access in person. The past several weeks, though, have wrought a change in the national mental health care landscape — a big shift of services and social safety nets from face-to-face meetings to virtual ones.

At this point, you start to engage your mind and dig into the work required to understand what’s being said. I highly recommend you use marginalia to converse with the author.

Analytical reading is a thorough reading. If inspectional reading is the best you can do quickly, this is the best reading you can do given time.

Systematic skimming

Inspectional Reading We’ve been taught that skimming and superficial reading are bad for understanding. That is not necessarily the case. Using these tools effectively can increase understanding. Inspectional reading allows us to look at the author’s blueprint and evaluate the merits of a deeper reading experience.

Burn bosses in California can more easily be held liable than their peers in some other states if the wind comes up and their burn goes awry. At the same time, California burn bosses typically suffer no consequences for deciding not to light.

Much of the fire-suppression apparatus — the crews themselves, the infrastructure that supports them — is contracted out to private firms. “The Halliburton model from the Middle East is kind of in effect for all the infrastructure that comes into fire camps,” Beasley said, referencing the Iraq war. “The catering, the trucks that you can sleep in that are air-conditioned…”

For example, to search for text occurrences, I used ack-grep. Later on, I found that there is a faster approach using ag. Then, there is an even faster alternative called ripgrep.

Can't upvote this enough. It is highly irritating to see language destroyed (and we wonder why kids bastardize the language..).

As a web designer, I hate that "log in" creates a visual space between the words. If you line up "Log In Register" - is that three links or two? This creates a Gestalt problem, meaning you have to really fiddle with spacing to get the word groupings right, without using pipe characters.

I'm increasingly seeing 'login' used as a verb. And to be honest, once it's normalised it will be the correct form.

I don't doubt that we will soon treat the process of logging in as a figurative point of entry, meaning that log into will make full conceptual sense (cf you don't physically delve into a problem or pile into an argument, yet both are correct grammatically because they are semantically [i.e. figuratively])

Do not include the same information in multiple places. Link to a SSOT instead.