I don't think this is what really matters at the end, since whatever is the implementation the goal should be to provide a library that people actually like to use.

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

These are sequential because build:ssr imports the public/index.html that build:dom produces.

Appeal highlights

UNICEF’s Humanitarian Action for Children appeal helps support the agency’s work as it provides conflict- and disaster-affected children with access to water, sanitation, nutrition, education, health and protection services. Read more about this year’s appeal here.  

Key planned results for 2020

Funding requirements for 2020

For safety reasons, certain pumps and sprayers cannot be returned to the store if opened.

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 answer should be: you write a language that compiles to Go’s IR.

One important other option is using another programming language as your IR! If you can compile (or perhaps more accurately transpile) your language into C, then you can leverage gcc (or clang, etc) into compiling that all the way down into machine code.

delete myObject.regex; // or, delete myObject['regex']; // or, var prop = "regex"; delete myObject[prop];

emphasizing that 'this' and 'global object' are two different things not only in Node.js but in JavaScript in general

I wouldn't use Flutter for web, mobile is good though.

It's super promising for web apps, just maybe not for web pages. I went from React to Svelte to Flutter for my current app project, and every step felt like a major upgrade.Flutter provides the best developer experience bar none, and I think it also has the potential to provide the best user experience. But probably only for PWAs, which users are likely to install anyway. Or other self-contained experiences, like Facebook games. It does have some Flash vibes, but is far more suitable for proper app development than Flash ever was while still feeling more like a normal website to the average user. It won't be the right choice for everything, but I believe it will be for a lot of things.

I also find that a lot of the complexity of Flutter can be avoided, and I mostly use it to define the UI as a more app-centric alternative to HTML/CSS.

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.

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.

When writing copy for buttons, make sure that you keep consistency.

Note: Yes, it is sentence case, and yes, there should be a full stop if it was true sentence case — but for the love of all things good and designy, please don’t add a full stop.

“Why?” you ask. This is for two reasons.

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.

There are actually 3 other libraries that implements material in svelte, i hope this to become the community favorite because using MDC underneath it implements correctly Material guidelines.

from my point of view, it is (by far) the best way, to build a layer on top https://github.com/material-components/material-components-web . This is also the path that the Angular Material team has taken, although they have already made a huge effort to create the components themselves.

After i've stabilized the library i can start to discuss about adding new components and features!

This one gets the SEO, so I hope you're successful @raythurnevoid.

There is no rerender, when you call listen, then all scroll events will warn on chrome. See this entry from svelte: breaking the web

Many linguists believe that the natural language a person speaks affects how they think. Does the same concept apply to computer languages?

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.”

Svelte makes the pit of success larger because it hides all of this from us at compile time.

At the start this is hard to get right, and bad practices will sneak into the codebase.

Because of those similarities, it's possible to automate some of the changes.

I'm still calling this v1.00 as this is what will be included in the first print run.

So handling the interop upfront will avoid users writing invalid ES6 and make sure that they write ES6 that loads CommonJS in the right way.

It is important to notice that if you are planning on making your application a PWA, you don’t have to rewrite all the logic.

The ultimate goal of the Open Library is to make all the published works of humankind available to everyone in the world. While large in scope and ambition, this goal is within our grasp.

This library is part of a general project at the Internet Archive (archive.org) to support the decentralized web.

We convene the Decentralized Web Summit, dedicated to creating the Web we want and the Web we deserve. A Web that is private, safe and locked open for good.

This module should not be used in other npm modules since it modifies the default require behavior! It is designed to be used for development of final projects i.e. web-sites, applications etc.

IL-1β is anti-inflammatory

Never use x && y || z when y can return a non-zero exit status.

I think what the author intended to do was check if the second argument was a non-empty string (which is not the same thing as checking whether there are more than 1 argument, as the second argument could be passed but be the empty string).

Man, for some reason, I really like this answer. I recognize it's a bit more complicated, but it seems so useful. And given that I'm no bash expert, it leads me to believe that my logic is faulty, and there's something wrong with this methodology, otherwise, I feel others would have given it more praise. So, what's the problem with this function? Is there anything I should be looking out for here?

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

Some people try to use && and || as a shortcut syntax for if ... then ... else ... fi, perhaps because they think they are being clever.

The imports in the published package should now be fixed in 3.29.5.

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

The meaning of the word "modularity" can vary somewhat based on context. The following are contextual examples of modularity across several fields of science, technology, industry, and culture:

This seems to be #31189 . It should be fixed when you update to v17.03.0-ce

It took us a long time for everyone to get on the same page about the requirements spanning frameworks, tooling and native implementations. Only after pushing in various concrete directions did we get a full understanding of the requirements which this proposal aims to meet.

