I started Solid years ago before I thought anyone would be interested in using it. I only started promoting it because it had already achieved the goals I had set out for it.

There's one downside to Reacts reactivity model - the hooks (useState and useEffect) have to always be called in the same order and you can't put them inside an if block.

createState and createSignal are improvements over React's useState as it doesn't depend on the order of calls.

It's designed for Single Page Applications (SPA). If you need Server Side Rendering then consider using Sapper.

For an API used by many third parties with many diverse uses cases, GraphQL is the right tool.

If a part of the content deserves its own heading, and that heading would be listed in a theoretical or actual table of contents, it should be placed in a <section>. The key exception is where the content may be syndicated; in this case, use <article> element instead.

This issue has been resolved in version 9.1.9

both copied much of their API from Redux Form, so, despite working very differently under the hood, there is a lot of overlap in their APIs.

But maybe this PR should still be merged until he finds time for that?

Whilst

I created a pull request to have the if (node.parentNode) conditional added to detach. It was not applied due to the desire to find the root cause of the <meta> tag manifestation of this issue.

Ontologically

I don't read comments as I think they are dangerous

Why the obfuscation of remaining to r and callbacks to c? This is fine for function-local variables but in this instance makes the code significantly harder to reason about? There is no notion of what c and r mean.

remaining: 0, callbacks: [] r: 0, // remaining outros c: [], // callbacks p: outros // parent group

If you’ve used Flow before, the syntax is fairly similar. One difference is that we’ve added a few restrictions to avoid code that might appear ambiguous.

let:hovering={active}

let:active={hovering}

Because Svelte is a compiler, we're not bound to the peculiarities of JavaScript: we can design a component authoring experience, rather than having to fit it around the semantics of the language.

Why do we use bundlers again?Historically, bundlers have been used in order to support CommonJS files in the browser, by concatenating them all into a single file. Bundlers detected usages of require() and module.exports and wrap them all with a lightweight CommonJS runtime. Other benefits were allowing you to serve your app as a single file, rather than having the user download several scripts which can be more time consuming.

Wow, no answers to this question. That's too bad. Did you ever find the solution?

You can see that Rollup mapped browser globals called "React" and "ReactDOM" to variables called "React" and "ReactDOM". The latter are what you imported by writing import React and import ReactDOM. (The variable names don't have to be the same as the browser globals, but it's common.)

But library users are more numerous, and so their needs are more important.

remember that the needs of the many outweigh the needs of the few

small modules allow library authors to become lazy. Why include that six-line helper function when you can do a one-line `require`?

These are all things that make your life as a library author easier.

possibly making it harder for them to appreciate how severe the discoverability issues are for the rest of us.

The natural assumption is that this is because a) it is the best package manager, and b) the JavaScript community is the most energetic and productive.

I think I know why: it’s because the small modules philosophy favours library authors (like Sindre) at the ultimate expense of library users.

The Why

See resolution in

For context, the previous API had a lazy promise. Currently I’m thinking we could just return a closure like in the React API

This is the same as useEffect in React, incidentally — the function must be synchronous in order to avoid race conditions.

Svelte will not offer a generic way to support style customizing via contextual class overrides (as we'd do it in plain HTML). Instead we'll invent something new that is entirely different. If a child component is provided and does not anticipate some contextual usage scenario (style wise) you'd need to copy it or hack around that via :global hacks.

The main rationale for this PR is that, in my hones opinion, Svelte needs a way to support style overrides in an intuitive and close to plain HTML/CSS way. What I regard as intuitive is: Looking at how customizing of styles is being done when applying a typical CSS component framework, and making that possible with Svelte.

Explicit interfaces are preferable, even if it places greater demand on library authors to design both their components and their style interfaces with these things in mind.

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

The problem with working around the current limitations of Svelte style (:global, svelte:head, external styles or various wild card selectors) is that the API is uglier, bigger, harder to explain AND it loses one of the best features of Svelte IMO - contextual style encapsulation. I can understand that CSS classes are a bit uncontrollable, but this type of blocking will just push developers to work around it and create worse solutions.

This has already forced me to forgo Svelte Material because I would like to add some actions to their components but I cannot and it does not make sense for them to cater to my specific use-case by baking random stuff into the library used by everyone.

The point of the feature is to not rely on the third-party author of the child component to add a prop for every action under the sun. Rather, they could just mark a recipient for actions on the component (assuming there is a viable target element), and then consumers of the library could extend the component using whatever actions they desire.

I think Svelte's approach where it replaces component instances with the component markup is vastly superior to Angular and the other frameworks. It gives the developer more control over what the DOM structure looks like at runtime—which means better performance and fewer CSS headaches, and also allows the developer to create very powerful recursive components.

Does it look like a decorator plugin in Ractive, right

Lets not extend the framework with yet another syntax

Your LazyLoad image is now inextensible. What if you want to add a class? Perhaps the author of LazyLoad thought of that and sets className onto the <img>. But will the author consider everything? Perhaps if we get {...state} attributes.

one problem with 'behavior' is that's the terminology we use to describe all of a component's encapsulated logic — methods, transitions, etc.

While there is some precedence in other frameworks for using as, the word doesn't fit well. Since you are adding functionality to elements I like the word add better (and it only has 1 more character).

The more I think about this, the more I think that maybe React already has the right solution to this particular issue, and we're tying ourselves in knots trying to avoid unnecessary re-rendering. Basically, this JSX... <Foo {...a} b={1} {...c} d={2}/> ...translates to this JS: React.createElement(Foo, _extends({}, a, { b: 1 }, c, { d: 2 })); If we did the same thing (i.e. bail out of the optimisation allowed by knowing the attribute names ahead of time), our lives would get a lot simpler, and the performance characteristics would be pretty similar in all but somewhat contrived scenarios, I think. (It'll still be faster than React, anyway!)

