Be explicit in the demo's intend. Eg. if you're building a demo for argTypes, don't create a Button.svelte component and Button.stories.svelte stories and come up with examples for how to write argTypes for buttons. Instead, build an ArgTypes.svelte component and stories that clearly and only demonstrates argTypes.

Given that they are not used that frequently, we traded a smaller surface area for more explicitness.

Autolinks do not work in MDX. The reason is that they can be indistinguishable from JSX (for example: <svg:rect>) and we prefer being explicit. If you want links, use full links: [descriptive text](https://and-the-link-here.com)

as crucial dimensions are left unacknowledged

Whether a personalized button or a generic text button displays has no impact on the UX flows after the button is clicked. The account displayed in the personalized button is not automatically selected.

and pressed the Confirm button to grant consent and share credentials.

Implement restrictive defaults (potentially allowing an explicit bypass) I understand that easy usability and rich out-of-the-box functionality is likely essential to this library's appeal to its users. Nevertheless I'd like to propose making the authorization properties ransackable_[attributes/associations/etc.] empty sets by default, forcing the developer to explicitly define whitelists for their use case. To soften the usability blow, a new ransack_unsafe(params[:q]) or ransack_explicit(params[:q], ransackable_attributes='*', ransackable_associations=(:post, :comment)) method could be introduced to offer developers a shorthand to bypass or override the whitelists for specific queries (after they've had to read a warning about why these methods can be dangerous).

Everything I'm saying to you right now is literally meaningless. (Laughter) 00:03:11 You're creating the meaning and projecting it onto me. And what's true for objects is true for other people. While you can measure their "what" and their "when," you can never measure their "why." So we color other people. We project a meaning onto them based on our biases and our experience.

Anything that isn't explicitly enforced by contract is vulnerable to misunderstandings. It's doing your teammates a great service, and reducing everyone's effort, by eliminating ambiguity and enforcing information flow by design.

There are different kinds of information, some of which don't make sense being recorded at all. I was struggling with what to record and what not to record for a long time. For example, I took notes on programming syntax that are just useless (most of these things can be googled in seconds and they are usually decently documented already).

I've edited the title slightly to make the intent of the question more obvious.

Within 2 years, I became explicitly aware, in a visionary moment, of what I now call ‘natural inclusion’. I

Explicitly defining the dependency in the reactive declarations

inputValue = updateInputValue(value);

3. The no-keyword-arguments syntax (**nil) is introduced You can use **nil in a method definition to explicitly mark the method accepts no keyword arguments. Calling such methods with keyword arguments will result in an ArgumentError. (This is actually a new feature, not an incompatibility)

This is useful to make it explicit that the method does not accept keyword arguments. Otherwise, the keywords are absorbed in the rest argument in the above example.

You need to explicitly delegate keyword arguments. def foo(*args, **kwargs, &block) target(*args, **kwargs, &block) end

foo({}, **{}) #=> Ruby 2.7: [{}] (You can pass {} by explicitly passing "no" keywords)

Prettier intentionally doesn’t support any kind of global configuration. This is to make sure that when a project is copied to another computer, Prettier’s behavior stays the same. Otherwise, Prettier wouldn’t be able to guarantee that everybody in a team gets the same consistent results.

Explicit types for function return values and arguments makes it clear to any calling code what is the module boundary's input and output.

The implicit dependencies between different versions of different services were not expressed anywhere, which led to various problems in building, continuous integration, and, notably, repeatable builds.

If your python3 executable is named "python" instead of "python3" (this particularly appears to affect a number of Windows users), then you'll also need to modify the first line of git-filter-repo to replace "python3" with "python".

--tag-rename '':'my-module-' (the single quotes are unnecessary, but make it clearer to a human that we are replacing the empty string as a prefix with my-module-)

I wish to define methods within the class they belong to. Using class << self demonstrates that approach clearly — we are defining methods within the actual singleton class scope.

Explicit affordances are obvious, perceptual features of an item that clue you in on how it is to be used. With explicit affordances, physical appearance and any accompanying language or text inform the user of how an object is to be used.

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.

An individual semantic feature constitutes one component of a word's intention, which is the inherent sense or concept evoked.

When you're didactic, you're trying to teach something. Just about everything teachers do is didactic: the same is true of coaches and mentors.

HTML elements have meaning. "Semantically correct" means that your elements mean what they are supposed to.

the explicit modelling has one massive advantage: all possible outcomes of the nested activity are visible and have to be connected in the outer diagram

To understand this helper, you should understand that every step invocation calls Output() for you behind the scenes. The following DSL use is identical to the one [above]. class Execute < Trailblazer::Activity::Railway step :find_provider, Output(Trailblazer::Activity::Left, :failure) => Track(:failure), Output(Trailblazer::Activity::Right, :success) => Track(:success)

Regardless of origin, allow/deny are simply clearer terms that does not require tracing the history of black/white as representations of that meaning. We can simply use the meaning directly.

Instead of dealing with a mix of before_filters, Rack-middlewares, controller code and callbacks, an endpoint is just another activity and allows to be customized with the well-established Trailblazer mechanics.

Because the Berne Convention in most countries by default grants copyright holders monopolistic control over their creations, copyright content must be explicitly declared free, usually by the referencing or inclusion of licensing statements from within the work.

Like Humpty Dumpty proclaimed in Lewis Carroll's Through the Looking Glass, "When I use a word, it means just what I choose it to mean -- neither more nor less."

a direct specific meaning as distinct from an implied or associated idea

Something that is explicit is stated directly and is clear in meaning. Explicit meaning is the easiest to pick out from a text.

While each of these two words has several possible meanings, they are notably distinct from each other in all senses. Denotation is concerned with explicit meaning, and connotation tends to be concerned with implicit meaning.

Explicit intents specify which application will satisfy the intent, by supplying either the target app's package name or a fully-qualified component class name. You'll typically use an explicit intent to start a component in your own app, because you know the class name of the activity or service you want to start.

Instead of trying to educate everyone on the complexities of copyright law, we’d rather make our intentions clear with this simple statement:

I think you want a symbol with a circle around it, like the circle around the C in ©. That way the association with the copyright symbol is clear.

The main objective of this project is to allow people to create Bible related apps using XML and JSON.

this second approach, while more verbose, sort of spells out better where things are coming from. (I like it, in other words.)

I open this issue to announce that i'm actively working on a rewrite of this library to accomplish these goals:

This decorators proposal is based on a common model where each decorator affects just one syntactic element--either a field, or a method, or a getter, or setter, or a class. It is immediately visible what is being decorated.

There are several built-in modules — math, color, string, list, map, selector, and meta — which have to be imported explicitly in a file before they are used:

In brief, @import is being replaced with more explicit @use and @forward rules. Over the next few years Sass @import will be deprecated, and then removed.

There's an issue #3368 for describing better what triggers reactive updates, as I do think there is some stuff we could be more explicit about

We aim to support all svelte features. In some cases this is not possible. For those cases we provided feasible workarounds.

It will not re-run your component’s code on update unless explicitly told to do so, using the $: operator.

This assumes that the module has been given a well-defined, stable description (the interface in the sense of information hiding).

I couldn't land on how I wanted to box primitives. Should I use a getter/setter, or function form like Knockout, or explicit get/set like MobX? These were all ugly.

Reducing the amount of code you have to write is an explicit goal of Svelte.

I can't add special props and keywords to every single component I have and will ever create for this to work.

Explicitly exposing any attributes that might get overridden by a parent seems impractical to me.

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.

Web developers are well aware of the mess you can get into with global CSS, and the action of writing <Child class="foo"/> and <div class={_class}>` (or similar) in the child component is an explicit indication that, while taking advantage of all the greatness of style encapsulation by default, in this case you have decided that you want a very specific and controlled "leak", of one class, from one component instance to one component instance.

Besides, it's probably better for component authors to be explicit about whether or not their component maps to a specific runtime element.

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.

Now it is much clearer that id is really a family of infinitely many functions. It is fair to say that it is an abstract function (as opposed to a concrete one), because its type abstracts over the type variable a. The common and proper mathematical wording is that the type is universally quantified (or often just quantified) over a.

Quantified Types

While Rails supports numbering of initializer file names for load ordering purposes, a better technique is to place any code that need to load in a specific order within the same file. This reduces file name churn, makes dependencies more explicit, and can help surface new concepts within your application.

Explicit Form (where the purpose of the sign-up mechanism is unequivocal). So for example, in a scenario where your site has a pop-up window that invites users to sign up to your newsletter using a clear phrase such as: “Subscribe to our newsletter for access to discount vouchers and product updates!“, the affirmative action that the user performs by typing in their email address would be considered valid consent.

Does a China-based company selling goods over a website only drafted in Chinese need to comply with the GDPR just because it’s possible, from a practical point of view, that some EU-based Chinese persons might purchase something from it? In principle we’d say no, unless it can be proven, that the company is doing relevant business with EU-based customers, or is addressing them expressly (for instance, by informing that “delivery to the EU” or “payment from an EU bank account” are possible etc.).

these active behaviors may include continued browsing, clicking, scrolling the page or some method that requires the user to actively proceed; this is somewhat left up to your discretion. Some website/app owners may favor a click-to-consent method over scrolling/continued-browsing methods as the former is less likely to be performed by user error.

Rather than using NFS for this task, use explicit data duplication, via one of the long-established mechanisms designed for this purpose.

just ask the question directly, and the person will respond asynchronously. If you truly need to have a synchronous communication, then start by asking for that explicitly, while mentioning the subject. e.g., "I'm having trouble understanding issue #x, can we talk about it quickly?"

language or customs.

Explicit culture makes up part of what we know, a level of knowledge people can communicate about with relative ease.

UsesExplicitTacitCultural

Explicit culture

Very good then; as you profess to be a rhetorician, and a maker of rhetoricians, let me ask you, with what is rhetoric concerned: I might ask with what is weaving concerned, and you would reply (would you not?), with the making of garments?