Moreover, React team even removed the “highlight updates” feature from dev tools because people used to obsessively haunt wasted renders with no reasoning behind it

Alfred Korzybski remarked that "the map is not the territory" and that "the word is not the thing", encapsulating his view that an abstraction derived from something, or a reaction to it, is not the thing itself.

The map–territory relation describes the relationship between an object and a representation of that object, as in the relation between a geographical territory and a map of it.

When using TypeScript, cast the type of file.contents on your side.

The default groups, that we talked about before, like domain users and domain admins are security groups. They're used to grant or deny access to IT resources.

A distribution group, is only designed to group accounts and contacts for email communication. You can't use distribution groups for assigning permission to resources.

The service that hosts copies of the Active Directory database are called domain controllers, or DCs

Active Directory has been used to centrally manage networks of computers

One of the most common methods for this authentication is using Kerberos.

role-based access control, or RBAC

A component shouldn’t break because it’s rendered more or less often.

Keep the local state isolated.Think about which state is local to a particular UI representation — and don’t hoist that state higher than necessary.

Even if a component is rendered just once, your design will improve if rendering twice doesn’t break it.

I'm suggesting there should be a way to write lifecycle related code that also responds to changing props, like how useEffect works. I think how React handles this could be a good source of inspiration.

While react hooks were one of the catalysts for v3 we don't agree with with the APIs or the model and won't be emulating it.

It provides several capabilities that are difficult to achieve with React alone, while being compatible with the newest features of React.

Disclaimer: I’m new to Svelte so this isn’t so much a recommendation as it is a “I guess this is a way to do it 🤷‍♂️”

I actually wasn't trying to promote this like I usually promote my articles.

I wasn't really intending this article to get spread as far as it did without context. I never tagged it, I didn't make it a general post on Social media or on Hacker News

you expect some hyperbole during these presentations and you should of course question and verify the claims being made.

helped me carve a niche for what would become SolidJS. I still see that space today, so I'm glad that I did.

If there was a place I thought reactivity would be weak, I embraced it and I worked on it until I was happy with the results.

but everything they were doing started to make sense

This was the piece that made all their other recent work all gel and I gazed into the sun for the beauty that was there.

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.

