It should be | { fallthrough: true } rather than | { fallthrough: boolean } I think (there's no reason you'd have false)

Caution: + continues the statement but not the string. puts "foo"+"bar".upcase gives you fooBAR, whereas puts ("foo"+"bar").upcase gives you FOOBAR. (Whether or not there's a newline after the +.) But: if you use a backslash instead of the plus sign, it will always give you FOOBAR, because combining lines into one statement, and then combining successive strings into one string, happen before the string method gets called.

These callbacks are smart enough to run after the final (outer) transaction* is committed. * Usually, there is one real transaction and nested transactions are implemented through savepoints (see, for example, PostgreSQL).

(Note this is NOT post.comments.order... we don’t know what post, yet. We want the final query to return comments, so our filter starts with Comment.)

If I create a model ActiveRecord sends NULL values for every field that is not defined. Postgres dutifully writes the NULL value into the field instead of the default value. Activerecord should either send nothing (preferable) or send DEFAULT.

Use apt as a first choice, but if you're scripting use apt-get. Apt-get has more stable output (meaning that the output format is left alone as much as possible so as not to break scripts which parse that output automatically). Apt-get also has some low-level commands not available in apt.

Note: triggering events by JS will never make CSS :hover work

Object hierarchies are very different from relational hierarchies. Relational hierarchies focus on data and its relationships, whereas objects manage not only data, but also their identity and the behavior centered around that data.

Note that this is a breaking API change in the libraries (more information in the README.md). It does not affect the backwards compatibility of the protocol itself.

"Context" manipulation is one of big topic and there are many related terminologies (academic, language/implementation specific, promotion terminologies). In fact, there is confusing. In few minutes I remember the following related words and it is good CS exam to describe each :p Thread (Ruby) Green thread (CS terminology) Native thread (CS terminology) Non-preemptive thread (CS terminology) Preemptive thread (CS terminology) Fiber (Ruby/using resume/yield) Fiber (Ruby/using transfer) Fiber (Win32API) Generator (Python/JavaScript) Generator (Ruby) Continuation (CS terminology/Ruby, Scheme, ...) Partial continuation (CS terminology/ functional lang.) Exception handling (many languages) Coroutine (CS terminology/ALGOL) Semi-coroutine (CS terminology) Process (Unix/Ruby) Process (Erlang/Elixir) setjmp/longjmp (C) makecontext/swapcontext (POSIX) Task (...)

As said in the chapter, there’s an "implicit try..catch" around the function code. So all synchronous errors are handled. But here the error is generated not while the executor is running, but later. So the promise can’t handle it.

Fundamentally, I think promise rejection is substantially different than "throwing" under normal synchronous flow.

but has a critical difference: the expression console.log("before 2"); does not and cannot depend on the resolved value result. The throw propagates through all chained promises, and when it stops, there is no remaining undefined behavior! No piece of code is left in an unclear state, and therefore there is no reason to crash.

SSR is used for pages as well, but prerendering means that rendering happens at build time instead of when a visitor visits the page.

Meaning if you have your own roll-your-own login process and never use HTTP Authentication, 403 is always the proper response and 401 should never be used.

So, for authorization I use the 403 Forbidden response. It’s permanent, it’s tied to my application logic, and it’s a more concrete response than a 401. Receiving a 403 response is the server telling you, “I’m sorry. I know who you are–I believe who you say you are–but you just don’t have permission to access this resource. Maybe if you ask the system administrator nicely, you’ll get permission. But please don’t bother me again until your predicament changes.”

Indicates that though the request was valid, the server refuses to respond to it. Unlike the 401 status code, providing authentication will not change the outcome.

I used the word "intended" behavior, because that is the behavior im looking for, but I may not be expressing it correctly in Svelte. It may not be the expected behavior of the code.

For me there is a distinct difference between these two scripts: let a = 1; $: b = a * 2; let a = 1; let b; $: { b = a * 2 }; The first example defines a "recipe" for how to create b and b is completely defined by that declaration. Outside of that it is immutable, data flows only into a single sink. The second example declares a variable b and then uses a reactive statement to update it. But it also allows you to do with b whatever you want. If someone wants to go that route (definitely not me), they are free to do so at their own risk of ensuring consistency.

[Vote!]! means that the field (in this case votes) cannot return null and that it must resolve to an array and that none of the individuals items inside that array can be null. So [] and [{}] and [{foo: 'BAR'}] would all be valid (assuming foo is non-null). However, the following would throw: [{foo: 'BAR'}, null] [Vote]! means that the field cannot return null, but any individual item in the returned list can be null. [Vote!] means that the entire field can be null, but if it does return a value, it needs to an array and each item in that array cannot be null. [Vote] means that the entire field can be null, but if it does return a value, it needs to an array. However, any member of the array may also be null.

The type-fest package contains only types, meaning they are only used at compile-time and nothing is ever compiled into actual JavaScript code. This package contains functions that are compiled into JavaScript code and used at runtime.

The hasOwnProperty() method returns a boolean indicating whether the object has the specified property as its own property (as opposed to inheriting it).

Inflections go the other way around.In classic mode, given a missing constant Rails underscores its name and performs a file lookup. On the other hand, zeitwerk mode checks first the file system, and camelizes file names to know the constant those files are expected to define.While in common names these operations match, if acronyms or custom inflection rules are configured, they may not. For example, by default "HTMLParser".underscore is "html_parser", and "html_parser".camelize is "HtmlParser".

it does not belong to the autoload paths by default but it belongs to $LOAD_PATH

A sanitary tee is shaped like the letter ‘T’, while a Wye is similar to ‘Y’. Sanitary tee is used for horizontal to vertical transition, and Wye is used for combining 2 lines into one horizontal line to maintain a flow without causing clogging.

Sanitary Tee and Wye are parts of the drain vent system. If you are doing plumbing works, you may have to use them in some sort. However, they look almost similar, and this confuses a lot of people. Especially to choose the one that best fits your drain system.

If your configuration is not provided by a name server (like the information given in /etc/hosts) those tools will not show them, because they directly ask the name server.

“Switch Windows”

“Switch windows“,

To revert the change, look for Switch applications

A controller is the entity that determines the purposes and means of the processing of personal data. Some examples of a controller are listed below.DigitalOcean is a controller for our customer’s personal data (e.g. personal information provided to DigitalOcean when signing up for our services)A DigitalOcean customer may be a controller if they collect and process personal data on their customers (e.g. personal data provided to you by your customers)A processor is the entity that processes personal data on behalf of another entity. An example of a processor is listed below.DigitalOcean is a processor for our customer’s end-user personal data (e.g. A DigitalOcean customer stores their customer’s personal data on a DigitalOcean service)

Generally, shrank is the simple past tense form of "shrink" like in "I shrank the shirt in the wash." Shrunk is the past participle being paired with "have" as in "I have shrunk the jeans." There are rarer examples of shrinked and shrunken in literature but not enough to support those usages as standard.

When referring to a change in direction, position, or course of action, the correct phrase is to change tack. This is in reference to the nautical use of tack which refers to the direction of a boat with respect to sail position. This phrase has long been confused as "change tact" but this is technically incorrect.

Instead of bind:this={ref}, use bind:el={ref}. this points to the wrapper component, el points to the native element

this implies an array of arrayLength empty slots, not slots with actual undefined values

svelte-preprocess doesn't do any kind of type-checking, it just transpiles your ts into js (see it here). If you want to fail your build when a type error is found, you can use svelte-check.

This particular project has a differentiation between a package's app/ folder and the current project's app/ folder.

Gems use a period and packages use a dot

The important part I have come to notice is <script type="module"></script> make sure you add that otherwise you will get that error.

I still don't understand the difference between a script and a module

The differences are subtle

it means that 42.0 == 42 produces true and 42.0.eql? 42 produces false

But it is always important to remember that those are not language concepts. Those are community concepts that only exist in our heads and in the names of some library methods.

Note: when I wrote above that "there is no such thing as X", what I meant was that "there is no such thing as X in the Ruby language". That does not mean that those concepts don't exist in the Ruby community.

rewrite all onload iframes to javascript-inserted elements

As with any classification there's a fuzzy line between them (Rake could be thought of either way.)

When people talk about internal DSLs I see two styles: internal minilanguages and language enhancements.

Special case check = Non-obvious, non-boundary special values, for example log(1 + the smallest floating point number).

Corner case check = A more complex boundary check (a corner is a two-dimensional boundary)

There are two ways SvelteKit does this: prerendering and server-side rendering

has the same effect (that is no side effect)

> I should have used "side-effect-free" instead of "idempotent" in my tweetsThe HTTP term is "safe method".

You would get a return value of the type "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function", because you're using the JavaScript typeof operator at runtime, which returns a string like "object", not the compile-time type seen by TypeScript.

1) all dependencies of the root package + sub-packages are installed into a single node_modules folder at the root and 2) sub-packages are symlinked into node_modules during npm install.

