After Alexi McCammond was named editor in chief of Teen Vogue, people discovered and recirculated on Instagram old anti-Asian and homophobic tweets she had written a decade earlier, while still a teenager.

You would think it would be a good thing for the young readers of Teen Vogue to learn forgiveness and mercy, but for the New Puritans, there is no statute of limitations.

In The Whisperers, his book on Stalinist culture, the historian Orlando Figes cites many such cases, among them Nikolai Sakharov, who wound up in prison because somebody fancied his wife; Ivan Malygin, who was denounced by somebody jealous of his success; and Lipa Kaplan, sent to a labor camp for 10 years after she refused the sexual advances of her boss. The sociologist Andrew Walder has revealed how the Cultural Revolution in Beijing was shaped by power competitions between rival student leaders.

However, unless my feeble brain is feeble, this looks like a valid use case and I might not be alone.

In a fiat currency system, neither money nor government debt are real. They are illusions, mass delusions. This allows politicians to periodically bring the nation to the imaginary brink, point the cameras into a fictitious abyss, and then rescue us from a crisis of their own creation – all with the stroke of a pen.

You're right, this discussion is starting to go off on a tangent.

Honestly, I think the current discussion has nothing to do with my original issue anymore.

sugar manufacturing industry,

a Standard to Unite Communities

Update API usage of the view helpers by changing javascript_packs_with_chunks_tag and stylesheet_packs_with_chunks_tag to javascript_pack_tag and stylesheet_pack_tag. Ensure that your layouts and views will only have at most one call to javascript_pack_tag or stylesheet_pack_tag. You can now pass multiple bundles to these view helper methods.

Cleanup the code

Why can you remove it? The loader will first try to resolve @import as a relative path. If it cannot be resolved, then the loader will try to resolve @import inside node_modules.

We understand that new bugs often occur when bugs are fixed and we want to leave the project in a stable state.

to layout tables

Even considering all these peculiarities, color is one of the simplest cases of nebulosity

two notes that are five pitches away from each other, one, two, three, four, five

I've copied his response here as this question ranks very high in web search results.

You particular circumstances may or may not warrant a way different from what lhunath (and other users) deem "best practices".

Remember that in the end, especially in scripting, there always are more than one way to skin a cat, but some ways are more portable, more reliable, make it simpler to handle error cases, parse the output, etc.

This kind of error handling does express error state (either via HTTP 500 or by the top-level "errors" key), but it doesn’t take advantage of GraphQL’s type system and can only express one error at a time.

In the end this plugin is a piece of software that I wrote and I'm just doing what I think is reasonable to make our community more inclusive.

"While it takes time to make these changes now, it's a one-time engineering cost that will have lasting impacts, both internally and externally," Sorenson said in an email. "We're in this for the long game, and we know inclusive language is just as much about how we code and what we build as it is about person-to-person interactions."

instance_eval { reduce(:+) / size.to_f }

To set multiple cookies in a single set of response headers, you can return an array:

In the earlier example, I used “no-reply@” because this is, unfortunately, a common practice used by many email marketers. As a brand utilizing email, you should never expect a personal experience like email to ever be one-sided.

It's free to play on iOS

Of course you must not use plain-text passwords and place them directly into scripts. You even must not use telnet protocol at all. And avoid ftp, too. I needn’t say why you should use ssh, instead, need I? And you also must not plug your fingers into 220 voltage AC-output. Telnet was chosen for examples as less harmless alternative, because it’s getting rare in real life, but it can show all basic functions of expect-like tools, even abilities to send passwords. BUT, you can use “Expect and Co” to do other things, I just show the direction.

0</dev/null script --quiet --flush --return --command "$(printf "%q " "$@")" /dev/null

Too new to comment on the specific answer

A one-liner alternative for hash-only cases can be implemented using Enumerable#reduce: root = {} [:a, :b, :c].reduce(root){@1[@2]||={}}[:d] = 'E' # root => {:a=>{:b=>{:c=>{:d=>"E"}}}}

You're right, it would solve the Nemo problem perfectly, but break a lot of other things, unfortunately.

Trying to force this one thing to work for everyone is the worst way to do that.

The elimination of what is arguably the biggest monoculture in the history of software development would mean that we, the community, could finally take charge of both languages and run-times, and start to iterate and grow these independently of browser/server platforms, vendors, and organizations, all pulling in different directions, struggling for control of standards, and (perhaps most importantly) freeing the entire community of developers from the group pressure of One Language To Rule Them All.

As to opinions about the shortcomings of the language itself, or the standard run-times, it’s important to realize that every developer has a different background, different experience, different needs, temperament, values, and a slew of other cultural motivations and concerns — individual opinions will always be largely personal and, to some degree, non-technical in nature.

Focus is better than features.

Write modules that do one thing well. Write a new module rather than complicate an old one.

That said, I wish more people would talk both sides. Yes, every dependency has a cost. BUT the alternatives aren't cost free either. For all the ranting against micropackages, I'm not seeing a good pro/con discussion.

