I'm very (VERY!) tempted to use that ppa, but without offense to it's maintainers... it's just some random ppa. If it had more "traction" I'd use it. Right now it has only 3 maintainers.

How do you know this? I've looked all over the internet and can't find any proof that Lightdm is more "lightweight" (whatever this means) or faster.

If you want a reference to the global object that works in any context, you can read this from a directly-called function. const global = (function() {return this})();. This evaluates to window in the browser, self in a service worker and global in nodejs.

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

Used by folks at

Test plan You need a large NPM package in a private org on the npmjs.org registry. 10MB download size is ideal.

How many times have you heard the cliché, for example, read between the lines? It turns out, the key to reading between the lines is actually to write between the lines. Once you start, you'll discover a whole new reading experience, elevated from that of a one-sided lecture to a two-sided conversation.

How to Create a Messaging Application from Scratch

All standard UI events are forwarded.

class: '' - A CSS class string.

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.

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.

But what should you write about? Simply ask yourself, What's bothering you most right now? Write a post where you work through that—and get to a conclusion. This is how I start every time. Writing is therapy that you publish for the world to learn from.

First, choose your topicThe best topic to write about is the one you can’t not write about. It’s the idea bouncing around your head that urges you to get to the bottom of it.You can trigger this state of mind with a two-part trick. First, choose an objective for your article:Open people’s eyes by proving the status quo wrong.Articulate something everyone’s thinking about but no one is saying. Cut through the noise.Identify key trends on a topic. Use them to predict the future.Contribute original insights through research and experimentation.Distill an overwhelming topic into something approachable. (This guide.)Share a solution to a tough problem.Tell a suspenseful and emotional story that imparts a lesson.Now pair that objective with a motivation:Does writing this article get something off your chest?Does it help reason through a nagging, unsolved problem you have?Does it persuade others to do something you believe is important?Do you obsess over the topic and want others to geek out over it too?That’s all that's needed: Pair an objective with a motivation. Now you have something to talk about.

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

The idea of the hermeneutic circle is to envision a whole in terms how the parts interact with each other, and how they interact with the whole. That may sound a little bit out there, so let’s have a look at a concrete example.

How to Win at College: Surprising Secrets for Success from the Country's Top Students Paperback – April 12, 2005 by Cal Newport

How to Become a Straight-A Student: The Unconventional Strategies Real College Students Use to Score High While Studying Less Kindle Edition by {"isAjaxComplete_B001IGNR0U":"0","isAjaxInProgress_B001IGNR0U":"0"} Cal Newport (Author) › Visit Amazon's Cal Newport Page Find all the books, read about the author, and more. See search results for this author Are you an author? Learn about Author Central Cal Newport (Author)

How to Be a High School Superstar: A Revolutionary Plan to Get into College by Standing Out (Without Burning Out) 1st Edition, Kindle Edition by {"isAjaxComplete_B001IGNR0U":"0","isAjaxInProgress_B001IGNR0U":"0"} Cal Newport (Author) › Visit Amazon's Cal Newport Page Find all the books, read about the author, and more. See search results for this author Are you an author? Learn about Author Central Cal Newport (Author)

Deep Work: Rules for Focused Success in a Distracted World Hardcover – January 5, 2016 by Cal Newport

Learning How to Learn: How to Succeed in School Without Spending All Your Time Studying; A Guide for Kids and Teens Paperback – Illustrated, August 7, 2018 by Barbara Oakley PhD

A Mind for Numbers: How to Excel at Math and Science (Even If You Flunked Algebra) Audible Audiobook – Unabridged Barbara Oakley (Author), Grover Gardner (Narrator), Gildan Media, LLC (Publisher) & 2 more

Using the keyboard arrows, navigate down the suggestion list to the item(s) you want to remove from the Chrome autofill suggestions With the suggestion highlighted, use the appropriate keystroke sequence to delete the Chrome suggestion:

If the react cargo cult didn't have the JSX cowpath paved for them and acclimated to describing their app interface with vanilla javascript, they'd cargo cult around that. It's really about the path of least resistance and familiarity.

For the sake of best compatibility we convert the className attribute to class for svelte.

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.

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 🤷‍♂️”

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.

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.

be quick to start books, quicker to stop them, and read the best ones again right after you finish

I pushed the build files & tested it in my environment so this should work as is.

I pushed a hotfix, based on v3.6.3 proposed by #2086 (comment) In package.json, under devDependencies, use: "svelte": "btakita/svelte#svelte-gh-2086-hotfix"

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

setContext / getContext can only be used once at component init, so how do you share your API result through context? Related: how would you share those API results if the call was made outside of a Svelte component, where setContext would be even more out of the question (and the API call would arguably be better located, for separation of concerns matters)? Well, put a store in your context.

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.

the error/warning output about unresolved dependencies and missing global variable names doesn't provide any more information about which dependencies are part of the problem:

