Job control is what happens when you press ^Z to suspend a program, or when you start a program in the background using &

I have already tried '--ignore-failed-read', but the problem is that it doesn't only ignore failed reads on the -T files. It ignores all failed reads.

“Digital technology allows us to be far more adventurous in the ways we read and view and live in our texts,” she said. “Why aren’t we doing more to explore that?”

“As humans we resist change,” says Twitter and Square’s Dorsey. “It’s scary and something we can’t necessarily control. You hear that Twitter is important or Facebook is important or HTML5 is important, but how do you actually begin? There’s no easy way. It’s not fun to be self-reflective or self-aware. “In many cases it means we have to do more work,” he adds. “So we have to do more work.”

Unlike the latter, however, the neurosciences are extremely well funded by the state and even more so by private investment from the pharmaceutical industry.

Second, I don't agree that there are too many small modules. In fact, I wish every common function existed as its own module. Even the maintainers of utility libraries like Underscore and Lodash have realized the benefits of modularity and allowed you to install individual utilities from their library as separate modules. From where I sit that seems like a smart move. Why should I import the entirety of Underscore just to use one function? Instead I'd rather see more "function suites" where a bunch of utilities are all published separately but under a namespace or some kind of common name prefix to make them easier to find. The way Underscore and Lodash have approached this issue is perfect. It gives consumers of their packages options and flexibility while still letting people like Dave import the whole entire library if that's what they really want to do.

I'd suggest there ought to be config to disable source maps specifically, and specifically for either CSS or JS (not alwasy both), without turning off debug mode. As you note, debug mode does all sorts of different things that you might want with or without source maps.

putting a line break before the directive in the Gem (not suitable because I don't own the gem)

There's not a way to do it at the moment without enabling all debug features.

In both filters, you’re able to rename and coerce variables. This gives you a bit more control than the simpler DSL.

Each step receives the return value of its predecessor. The return value decides about what next step is called.

While you could program this little piece of logic and flow yourself using a bunch of Ruby methods along with a considerable amount of ifs and elses, and maybe elsif, if you’re feeling fancy, a Trailblazer activity provides you a simple API for creating such flow without having to write and maintain any control code. It is an abstraction.

found that using only the Pascal-provided control structures, the correct solution was given by only 20% of the subjects, while no subject wrote incorrect code for this problem if allowed to write a return from the middle of a loop.

Better control over flow of our application: more ways to add branching

The DSL has a weaker control over the program’s flow — we can’t have conditions unless we add a special step

Whoever controls the third place controls the community. If the third place is a building, and they decide to renovate, tough luck. It's being renovated. The third place is where the community lives, it's where they go by default essentially. If you own that place, you own a considerable amount of power in the community.

This task force could also meet regularly with tech platforms, and push for structural changes that could help those companies tackle their own extremism and misinformation problems

It appears that Canonical is continuing it's vice grip of unliateral, maybe dictatorial control on the development of Snap to the benefit of Ubuntu, but to the detriment of groups like Linuxmint, and all other non-Ubuntu based Linux distributions - like CentOS/Redhat, Suse/openSuSe, Solus, Arch/Manjaro, PCLinuxOS, etc, that are pushing Flatpak as a truly cross-distro application solution that works equally well and non-problematic for all. .

What's wrong here is Canonical trying to position itself as a powerhouse and ascertain control over Linux users.

If we're not careful, it could become the new 'systemd' problem It probably already is. I don't want to sound too Stallman, but this is the inevitable "company" influence you'll always have. Companies do have their objectives which they will pursue determinedly, since they are not philanthropic (no judgment, just observation). Systemd and Red Hat. Nvidia and their drivers. Google and Android. Apple and iOS. Manufacturers with MS only support. And Canonical also has a history there: the Amazon links, Unity, Mir, and now snap.

What we didn't want it to be was for Canonical to control the distribution of software between distributions and 3rd party editors, to prevent direct distribution from editors, to make it so software worked better in Ubuntu than anywhere else and to make its store a requirement,"

Everything Lives in GitWith a Jamstack project, anyone should be able to do a git clone, install any needed dependencies with a standard procedure (like npm install), and be ready to run the full project locally. No databases to clone, no complex installs. This reduces contributor friction, and also simplifies staging and testing workflows.

Why let other websites and social platforms tell your story? Share the real, authentic you the way you want to, and when you want to.

Remind yourself that getting angry is not going to fix anything, that it won't make you feel better (and may actually make you feel worse).

Slowly repeat a calm word or phrase such as "relax," "take it easy." Repeat it to yourself while breathing deeply.

Use the SourceMapDevToolPlugin for a more fine grained configuration

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

There's not much we can do there. It's not possible for a Svelte component to inspect another Svelte component and check if it exposes any prop

I understand this is not ideal, but sadly this is not something we can change as it's how Svelte works.

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.

withindex.js, we have a single source of truth, giving fine grained control on what we expose to the outside world.

The reason that this solves our problem is: we now have full control over the module loading order. Whatever the import order in internal.js is, will be our module loading order.

Tell her to wear that sweet hat she had on last Sunday

I'm more inclined towards an {@ tag than a {# tag because the indentation could quickly get out of control

The reason for this is very simple: once code gets checked-in, it takes on a life of its own.

Checking in is akin to sharing your code with others, and once out in the world, it’s hard to predict what that code will do.

Linux Memory Management at Scale

Here, when x is a Boolean value then the section tag acts like an if conditional, but when x is an array then it acts like a foreach loop.

I kept losing content that I edited out and then wanted to put it back in.

When you can assume that all the materials you’re using in and with your class are open educational resources, here’s one way to remix the effective practices listed above with OER in order to provide you and your students with opportunities to spend your time and effort on work that makes the world a better place instead of wasting it on disposable assignments.

Free to accessFree to reuseFree to reviseFree to remixFree to redistributeThe question becomes, then, what is the relationship between these additional capabilities and what we know about effective teaching and learning? How can we extend, revise, and remix our pedagogy based on these additional capabilities?

I take your point, but I wonder if Trump is just kryptonite for a liberal democratic system built on a free press.

The hysterical passion

The benefit of this approach is that rather than having these defaults and fighting against them, it’s fully up to you to decide how to handle everything.

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.

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.

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

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.

The main reason using classes isn't a great solution is that it completely breaks encapsulation in a confusing way, the paren't shouldn't be dictating anything, the component itself should. The parent can pass things and the child can choose to use them or not but that is different: control is still in the hands of the component itself, not an arbitrary parent.

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.

Ideally: Only let a parent control those specific CSS properties, and never let a child use them on the root element.

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.

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.

What I’ve been doing to these people, it – it hasn’t been because I was puppeted, or controlled, or possessed. I wanted to do it. It felt good.

What we don't want to happen is to bless an approach that inverts this control, allowing an arbitrary parent to impact the inner-workings of a component.

This would be a component that is meant to be styled by its parents, and it would make no logical sense to have every possible type of style available inside the Link component. If I wanted to turn one of these anchor tags into a button, another into a nav-link, and another into a footer link, I should be able to. There's no reason that there shouldn't be a feature to treat a component like a normal HTML element.