I'll work on a preliminary PR (which I expect will need some love from maintainers, sorry!)

The value of dotAll is a Boolean and true if the "s" flag was used; otherwise, false. The "s" flag indicates that the dot special character (".") should additionally match the following line terminator ("newline") characters in a string, which it would not match otherwise: U+000A LINE FEED (LF) ("\n") U+000D CARRIAGE RETURN (CR) ("\r") U+2028 LINE SEPARATOR U+2029 PARAGRAPH SEPARATOR This effectively means the dot will match any character on the Unicode Basic Multilingual Plane (BMP). To allow it to match astral characters, the "u" (unicode) flag should be used. Using both flags in conjunction allows the dot to match any Unicode character, without exceptions.

Your knowledge of her character dates from a day or two since. My knowledge of her character dates from the beginning of her life. State your suspicion of her as strongly as you please–it is impossible that you can offend me by doing so. I am sure, beforehand, that (with all your experience) the circumstances have fatally misled you in this case. Mind! I am in possession of no private information. I am as absolutely shut out of my daughter’s confidence as you are. My one reason for speaking positively, is the reason you have heard already. I know my child.”

The Colonel had been a notorious opium-eater for years past

“The Last Rose of Summer”

I'm more likely to use it than alternatives in future projects - it's simple and clean

when choosing community building activities that ask students to disclose information about themselves, and especially about how they are feeling, it is important to recognise the risk of unintended harm.

But you think sometimes about what the real world is. Just what your brain mixes together from what your senses tell you. We create the world in a lot of ways. I suppose it shouldn’t be surprising that, when we’re not being careful, we can change it.

The feature is highly likely to be implemented, the API and implementation are the only real topics of discussion right now.

protect against polluting the global environment

They might even hate each other; the creature who already lived loathed his own deformity, and might he not conceive a greater abhorrence for it when it came before his eyes in the female form? She also might turn with disgust from him to the superior beauty of man; she might quit him, and he be again alone, exasperated by the fresh provocation of being deserted by one of his own species.

Nic Fildes in London and Javier Espinoza in Brussels April 8 2020 Jump to comments section Print this page Be the first to know about every new Coronavirus story Get instant email alerts When the World Health Organization launched a 2007 initiative to eliminate malaria on Zanzibar, it turned to an unusual source to track the spread of the disease between the island and mainland Africa: mobile phones sold by Tanzania’s telecoms groups including Vodafone, the UK mobile operator.Working together with researchers at Southampton university, Vodafone began compiling sets of location data from mobile phones in the areas where cases of the disease had been recorded. Mapping how populations move between locations has proved invaluable in tracking and responding to epidemics. The Zanzibar project has been replicated by academics across the continent to monitor other deadly diseases, including Ebola in west Africa.“Diseases don’t respect national borders,” says Andy Tatem, an epidemiologist at Southampton who has worked with Vodafone in Africa. “Understanding how diseases and pathogens flow through populations using mobile phone data is vital.”

the best way to track the spread of the pandemic is to use heatmaps built on data of multiple phones which, if overlaid with medical data, can predict how the virus will spread and determine whether government measures are working.

Why TypeScript?

Why make another UI component kit when we already got Smelte and SMUI? What's so special about Svelta?

Because of that, it's easy to end up in a situation where the styles for a given piece of markup are defined far away (in terms of number of lines) from the markup itself, which reduces the advantage of having styles and markup co-located in the first place.

6to5 attempted to ship a quick and dirty TDZ static checking feature but had to retract it immediately afterwards due to various bugs in the algorithm.

Please focus on explaining the motivation so that if this RFC is not accepted, the motivation could be used to develop alternative solutions. In other words, enumerate the constraints you are trying to solve without coupling them too closely to the solution you have in mind.

A huge part of the value on an RFC is defining the problem clearly, collecting use cases, showing how others have solved a problem, etc.

An RFC can provide tremendous value without the design described in it being accepted.

