You should default to the most permissive option imo and there really is no reason to check anything until you really need to If it were left to me I'd just use optional chaining, as it also eliminates the need for no-ops

In other words, programs that send messages to other machines (or to other programs on the same machine) should conform completely to the specifications, but programs that receive messages should accept non-conformant input as long as the meaning is clear.

be conservative in what you do, be liberal in what you accept from others

"Headless Tippy" refers to Tippy without any of the default element rendering or CSS. This allows you to create your own element from scratch and use Tippy for its logic only.

It's a generic abstraction for the logic and styling of elements that pop out from the flow of the document and float next to a reference element, overlaid on top of the UI.

A cleaner approach could be the use:action API.

Popper has a sole goal: position elements. That's why we call it a "positioning engine" and not a "tooltip library".

Popper for Svelte with actions, no wrapper components or component bindings required! Other Popper libraries for Svelte (including the official @popperjs/svelte library) use a wrapper component that takes the required DOM elements as props. Not only does this require multiple bind:this, you also have to pollute your script tag with multiple DOM references. We can do better with Svelte actions!

Progress is made of compromises, this implies that we have to consider not only disadvantages, but also the advantages. Advantages do very clearly outweigh disadvantages. This doesn’t mean it perfect, or that work shouldn’t continue to minimize and reduce the disadvantages, but just considering disadvantages is not the correct way.

How do you know this? I've looked all over the internet and can't find any proof that Lightdm is more "lightweight" (whatever this means) or faster.

O tucano Orlando Morando, de São Bernardo do Campo, diz que não há a menor chance de fazê-lo em um futuro próximo e que tem doado parte de seu salário correspondente a um aumento concedido na gestão anterior com o qual não concordou.

Heading hierarchy. Don't skip heading levels. In order to solve this problem, you need to separate the semantics from the style.

Dropped FFmpeg support (focus on primary functions instead)

you can set up notifications to alert you to new recommendations

Jbuilder gives you a simple DSL for declaring JSON structures that beats manipulating giant hash structures. This is particularly helpful when the generation process is fraught with conditionals and loops.

The Web Storage API provides mechanisms by which browsers can store key/value pairs, in a much more intuitive fashion than using cookies.

I guess it's about "preloading" and not "navigation", if it's the case, then I guess there is still no way to attach to navigation events, and this issue should be kept open.

No JS event is fired, so there currently isn't any clean way to do this that I can see.

I tried leaking session and page data and indeed it's easy. Too easy. So I definitely agree that session data should not be readable from anywhere but the request itself.

Like JSON.stringify, but handles

it focuses on compiling non-standard language extensions: JSX, TypeScript, and Flow. Because of this smaller scope, Sucrase can get away with an architecture that is much more performant but less extensible

Phantom emotionsPsychological determinants of emotional experiences on the InternetAzy Barak

You can afford to make a proper PR to upstream.

No more waiting around for pull requests to be merged and published. No more forking repos just to fix that one tiny thing preventing your app from working.

Some devs prefer Svelte’s minimal approach that defers problems to userland, encouraging more innovation, choice, and fragmentation, and other devs prefer a more fully integrated toolkit with a well-supported happy path.

It’s worth mentioning that Svelte limits its scope to being only a UI component framework. Like React, it provides the view layer, but it has more batteries included with its component-scoped CSS and extensible stores for state management. Others like Angular and Vue provide a more all-in-one solution with official routers, opinionated state management, CLIs, and more. Sapper is Svelte’s official app framework that adds routing, server-side rendering, code splitting, and some other essential app features, but it has no opinions about state management and beyond. Some devs prefer Svelte’s minimal approach that defers problems to userland, encouraging more innovation, choice, and fragmentation, and other devs prefer a more fully integrated toolkit with a well-supported happy path.

It’s worth mentioning that Svelte limits its scope to being only a UI component framework. Like React, it provides the view layer, but it has more batteries included with its component-scoped CSS and extensible stores for state management.

If you'd prefer, you can use a third-party library like Modernizr or Detect It to do this test for you.

I think the main difference between the two are the way API are served. Some smelte components need you to input big chunk of json as props, while i prefer keep props as primitive types and in the other hand give you different components tags to compose.

