Note: your arrow must be an HTMLElement (not an SVGElement). To use an SVG arrow, wrap it in a <div> tag with the data-popper-arrow attribute.

A tooltip is an element containing simple text content describing a particular element. It's hidden until the user desires more information from the element, e.g. before deciding to click a button.

A popover is an interactive HTML tooltip. It can be a dropdown, menu, or any other kind of box that pops out from the normal flow of the document. This type of element contains non-vital functionality and can be hidden behind a click or hover to conserve space.

A hyponym refers to a type. A meronym refers to a part. For example, a hyponym of tree is pine tree or oak tree (a type of tree), but a meronym of tree is bark or leaf (a part of tree).

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

The rationale for branches is simple. Each snap in the Snap Store has a default track called ‘latest’ in which there are four channels named ‘stable’, ‘beta’, ‘candidate’ and ‘edge’. These are all typical buckets in which snaps are published for an extended period, perhaps months or maybe even years. Branches on the other hand are short-lived silos for publishing snaps. 

I don’t think he implies that, he didn’t mentioned FOSS or non-FOSS. Third party doesn’t refer to licensing, only to who provides it.

more leading edge than bleeding

Event listener and event handler are two terms that cause confusion.

A listener watches for an event to be fired. For example, a KeyListener waits for KeyEvents, a MessageListener waits for messages to arrive on a queue and so on. The handler is responsible for dealing with the event. Normally, listeners and handlers go hand-in-hand. For example, the KeyListener tells the ExitHandler that "the letter Q was pressed" and the handler performs logic such as cleaning up resources and exiting the application gracefully. Similary a ButtonClickListener would tell the same ExitHandler that the "Exit button was clicked". So, in this case you have two different events, two different listeners but a single handler.

The most basic difference is the association Listener is associated with Event Source (Ex: key board) Handler is associated with an Event (Ex: keydown)

In a browser, the chrome is any visible aspect of a browser aside from the webpages themselves (e.g., toolbars, menu bar, tabs). This is not to be confused with the Google Chrome browser.

Universal = code that can run in any JS runtime (browser and/or node). Isomorphic = application that runs the same universal code in multiple runtimes to avoid code duplication.

The delete operator does not directly free memory, and it differs from simply assigning the value of null or undefined to a property, in that the property itself is removed from the object.

Often the term intransitive is used to refer to the stronger property of antitransitivity.

Fallback values aren't used to fix the browser compatibility. If the browser doesn't support CSS custom Properties, the fallback value won't help.

So if you are designing for an app

The style is just the aesthetics of the button and not how it should be used.

@import url() is a runtime CSS statement, not a Sass @import module.

this in particular comes from the addressee

positive feedback loops, in which a change in a given direction causes additional change in the same direction.For example, an increase in the concentration of a substance causes feedback that produces continued increases in concentration. negative feedback loops, in which a change in a given direction causes change in the opposite direction.For example, an increase in the concentration of a substance causes feedback that ultimately causes the concentration of the substance to decrease.

To bundle this in your own code, use a Sass processor (not a Sass Svelte preprocessor, but a Sass processor)

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.

The resolving process is basically simple and distinguishes between three variants: absolute path: require("/home/me/file") relative path: require("../src/file") or require("./file") module path: require("module/lib/file")

if the value given in value is contained in the array that is the value for the field for the form

If it's closing the "window" likely you're putting the exit # command inside a function, not a script. (In which case use return # instead.)

Some people try to use && and || as a shortcut syntax for if ... then ... else ... fi, perhaps because they think they are being clever.

