Also agree that <svelte:slot> is perhaps a little confusing since it replaces the slot attribute rather than the slot element, so <svelte:fragment> would make more sense

Just to reiterate the discussion on the RFC, there was a suggestion that we change <svelte:slot slot="foo"> to <svelte:fragment slot="foo">, since it's the counterpart to a <slot> rather than an equivalent to it

Our team is building open source community tools and Svelte fits our identity as an independent labor of love with an organic community.

With some frameworks, you may find your needs at odds with the enterprise-level goals of a megacorp owner, and you may both benefit and sometimes suffer from their web-scale engineering. Svelte’s future does not depend on the continued delivery of business value to one company, and its direction is shaped in public by volunteers.

Svelte’s aesthetics feel like a warm cozy blanket on the stormy web.

Making UIs with Svelte is a pleasure. Svelte’s aesthetics feel like a warm cozy blanket on the stormy web. This impacts everything — features, documentation, syntax, semantics, performance, framework internals, npm install size, the welcoming and helpful community attitude, and its collegial open development and RFCs — it all oozes good taste. Its API is tight, powerful, and good looking — I’d point to actions and stores to support this praise, but really, the whole is what feels so good. The aesthetics of underlying technologies have a way of leaking into the end user experience.

It's true that Svelte does not allow you to map over children like React, but its slot API and <svelte:component> provide similarly powerful composition. You can pass component constructors as props and instantiate them with <svelte:component>, and use slots and their let bindings for higher order composition. It sounds like you're thinking in virtual DOM idioms instead of Svelte's.

However, Svelte isn't React or Vue or any other framework, the same approach will not always work and given that Svelte has very different constraints and approach that works well in another framework is not suitable with Svelte. Trying to apply approaches use with other frameworks to Svelte will invariably end in frustration.

locked and limited conversation to collaborators

I think this issue can be closed and new issues be created / referenced here for any related functionality that isn't in yet.

Each area requires specific learning and thinking in a certain way. Front-end is user centric, back-end is closer to algorithms and parallel programming, databases require thinking in streams of data based on a model (similar to set theory and model checking).

To stay up-to-date with the new parts, just follow this medium or observe me on Twitter. In case you need some help, remember that I am open for consultation.

Serving pages and assets as pre-generated files allows read-only hosting reducing attack vectors even further. Meanwhile dynamic tools and services can be provided by vendors with teams dedicated to securing their specific systems and providing high levels of service.

Put yourself in the reader’s position and see if you can get a grip on how they might respond to your writing.

I personally think that starting from google's components makes easier to keeping update to material specs updates.

All replication in R6K relies on the two essential components of a minimal replicon, the γ ori, and its cognate Rep, π protein, encoded by the pir gene

; e-commerce sites have an economic incentiveto use personalization to induce users into spending moremoney

A new study that found traces of coronavirus in US blood samples from December last year is adding to the growing evidence that the virus was circulating for months before China announced its existence, casting more shadows over the truth about the pandemic and fuelling suspicions of a cover-up by Beijing. 

It does not include any user interface at all (not even a terminal UI)

The Thirteen Sources of Well-Being:More positive emotionsFewer negative emotionsLife satisfactionVitalityEnvironmental masteryPositive relationshipsSelf-acceptanceMasteryAutonomyPersonal growthEngagement in lifePurpose and meaning in lifeTranscendent experiences

Selection by association, rather than indexing, may yet be mechanized. One cannot hope thus to equal the speed and flexibility with which the mind follows an associative trail, but it should be possible to beat the mind decisively in regard to the permanence and clarity of the items resurrected from storage.

The real heart of the matter of selection, however, goes deeper than a lag in the adoption of mechanisms by libraries, or a lack of development of devices for their use. Our ineptitude in getting at the record is largely caused by the artificiality of systems of indexing. When data of any sort are placed in storage, they are filed alphabetically or numerically, and information is found (when it is) by tracing it down from subclass to subclass. It can be in only one place, unless duplicates are used; one has to have rules as to which path will locate it, and the rules are cumbersome. Having found one item, moreover, one has to emerge from the system and re-enter on a new path.

Traditional online funnels — more often than not — require you to have a separate:Content management system (ex. WordPress, Joomla)Web host (ex. SiteGround, Bluehost)Page builder (ex. Elementor, Beaver)Email autoresponder (ex. MailChimp, Aweber, GetResponse)Order formShopping cartWeb analyticsOther marketing tools

the adjective strong or the adverb strongly may be added to a mathematical notion to indicate a related stronger notion; for example, a strong antichain is an antichain satisfying certain additional conditions, and likewise a strongly regular graph is a regular graph meeting stronger conditions. When used in this way, the stronger notion (such as "strong antichain") is a technical term with a precisely defined meaning; the nature of the extra conditions cannot be derived from the definition of the weaker notion (such as "antichain")

Svelte by itself is great, but doing a complete PWA (with service workers, etc) that runs and scales on multiple devices with high quality app-like UI controls quickly gets complex. Flutter just provides much better tooling for that out of the box IMO. You are not molding a website into an app, you are just building an app. If I was building a relatively simple web app that is only meant to run on the web, then I might still prefer Svelte in some cases.