These are sequential because build:ssr imports the public/index.html that build:dom produces.

The answer should be: you write a language that compiles to Go’s IR.

delete myObject.regex; // or, delete myObject['regex']; // or, var prop = "regex"; delete myObject[prop];

dfn export for=tree

After i've stabilized the library i can start to discuss about adding new components and features!

Svelte makes the pit of success larger because it hides all of this from us at compile time.

Another difference is that context in Svelte does not insert anything into the visual component tree. There is no <Context.Provider> element like in React

So handling the interop upfront will avoid users writing invalid ES6 and make sure that they write ES6 that loads CommonJS in the right way.

If everyone did this, the repair shops would be out of business.

Used by folks at

This nested if blocks seems a bit untidy and confusing to me but I've also failed to come up with a clearer way.

i like working on application frameworks, compilers, interpreters, and emulators.

but know I know what I don't want to do. I definitely know I want to be an Engineer now, and it makes it more clear that I should start my own business.

I encounter this problem in all of my Svelte projects- feels like I'm missing something. Fighting it with absolute positioning usually forces me to re-write a lot of CSS multiple times. Is there is a better way to solve this that I've overlooked?

Converting Angular components into Svelte is largely a mechanical process. For the most part, each Angular template feature has a direct corollary in Svelte. Some things are simpler and some are more complex but overall it's pretty easy to do.

