Cognitive Overhead (aka Cognitive Load): often the task of specifying formalism is extraneous to the primary task, or is just plain annoying to do.

The basic intuition is described well by the Shipman & Marshall paper: users enter information in a mostly informal fashion, and then formalize only later in the task when appropriate formalisms become clear and also (more) immediately useful.

It’s important to notice something about these examples of synthesis representations: they go quite a bit further than simply grouping or associating things (though that is an important start). They have some kind of formal semantic structure (otherwise known as formality) that specifies what entities exist, and what kinds of relations exist between the entities. This formal structure isn’t just for show: it’s what enables the kind of synthesis that really powers significant knowledge work! Formal structures unlock powerful forms of reasoning like conceptual combination, analogy, and causal reasoning.

Systems which display backlinks to a node permit a new behavior: you can define a new node extensionally (rather than intensionally) by simply linking to it from many other nodes—even before it has any content.

Replication begins

“Diversity of Thought” without Diverse Representation is Status Quo

We don't have clear visibility on which issues the VSCode team is planning on fixing & we would like to avoid duplicating work.

However, this construct is not completely equivalent to if ... fi in the general case.

What's not obvious here is how the quotes nest. A C programmer reading this would expect the first and second double-quotes to be grouped together; and then the third and fourth. But that's not the case in Bash. Bash treats the double-quotes inside the command substitution as one pair, and the double-quotes outside the substitution as another pair.

Important caveat: in the combined expression, if the middle command has a non-zero exit status, then both the middle and the rightmost command end up getting executed.

bedmap && mv || fail

⟫ true && false || echo 'fail'
fail

⟫ false && true || echo 'fail'
fail

I just learned here that || and && have equal precedence in bash (different from C, Java, etc.)

When you email me, please include a minimal bash script that demonstrates the problem in the body of the email (not as an attachment). Also very clearly state what the desired output or effect should be, and what error or failure you are getting instead. You are much more likely to get a response if your script isn't some giant monster with obtuse identifiers that I would have to spend all afternoon parsing.

It is open to the community to help set its direction.

Broadly speaking, modularity is the degree to which a system's components may be separated and recombined, often with the benefit of flexibility and variety in use.

In Rust, we use the "No New Rationale" rule, which says that the decision to merge (or not merge) an RFC is based only on rationale that was presented and debated in public. This avoids accidents where the community feels blindsided by a decision.

I'd like to go with an RFC-based governance model (similar to Rust, Ember or Swift) that looks something like this: new features go through a public RFC that describes the motivation for the change, a detailed implementation description, a description on how to document or teach the change (for kpm, that would roughly be focused around how it affected the usual workflows), any drawbacks or alternatives, and any open questions that should be addressed before merging. the change is discussed until all of the relevant arguments have been debated and the arguments are starting to become repetitive (they "reach a steady state") the RFC goes into "final comment period", allowing people who weren't paying close attention to every proposal to have a chance to weigh in with new arguments. assuming no new arguments are presented, the RFC is merged by consensus of the core team and the feature is implemented. All changes, regardless of their source, go through this process, giving active community members who aren't on the core team an opportunity to participate directly in the future direction of the project. (both because of proposals they submit and ones from the core team that they contribute to)

also, should RFCs include working code (basics for the IETF work)?

If this PR merges and it has unforseen bugs / issues, I'm not sure anyone would have the time to jump in and fix it. So, that's why I'm being cautious about approving/merging it.

I refuse to back anything from Queen games. Their kickstarters, IMO, are meant to get people to have FOMO instead of something being worth the price.

This plugin was designed as a proof-of-concept for a feature that's destined for Rails 4. It has only been tested on Rails 3.2+, but may work on earlier versions as well.