questions the status quo in the UI framework world again

One key advantage of 'HTML-plus' languages is that you don't actually need tooling in order to be productive — most editors give you out-of-the-box support for things like syntax highlighting (though imperfect, as JavaScript expressions are treated as strings) and auto-closing tags. Tools like Emmet work with no additional setup. HTMLx should retain that benefit.

I understand what you're getting at, but we shouldn't miss out on useful features just because a few developers will abuse it...

Tree of Life

Original Instructions.

he will crush[j] your head,(BL)    and you will strike his heel.”

Materialism and the Dialectical Method

loss of Silesia

Thus, Confucius meditated upon water; and the Confucian Xunzi later attempted to systematize the relationship between water’s various forms and people’s moral qualities. This assumption of a correspondence between the principles which inform both water and human conduct was not limited to the Confucians; it was generally assumed in all early philosophical texts. Nor was the imagery the provenance of any particular school. For example, water which moves forward without force, giving life to everything, is described in Xunzi as ‘wuwei’ (without action) or (doing nothing) a term that is particularly associated with Daoism.

LSP creates the opportunity to reduce the m-times-n complexity problem of providing a high level of support for any programming language in any editor, IDE, or client endpoint to a simpler m-plus-n problem.

require 'minitest/autorun' class BugTest < Minitest::Test

If you're going to change the rules on us, I think it would be helpful to do so by first explaining best practices.

many organizations have been burned by the high churn in JavaScript tooling, which sadly moves projects backwards as a part of moving the web forward

They write their own function because it’s easier and more fun than figuring out how the old function works.

Customers care more about the value our application adds to their lives than the programming language or framework the application is built with. Visible Technical Debt such as bugs and missing features and poor performance takes precedence over Hidden Technical Debt such as poor test code coverage, modularity or removing dead code

In the real world — the time to pay off technical debt is scarce — in most of the time fueled by the fear of the unknown. The management loves to milk the cow but not to change the litter. The developers on another hand avoid modernizing legacy code — to avoid trouble in case anything breaks.

It can come as a refreshment to follow the hype and ride the bandwagon from time to time, but you should always do your research first.

The hype is something common in our industry. Remember NoSQL? Or when everyone went crazy over microservices? Or the AI / Machine learning burst? The list goes on and on. People get excited about new and breakthrough technologies and ideas.

The idea of having to learn something new is good, and I agree with that, but how often should you do that? Looking at the world of JavaScript, a new idea, blog post, library, framework, and whatnot pops up very often. Things become trending, and people quickly try to adopt that. I’m not saying you should not adopt new things and consider different approaches to a solution, not at all! I am trying to propose the idea of doing that less often.

Furthermore, incumbents who generally do a good job, often manage to continue reigning. According to Brad Gerstner, CEO of Altimeter Capital, who recently did a podcast on Invest Like The Best, large tech companies have managed to take even more market share than 10 years ago. Some people may argue this is because the large tech companies have improved their products over time to stay ahead due to their increased collection of data and better algorithms that feed on that data over time. That may be true for some companies but not all. This also applies to other products that have not made significant strides in their technology — Craigslist, Salesforce CRM, Turbotax, Quickbooks to name a few. Even Google Search which arguably had a better product in the 1990s compared to its peers is about on par with alternative search engines today, but 90% of people worldwide still use Google. Old habits die hard, and distribution matters more than ever if you are just starting a business. It’s hard to topple incumbents who have strong distribution and already large audiences — even if you can build a much better product.

Facebook has apologized to its users and advertisers for being forced to respect people’s privacy in an upcoming update to Apple’s mobile operating system – and promised it will do its best to invade their privacy on other platforms.

“the unexamined life is not worth living.

We share our labor of love

As a web designer, I hate that "log in" creates a visual space between the words. If you line up "Log In Register" - is that three links or two? This creates a Gestalt problem, meaning you have to really fiddle with spacing to get the word groupings right, without using pipe characters.

With more and more productivity apps creating their own messaging systems, users suddenly face a new problem: Multiple inboxes. You now have to check notifications in Github, Trello, Google Docs and half a dozen (if not more) other tools in your productivity stack.

I will have to look at code to be sure but the rule that */* trumps all is applied only when the request is not an ajax request. So if you are making ajax request then you should be good.

The problem is that opting out of mime type negotiation simply because there is a catch-all in there is wrong according to the specifications of HTTP.

In graph theory, a tree is a connected acyclic graph; unless stated otherwise, in graph theory trees and graphs are assumed undirected. There is no one-to-one correspondence between such trees and trees as data structure.

More information about CC and open licensing

Elinor Ostrom’s 8 Principles for Managing a Commons by On the Commons

count_value

Stallman has also stated that considering the practical advantages of free software is like considering the practical advantages of not being handcuffed, in that it is not necessary for an individual to consider practical reasons in order to realize that being handcuffed is undesirable in itself.