Your packages (the ones you created)

Selected state should be applied on the .mdc-list-item when it is likely to frequently change due to user choice. E.g., selecting one or more photos to share in Google Photos.Activated state is more permanent than selected state, and will NOT change soon relative to the lifetime of the page. Common examples are navigation components such as the list within a navigation drawer.

In Material Design, the selected and activated states apply in different, mutually-exclusive situations:

In general, top-level errors should only be used for exceptional circumstances when a developer should be made aware that the system had some kind of problem. For example, the GraphQL specification says that when a non-null field returns nil, an error should be added to the "errors" key. This kind of error is not recoverable by the client. Instead, something on the server should be fixed to handle this case. When you want to notify a client some kind of recoverable issue, consider making error messages part of the schema, for example, as in mutation errors.

Authorization is the process of verifying that the current user has permission to do something (or see something), for example, checking admin? status or looking up permission groups from the database.

Authentication is the process of determining what user is making the current request, for example, accepting a username and password, or finding a User in the database from session[:current_user_id].

even acceptance tests (though the latter are ideologically different)

Capybara.default_host only affects tests using the rack_test driver (and only if Capybara.app_host isn't set). It shouldn't have the trailing '/' on it, and it already defaults to 'http://www.example.com' so your setting of it should be unnecessary. If what you're trying to do is make all your tests (JS and non-JS) go to 'http://www.example.com' by default then you should be able to do either Capybara.server_host = 'www.example.com' or Capybara.app_host = 'http://www.example.com' Capybara.always_include_port = true

app_host is used whenever you call visit to generate the url, server_host sets the ip the server should accept connections from to use (0.0.0.0 means all network interfaces) and finally server_port sets the server port (auto generated by default).You are correct in that both app and server host should be set. Could you try server_host = “0.0.0.0” and app_host = “http://rails:#{Capybara.server_port}”.

I see a 'virtual attribute' as something we're forced to implement when using frameworks, ORMs and the like. Something that lets us inject our code into the path of whatever metaprogramming has been put in place for us. In a simple PORO like this, I don't see how it has meaning; it's just a method. :)

That's not exactly Symbol#to_proc conversion — it's part of the inject interface, mentioned in the documentation. The to_proc operator is &

Use the -> operator instead of ->> in the reference to children. The way you have it, you'd first cast json / jsonb to text and then back to json.

Careful, Instead of != you may need to IS DISTINCT FROM operator which also compares NULL value

import { knex } from 'knex' // this is a function that you call to instantiate knex import { Knex } from 'knex' // this is a namespace, and a type of a knex object

TypeScript type exports changed significantly. While `import Knex from 'knex';` used to import the knex instantiation function, the namespace and the interface for the knex instantiation function/object, there is now a clear distinction between them:

It doesn't say that the constant is dynamic. It says that the assignment is dynamic.

Select a redirect type from the Type menu. Permanent (301) — This setting notifies the visitor’s browser to update its records. Temporary (302) — This setting does not update the visitor’s bookmarks.

Note the difference between pace and cadence. Pace is 1/speed in (eg. min/km) whereas cadence refers to steps/minute

The difference is that this happens in the email client, not at the subscription step. Why is this a big deal? Because, even though they just subscribed to your email, there’s a chance your email won’t get a thumbs up.

The use of U+212B 'Angstrom sign', which was encoded due to round-trip mapping compatibility with an East-Asian character encoding, is discouraged, and the preferred representation is U+00C5 'capital letter A with ring above', which has the same glyph.

It should be defined inline. If you are using the img tag, that image should have semantic value to the content, which is why the alt attribute is required for validation. If the image is to be part of the layout or template, you should use a tag other than the img tag and assign the image as a CSS background to the element. In this case, the image has no semantic meaning and therefore doesn't require the alt attribute. I'm fairly certain that most screen readers would not even know that a CSS image exists.

Ah yes, excactly the right answer. Img tags are for information, css backgrounds are for layout.

use the width (and the height) attribute....to identify the intrinsic height of the image file, not to specify the desired layout size

Historical negationism,[1][2] also called denialism, is falsification[3][4] or distortion of the historical record. It should not be conflated with historical revisionism, a broader term that extends to newly evidenced, fairly reasoned academic reinterpretations of history.

Socrates' dictum may be wise, but I think there's a world of difference between OP's acknowledgement that the amount of things one doesn't know is indeterminate, and Socrates' assertion that, for him, everything falls into that category.

Dry humor is a delivery technique. As such, it shouldn't be confused with specific types of humor or with sarcasm. Sarcasm is delivered without humor because it's generally not funny but intended to mock or convey contempt. Dry humor pertains to something funny.

What is the difference between “wry” and “dry” humor?

Operating systems implement a command-line interface in a shell for interactive access to operating system functions or services.

If no file is detected (in case, it's being run as part of a script or the command is being piped)

STREAMS originated in Version 8 Research Unix, as Streams (not capitalized).

The virtual terminal process resides in kernel space (called the console).It reads from the "tty", say the output from the "ls" process and renders the text. It interacts with the VGA driver to do so.

The (virtual) terminal (not the "tty") plays a central role here

Although echo "$@" prints the arguments with spaces in between, that's due to echo: it prints its arguments with spaces as separators.

Unfortunately, unlike what is described in SWdream solution, --ignore-missing-args has no impact on vanished files. It will simply ignore source arguments that doesn't exist.

You can create a separate grassland area (mountain in between) but you can NOT create a separate landmass (water in between).

A modified timestamp signifies the last time the contents of a file were modified. A program or process either edited or manipulated the file. “Modified” means something inside the file was amended or deleted, or new data was added. Changed timestamps aren’t referring to changes made to the contents of a file. Rather, it’s the time at which the metadata related to the file was changed. File permission changes, for example, will update the changed timestamp.

It's simple really ... put tests into a shared example that you want multiple things to conform to. Put code into a shared context that you need to include in multiple tests.

shared_contexts is any setup code that you can use to prepare a test case . This allows you to include test helper methods or prepare for the tests to run.

It might be better to think of it this way: with the shape-outside property we’re changing the relationship of other elements around an element, not the geometry of the element itself.

CSS-generated content is not included in the DOM. Because of this, it will not be represented in the accessibility tree and certain assistive technology/browser combinations will not announce it. If the content conveys information that is critical to understanding the page's purpose, it is better to include it in the main document.

Requirement #2 contains an unwarranted assumption. The body needs to flow not around the sidebar, but around the sidebar's position. That may seem like splitting hairs, but it isn't -- because what if there were something floated where we want to put the sidebar? The body would flow around that space. If we could put the sidebar in that same location, we'd have a solution.

In my opinion, the W3C definition is unnecessarily confusing and restrictive. The dictionary definition of aside is "a temporary departure from a main theme or topic", and the spec should just stick to that, rather than introducing subtle distinctions.

I believe the accepted answer is not quite correct. According to the HTML5 working draft, the <aside> element can be used to mark up side notes in certain, but not all cases:

a remark or passage that departs from the theme of a discourse : digression The speaker inserted some often amusing parentheses during his speech.

an amplifying (see amplify sense 1) or explanatory word, phrase, or sentence inserted in a passage from which it is usually set off by punctuation explained further in a parenthesis

Parking Attendant is a glorified app game that somehow landed into the Steam Store

I like this approach more because I can scan the code that renders the Box component and easily spot that it takes two children. If the Box took any props, they'd be within the opening <Box> tag, and they would be distinct from any children props.

Lexical (semiotics) or content word, words referring to things, as opposed to having only grammatical meaning

Not to be confused with tree (graph theory), a specific type of mathematical object.

Not to be confused with trie, a specific type of tree data structure. Not to be confused with tree (graph theory), a specific type of mathematical object.

Some types exist as descriptions of objects, but not as tangible physical objects. One can show someone a particular bicycle, but cannot show someone, explicitly, the type "bicycle", as in "the bicycle is popular."

Property types (e.g. "height in metres" or "thorny") are often understood ontologically as concepts. Property instances (e.g. height = 1.74) are sometimes understood as measured values, and sometimes understood as sensations or observations of reality.

The words type, concept, property, quality, feature and attribute (all used in describing things) tend to be used with different verbs. E.g. Suppose a rose bush is defined as a plant that is "thorny", "flowering" and "bushy". You might say a rose bush instantiates these three types, or embodies these three concepts, or exhibits these three properties, or possesses these three qualities, features or attributes.

The distinction in computer programming between classes and objects is related, though in this context, "class" sometimes refers to a set of objects (with class-level attribute or operations) rather than a description of an object in the set, as "type" would.

The distinction is important in disciplines such as logic, linguistics, metalogic, typography, and computer programming.

The sentence "they drive the same car" is ambiguous. Do they drive the same type of car (the same model) or the same instance of a car type (a single vehicle)?

In the simple biology example, dog is a hypernym and Fido is one of its hyponyms. A word can be both a hyponym and a hypernym. For example, dog is a hyponym of mammal and also a hypernym of Fido.

words that are examples of categories are hyponyms

Two of the predominant types of relationships in knowledge-representation systems are predication and the universally quantified conditional.

Taxonomy is different from meronomy, which is dealing with the categorisation of parts of a whole.

The is-a relationship may also be contrasted with the instance-of relationship between objects (instances) and types (classes): see Type–token distinction.

While propositional logic can only express facts, autoepistemic logic can express knowledge and lack of knowledge about facts.

A predicate whose quantifiers all apply to individual elements, and not to sets or predicates, is called a first-order predicate.

a class is an implementation‍—‌a concrete data structure and collection of subroutines‍—‌while a type is an interface

Elin K. Jacob found that classification and categorization are different processes

Categorization is grounded in the features that distinguish the category's members from nonmembers.

semantic domain or semantic field