We expect a certain pattern when validate devtool name, pay attention and dont mix up the sequence of devtool string. The pattern is: [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map.

I've only done components that need to/can be Svelte-ified. For some things, like RTL and layout grid, you can just use the MDC packages.

can you not also use a .babelrc?

This is very annoying and I think there must be a better solution.

Obviously we shouldn't rush into anything. But changes like these are best made earlier on in a project's lifecycle, so I'm eager to hear what people think so that we can start making some progress.

Some of the verbs implemented by systemctl are designed to provide a high-level overview in a human readable format. All that information is available over dbus, and/or journalctl, systemctl show. We could provide that information in json format, but there's a second problem. Information and format of information printed by e.g. systemctl status is not stable. Since the output is not suitable for programmatic consumption anyway, there's no need to provide it in a machine readable format.

In principle, this information is already available through other means, but it is actually a fair amount of work to gather it in this form, and I think it could be useful to open it up to programmatic consumption.

Although I agree that -o json should return proper JSON, believe the proper way for external tools like SaltStack etc. to talk to systemd is DBus. See also saltstack/salt#20392 - everything else is more or less just hack-ish and prone to break easily.

If you have a better/simpler/"more official" solution, I'd still love to see it!

is this solution considered a hack or is something that we can use as an approved workaround in scenarios where we need to manually trigger validations?

The more official way to do this would be to run the check (you could even reuse this.validate) in onSubmit.

Focus on your application: forget about forms details like I'm dirty, field touched...

You may want to execute validations in a given specific order (this can be tricky especially when you have got asynchronous validations).

You can try to build a solution to tackle these issues on your own, but it will cost you time and money... why not use a battle-tested solution to handle all this complexity?

If you want to implement a form with a superb User Experience, you have to take care of many variables:

Form validation can get complex (synchronous validations, asynchronous validations, record validations, field validations, internationalization, schemas definitions...). To cope with these challenges we will leverage this into Fonk and Fonk Final Form adaptor for a React Final Form seamless integration.

Managing Form State (holding field information, check if a control has been touched, if the user has clicked the submit button, who owns the current focus...) can be tedious and prone to errors. We can get help from React Final Form to handle these challenges for us.

In the software industry we use "dependency" to refer to the relationship between two objects. We say "looking for dependents" for relationships to dependent things and "looking for dependencies" for relationships to prerequisite things, so it gets that connotation, but the literal meaning is the relationship itself, not the object. Finding a better word is exactly the point of the question

But it sounds like the library could use some way to setTouched()

I highly recommend setting a higher bound on the number of returned entities by each resolve function in your code.

Yeah I see what you're saying. In my case, I had a group of classes that relied on each other but they were all part of one conceptual "module" so I made a new file that imports and exposes all of them. In that new file I put the imports in the right order and made sure no code accesses the classes except through the new interface.

Doing so also means adding empty import statements to guarantee correct order of evaluation of modules (in ES modules, evaluation order is determined statically by the order of import declarations, whereas in CommonJS – and environments that simulate CommonJS by shipping a module loader, i.e. Browserify and Webpack – evaluation order is determined at runtime by the order in which require statements are encountered).

Specifically, since Root, Rule and AtRule all extend Container, it's essential that Container is evaluated (and therefore, in the context of a Rollup bundle, included) first. In order to do this, input.js (which is the 'gateway' to all the PostCSS stuff) must import root.js, root.js must import rule.js before it imports container.js, and rule.js must import at-rule.js before it imports container.js. Having those imports ensures that container.js doesn't then try to place Root, Rule or AtRule ahead of itself in the bundle.

Replaced nested `require` statements with `import` declarations for the sake of a leaner bundle. This entails adding empty imports to three files to guarantee correct ordering – see https://github.com/styled-components/styled-components/pull/100

Modules from the following layer can require anything from all the previous layers, but not vice versa.

Any software that makes HTTP requests to other sites should make it straightforward to enable the use of a cache.

Note that the <WarningEngine/> component must be at the bottom of the form to guarantee that all the fields have registered.

Wondering how to get field state from multiple fields at once? People coming from Redux-Form might be wondering where the equivalent of Redux Form's Fields component is, as a way to get state from several fields at once. The answer is that it's not included in the library because it's so easy to write one recursively composing Field components together.

Use ponyfill.com for linking here.

formvalidation: path.resolve

import luhn from 'formvalidation/algorithms/luhn';

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

I'm okay with an overall design that allows people to plugin the parts they need in order to be able to generically support a compile-to-javascript language, but to bake in support for one singular solution because its popular is simply bad engineering.

Of all the compile-to-languages, the one that strikes me as having the least merit is JSX. It's basically a ton of added complexity for the sake of what boils down to syntax. There are no real gains in terms of language semantics in JSX.

Furthermore, JSX encourages bad non-dry code. Having seen a lot of JSX over the past few months, its encourages copypasta coding.

For event listeners we support the standard jsx naming convention onEventname (this is converted to on:eventname in svelte) as well.

An onevent event handler property serves as a placeholder of sorts, to which a single event handler can be assigned. In order to allow multiple handlers to be installed for the same event on a given object, you can call its addEventListener() method, which manages a list of handlers for the given event on the object.

However, in practice I do not think these tradeoffs are enough to justify logic-less templates.

Cons aren't covered by pros.

An alternative (maybe not good) would be to restrict {@const} to certain blocks like {#each} and {#if}. In both cases, it significantly reduces the "multiple ways to do the same thing" problem and avoids ergonomic and performance overhead of our current situation.

it also allows for more divergence in how people write there code and where they put their logic, making different svelte codebases potentially even more different due to fewer constraints. This last point is actually something I really value, I read a lot of Svelte code by a lot of different people and broadly speaking things look the same and are in the same places.

Svelte should make something like useEffect part of the framework so that this could work better and be less verbose.

I do like the direction Svelte is heading but I think this is one area that could be improved.

I'm suggesting there should be a way to write lifecycle related code that also responds to changing props, like how useEffect works. I think how React handles this could be a good source of inspiration.

I think it just needs a few changes, possibly non-breaking additions, to be as powerful as hooks, when it comes to abstracting lifecycle related logic, and making it easy to keep effects in sync with props.

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

If Svelte came up with some kind of hooks like API maybe it could solve both these issues at once.

It provides several capabilities that are difficult to achieve with React alone, while being compatible with the newest features of React.

For reasons of compatibility and simplicity, it's best to use React's built-in state management capabilities rather than external global state.

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

Disclaimer: I’m new to Svelte so this isn’t so much a recommendation as it is a “I guess this is a way to do it 🤷‍♂️”

A “solution” to GR is more like a model in logic: it may satisfy a theory’s axioms but have other properties that are contingent (unless the theory is categorical, meaning that all of its models are isomorphic).

Solid supports templating in 3 forms JSX, Tagged Template Literals, and Solid's HyperScript variant.