This was implemented (completely differently to anything discussed in this issue) in #642.

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

Like JSON.stringify, but handles

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 true that Svelte does not allow you to map over children like React, but its slot API and <svelte:component> provide similarly powerful composition. You can pass component constructors as props and instantiate them with <svelte:component>, and use slots and their let bindings for higher order composition. It sounds like you're thinking in virtual DOM idioms instead of Svelte's.

However, Svelte isn't React or Vue or any other framework, the same approach will not always work and given that Svelte has very different constraints and approach that works well in another framework is not suitable with Svelte. Trying to apply approaches use with other frameworks to Svelte will invariably end in frustration.

Each area requires specific learning and thinking in a certain way. Front-end is user centric, back-end is closer to algorithms and parallel programming, databases require thinking in streams of data based on a model (similar to set theory and model checking).

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.

That’s how developers create buttons — they add padding to their div containers, not heights.

Programmers working in different kinds of programming languages often come up with radically different solutions to problems.

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

Not being cancelable makes validating dialog content impossible - eg a login dialog or anything that takes user input. Of course, it's easy enough to get around - but I think this should be a requirement of a dialog.

Depending on your needs, you can use the Simple Approach: Wrapping MDC Web Vanilla Components, or the Advanced Approach: Using Foundations and Adapters.

I'm excited for the RTM of webpack 2!

I think it would be much better to whitelist registries

There are a few intentional behavioral differences between Dart Sass and Ruby Sass. These are generally places where Ruby Sass has an undesired behavior, and it's substantially easier to implement the correct behavior than it would be to implement compatible behavior. These should all have tracking bugs against Ruby Sass to update the reference behavior.

You’ll learn how to cause stack overflows, illegal memory access, andother common flaws that plague C programs so that you know what you’re upagainst

Thanks for the PR @RedHatter. I think it's important to be able to specify which warnings are being disabled, and I'm nervous about the use of the code frame for this sort of thing (feels brittle), so I've opened a new PR, #3351. Will close this in favour of that

You will want to report this as follows:

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.

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.

http://jonudell.info/h/tag-rename-02.mp4

Please don't copy answers to multiple questions; this is the same as your answer to a similar question

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?

Library author here. I'm always fascinated by new ways people can invalidate my assumptions. I mean that in a sincerely positive way, as it results in learning.

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

This is a philosophical issue, I think. People (and presumably form libraries) have different definitions of what "dirty" means. Yours: "The field has ever been edited" Mine: "The value of the field is different from the initial value"

I'm afraid there's only so much the docs & tutorials can do about something like this actually. When you first read them, you don't get Svelte well enough (since you're reading a tutorial...) for this to make sense to you. Then you try something, encounter a behaviour, question it, understand better... That's learning.

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

Identify your user agents When deploying software that makes requests to other sites, you should set a custom User-Agent header to identify the software and provide a means to contact its maintainers. Many of the automated requests we receive have generic user-agent headers such as Java/1.6.0 or Python-urllib/2.1 which provide no information on the actual software responsible for making the requests.

formvalidation: path.resolve

import luhn from 'formvalidation/algorithms/luhn';

FI:

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

http://facebook.github.io/jsx/#why-not-template-literals (respectfully disagree)

I've recently started playing with segmentio/deku, an alternative to React, and I'm also using Babel to transpile my js and jsx code.

Deku is a library for rendering interfaces using pure functions and virtual DOM.

Svelte chooses a reverse approach.

About the argument against it, "{@const will make code less consistent ": I think the same is true now, since people can come up with very different ways of dealing with the "computed value inside each loop/if function" problem. Some extract components, some use functions, some will prepare the array differently beforehand.

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

Svelte doesn't re-render, so you need to respond to component mount/dismount and prop changes separately as they are distinct concepts and never tied together, unlike in React.

While react hooks were one of the catalysts for v3 we don't agree with with the APIs or the model and won't be emulating it.

Sometimes, you may be tempted to write that wrapper. Because all your (React or Vue or insert your reactive framework here) instincts tell you so.Resist the temptation. There is a better way. A svelter way. Introducing: the use-directive (a.k.a. “actions”).

However, especially when starting out, it’s very easy to fall into the “this is how I did things in my previous framework” trap.

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 🤷‍♂️”

but everything they were doing started to make sense

MobX - for me personally MobX is a far better way to manage state than React Hooks. It doesn't care about the UI layer so it can be used outside the React ecosystem, and it's simple to mutate data.

This library exports a single React Hook, useMethods, which has all the power of useReducer but none of the ceremony that comes with actions and dispatchers.

But maybe this PR should still be merged until he finds time for that?

