You can afford to make a proper PR to upstream.

The change would be useful to other people as-is.

The change is too consequential to be developed in situ.

Patches can be reviewed as part of your normal review process, forks probably can't

Get told in big red letters when the dependency changed and you need to check that your fix is still valid.

Keep your patches colocated with the code that depends on them.

Sometimes forks need extra build steps, e.g. with react-native for Android. Forget that noise.

You can use --save-dev if you don't need to run npm in production, e.g. if you're making a web frontend.

As a workaround for the need of having more than 1 root nodes for the same slot, we can introduce the <svelte:slot> as a wrapper:

Got a bit sidetracked into refactoring the Element visitor code, so haven't actually started on the event handler stuff per se, but that'll come soon. Element stuff is starting to feel a bit more logical and easier to follow.

If you want a reference to the global object that works in any context, you can read this from a directly-called function. const global = (function() {return this})();. This evaluates to window in the browser, self in a service worker and global in nodejs.

emphasizing that 'this' and 'global object' are two different things not only in Node.js but in JavaScript in general

The Object.getPrototypeOf() method returns the prototype (i.e. the value of the internal [[Prototype]] property) of the specified object.

Sentence case, e.g. ‘Next section’. I use sentence case for more ‘friendly’ or ‘conversational’ platforms.

Sharp edge buttons look more serious, while buttons with a rounder radius look more playful.

This sort of library probably should be communitized so there's really just a single library.

// DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>. // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.

Certainly during the first few turns in a less developed game, you are taking more strategic gambles, and later you are more tactically choosing who will mail off their Form 1120 on time.

Warning: Many native English speakers find who versus whom difficult and frequently get it wrong. This is also due to the fact that it is falling out of fashion and is often seen as archaic.

It is important to notice that if you are planning on making your application a PWA, you don’t have to rewrite all the logic.

I'd say it's better overall because it replaces paths at compile-time. It means there is no runtime dependency or any performance overhead.

Loaders use a mapping configuration to map module names to files at run-time, see RequireJs documentation and SystemJS documentation.

This module should not be used in other npm modules since it modifies the default require behavior! It is designed to be used for development of final projects i.e. web-sites, applications etc.

In short, I think the idea of public methods being actions works just fine as an api.

well... it's the same question

The following options are ideal for development:

Some of these values are suited for development and some for production. For development you typically want fast Source Maps at the cost of bundle size, but for production you want separate Source Maps that are accurate and support minimizing.

Note that you can also use dynamic partials, that conditionally select the partial to render based on the value in the JSON.

I'm looking at https://html.spec.whatwg.org/#attributes-3 right now, and it seems that there are a few others that ought to be boolean but are not currently in this list: allowpaymentrequest, formnovalidate, hidden (is on the original list in the master branch), itemscope, nomodule, and playsinline.

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.

Now let me get back to your question. The FBI presents its conflict with Apple over locked phones as a case as of privacy versus security. Yes, smartphones carry a lot of personal data—photos, texts, email, and the like. But they also carry business and account information; keeping that secure is really important. The problem is that if you make it easier for law enforcement to access a locked device, you also make it easier for a bad actor—a criminal, a hacker, a determined nation-state—to do so as well. And that's why this is a security vs. security issue.

It is only soft-deprecated, which means that your code will not break at the moment and no deprecation warning will be displayed, but this constant will be removed in the future.

If you don't like to create an extra function and remove the items 'inline'

However, this will only walk the object shallowly. To do it deeply, you can use recursion:

Note that if you're willing to use a library like lodash/underscore.js, you can use _.pick instead. However, you will still need to use recursion to filter deeply, since neither library provides a deep filter function.

we update the validation schema on the fly (we had a similar case with a validation that needs to be included whenever some fetch operation was completed)

Ubiquity: you can also run your validation on the server side (e.g. nodejs)

What would happen if we get the list from a rest api when the form component is mounted? That's an interesting topic, you can add a rule once a component has been mounted and update the associated validation schema.

Ok, I have seen that there are lot of built-in and third party validations, but sooner or later I will face a validation rule not covered by this buffet. Can I build a custom one? Of course you can!

SwiftUI is a user interface toolkit that lets us design apps in a declarative way. That’s a fancy way of saying that we tell SwiftUI how we want our UI to look and work, and it figures out how to make that happen as the user interacts with it.

Imperative UI causes all sorts of problems, most of which revolve around state, which is another fancy term meaning “values we store in our code”. We need to track what state our code is in, and make sure our user interface correctly reflects that state.

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).

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

