There is a law somewhere that says that when one person is thoroughlysmitten with the other, the other must unavoidably be smitten as well. Amorch’a null’amato amar perdona.

The book changed my point of view. Statistics, surveys, and anecdotes bear out that there are a great many marriages that are soul crushing for a woman based on the traditional marriage roles that still dominate. There’s an inequality of sharing household chores and childcare and an inequality of who sacrifices their desired careers, especially poignant at a time when women are ascendant in their educational attainment and career opportunities. 2Lyz’s book gave me a clear picture of how in many “normal” seeming marriages––no infidelity, no physical or cruel emotional abuse, no addictions or criminal behavior–––a woman might live a far happier and more fulfilling life if she got a divorce or had never married.

I believe it is possible to disprefer something while either 1. not disliking it, or 2. liking it but not intensely enough to be the preference. As in, "I like tart apples, but I sometimes disprefer them as an ingredient on a green salad." It doesn't and hasn't, meant I would refuse to eat a salad with this ingredient included, but there are times when my preference would have been to have a salad without them.

I think you linguists worry too much. It's a simple enough formation using a very common prefix, and while it is not clear whether "I disprefer" means "I do not prefer" or "I prefer something other than" or "I prefer the opposite of" or "I stop preferring", either it'll settle down to one meaning or it'll carry a range. So what? This is the first time I've heard the word but I don't find it particularly puzzling.

I had the advantage, early in my career, of starting making music without any experience,

hat you need is to filter on the count of the number of races for each horse. The HAVING clause does exactly what we need here – it has syntax like the WHERE clause, but it is applied to each group after grouping has taken place

So when configuring Capybara, I'm using ignore_default_browser_options, and only re-use this DEFAULT_OPTIONS and exclude the key I don't want Capybara::Cuprite::Driver.new( app, { ignore_default_browser_options: true, window_size: [1200, 800], browser_options: { 'no-sandbox': nil }.merge(Ferrum::Browser::Options::Chrome::DEFAULT_OPTIONS.except( "disable-features", "disable-translate", "headless" )), headless: false, } )

opts = method(__method__).parameters.map(&:last).map { |p| [p, eval(p.to_s)] }.to_h SomeOtherObject.some_other_method(opts)

that's right, we don't want to do params = { ... } because then we're hardcoding the implementation and it becomes very coupled. The benefit of doing it like in my examples is that you can change the method signature and still automatically capture all keyword parameters.

git -c log.follow= log: that will unset log.follow, just for that one git log instance.

Here are the rules associated with the free and checked vowels. Theserules apply only to stressed syllables.

5.12 Be cautious about trusting AI without having deep understanding.

As for publishing this as an actual gem on rubygems.org...I have enough open source I'm involved in all ready (or too much, as my wife would probably say) and I'm not really interested in maintaining another gem.

Instead read this gems brief source code completely before use OR copy the code straight into your codebase.

Why not just prettier-ignore? Because I want to keep Prettier here. Still format my code. But just with another config. This already works with prettierrc > overrides. But this proposal is for a better usability and flexibility.

In the vast majority of cases when I'm using prettier-ignore I'm only really looking to prevent it from breaking my code into new lines, whilst keeping its other transformations such as switching quotes and adding space between brackets. When ignoring single lines, fixing these formatting problems by hand is very manageable. With the ability to have Prettier ignore entire blocks of code I think the ability to specify what you want it to ignore is essential.

By looking at the code screenshot, you are either opening your mouth in awe or in appall. I feel there is no in-between here.

Programmers should be encouraged to understand what is correct, why it is correct, and then propagate.

HAVING avg(score) < 0.75 * (SELECT avg(score) FROM performance_reviews)

A transition period rather than Stop-The-World migration; we want to merge in a few repositories per day, with minimal disruption to work-flow.

# +devise_for+ is meant to play nicely with other routes methods. For example, # by calling +devise_for+ inside a namespace, it automatically nests your devise # controllers: # # namespace :publisher do # devise_for :account # end

find_field finds by id, name or placeholder text - so find_field('Prefix') should find the element with matching placeholder text rather than needing xpath.

but I like that Svelte comes with a good CSS story out the box.

Mutually exclusive categories can be beneficial. If categories appear several places, it's called cross-listing or polyhierarchical. The hierarchy will lose its value if cross-listing appears too often. Cross-listing often appears when working with ambiguous categories that fits more than one place.

Right now major changes require a deep and broad understanding of the codebase and how things get done.

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

In the classroom, I delegate responsibilities to my students at a rate that astounds people. There is almost nothing that I will not allow my students to do, including teaching my lessons whenever possible. My students take full and complete ownership of the classroom, whether they like it or not, and as a result, they possess great ownership of their learning.

They fail to understand the importance of autonomy when delegating responsibilities.

They lack faith in the capacity of others.

I learned to “let go” and simply trust others to maintain certain gem suites.

For this one we'll define a helper method to handle raising the correct errors. We have to do this because calling .run! would raise an ActiveInteraction::InvalidInteractionError instead of an ActiveRecord::RecordNotFound. That means Rails would render a 500 instead of a 404.