Why do I need a global variable? Is the global requirement from ES6 modules (I'd have thought modules would be in a functional scope) or rollup?

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.

We could at least try to offer better error message for this, before it becomes our next NullPointerException, Segmentation Fault or Kernel Panic

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.

Most simple example: <script> import ChildComponent from './Child.svelte'; </script> <style> .class-to-add { background-color: tomato; } </style> <ChildComponent class="class-to-add" /> ...compiles to CSS without the class-to-add declaration, as svelte currently does not recognize the class name as being used. I'd expect class-to-add is bundled with all nested style declarations class-to-add is passed to ChildComponent as class-to-add svelte-HASH This looks like a bug / missing feature to me.

I wrote hundreds of Rect components and what I learned is that Componets should be able to be styled by developer who is using it.

color: red; //doesn't apply this rule, because scoping doesn't extend to children

Say I want to style this javascript routing anchor tag on various pages (some may be buttons, plain links, images) it makes it incredibly difficult. Eg:

Having to wrap everything in a selector :global(child) { } is hacky

I think instead, there would need to be some special way to make the distinction of what is a slot attribute and what is a slot prop to be consumed with let:. Maybe a new directive like <slot attr:class="abc"/>?

feel like there needs to be an easy way to style sub-components without their cooperation

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.

There is a good amount of properties that should mostly be applied from a parent's point of view. We're talking stuff like grid-area in grid layouts, margin and flex in flex layouts. Even properties like position and and the top/right/left/bottom following it in some cases.

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.

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.

This allows passing classes to child components with svelte-{hash} through the class prop and prevents removing such classes from css.

Does it look like a decorator plugin in Ractive, right

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

the ability to pass around element names as strings in place of components

No, this is about using a string to create an element of that tag name.

I would hope for it to come with React-like behavior where I could pass in a string (like div or a) and have it show up as a normal div/a element when the child component used it.

Part of the functionality that is returned are event handlers. I'd like to avoid needing to manually copy the events over one by one so the hook implementation details are hidden.

However, we've another unresolved problem - passing parent's styles to child components.

This has the merit of simplicity and obviousness, but it's not particularly ergonomic: it signals that we don't consider component themeability to be a problem worth solving properly.

Knowing all this, what would you do? Which path would you choose and why? The answer might seem obvious now that you come from the future - React

"When an OP rejects your edit, please do not edit it back in!" Correspondingly, when a user repeatedly does try to edit, understand that something in your framing isn't working right, and you should reconsider it.

"that text has been removed from the official version on the Apache site." This itself is also not good. If you post "official" records but then quietly edit them over time, I have no choice but to assume bad faith in all the records I'm shown by you. Why should I believe anything Apache board members claim was "minuted" but which in fact it turns out they might have just edited into their records days, weeks or years later? One of the things I particularly watch for in modern news media (where no physical artefact captures whatever "mistakes" are published as once happened with newspapers) is whether when they inevitably correct a mistake they _acknowledge_ that or they instead just silently change things.

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

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

Refrigerator Evaporator Fan Motor - How it Works & Installation Tips

Wish more questions are asked that way

"At the company's headquarters they created the bureaucracy to process information and make decisions about things that were taking place thousands of miles away."

This corpus became the largest collection of English language data in the world

managing yourself and others.

These two are in my opinion the most problematic — the basically go against each other. Typically, I try to work in increments over a feature and commit when I reach whatever techinical milestone I want to "checkpoint" at. It can also be out of the need to expose some idea or architecture and push it.

Did the marketing team create a new landing page that isn't searchable? Osano is aware of hidden pages and keeps you in the loop about what is loaded where – everywhere on your site.

Instead of having a task like “write an outline of the first chapter,” you have a task like “find notes which seem relevant.” Each step feels doable. This is an executable strategy (see Executable strategy).

However, since problems are only addressed when they arise, maintenance is reactive rather than proactive. Small problems left unaddressed can balloon into major failures due to focus on cost.

But now, I think there’s still some lack of clarity from consumers on exactly what they need to do

purposes are grouped into 5 categories (strictly necessary, basic interactions & functionalities, experience enhancement, measurement, targeting & advertising)

Potential for political focus on building new features over technical improvements (such as refactoring)

What we actually want to do is to escape content if it is unsafe, but leave it unescaped if it is safe. To achieve this we can simply use SafeBuffer's concatenation behavior:

Our helper still returns a safe string, but correctly escapes content if it is unsafe. Note how much more flexible our group helper has become because it now works as expected with both safe and unsafe arguments. We can now leave it up to the caller whether to mark input as safe or not, and we no longer need to make any assumptions about the safeness of content.

Fibroblasts stimulated by growth factors can produce type I collagen and glycosaminoglycans (e.g., chondroitin sulfates), which adhere to the wound surface to permit epithelial cell migration, as well as adhesive ligands (e.g., the matrix protein fibronectin), which promote cell adhesion.

Sedation, osmotic diuresis, paralysis, ventricular drainage, and barbiturate coma are used in sequence, with coma induction being the last resort.

CPP can be increased by either lowering ICP or raising mean arterial pressure.

To read the consent from the __cmp function, you can open the browser console and launch these commands

Describe the problem fully Link to a test case showing the problem.

Without this information, very likely your question will not be answered, frustrating both yourself and anyone else who does want to help, because they are unable to do so

ask your question in a way that it provides enough information that it can be answered

I thought I understood Ruby error handling until this week and ran across this question.

has a surprising connection to the world of aging today.