Here we go again. [ is a command. It is not a syntactic marker that sits between if and some sort of C-like "condition". Nor is it used for grouping. You cannot take C-like if commands and translate them into Bash commands just by replacing parentheses with square brackets!

you still can, if the image was built locally, the intermediate layers are still stored locally as images during docker build. Those images are not distributed though, when doing docker push

The image specified in --cache-from is the image from the previous CI build. It doesn't have anything to do with the FROM line in Dockerfile. CI can pull it with regular docker pull, like they could before v1.10.

Because the router uses the HTTP verb and URL to match inbound requests, four URLs map to seven different actions.

Please remember that setting NODE_ENV doesn't automatically set mode.

Using as * adds a module to the root namespace, so no prefix is required, but those members are still locally scoped to the current document.

@import is also a CSS feature, and the differences can be confusing

Did you look at it and decide not, or not look at it?

This is not an issue related to using a virtual DOM. Plenty of non VDOM libraries have solved this. Imba and Solid come to mind.

If you import a Sass file without a prepended underscore into another Sass file, that also is without a prepended underscore, then only one CSS file will be generated, so the claim Partials must start with an underscore if you do not want them to be generated into a css file. isn't really true

When you do import '../scss/application.scss', you're telling webpack to include application.scss in the build. This does not mean it's going to be compiled into your javascript, only that webpack now compiles and knows how to load this file.

Note that you use IP instead of DNS for alternate_names if you're working with an ip address.

I don't think the heading/bearing split is as clear-cut as that.

In summary TLS uses PKI to secure information over the internet. However, it is important to note that TLS supports other encryption standards which are not part of PKI.

I want to run docker daemon with TLS enabled but client certificate authentication disabled so that clients can verify authenticity of docker daemon but docker daemon doesn't need to verify clients.

While they are listed as synonyms by many dictionaries, they are really not the same word.

Current (13)

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.

A URL is special type of identifier that also tells you how to access it, such as HTTPs, FTP, etc.

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.

Informative data about objects that are considered prototypes for the role. Base concept is similar to type, but without inheritance of limitations and properties. Base concepts are designed as a substitute for inheritance for external concepts. A base concept is like a related concept except that the base concept is almost identical to the role definition.

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.

Taxonomy A hierarchical definition of how the characteristics of various classes relate to each other, in which classes inherit the properties of superclasses in the hierarchy. A taxonomy can comprise part of the formal definition of an ontology.

Self-concept also differs from self-esteem: self-concept is a cognitive or descriptive component of one's self (e.g. "I am a fast runner"), while self-esteem is evaluative and opinionated (e.g. "I feel good about being a fast runner").

Self-concept is distinguishable from self-awareness, which refers to the extent to which self-knowledge is defined, consistent, and currently applicable to one's attitudes and dispositions.

Subgroups of the computer underground with different attitudes and motives use different terms to demarcate themselves from each other. These classifications are also used to exclude specific groups with whom they do not agree.

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.

One of the significant differences between the two is that a call to a partially applied function returns the result right away, not another function down the currying chain; this distinction can be illustrated clearly for functions whose arity is greater than two.

As such, curry is more suitably defined as an operation which, in many theoretical cases, is often applied recursively, but which is theoretically indistinguishable (when considered as an operation) from a partial application.

Also, if you don't put that implementation of URLSearchParams in the global scope you're not using it as a polyfill but a ponyfill, and those are meant for your code, not for external dependencies.

A ponyfill is almost the same as a polyfill, but not quite. Instead of patching functionality for older browsers, a ponyfill provides that functionality as a standalone module you can use.

The intuition behind POJOs is that a POJO is an object that only contains data, as opposed to methods or internal state. Most JavaScript codebases consider objects created using curly braces {} to be POJOs. However, more strict codebases sometimes create POJOs by calling Object.create(null) to avoid inheriting from the built-in Object class.

The word is a blend of back and acronym.

We could freeze the objects in the model but don't for efficiency. (The benefits of an immutable-equivalent data structure will be documented in vtree or blog post at some point)

Escaping is a subset of encoding: You only encode certain characters by prefixing a special character instead of transferring (typically all or many) characters to another representation.

They're different, and I think you're getting the distinction correctly.

When processing untrusted user input for (web) applications, filter the input, and encode the output.

what's the difference between escaping and encoding

The Shadow DOM is a browser technology designed primarily for scoping variables and CSS in web components. The virtual DOM is a concept implemented by libraries in JavaScript on top of browser APIs.

Since “virtual DOM” is more of a pattern than a specific technology, people sometimes say it to mean different things. In React world, the term “virtual DOM” is usually associated with React elements since they are the objects representing the user interface

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.

Unlike DOM events, component events don't bubble. If you want to listen to an event on some deeply nested component, the intermediate components must forward

(The distinction is conceptually similar to passive versus active event listeners.)

encapsulation refers to one of two related but distinct notions, and sometimes to the combination thereof:[3][4] A language mechanism for restricting direct access to some of the object's components.[5][6] A language construct that facilitates the bundling of data with the methods (or other functions) operating on that data.[1][7]

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.

Especially when coming from a framework like React, it might feel very tempting to start creating a component wrapper around the input (i.e. <input> becomes <Input/>) and add your custom event handlers in there.This is a great approach in React, but not so much in Svelte. Why, you ask?Well, Svelte (at least in its current form, v3) really shines when you have native DOM elements at your disposal. You can use transition directives, conditionally switch CSS classes, bind to the current value with ease, and more.

JSX is an XML-like syntax extension to EcmaScript (https://facebook.github.io/jsx/). It is not a language or runtime.

This is just a library not a Framework.

A library is a set of functions you can use in your project. It does not care how and where you use that functionality. A framework tells you how to write code with the framework you are working with so you can make the best use of patterns, architecture, and functions in a framework. A framework can encompass a library.

It's designed for Single Page Applications (SPA). If you need Server Side Rendering then consider using Sapper.

Returning null defers to other resolveId functions and eventually the default resolution behavior; returning false signals that source should be treated as an external module and not included in the bundle.

It lives in a context="module" script — see the tutorial — because it's not part of the component instance itself; instead, it runs before the component is created, allowing you to avoid flashes while data is fetched.

Your problem is that you were returning the rejected loginDaoCall, not the promise where the error was already handled. loginApi.login(user, password) did indeed return a rejected promise, and even while that was handled in another branch, the promise returned by the further .then() does also get rejected and was not handled.

“should I use the private keyword, or ECMAScript’s hash/pound (#) private fields?”

The problem I have with this approach to state and prop variables is that the difference between them is very blurry. In React you can clearly see that a prop is an input to component (because of clear function notation), and that state is something internal. In Svelte they are both just variables, with the exception that props use export keyword.

When you publish this module, you do not want to bundle React, for the reasons described above. (It would be even worse to bundle React in a library, because then its copy would duplicate that loaded by the application!) But the fix is slightly different for a library than an application. In this library's Rollup configuration, we only want to specify external, not globals:

we've learned why you might want to use external but not globals: libraries. We've started to factor some of our client-side JS as libraries to share between projects. These libraries import $ from 'jquery'. However they don't want to presume how that import might be "fulfilled". In most projects it's fulfilled from a global i.e. a script loaded from a CDN. However in one project it's fulfilled from a local copy of jQuery for reasons I won't get into. So when these libraries bundle themselves for distribution, as ES6 modules, they mark 'jquery' as an external and not as a global. This leaves the import statements in the bundle. (Warning: Don't bundle as an IIFE or UMD, or Rollup will guess at fulfilling the import from a global, as @Rich-Harris mentions above.)

This isn't really a bug, because if you have an async function that returns a function, it doesn't really return a function - it returns a promise. I don't remember whether the Svelte internals currently check for the onMount callback's return being a function or whether they check for it being truthy. Maybe there's some adjustment to be made there.

I think instead, there would need to be some special way to make the distinction of what is a slot attribute and what is a slot prop to be consumed with let:. Maybe a new directive like <slot attr:class="abc"/>?

I considered it, but dynamism refers to personality and philosophy, while dynamicity is just the condition of being dynamic.

Non-store reactivity needs to be analyzable at compile time.

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.

I don't think componentDidRender is a substitute for componentDidMount because the component can render multiple times when props change after it's mounted once.

Note that normally you'd only call ReactDOM.render() to mount the root component(s). You don't need to manually "mount" the child components.

Stores are global state. While context is local state.

Notice it's not related to components. Another crucial difference is that it's accessible from outside of components. And good way to determine where goes where is to ask yourself, can this particular state and functionality still makes sense outside of the displayed component?

In fact, you might use the two together. Since context is not reactive, values that change over time should be represented as stores:

Even though it works much like a function, import() is an operator

A dialog is a type of modal window that appears in front of app content to provide critical information or ask for a decision

When it comes to exercise, the terms “stamina” and “endurance” are essentially interchangeable. However, there are some subtle differences between them.

There is a distinction between a tree as an abstract data type and as a concrete data structure, analogous to the distinction between a list and a linked list.

In graph theory, a tree is a connected acyclic graph; unless stated otherwise, in graph theory trees and graphs are assumed undirected. There is no one-to-one correspondence between such trees and trees as data structure.

Free software thus differs from: proprietary software, such as Microsoft Office, Google Docs, Sheets, and Slides or iWork from Apple. Users cannot study, change, and share their source code. freeware, which is a category of proprietary software that does not require payment for basic use.

What is the difference between an acronym and an initialism?

Both acronyms and initialisms are made up of the first letter or letters of the words in a phrase. The word acronym typically applies when the resulting thing can be read as a word; for example, radar comes from "radio detection and ranging" and scuba comes from "self-contained underwater breathing apparatus."

The word initialism only applies when the resulting thing is read as an abbreviation; for example DIY, which comes from "do it yourself," is pronounced by saying the names of the letters.

Whether or not you find the use case for JavaScript unit tests compelling, it helps to know that Webpacker does not make any distinction between your development and test environments beyond the settings in your webpacker.yml; both are local concerns that target the same runtime, i.e., the browser.

RAILS_ENV determines which Webpacker YAML settings are used and NODE_ENV determines which webpack configuration is used.

Unlike the webpack config, webpacker.yml settings are determined by the current RAILS_ENV.

This finally brings us to the use case for NODE_ENV=test: JavaScript unit testing By this I mean executing tests, written in JavaScript, against your application JavaScript code within a Node.js process.

Time.current returns said timestamp, and Time.now its equivalent in the system time zone.

The term "modal" is sometimes used to mean "dialog", but this is a misnomer. A modal window describes parts of a UI. An element is considered modal if it blocks interaction with the rest of the application.

In addition, if the option, An administrator must always approve the comment, is set in Administration > Settings > Discussion, this e-mail address will receive notification that the comment is being held for moderation. Please note this is different than the address you supplied for the admin user account; the admin account e-mail address is sent an e-mail only when someone submits a comment to a post by admin.

hypothes.is is an exciting project, but not a commenting system. It belongs, therefore, to a different category of software (annotation systems).