The great thing about working with reinteractive is you get to work directly with the developers, which is a huge plus. As a technical founder, I find proxying through a project manager adds unnecessary layers of complexity and creates opportunity for human error.

If components gain the slot attribute, then it would be possible to implement the proposed behavior of <svelte:fragment /> by creating a component that has a default slot with out any wrappers. However, I think it's still a good idea to add <svelte:fragment /> so everyone who encounters this common use case doesn't have to come up with their own slightly different solutions.

When enough people make false promises, words stop meaning anything, then there are no answers just better and better lies.

Only folks who help package Chromium get to decide how Chromium gets packaged. This gives anyone two options: You can get involved and help package Chromium so you have a voice in the decision-making, or not.

This one gets the SEO, so I hope you're successful @raythurnevoid.

This sort of library probably should be communitized so there's really just a single library.

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

It won't work in all use cases, but it's better than the div soup.

I run into this on almost every project and end up doing this as a workaround: :global([slot="content"]) This allows me to style that extra div in the component that contains the slots but it would be super nice to have <MyComponent slot="content"/> and eliminate that extra div

If this is getting implemented, I think I'll love to see both implemented. I can see a lot of use cases where I would like to encapsulate the component with additional wrappers and in another scenarios I would like to just use the component. Now i work around this using empty div but then at times it breaks the structure because of the div element and I'll have to add more class utilities to make it work. This will be a great addition for Svelte.

I don't like adding unnecessary divs.

Note that when using sass (Dart Sass), synchronous compilation is twice as fast as asynchronous compilation by default, due to the overhead of asynchronous callbacks.

Note that you can also use dynamic partials, that conditionally select the partial to render based on the value in the JSON.

we update the validation schema on the fly (we had a similar case with a validation that needs to be included whenever some fetch operation was completed)

What would happen if we get the list from a rest api when the form component is mounted? That's an interesting topic, you can add a rule once a component has been mounted and update the associated validation schema.

Ok, I have seen that there are lot of built-in and third party validations, but sooner or later I will face a validation rule not covered by this buffet. Can I build a custom one? Of course you can!

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.

This is a very dangerous practice as each optimization means making assumptions. If you are compressing an image you make an assumption that some payload can be cut out without seriously affecting the quality, if you are adding a cache to your backend you assume that the API will return same results. A correct assumption allows you to spare resources. A false assumption introduces a bug in your app. That’s why optimizations should be done consciously.

In the vast majority of cases there’s nothing wrong about wasted renders. They take so little resources that it is simply undetectable for a human eye. In fact, comparing each component’s props to its previous props shallowly (I’m not even talking about deeply) can be more resource extensive then simply re-rendering the entire subtree.

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

A simple Vue project can be run directly from a browser with no need of transpilation. This allows Vue to be easily dropped into a project the way jQuery is.While this is also technically possible with React, typical React code leans more heavily on JSX and on ES6 features like classes and non-mutating array methods.

I just created an empty Rails project and just find node_modules -print | wc -l gives me 18366 files!

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.

Why include that six-line helper function when you can do a one-line `require`? Never mind that the required module has its own dependencies, with their own dependencies, until your users suddenly find that `npm install` involves downloading 70Mb of gubbins split into 15,000 files. I exaggerate, but barely.

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.

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

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.

You'll have to create a new component that brings in the functionality of both. TooltipButton, TooltipLink, Link, and TooltipRoutedLink. We're starting to get a lot of components to handle a bit of added functionality.

For the tooltip example, if you had a whole bunch of tooltips on different elements, it would be annoying to have different event listeners and "should it be shown" variables for each one.

Perhaps at that point we're better off settling on a way to pass components through as parameters? <!-- App.html --> <Outer contents={Inner}/> <!-- Outer.html --> <div> <div>Something</div> <[contents] foo='bar'/> </div>

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.

Use case: Wrapper components that need to render an element (e.g. because they attach event listeners). You'd probably use a <div> there by default but there may be places where this is not desirable for semantic reasons (e.g. in lists).

const components = { Label, Tree, Menu };

The lack of spread continues to be a big pain for me, adding lots of difficult-to-maintain cruft in my components. Having to maintain a list of all possible attributes that I might ever need to pass through a component is causing me a lot of friction in my most composable components.

Performance optimizations are not free. They ALWAYS come with a cost but do NOT always come with a benefit to offset that cost.

Even having useCallback() returning the same function instance, it doesn’t bring any benefits because the optimization costs more than not having the optimization.

I originally did not use this approach because many pages that require translation are behind authentication that cannot/should not be run through these proxies.

you have less direct control as you must rely on the vendor’s adherence to IAB’s guidelines for compliance.

Directly blocking the vendor scripts (using another prior blocking method), then executing them only after consent has been collected. This method requires more implementation work and it’s a bit slower in terms of execution time, but it allows personalized ads to be served from the first page view (where consent hasn’t been collected yet) and gives you more direct and solid control in regards to ensuring compliance.