Avoid transpilers like Babel and Bublé (and if you're using TypeScript, target a modern version of JavaScript)

Reviewing pre-prints with hypothes.is?

{#key} was introduced in Svelte v3.28, before that you needed to use a keyed {#each} block with only one item When the key changes, svelte removes the component and adds a new one, therefor triggering the transition.

by Irfan Skiljan

Coming from stuff like jQuery, a lot of devs who used React were like "wow", and coming from React, Svelte feels amazing too! People just need to try it, it's so incredibly simple too!

Svelte's advantage here is that it indicates the need for an update at the place where the associated data is updated, instead of at each place the data is used. Then each template expression of reactive statement is able to check very quickly if it needs to rerender or not.

We don't use "attribute directives" much which makes things easier.

Svelte slots are much easier to use and reason about than Angular transclude, especially in cases where you don't want an extra wrapper element around the slot content.

first-personal thought and language is irreducible to non-first-personal thought and language, and is essential to the explanation of action

I guess I was just waiting for some interest from a maintainer, since there's not much point in wasting my time on developing this if the maintainers aren't even interested in this feature.

I realise this is old, but as it isn’t a forum i see no problem in replying

I've only done components that need to/can be Svelte-ified. For some things, like RTL and layout grid, you can just use the MDC packages.

This is Sass based, and therefore doesn't require Svelte components

You can support my work on this project through my other project, Tunnelgram.

This is not an MDC Web component. It is an addition that SMUI provides.

Tunnelgram is fully open source (server and client) and uses the Tunnelwire Encryption Scheme, so you can see all of the code it's built on.

The resolve.alias option is used to make sure that only one copy of the Svelte runtime is bundled in the app, even if you are npm linking in dependencies with their own copy of the svelte package. Having multiple copies of the internal scheduler in an app, besides being inefficient, can also cause various problems.

If your Svelte components contain <style> tags, by default the compiler will add JavaScript that injects those styles into the page when the component is rendered. That's not ideal, because it adds weight to your JavaScript, prevents styles from being fetched in parallel with your code, and can even cause CSP violations. A better option is to extract the CSS into a separate file. Using the emitCss option as shown below would cause a virtual CSS file to be emitted for each Svelte component. The resulting file is then imported by the component, thus following the standard Webpack compilation flow.

Frontend frameworks are a positive sum game! Svelte has no monopoly on the compiler paradigm either. Just like I think React is worth learning for the mental model it imparts, where UI is a (pure) function of state, I think the frontend framework-as-compiler paradigm is worth understanding. We're going to see a lot more of it because the tradeoffs are fantastic, to where it'll be a boring talking point before we know it.

Quick self-promotion plug (but in the name of altruism)

overmind is basically foreman but done "well"

I understand your point and yes, at least as of now, the issue is purely related to #4652 (can’t exclude that others will find different uses in the future, however).

Just coming here to voice my agreement that these warnings are annoying and exist in other libraries as well. For me this happened with svelma. I didn't write the library code, so I don't have complete control over it even though I agree there is an argument to be had around whether I should be notified anyway. In either case, these warnings should be easily disabled since libraries don't always get updated over night.

Maybe it's also a bug because every warning should be ignorable? Not sure.

I would like the compiler to add a property like canIgnore: false to the warning, if the warning cannot be disabled.

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

Since 'using decorators' has come to mean 'smothering your code in @ symbols' it's probably no longer a great name.

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

We all know that real business logic does not belong in the presentation layer, but what about simple presentation-oriented things like coloring alternate rows in table or marking the selected option in a <select> dropdown? It seems equally wrong to ask the controller/business logic code to compute these down to simple booleans in order to reduce the logic in the presentation template. This route just lead to polluting the business layer code with presentation-oriented logic.

Templates with logic versus "logic-less" templates is a hotly debated point among template language designer and users. Dust straddles the divide by adopting a "less logic" stance.

To detect foreign DNA in 5 ml of lake water, 15 ml of lake water must be screened.

'Sleeping giant' Arctic methane deposits starting to release, scientists find

As of OpenSSL 1.1.1, providing subjectAltName directly on command line becomes much easier, with the introduction of the -addext flag to openssl req

Over 4 million people trust CloudApp

Win back your calendar and stop wasting time in meetings. Our screen recorder can provide the context and connection of a meeting without the time commitment.

the azaleas

A spreadsheet may be represented as a directed acyclic graph, with each cell a vertex and an edge connected a cell when a formula references another cell. Other applications include scheduling, circuit design and Bayesian networks.

"We should try to find a replacement for omgwtfssl, which is currently used to generate self-signed certificates. The name is inappropriate and unprofessional."

Instead of this, you can use a File type variable.

Previously, a common pattern was to read the value of a CI variable, save it in a file, and then use that file in your script:

Here is a simplified example of a malicious .gitlab-ci.yml

there are superior ways to share environment variables

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

I use a mutator and use it's changeValue function to 'change' the value of the relevant field (I supply the same value). This in turn notifies all relevant parties of the change to the form's state, and a validation is triggered.

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)

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.

I'd be happy to take on this issue, if no one else has up to this point!

The great ones have a thought pro-cess, philosophy and habit all rolled into one that overshadows the rest: I am responsible.

Separation of concerns: You will avoid having your business logic being tied up to the UI

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.

const countriesRegExp = countries.reduce( (regex, country, i) => (i === 0 ? `(${country})` : `${regex}|(${country})`), "" )

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!

On the other hand, handling form validation on your own can be tempting, but you have to cover scenarios like:

If you want to implement a form with a superb User Experience, you have to take care of many variables:

Use the same value that was submitted, which ensures that a 'change' is triggered even though the value itself doesn't change. Therefore, the same value gets validated again.

  mutateValue([name], state, { changeValue }) {
    // change the value to the same value, thus
    // triggering a revalidation of the same value
    changeValue(state, name, value => value);
  }

Unfortunately, it is an expression mired with a negative context because of how Rumsfeld used it to lie.

In agent-oriented programming the antonym is depender, though in general usage the common term dependent is used instead. There is no common language equivalent for dependee', however – other metaphors are used instead, such as parent/child. The circumlocutions “A depends on B” and “B is depended on by A” are much more common in general use than “A is the depender, B is the ' dependee ”.

In the software industry we use "dependency" to refer to the relationship between two objects. We say "looking for dependents" for relationships to dependent things and "looking for dependencies" for relationships to prerequisite things, so it gets that connotation, but the literal meaning is the relationship itself, not the object. Finding a better word is exactly the point of the question

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.

withindex.js, we have a single source of truth, giving fine grained control on what we expose to the outside world.

Here are few, real-life commits of refactorings that make use of this solution:

Examples of this include: requiring base classes or reading from imported variables that have not been initialized yet.

Human empathy in the perception of nature

To silence circular dependencies warnings for let's say moment library use: // rollup.config.js import path from 'path' const onwarn = warning => { // Silence circular dependency warning for moment package if ( warning.code === 'CIRCULAR_DEPENDENCY' && !warning.importer.indexOf(path.normalize('node_modules/moment/src/lib/')) ) { return } console.warn(`(!) ${warning.message}`) }

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

When communicating, being more specific is usually better, and a “URL” is a specific type of URI that provides an access method/location.

Venn diagrams are a more restrictive form of Euler diagrams

Handling all these requests costs us considerably: servers, bandwidth and human time spent analyzing traffic patterns and devising methods to limit or block excessive new request patterns. We would much rather use these assets elsewhere, for example improving the software and services needed by W3C and the Web Community.

For the law ofnature, like every law concerning men in this world, would befutile if no-one had power to enforce it and thereby preservethe innocent and restrain offenders

A simple rule of thumb: the name of the updated variable must appear on the left hand side of the assignment. For example this... const foo = obj.foo; foo.bar = 'baz';...won't update references to obj.foo.bar, unless you follow it up with obj = obj.

you are granting us the right to use your User Content without the obligation to pay royalties to any third party

You or the owner of your User Content still own the copyright in User Content sent to us, but by submitting User Content via the Services, you hereby grant us an unconditional irrevocable, non-exclusive, royalty-free, fully transferable, perpetual worldwide licence to use, modify, adapt, reproduce, make derivative works of, publish and/or transmit, and/or distribute and to authorise other users of the Services and other third-parties to view, access, use, download, modify, adapt, reproduce, make derivative works of, publish and/or transmit your User Content in any format and on any platform, either now known or hereinafter invented.

He took three paces—with the fourth he reached his goal,       

Adding an API for something is an endorsement of that approach.

I'm more inclined towards an {@ tag than a {# tag because the indentation could quickly get out of control

But of course this could be overused.

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.

<p>{(x *= 4)} {(x *= x)} {(x *= x)}</p>

Listening for External Changes By wrapping a stateful ExternalModificationDetector component in a Field component, we can listen for changes to a field's value, and by knowing whether or not the field is active, deduce when a field's value changes due to external influences.

I run s.search() by typing into an input box, and if I type gibberish very quickly, the console prints out "making search request" on every key press, so many times per second -- indicating that it hasn't been debounced at all.

but the design pattern is so simple that it takes hardly any effort to implement it on any existing reducer, so I rejected abstraction for abstraction's sake.

Link to https://ponyfill.com in your readme. Example. Add ponyfill to the keywords section in package.json.

Cognitive Presence “is the extent to which learners are able to construct and confirm meaning through sustained reflection and discourse” (Community of Inquiry, n.d, para. 5). Video is often used as a unidirectional medium with information flowing from the expert or instructor to the learner. To move from transmission of content to construction of knowledge, tools such as Voice Thread (VoiceThread, 2016) support asynchronous conversation in a multimedia format.

15 Fall Scenarios

Online learning, blended learning, flipped learning, hybrid learning, flexible learning, open learning and distance education are all terms that are often used inter-changeably, but there are significant differences in meaning. More importantly, these forms of education, once considered somewhat esoteric and out of the mainstream of conventional education, are increasingly taking on greater significance and in some cases becoming mainstream themselves. As teachers and instructors become more familiar and confident with online learning and new technologies, there will be more innovative methods developing all the time.

You might be interested in my products:

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

For years, I’ve shared with friends and clients what I call the bunny theory of code. The theory is that code multiplies when you’re not looking, not unlike bunnies that tend to multiply when you’re not looking.

Anyone who’s ever worked with me knows that I place a very high value on what ends up checked-in to a source code repository.

Checking in is akin to sharing your code with others, and once out in the world, it’s hard to predict what that code will do.

nzaka's theory of bunny code is relevant here

mixing the turing complete of javascript with the markup of HTML eliminates the readability of JSX so that it is actually harder to parse than a solution like hyperscript

I'm okay with an overall design that allows people to plugin the parts they need in order to be able to generically support a compile-to-javascript language, but to bake in support for one singular solution because its popular is simply bad engineering.