JSX is an XML-like syntax extension to EcmaScript (https://facebook.github.io/jsx/). It is not a language or runtime.

Templates are prone to unnoticed runtime errors, are hard to test, and are not easy to restructure or decompose.

React does not attempt to provide a complete "application library". It is designed specifically for building user interfaces[3] and therefore does not include many of the tools some developers might consider necessary to build an application.

We want arr.push(foo); arr = arr; to work, and this is a bug.

(Note sure if this is a feature request or a bug...)

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.

However, IMO, having the conditional in the detach function is necessary, because there are other manifestations of this error. For example, if the DOM element in a component is removed from software outside of svelte, detach will have the same error.

IMO, the conditional needs to be added to detach to fix all manifestations of this error.

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

By default, npx will check whether <command> exists in $PATH, or in the local project binaries, and execute that. Calling npx <command> when <command> isn't already in your $PATH will automatically install a package with that name from the NPM registry for you, and invoke it. When it's done, the installed package won’t be anywhere in your globals, so you won’t have to worry about pollution in the long-term. You can prevent this behaviour by providing --no-install option.

export let client; setContext("client", client);

This is so common that ECMAScript 2020 recently added a new syntax to support this pattern!export * as utilities from "./utilities.js";This is a nice quality-of-life improvement to JavaScript, and TypeScript 3.8 implements this syntax. When your module target is earlier than es2020, TypeScript will output something along the lines of the first code snippet.

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.

Rollup also does something very different compared to the other bundlers. It only tries to achieve one simple goal: Bundle ES modules together and optimise the bundle.

But this is only a halfway decent way to clarify that this is an external dependency, because the only way to resolve a peer dependency warning is to install react from npm—there's no way to notify npm that you resolve the dependency to a browser global. So peer dependencies should be avoided in favor of external declarations. Then Rollup will take care of warning about "unresolved dependencies", even if external declarations can't express a particular version range with which your library is compatible like peer dependencies can.

Then, the projects that use these libraries get to process these import statements how they like when they are bundled. For the ones that wish to load jQuery from a global, we again mark 'jquery' as an external—since we still don't want Rollup to bundle jQuery—and as a global.

Luckily, there is absolutely no good reason not to use strict mode for everything — so the solution to this problem is to lobby the authors of those modules to update them.

Basically, the idea is that a train tried to start with the caboose brakes stuck on. After releasing the caboose, the train still could not start. The problem was that when the train attempted to start with the caboose brake on, it stretched all the inter-car couplings so that the whole train was just like one big car. At this point, the friction from the engine train wheels was not enough to get the whole thing going. Instead, you need to just get one car moving at a time - this is why there is space between the couplings.

Even without the dedupe, you waste some drive space, but the code at least works and can resolve its dependencies!

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

DX: start sapper project; configure eslint; eslint say that svelt should be dep; update package.json; build fails with crypt error; try to figure what the hell; google it; come here (if you have luck); revert package.json; add ignore error to eslint; Maybe we should offer better solution for this.

When the message say function was called outside component initialization first will look at my code and last at my configuration.

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.

(Note that you're responsible for handling any race conditions that arise as a result of the component being destroyed before the promise resolves, though assigning state inside a destroyed component is harmless.)

This isn't really a bug, because if you have an async function that returns a function, it doesn't really return a function - it returns a promise. I don't remember whether the Svelte internals currently check for the onMount callback's return being a function or whether they check for it being truthy. Maybe there's some adjustment to be made there.

Also Svelte is so great because developer do not need to worry about class names conflict, except of passing (global) classes to component (sic!).

There are work arounds, but nothing clean. I just feel like this should be functionality that should be part of the slot feature.

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.

The RFC is more appropriate because it does not allow a parent to abritrarily control anything below it, that responsibility still relies on the component itself. Just because people have been passing classes round and overriding child styles for years doesn't mean it is a good choice and isn't something we wnat to encourage.

margin, flex, position, left, right, top, bottom, width, height, align-self, justify-self among other is CSS properties that should never be modified by the child itself. The parent should always have control of those properties, which is the whole reason I'm asking for this.

new style RFC

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.

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.

I totally get not wanting to extend the syntax. I tried doing these things and in practice it was not easy or pretty. Actions provide a much cleaner and easier way to accomplish a certain set of functionality that would be much more difficult without it.

And to illustrate another way actions are helpful, take your above example and put the button into a {{#each}}. It gets more complicated.

I'm just pushing on the "is this really a good idea" front

If this was tied into Svelte's flow with hooks this would not be necessary since it would know when it was being removed from the DOM.

Another problem I ran into was knowing when an element is removed. I had to add a MutationObserver on the current tooltip target so if it gets removed by Svelte while the tooltip is visible (e.g. if a click moves to another route) the tooltip isn't left hanging around on the screen. No mouseleave/mouseout events are dispatched on elements that are removed.

You must: reference each element you are extending using refs or an id add code in your oncreate and ondestroy for each element you are extending, which could become quite a lot if you have a lot of elements needing extension (anchors, form inputs, etc.)

This is where hooks/behaviors are a good idea. They clean up your component code a lot. Also, it helps a ton since you don't get create/destroy events for elements that are inside {{#if}} and {{#each}}. That could become very burdensome to try and add/remove functionality with elements as they are added/removed within a component.

I would be willing to take a stab at it if you think it would be a task within reach.

But some sort of official way to do that in the language would make this nicer - and would mean I would have to worry less about destroying components when their parent is destroyed, which I'm certainly not being vigilant about in my code.

Re Object.keys(undefined), I think I'm ok with that failing. AFAIK it would also fail in React

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 think we could even broadly caveat that by saying “do whatever element you want” but don't expect Svelte to care about following any HTML spec, etc.

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

Yup, which was released six years ago, is obviously a more popular choice at this time. Zod is smaller in size, probably because it doesn’t have as many APIs as Yup, but it’s sure to grow as more features are developed.

When a component reaches such a size that this becomes a problem, the obvious course of action is to refactor it into multiple components. But the refactoring is complex for the same reason: extracting the styles that relate to a particular piece of markup is an error-prone manual process, where the relevant styles may be interleaved with irrelevant ones.

(At the point at which it does make sense to turn this into a separate Tooltip.svelte component, the extraction is a completely mechanical process that could even be automated by tooling.)

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.

You can help ensure your RFC is reviewed in a timely manner by putting in the time to think through the various details discussed in the template. It doesn't scale to push the thinking onto a small number of core contributors.

There are tools in Svelte that break this expectation to a degree, but they are a bit annoying to use, which makes it an active decision on the part of the developer. The API hints at the way we want you to do things because we feel that this will give the better experience.

There is an escape hatch in :global() that facilitates this. It is verbose, and we are okay with that, we don't want it to be too pleasant to use. We don't want people doing this at all, but it is there when needed.

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

It’s amazing how easy it is to make these HTML pages with Rails generators. But of course, it can’t last.

If your reaction to the video was 'fine, but if we use TypeScript and write plugins for each editor then we can get all the autocomplete and syntax highlighting stuff' — in other words, if you believe that in order to achieve parity with CSS it makes sense to build, document, promote and maintain a fleet of ancillary projects — then, well, you and I may never see eye to eye!

I don’t want my source to be human-readable, not for protective reasons, but because I care about web performance more. I want my website to arrive at light speed on a tiny spec of magical network packet dust and blossom into a complete website. Or do whatever computer science deems is the absolute fastest way to send website data between computers. I’m much more worried about the state of web performance than I am about web education. But even if I was very worried about web education, I don’t think it’s the network’s job to deliver teachability

Now I know what you're thinking, "this is an atrocity, what a horrible mess!" and you're right, it's kind of ugly. In fact it's just about impossible to think this is a good idea the first time you see it — you have to actually try it.

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

It’s harder to read code than to write it

rarely reheat leftover pizza

If you are a senior, try talking to a junior or someone less experienced than you. Many companies are running what is called ”reverse mentoring” programs where juniors coach senior members of a company. Senior’s experience is traded for a fresh perspective from a junior. You’d be amazed at how much you could learn and share.

We share our labor of love

Fix it, please, if it's incorrect.

FWIW, I would have raised it earlier if I thought it would have made a difference.

If we've gone more than a year without this being a problem in the slightest, I don't see how the next year would be any different.

+1 for taking the language back.

Can't upvote this enough. It is highly irritating to see language destroyed (and we wonder why kids bastardize the language..).

my point is that using "into" in such a case is just as incorrect as using "inas" would be. The fact that people make mistakes doesn't change this.

I don't think it should be the individual application's responsibility to add Cache-Control: Vary when that negotiation/routing is done by Rails on behalf of the app, do you?

At a certain point it is up to the application to specify when they're varying.

As a later iteration, it might be cool to see a link between the quoted content and my comment

you could imagine my extreme disappointment after i came back after a year and a half to find that the entire exploration map was about 80% smaller, every different island was within clear view of your starting island completely decimating any sense of adventure or exploration you could have had.Almost all materials could be collected and all items built within four and a half hours. Islands are literally numbered one to five to display they're level of danger.not only that but you were practically spoon fed each advancement in the game, it feels like it was taken from a greatly ambitious open world, exploration survival game that would take months to finish and achieve everything in. To now being an arcade style iphone app game catered to ten year olds that would foolishly enter their parents card details in order to buy 10,000 roblox coins.

I have over 689 hours into this game and would like to talk about the changes made to the Exploration. In my opinion the Exploration which made this game amazing now stinks!. You know longer need a ship to hit the islands. The exploration has pretty much been removed. One of the things that made this game so amazing was grinding to make your ship and heading out to Explore and find the other islands. Now all the islands are really close to the spawn point, there are not that many and well they stink. There is no reason or need to make a ship because you can easily reach all the island with a raft.

But I'll definitely take underscore mixins over extending String.prototype or other clunky implementations any day.

"AOO is not, and isn't designed to be, the 'super coolest open source office suite with all the latest bells and whistles,'" Jagielski continued. "Our research shows that a 'basic,' functional office suite, which is streamlined with a 'simple' and uncluttered, uncomplicated UI, serves an incredible under-represented community.

Article 7(3) of the GDPR prescribes that the controller must ensure that consent can be withdrawn bythe data subject as easy as giving consent and at any given time. The GDPR does not say that givingand withdrawing consent must always be done through the same action.

consent is obtained through use of a service-specific user interface (for example, via a website, an app,a log-on account, the interface of an IoT device or by e-mail), there is no doubt a data subject must beable to withdraw consent via the same electronic interface, as switching to another interface for thesole reason of withdrawing consentwould require undue effort.

The controller informs customers that they havethe possibility to withdraw consent. To do this, they could contact a call centre on business daysbetween 8am and 5pm, free of charge. The controller in this example doesnotcomply with article 7(3)of the GDPR. Withdrawing consent in this case requires a telephone call during business hours, this ismore burdensome than the one mouse-click needed for giving consent through the online ticketvendor, which is open 24/7.

have EU based users (i.e any website running cookies that isn’t actively blocking EU based users);

The User has the right to object to such processing and may exercise that right by visiting the privacy policies of the respective vendors.

The carefully crafted Medium story can give the appearance that- at the nadir of your professional life- you are above it all, you are concerned about others, and you are a soulful human being moving on to an even more lucrative future.

These seem to be better reasons to support sub-nanosecond resolution. I think either storing picoseconds or storing sec fraction as 64-bit integer are better approaches than storing a rational. However, either change would be very invasive, and it seems unlikely to be worth the effort.

Just to provide some context on the extent of the issue. Running the spec suite for Discourse results in 2,698,774 rows being printed to STDERR.

JSON parsing is always pain in ass. If the input is not as expected it throws an error and crashes what you are doing. You can use the following tiny function to safely parse your input. It always turns an object even if the input is not valid or is already an object which is better for most cases.

In your environment you may want to always configure internationalization, routers, user data etc. If you have many different React roots it can be a pain to set up configuration nodes all over the place. By creating your own wrapper you can unify that configuration into one place.

is to make sure that students have sufficient background knowledge to stimulate interest and avoid confusion.

While the modifying version will occasionally be useful, in general, we should gently push people towards using non-modifying code.

Matz, alas, I cannot offer one. You see, Ruby--coding generally--is just a hobby for me. I spend a fair bit of time answering Ruby questions on SO and would have reached for this method on many occasions had it been available. Perhaps readers with development experience (everybody but me?) could reflect on whether this method would have been useful in projects they've worked on.

I agree in general splitting an array, according to some property using the order of the elements (no take_drop_while) or to some other array (this request) is more difficult than it could be.

Some may say that copied/not-copied goes without saying. I agree with Tallyrand: "If it goes without saying, it goes all the better for saying it."

ΨΤ Corporation

Refrigerator Evaporator Fan Motor - How it Works & Installation TipsTroubleshooting a No Cool Refrigerator - Part 1

Refrigerator Evaporator Fan Motor - How it Works & Installation Tips

According to our understanding of the inconsistencies, the feature was likely trying to support too many edge cases. All caching strategies have weaknesses and eventually break down if the usage is not properly scoped.

Sometimes, the line between 'bug' and 'feature' is a hard one to draw. Generally, a feature is anything that adds new behavior, while a bug is anything that causes incorrect behavior. Sometimes, the core team will have to make a judgment call.

Bad people will always be motivated to go the extra mile to do bad things.

Meanwhile, criminals would just continue to use widely available (but less convenient) software to jump through hoops and keep having encrypted conversations.

Security agency frustration at the lack of lawful interception for encrypted messaging is understandable, but the problem with global over-the-top platforms is that once those weaknesses are inbuilt, they become potentially available to bad actors as well as good.