Don't sacrifice clarity for brevity when creating a minimal example.

Note that these are not hyperlinks; these URIs are used for identification. This is a machine-readable way to say “this is HTML”. In particular, software does not usually need to fetch these resources, and certainly does not need to fetch the same one over and over!

A URI is an identifier.A URL is an identifier that tells you how to get to it.

Every URL is a URI; Every URN is a URI; URI and URL are NOT interchangeable – a URL is a URI, but a URI is not always a URL; URLs always contain an access mechanism.

Roles are element types and authors MUST NOT change role values over time or with user actions. Authors wishing to change a role MUST do so by deleting the associated element and its children and replacing it with a new element with the appropriate role.

Longstanding controversy surrounds the meaning of the term "hacker". In this controversy, computer programmers reclaim the term hacker, arguing that it refers simply to someone with an advanced understanding of computers and computer networks[5] and that cracker is the more appropriate term for those who break into computers, whether computer criminals (black hats) or computer security experts (white hats).

Returns a Promise<?Object> that resolves with no value on success or resolves with an Object of submission errors on failure. The reason it resolves with errors is to leave rejection for when there is a server or communications error.

hyperscript is much simpler to refactor and DRY up your code than with JSX, because, being vanilla javascript, its easier to work with variable assignment, loops and conditionals.

Use a node-style require() to organize your browser code and load modules installed by npm.

browserify is a tool for compiling node-flavored commonjs modules for the browser.

In highlighting the dangers of big-up-front-design (BUFD) and waterfall development, Agilists seem to advocate no-up-front-design (NUFD) or no-up-front-requirements (NUFR) or no-up-front-architecture (NUFA).

Think of JavaScript. In the browser you don't have direct access to the file system. In Node.js you have. Same programming language. Different APIs.

In a declarative language like Svelte's HTMLx, you're not writing a program so much as describing a graph.

Most people seem to follow one of two strategies - and these strategies come under the umbrella of tree-traversal algorithms in computer science.

In general it is recommended you handle forms in this "controlled" manner. In some cases it might make sense to manage the form state outside of Solid via refs. These "uncontrolled" forms can also work. Just be conscious of the difference as mixing approaches can lead to unexpected results.

formal<---------------|--X------------->informal

This is just a library not a Framework.

Templates are prone to unnoticed runtime errors, are hard to test, and are not easy to restructure or decompose.

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

In contrast, React apps shun templates and require the developer to create their DOM in Javascript, typically aided with JSX.

Node.js code must be run by the node process, not the browser (the code must run in the server).

t’s not clear why the sequence of the vaccines only mattered in girls, partly because there has been very little research into how male and female immune systems are different. “Somehow immunology has been blind to sex,” says Aaby. “If you read research about mortality in low income countries, there is no such thing as boys and girls – there are children. So we perceive that they have to be the same, and they are definitely not the same.”

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

detach, as an api, should be declarative (ensure the node is detached) instead of imperative (detach the node), allowing it to be called multiple times by performing a noop if the node is already detached. This way, it won't matter if the node is removed from the DOM from outside of svelte.

Please also make sure svelte is installed as a devDependency and not an actual dependency. Svelte itself should never be bundled with your application code.

If you’ve used Flow before, the syntax is fairly similar. One difference is that we’ve added a few restrictions to avoid code that might appear ambiguous.

Let’s take a look at some facts and figures related to iOS vs. Android, which can help you choose one of two operating systems:

Modules using code that doesn’t exist in browsers such as process.env.NODE_ENV and forcing you to convert or polyfill it.

Some modules, like events or util, are built in to Node.js. If you want to include those (for example, so that your bundle runs in the browser), you may need to include rollup-plugin-node-polyfills.

dependencies are the packages your project depends on. devDependencies are the packages that are needed during the development phase. Say a testing framework like Jest or other utilities like Babel or ESLint.

Having the bundler config bundle dev deps and leave prod deps as external seems to be the sanest thing it could default to, and I don't see us wanting to change that.

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.

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.

As a general rule, I would recommend reading the article in it's entirety. With that said, if you wish to "cut to the chase", I have summarized my findings at the end ... feel free to jump ahead to the Summary!

In general, I'm unpersuaded by these arguments (learning curve is determined not just by unfamiliar syntax, but by unfamiliar semantics and APIs as well, and the frameworks in question excel at adding complexity in those areas).

Svelte currently has no opinion as to what you store in an exported class prop of a component. It will not necessarily be used a class attribute.