This is a copy of the "AMD" document in the repo, kept here to maintain historical links. If this document differs from the one in the repo, the repo version is the correct one.

And we shave off 6 or so seconds, that is huge.

Since the common problem with concatenating JavaScript files is the lack of semicolons, automatically adding one (that, like Sam said, will then be removed by the minifier if it's unnecessary) seems on the surface to be a perfectly fine speed optimization.

I think that's fine, but I also don't particularly care about @mikeycgto's desire to not have the linking comment be present in the minified JS.

Webshim is also more than a polyfill, it has become a UI component and widget library. Webshim enables a developer to also enhance HTML5 capable browsers with more highly customizable, extensible and flexible UI components and widgets.

Peñe, kenn du ko able.

Hey, that’s is an imaginary complication of our example - please don’t do this with every condition you have in your app.

For branching out a separate path in an activity, use the Path() macro. It’s a convenient, simple way to declare alternative routes

step :decide_type, Output(Activity::Left, :credit_card) => Track(:with_credit_card)

# Create the track, which would automatically create an implicit End with the same id.
Track(:with_credit_card) do
    step :authorize
    step :charge
end

class Example::ValidationErrorTrack < Trailblazer::Activity::Railway
  step :validate_model, Output(:failure) => Track(:validation_error)
  step :save,           Output(:failure) => Track(:validation_error)

  # Can't use fail here or the magnetic_to won't work and  Track(:validation_error) won't work
  step :log_validation_error, magnetic_to: :validation_error,
    Output(:success) => End(:validation_error), 
    Output(:failure) => End(:validation_error) 
end

puts Trailblazer::Developer.render o
Reloading...

#<Start/:default>
 {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
#<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
 {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
 {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
#<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
 {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
 {Trailblazer::Activity::Right} => #<End/:success>
#<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
 {Trailblazer::Activity::Left} => #<End/:validation_error>
 {Trailblazer::Activity::Right} => #<End/:validation_error>
#<End/:success>

#<End/:validation_error>

#<End/:failure>

class Example::ValidationErrorTrack::VPathHelper1 < Trailblazer::Activity::Railway
   validation_error_path = Path(end_id: "End.validation_error", end_task: End(:validation_error)) do
    step :log_validation_error
  end
  step :validate_model, Output(:failure) => validation_error_path
  step :save,           Output(:failure) => validation_error_path
end

o=Example::ValidationErrorTrack::VPathHelper1; puts Trailblazer::Developer.render o
Reloading...

#<Start/:default>
 {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
#<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
 {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
 {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
#<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
 {Trailblazer::Activity::Right} => #<End/:validation_error>
#<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
 {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
 {Trailblazer::Activity::Right} => #<End/:success>
#<End/:success>

#<End/:validation_error>

#<End/:failure>

step :direct_debit

This connects the failure output to the previous task, which might create an infinity loop and waste your computing time - it is solely here for demonstrational purposes.

Source maps eliminate the need to serve these separate files. Instead, a special source map file can be read by the browser to help it understand how to unpack your assets. It "maps" the current, modified asset to its "source" so you can view the source when debugging. This way you can serve assets in development in the exact same way as in production.

When Sprockets was introduced, one of the opinions that it held strongly, is that assets such as CSS and JS should be bundled together and served in one file.

The alternative was to have multiple scripts or stylesheet links on one page, which would trigger multiple HTTP requests. Multiple requests mean multiple connection handshakes for each link “hey, I want some data”, “okay, I have the data”, “alright I heard that you have the data, give it to me” (SYN, ACK, SYNACK). Even once the connection is created there is a feature of TCP called TCP slow start that will throttle the speed of the data being sent at the beginning of a request to a slower speed than the end of the request. All of this means transferring one large request is faster than transferring the same data split up into several smaller requests.

Yes, we could and should use Reform or Dry-validation here.

They possess an unwavering belief in “one right way.”

There is nothing wrong with building your own “service layer”, and many companies have left the Traiblazer track in the past years due to problems they had and that we think we now fixed.

The assert method is used by all the other assertions. It pushes the second parameter to the list of errors if the first parameter evaluates to false or nil.

My understanding of "programming to an interface" is different than what the question or the other answers suggest. Which is not to say that my understanding is correct, or that the things in the other answers aren't good ideas, just that they're not what I think of when I hear that term.

Naming is just one part of the micro-design activity that we call programming. If design weren’t hard, we wouldn’t find good design so satisfying.

It's difficult because it's a case-by-case basis - there is no one right answer so it falls into subjective arguments.

You can write the query in this good old way to avoid error

Also there is always an option to use SQL: @items .joins(:orders) .where("orders.user_id = ? OR items.available = true", current_user.id)

but if .or() throws an error then I'm back to the bad old days of using to_sql

Although one thing you want to avoid is using frames in such a manner that the content of the site is in the frame and a menu is outside of the frame. Although this may seem convienient, all of your pages become unbookmarkable.

Iframes can have similar issues as frames and inconsiderate use of XMLHttpRequest: They break the one-document-per-URL paradigm, which is essential for the proper functioning of the web (think bookmarks, deep-links, search engines, ...).

The most striking such issue is probably that of deep linking: It's true that iframes suffer from this to a lesser extent than frames, but if you allow your users to navigate between different pages in the iframe, it will be a problem.

Yeah, this is one of those cases where it's not a "yes or no" type answer.

Multiple answers are great. Check out all of them, not just the accepted one.

Systemd flies in the face of the Unix philosophy: 'do one thing and do it well,' representing a complex collection of dozens of tightly coupled binaries

systemd has such huge documentation. systemd.unit Did you try searching for explanation yourself? What did you find?

http://letmegooglethat.com/?q=How+to+change+the+default+search+engine+in+chromium&l=1

It's not impossible, but it's not likely I would accept someone I haven't worked with IRL or know on a personal level. That's because I want some form of creative control over the direction and I want to maintain the existing code style. If I know you I'm more likely to know that this will keep working the way I want it to.

Show me good PRs, bug triaging, documentation fixes, whatever and you're a candidate if you ask for it.

Depending on what other component libraries you’ve used, you may be used to handling events by passing callback functions to component properties, or using a special event syntax – Svelte supports both, though one is usually more appropriate than the other depending on your situation. This post explains both ways.

"Headless Tippy" refers to Tippy without any of the default element rendering or CSS. This allows you to create your own element from scratch and use Tippy for its logic only.

It's a generic abstraction for the logic and styling of elements that pop out from the flow of the document and float next to a reference element, overlaid on top of the UI.

Popper has a sole goal: position elements. That's why we call it a "positioning engine" and not a "tooltip library".

While the very same software might be in a PPA and a snap, the fact that the snap is shown in Ubuntu Software is the point I’m making. Many people use that to install software. So making software appear there is beneficial for developers - their software is found, and beneficial for users - they discover new software.

The benefits for developers do reflect on benefits for users, with more software delivered faster and more securely.

something that the alternative online media has been unable to do is where mainstream media platforms are still unrivalled – being a one-stop repository for different sets of news consumers. MSM digital platforms, despite many flaws, thrive as catch-all baskets for round-the-clock information seekers, ranging from politics to cricket, from fashion to music and important news (which doesn’t only mean the unusual massacres) from a hamlet in Arwal district in Bihar to that from a Delhi suburb.

Dropped FFmpeg support (focus on primary functions instead)

it focuses on compiling non-standard language extensions: JSX, TypeScript, and Flow. Because of this smaller scope, Sucrase can get away with an architecture that is much more performant but less extensible

With some frameworks, you may find your needs at odds with the enterprise-level goals of a megacorp owner, and you may both benefit and sometimes suffer from their web-scale engineering. Svelte’s future does not depend on the continued delivery of business value to one company, and its direction is shaped in public by volunteers.

One pane: With one pane outliners, the content is displayed immediately below the category. A printed legal document is an example of a one-pane document. A web site with a table-of-contents "frame" on the left hand side is similar to a two-pane outline. A Usene t news group is similar to a three pane outline. When writing documents, or organizing ideas for a project (such as a speech, or for software design) I much prefer one pane outlines. I find they are more conducive to collapsing ideas, because you can mix text with categories, rather than radically split ting the organizational technique from the content (as the two and three pane outlines do).

yell() { echo "$0: $*" >&2; } die() { yell "$*"; exit 111; } try() { "$@" || die "cannot $*"; }

which are passed onto controller actions.

You will want to report this as follows:

Incurring high-cost changes isn't evolutionary design-it's oscillation caused by poor planning and requirements specification on a high cost-of-change component-it tips the anticipation/adaptation balance too far towards adaptation.

Offsetting the rules of a logic-less template requires a lot of helper methods.

The other reason I am writing it, however, is that I know that many of my fellow exvies have, like me, struggled for years to make an open break with their families because of the pressure to conform that comes from inherently abusive fundamentalist socialization.

It was clear no one was interested in what I was working towards.

Very few were interested in furthering the platform in the places they just took for granted.

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.

Setup

Set up

Step One: 

This dynamic is playing out during the pandemic among the many people who refuse to wear masks or practice social distancing.

I used a "specific function". But maybe it could be done within a derived store. A kind of auto reset on ... But I think there is no elagant solution, so I stick with the specific function.

I'm certainly not claiming that we should use clever tricks to scrunch our code into the most compact form possible at the expense of readability. Nor am I claiming that reducing lines of code is necessarily a worthwhile goal, since it encourages turning readable code like this...

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.

When you're using urql to send one-off queries or mutations

This may be useful when we don't plan on cancelling queries or we don't care about future updates to this data and are just looking to query a result once.

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

Onto

checkout

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.

Even without going to that extreme, the constraint of having a single <style> can easily force component authors to resort to the kinds of classes-as-namespaces hacks that scoped styles are supposed to obviate.

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!

And you don't have to find solutions to the additional problems that CSS-in-JS introduces.

With Svelte, components and files have a one-to-one relationship. Every file is a component, and files can't have more than one component. This is generally a "best practice" when using most component frameworks.