By default, npx will check whether <command> exists in $PATH, or in the local project binaries, and execute that. Calling npx <command> when <command> isn't already in your $PATH will automatically install a package with that name from the NPM registry for you, and invoke it. When it's done, the installed package won’t be anywhere in your globals, so you won’t have to worry about pollution in the long-term. You can prevent this behaviour by providing --no-install option.

As you can see, it uses Javascript label syntax to tell the compiler where recalculation should be carefully managed. And you thought that no one uses labels any more.

While Webpack is focused on using CommonJS as its primary module system and converting everything to that, Rollup decided to take the opposite approach — focusing on ES Modules instead.

Unfortunately, many third party libraries, even though they are written in ESM, are published to npm as CJS modules, so we still need to concatenate them.

But this is only a halfway decent way to clarify that this is an external dependency, because the only way to resolve a peer dependency warning is to install react from npm—there's no way to notify npm that you resolve the dependency to a browser global. So peer dependencies should be avoided in favor of external declarations. Then Rollup will take care of warning about "unresolved dependencies", even if external declarations can't express a particular version range with which your library is compatible like peer dependencies can.

There are two ways of handling this with Rollup, as described by the troubleshooting link from the warning. Unfortunately, both Rollup and React recommend the wrong one.

Luckily, there is absolutely no good reason not to use strict mode for everything — so the solution to this problem is to lobby the authors of those modules to update them.

The recommended solution for onMount is the same as for useEffect — place an async function inside the handler

If you want this control then wrap them in a DOM node that the parent controls. If you want to pass in values then use props and if you want to pass in values from higher up the tree, the new style RFC may be able to help.

I think Svelte's approach where it replaces component instances with the component markup is vastly superior to Angular and the other frameworks. It gives the developer more control over what the DOM structure looks like at runtime—which means better performance and fewer CSS headaches, and also allows the developer to create very powerful recursive components.

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

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

You should install the packages individually. Alternatively, you can install all of them at once with the svelte-material-ui package.

I don't plan to push this to npm, cause I'm in favour with Deno's approach.

There are tools in Svelte that break this expectation to a degree, but they are a bit annoying to use, which makes it an active decision on the part of the developer. The API hints at the way we want you to do things because we feel that this will give the better experience.

Most of the linked issues, as well as this RFC, attempt to solve this problem by relaxing Svelte's CSS scoping rules, providing a better API with which to use global, or by manually passing down classes. We have never found this to be an acceptable solution which is why those issues have been closed. That position has not changed.

Or if we formally took a stance that the class prop is THE ordained way to pass class attributes, though I don't think this functionality warrants this restriction.

When you visit location /one and the server redirects you to location /two, you expect the browser’s address bar to display the redirected URL. However, Turbolinks makes requests using XMLHttpRequest, which transparently follows redirects. There’s no way for Turbolinks to tell whether a request resulted in a redirect without additional cooperation from the server. To work around this problem, send the Turbolinks-Location header in the final response to a visit that was redirected, and Turbolinks will replace the browser’s topmost history entry with the value you provide.

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

I went against the grain, applying other tools that people have written over the years to directly perform the job at hand which do not involve entering a program for awk or a shell to run, with answers like https://unix.stackexchange.com/a/574309/5132 and https://unix.stackexchange.com/a/578242/5132 . Others have done similar. https://unix.stackexchange.com/a/584274/5132 and https://unix.stackexchange.com/a/569600/5132 are (for examples) answers that show alternative tools to answers employing shell script and (yet again) awk programs, namely John A. Kunze's jot and rs (reshape), which have been around since 4.2BSD for goodness' sake!

There's a few other questions on StackOverflow regarding how to structure YAML files for i18n, and I don't think there is a 'right' answer to your question. If it works for you, then great! I would say that any answer you get will be completely subjective, and more about i18n and translation management rather than anything specifically to do with the Rails way.

The carefully crafted Medium story can give the appearance that- at the nadir of your professional life- you are above it all, you are concerned about others, and you are a soulful human being moving on to an even more lucrative future.

This follows the original vision of the Web as a space for collaboration and not just a one-way publishing medium.

Designers are tempted to enforce users to actually use the interface or browse through the site they have created.

Any top-level statement (i.e. not inside a block or a function) can be made reactive by prefixing it with the $: JS label syntax.

No need for DatabaseCleaner (rolling back transactions are usually faster than truncate).

Using OpenBTS, which we will be including in FreedomBox soon, and with cheap additional hardware, a FreedomBox can talk directly to GSM handsets, to provide alternatives to commercial mobile services.

examples, listing both the conventional systems and their counterpart systems: Conventional schooling Home schooling Encyclopedia Britannica Wikipedia Microsoft Office Open Office Taxicabs Uber Hotel chains Airbnb Big-box stores Ebay National currency Cryptocurrency