Yow loveres axe I now this questioun:      1347 Who hath the worse, arcite or palamoun?      1348

A paradigm is a model or pattern. In JavaScript, there are a number of popular paradigms including object-oriented programming (OOP) and functional programming (FP). Paradigms are more important than is sometimes recognized. They help form mental models for solving problems. Becoming well-versed in the principles of a given paradigm can help accelerate development by providing mental shortcuts for solving the challenges that arise while building applications. They can also help produce higher quality software.

Ways of delivering JavaScript source code

You are not sure which path to take between the big re-write or continuous improvements(using refactoring)

It’s 2020, doesn’t everyone use VSCode already?

Facilitators don't have to be experts in the topic — they can be learners too!

Online courses tend to be based around linear playlists of videos, along with associated readings and other activities. These often look like university courses filmed and translated more or less directly to online form. More internet native courses tend to be shorter and more focused, but still just as linear and video-centric.

Stallman has also stated that considering the practical advantages of free software is like considering the practical advantages of not being handcuffed, in that it is not necessary for an individual to consider practical reasons in order to realize that being handcuffed is undesirable in itself.

RDFa is intended to solve the problem of marking up machine-readable data in HTML documents. RDFa provides a set of HTML attributes to augment visual data with machine-readable hints. Using RDFa, authors may turn their existing human-visible text and links into machine-readable data without repeating content.

This is very irresponsible of them, with respect to the number of downloads. They should finally realize this and just redirect people to LO. Continuing like this hurts the Apache Foundation credibility as well as the open source community as a whole.

He had put the case (without mentioning names) to an eminent physician; and the eminent physician had smiled, had shaken his head, and had said–nothing. On these grounds, Mr. Bruff entered his protest, and left it there.

It does, however, provide the --porcelain option, which causes the output of git status --porcelain to be formatted in an easy-to-parse format for scripts, and will remain stable across Git versions and regardless of user configuration.

Parsing the output of git status is a bad idea because the output is intended to be human readable, not machine-readable. There's no guarantee that the output will remain the same in future versions of Git or in differently configured environments.

The chief justice explained that he continues to think the Texas case was wrongly decided, but believes it’s important for the court to stand by its prior decisions.

Security agency frustration at the lack of lawful interception for encrypted messaging is understandable, but the problem with global over-the-top platforms is that once those weaknesses are inbuilt, they become potentially available to bad actors as well as good.

EFF describes this as “a major threat,” warning that “the privacy and security of all users will suffer if U.S. law enforcement achieves its dream of breaking encryption.”

Once the platforms introduce backdoors, those arguing against such a move say, bad guys will inevitably steal the keys. Lawmakers have been clever. No mention of backdoors at all in the proposed legislation or the need to break encryption. If you transmit illegal or dangerous content, they argue, you will be held responsible. You decide how to do that. Clearly there are no options to some form of backdoor.

While this debate has been raging for a year, the current “EARN-IT’ bill working its way through the U.S. legislative process is the biggest test yet for the survival of end-to-end encryption in its current form. In short, this would enforce best practices on the industry to “prevent, reduce and respond to” illicit material. There is no way they can do that without breaking their own encryption. QED.

Governments led by the U.S., U.K. and Australia are battling the industry to open up “warrant-proof” encryption to law enforcement agencies. The industry argues this will weaken security for all users around the world. The debate has polarized opinion and is intensifying.

Such is the security of this architecture, that it has prompted law enforcement agencies around the world to complain that they now cannot access a user’s messages, even with a warrant. There is no backdoor—the only option is to compromise one of the endpoints and access messages in their decrypted state.

As EFF has warned, “undermining free speech and privacy is not the way to protect children.”

“not only jeopardizes privacy and threatens the right to free expression, but also fails to effectively protect children from online exploitation.”

The US president has claimed the social media platform is "interfering in the 2020 presidential election" and "completely stifling FREE SPEECH" after it added a warning to two of his tweets on Tuesday.

Out of Scope

This starter takes advantage of Typescript and Emotion. This is a personal choice, and I'd encourage you to give it a shot. If you're interested in using plain ES6 and regular scss styling, see release v1 of this library.

Certified Ethical Hacker

Out of Scope The following details what is outside of the scope of support for GitLab.com customers with a subscription.

The GitLab.com support team does offer support for: Account specific issues (unable to log in, GDPR, etc.) Broken features/states for specific users or repositories Issues with GitLab.com availability

Out of Scope The following details what is outside of the scope of support for self-managed instances with a license.