Others have already said how Flutter renders inside a canvas and how it's difficult/impossible for it to interact with other JS libraries (and why would you want to... the whole thing is so different that even the issues are solved by completely different libraries).

As was mentioned in the comments above, the material design spec for buttons specifies that the text should be uppercase, but you can easily override its CSS property: paper-button { text-transform: none; }

However, in the all caps example the order of importance goes Title->Actions->Description (or even the actions before the title), while in the others this order is not as evident at first glance.

That’s how developers create buttons — they add padding to their div containers, not heights.

enables passive event listeners by default for some events (see list below). It basically will set { passive: true } automatically every time you declare a new event listener.

Microbundle also outputs a modern bundle specially designed to work in all modern browsers. This bundle preserves most modern JS features when compiling your code, but ensures the result runs in 90% of web browsers without needing to be transpiled. Specifically, it uses preset-modules to target the set of browsers that support <script type="module"> - that allows syntax like async/await, tagged templates, arrow functions, destructured and rest parameters, etc. The result is generally smaller and faster to execute than the esm bundle

passive: true instructs chrome that no body will call e.preventDefault() so chrome can optimized scrolling just because no body will call e.preventDefault and so there is no need to wait listeners...

Programmers working in different kinds of programming languages often come up with radically different solutions to problems.

@use "@material/theme" with (  $primary: #FEDBD0,  $on-primary: #442C2E);

In the case of email, it can be argued that the widespread use of the unhyphenated spelling has made this compound noun an exception to the rule. It might also be said that closed (unhyphenated) spelling is simply the direction English is evolving, but good luck arguing that “tshirt” is a good way to write “t-shirt.”

If I understand the problem correctly, just changing the imports to point to svelte/internal isn't enough because they could still point to different packages depending on how your components are bundled. It solved your specific issue, but if you had two completely unrelated Svelte components compiled to vanilla javascript bundled with Svelte, you'd still hit issues with mismatching current_component when using slots or callbacks.

It sounds like another case of multiple svelte/internal modules? I think we need to look into reworking how svelte/internal keeps track of the current component since it breaks when mixing components not bundled with the app. It sounds like we need to find a way to pass Svelte's internal runtime state when instantiating components, since slots and callbacks end up mixing different svelte/internal together.

As mentioned in #2937, this is the sort of thing that happens when you have two copies of Svelte's internal scheduler running. If you're importing the compiled version of an external Svelte component into another Svelte component, this is what you end up with. There's a svelte field in package.json that's respected by rollup-plugin-svelte and which is intended to point at the uncompiled Svelte source, so that the external component can be bundled together with the main app, without any duplicated internals.

When using the exact same Button code, the binding only works for the local Svelte module.

You could totally just write your own name and not use the name in package.json, this template is made so the users wouldn't need to think about the UMD build.

But seriously, give snowpack a read to understand the benefits of leaning on standard esm imports, allowing you to avoid a bundling process entirely.

I don't need to support non-esm browsers for most projects and I really like the idea of a super light build process. By removing the complexity of configuration and the overhead of bundling, svelvet makes the development process an optimal experience for myself and hopefully others

It replaces heavier, more complex bundlers like webpack or Parcel in your development workflow.

Who’s Using Snowpack?

Depending on your needs, you can use the Simple Approach: Wrapping MDC Web Vanilla Components, or the Advanced Approach: Using Foundations and Adapters.

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.

I asked for leave to go to the bazaar on Saturday night. My aunt was surprised and hoped it was not some Freemason affair. I answered few questions in class

Self-Actualization Self-actualization refers to feeling fulfilled, or feeling that we are living up to our potential. One unique feature of self-actualization is that it looks different for everyone. For one person, self-actualization might involve helping others; for another person, it might involve achievements in an artistic or creative field. Essentially, self-actualization means feeling that we are doing what we believe we are meant to do. According to Maslow, achieving self-actualization is relatively rare, and his examples of famous self-actualized individuals include Abraham Lincoln, Albert Einstein, and Mother Teresa.

The most recognized theory of intrinsic motivation was first based on people’s needs and drives. Hunger, thirst, and sex are biological needs that we’re driven to pursue in order to live and be healthy.

Used by folks at

The project organization is a bit weird because we have a mono-repository that contains projects and libraries. The projects are grouped by company and by browser / server / universal.

For future reference, webpack 2 removed everything but modules as a way to resolve paths. This means root will not work.

There was a major refactoring in the resolver (https://github.com/webpack/enhanced-resolve). This means the resolving option were changed too. Mostly simplification and changes that make it more unlikely to configure it incorrectly.

Alexanderproposeshomesandofficesbedesignedandbuiltbytheireventualoccupants.Thesepeople,hereasons,knowbesttheirrequirementsforaparticularstructure.Weagree,andmakethesameargumentforcomputerprograms.Computerusersshouldwritetheirownprograms.KentBeck&WardCunningham,1987 [7]

Connected to this are Andy Matuschak’s comments about contextual backlinks bootstrapping new concepts before explicit definitions come into play.

Easily updated pages: don’t worry about precisely naming something at first. Let the meaning emerge over time and easily change it (propagating through all references).

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