that's the only really accurate answer to the question: all the others propositions run an "almost same" container, but they forget the volumes, env, UIDs,

Why the urgency? You can always fall back to a full clone.

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)?

All browers handle 302 incorrectly. Chrome 30, IE10. It became the de facto incorrect implementation; that cannot be changed because so many web-sites issue mistakenly issue 302. In fact ASP.net MVC incorrectly issues 302, depending on the fact that browsers handle it incorrectly.

You’ve let this room and this house replace you and yourwife in your children’s affections.

Their approach sensitized a switch somewhere and the nursery light flicked on when they came within ten feet of it. Similarly, behind them, in the halls, lights went on and off as they left them behind, with a soft automaticity.

“Don’t let them do it!”wailed Peter at the ceiling, as if he was talking to the house, the nursery. “Don’t let Father kill everything.”He turned to his father. “Oh, I hate you!”“Insults won’t get you anywhere.”

Things that cause the error to go away If I change any one of the following factors (which should not make any difference), then everything works fine:

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.

Some of these values are suited for development and some for production. For development you typically want fast Source Maps at the cost of bundle size, but for production you want separate Source Maps that are accurate and support minimizing.

We expect a certain pattern when validate devtool name, pay attention and dont mix up the sequence of devtool string. The pattern is: [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map.

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

can you not also use a .babelrc?

There are a few intentional behavioral differences between Dart Sass and Ruby Sass. These are generally places where Ruby Sass has an undesired behavior, and it's substantially easier to implement the correct behavior than it would be to implement compatible behavior. These should all have tracking bugs against Ruby Sass to update the reference behavior.

Internal Sass features have also moved into the module system, so we have complete control over the global namespace.

will only apply up the chain

We already are reserving a prop called slot so that we can do <Foo slot='bar'/> someday

Note that when using sass (Dart Sass), synchronous compilation is twice as fast as asynchronous compilation by default, due to the overhead of asynchronous callbacks.

You will be disrupted by this first issue. It is natural to expect relative references to be resolved against the .sass/.scss file in which they are specified (like in regular .css files).

When you do import '../scss/application.scss', you're telling webpack to include application.scss in the build. This does not mean it's going to be compiled into your javascript, only that webpack now compiles and knows how to load this file.

You’ll learn how to cause stack overflows, illegal memory access, andother common flaws that plague C programs so that you know what you’re upagainst

If the goal of this is purely to avoid showing a runtime warning (and isn't needed for other functionality) I think we should try to consider other ways of dealing with the root issue. See also #4652, which has been opened for just this concern.

they're in the svelte compiler: https://github.com/sveltejs/svelte/blob/master/src/compiler/compile/nodes/Element.ts#L668 (search for the warning text)

Obviously we shouldn't rush into anything. But changes like these are best made earlier on in a project's lifecycle, so I'm eager to hear what people think so that we can start making some progress.

When you’re implementing a bad plan yourself, instead of having a mentor bail you out by fixing it, a few really useful things happen:You learn many more details about why it was a bad idea. If someone else tells you your plan is bad, they’ll probably list the top two or three reasons. By actually following through, you’ll also get to learn reasons 4–1,217.You spend about 100x more time thinking about how you’ll avoid ever making that type of mistake again, i.e., digesting what you’ve learned and integrating it into your overall decision-making.By watching my mistakes and successes play out well or badly over the course of months, I was able to build much more detailed, precise models about what does and doesn’t matter for long-term codebase health. Eventually, that let me make architectural decisions with much more conviction.

This is linux. Ouput first, formatting second. systemctl --no-pager -l should be the default.

The make install task installs the following files:

Why is it your solution? Can you talk us through it?

I came up with this solution by piecing together man pages and random google result. I was surprised at how many incomplete and inaccurate answers were out there. What may have been more surprising was the complete lack of a full intact solution.

Retagging the HTML/CSS questions to use html-heading seems the right thing to do. For the other uses, I don't have enough grounding in the geographic area to know whether the direction and bearing are replacements for heading. But the tag information for heading should be created and should firmly point at the other tags — at least until it is expunged.

We could broadcast a warning if we find the variable to be set in the environment, but that is more likely than not to annoy people who intentionally set it.

It took a lot of searching around to find that variable.

In summary TLS uses PKI to secure information over the internet. However, it is important to note that TLS supports other encryption standards which are not part of PKI.

If you have a better/simpler/"more official" solution, I'd still love to see it!

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.

You may want to execute validations in a given specific order (this can be tricky especially when you have got asynchronous validations).

Of course you can start implementing your own thing, but you will waste a lot of precious time reinventing the wheel. Why not take advantage of a validation library that takes care of all this complexity for you?

You can try to build a solution to tackle these issues on your own, but it will cost you time and money... why not use a battle-tested solution to handle all this complexity?

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

I really dont need a solution to this problem! I can find many workararounds

First of all, we solved our problem! As demonstrated here our app is happily running again.

Yeah I see what you're saying. In my case, I had a group of classes that relied on each other but they were all part of one conceptual "module" so I made a new file that imports and exposes all of them. In that new file I put the imports in the right order and made sure no code accesses the classes except through the new interface.

Doing so also means adding empty import statements to guarantee correct order of evaluation of modules (in ES modules, evaluation order is determined statically by the order of import declarations, whereas in CommonJS – and environments that simulate CommonJS by shipping a module loader, i.e. Browserify and Webpack – evaluation order is determined at runtime by the order in which require statements are encountered).

Specifically, since Root, Rule and AtRule all extend Container, it's essential that Container is evaluated (and therefore, in the context of a Rollup bundle, included) first. In order to do this, input.js (which is the 'gateway' to all the PostCSS stuff) must import root.js, root.js must import rule.js before it imports container.js, and rule.js must import at-rule.js before it imports container.js. Having those imports ensures that container.js doesn't then try to place Root, Rule or AtRule ahead of itself in the bundle.

Replaced nested `require` statements with `import` declarations for the sake of a leaner bundle. This entails adding empty imports to three files to guarantee correct ordering – see https://github.com/styled-components/styled-components/pull/100

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

You might think something like “don’t request the same resource thousands of times a day, especially when it explicitly tells you it should be considered fresh for 90 days” would be obvious, but unfortunately it seems not.

Any software that makes HTTP requests to other sites should make it straightforward to enable the use of a cache.

                                        “Ajax, one of the gods dwelling on Olympus, in a prophet’s shape, tells us both to fight on by the ships. For that man was no prophet Calchas,                                                [70] who reads our omens. It was easy for me, as he went away, to see that from the back                                 80 by the markings on his feet and legs. Besides, it’s easy to recognize the gods.

Note that the <WarningEngine/> component must be at the bottom of the form to guarantee that all the fields have registered.

As The Social Dilemma shows, entertainers are in no rush to hold us, or themselves, accountable.

It seems like a waste of money to hire an actor to play the “algorithm guy” when there are actual algorithm creators being interviewed in the film.

// Use `noConflict` to restore the pre-fp variant. var fp = _.noConflict();

Sometimes we can’t implement a solution that’s fully spec-compliant, and in those cases using a polyfill might be the wrong answer. A polyfill would translate into telling the rest of the codebase that it’s okay to use the feature, that it’ll work just like in modern browsers, but it might not in edge cases.

Polyfills are naughty as they patch native APIs, while ponyfills are pure and don't affect the environment.

How are ponyfills better than polyfills? A polyfill is code that adds missing functionality by monkey patching an API. Unfortunately, it usually globally patches built-ins, which affects all code running in the environment. This is especially problematic when a polyfill is not fully spec compliant (which in some cases is impossible), as it could cause very hard to debug bugs and inconsistencies. Or when the spec for a new feature changes and your code depends on behavior that a module somewhere else in the dependency tree polyfills differently. In general, you should not modify API's you don't own.

It’s a risky blanket statement that causes bloat by including all the mistakes you made while building the original product.

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.

Of all the compile-to-languages, the one that strikes me as having the least merit is JSX. It's basically a ton of added complexity for the sake of what boils down to syntax. There are no real gains in terms of language semantics in JSX.

One of the primary tasks of engineers is to minimize complexity. JSX changes such a fundamental part (syntax and semantics of the language) that the complexity bubbles up to everything it touches. Pretty much every pipeline tool I've had to work with has become far more complex than necessary because of JSX. It affects AST parsers, it affects linters, it affects code coverage, it affects build systems. That tons and tons of additional code that I now need to wade through and mentally parse and ignore whenever I need to debug or want to contribute to a library that adds JSX support.

Without elegant ways of expressing loops/iterators (like angular does with directives), the primary way to keep JSX readable thus becomes copying and pasting.

Furthermore, JSX encourages bad non-dry code. Having seen a lot of JSX over the past few months, its encourages copypasta coding.

Supporting JSX out of the box is the engineering equivalent of Mozilla supporting DRM out of the box in FireFox.

@subfuzion That error looks unrelated to the existing discussion.

Doesn't require the use of transpiler or modifications to all JS tooling ever invented.

Other frameworks, which use a template syntax built atop HTML — Svelte, Vue, Ractive, Glimmer etc — have historically been fragmented, meaning those tools need to be reinvented many times.

Right, and if most uses of an FTP service use new FtpService() the one that sets an alternate port will stand out (service.SetPort(12345))