In natural languages, some apparent tautologies may have non-tautological meanings in practice. In English, "it is what it is" is used to mean 'there is no way of changing it'.[1] In Tamil, vantaalum varuvaan literally means 'if he comes, he will come', but really means 'he just may come'.[2]

f.ex.

Non-traditional navigation styles can be a fun way to break up some of the same old design patterns.

many organisations block torrents (for obvious reasons) and I know, for example, that either of these options would have posed insurmountable hurdles at my previous employment

Actually, I probably would have ended up just paying for it myself due to the procurement challenges of even a single-digit dollar amount, but let's not get me started on that

[link](url){:target="_blank"} Works for jekyll or more specifically kramdown, which is a superset of markdown, as part of Jekyll's (default) configuration. But not for plain markdown. ^_^

there's no reasonable way to communicate effectively with the less technically minded without acquiescing to the nontechnical misuse of the term "hacker"

The more easily relabeled of the two uses of the term "hacker" is the malicious security cracker: it is not only the more recent phenomenon to acquire that label, but also the one whose meaning is most easily evoked by an alternative term. This is why, when you read an article of mine that talks about malicious security crackers, I use the term "malicious security cracker"

I had never considered it that in nearly a decade of using GNU find! Thank you for that! It will definitely change the way I think about -prune from now on.

I think this structure is much easier and correlates to the right approach

There are a couple of similar packages for anyone who does not want to completely accept standard:

We wondered - do voters carefully consider the political issues and then objectively study each candidate’s platform, or do they mainly go with from-the-gut “tribal” feelings? 

Not everybody uses rubygems as their package management system. If this sounds odd to you, read https://gist.github.com/54177.

27$/year

If these asset owners regarded the “robots” as having the same status as guide dogs, blind people or default human citizens, they would undoubtedly stop imposing CAPTCHA tests and just offer APIs with reasonable limits applied.

Q. Why does Rubinius not support frozen and tainted? A. Rubinius has better features; frozen and tainted are considered harmful. To elaborate... Both frozen and tainted depend on strewing checks throughout the source code. As a classic weak-link system, only one of those checks needs to be misplaced for the guarantees offered by either to fail. Since the number of checks is high, and as new code is written new checks need to be considered, the features inherently constitute unbounded complexity and unbounded risk.

If you ever need to work with external translators, it’s a bit of a pain sending both your YML files and a bunch of views like index.en.html.erb. For one thing, you need some code to find all those files and send them, and put them back after receiving the translations. For another, your translator must respect the markup and code of the template, and know not to translate them. And if you want to use tools like WebTranslateIt, it’s easier to stick to YML.

small coins of possibility

ReST

I would rather you vote against my position because you had an opposing view than vote with my position because you flipped a coin.

"The more your tests resemble the way your software is used, the more confidence they can give you. "

You want to write maintainable tests for your React components. As a part of this goal, you want your tests to avoid including implementation details of your components and rather focus on making your tests give you the confidence for which they are intended. As part of this, you want your testbase to be maintainable in the long run so refactors of your components (changes to implementation but not functionality) don't break your tests and slow you and your team down.

We try to only expose methods and utilities that encourage you to write tests that closely resemble how your web pages are used.

The more your tests resemble the way your software is used, the more confidence they can give you.

Most of the damaging features have to do with encouraging testing implementation details. Primarily, these are shallow rendering, APIs which allow selecting rendered elements by component constructors, and APIs which allow you to get and interact with component instances (and their state/properties) (most of enzyme's wrapper APIs allow this).

Culture is homogenous. This presumes that a (local) culture is free of internal paradoxes and contradictions such that (a) it provides clear and unambiguous behavioural “instructions” to individuals –a program for how to act –or (b) once grasped or learned by an outsider, it can be characterized in relatively straightforward ways (“the Dobuans are paranoid”). A homogenous view of culture makes the second inadequate idea easier to sustain, namely that

In the end

We refer to a way of life

We want better children—but not by turning procreation into manufacture or by altering their brains to gain them an edge over their peers. We want to perform better in the activities of life—but not by becoming mere creatures of our chemists or by turning ourselves into tools designed to win or achieve in inhuman ways. We want longer lives—but not at the cost of living carelessly or shallowly with diminished aspiration for living well, and not by becoming people so obsessed with our own longevity that we care little about the next generations. We want to be happy—but not because of a drug that gives us happy feelings without the real loves, attachments, and achievements that are essential for true human flourishing.

Conversely, western pedagogy continues to deal with content predominantly in the abstract form, in spite of attempts to contextualise subject matter.

Living The Way of Knowledge BUILDING THE FOUNDATION FOR BECOMING A MAN OR WOMAN OF KNOWLEDGE IN AN EMERGING WORLD