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

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.