the first thing to understand is human beings are relational beings

Alone at last, I think. The fact is that I don't want to be alone with him,not on a bed. I'd rather have Serena there too. I'd rather play Scrabble

havenot been the first then.

"What would you like?" he says, still with that lightness, as if it's amoney transaction merely, and a minor one at that: candy, cigarettes."Besides hand lotion, you mean," I say."Besides hand lotion," he agrees."I would like..." I say. "I would like to know.

y arms around him.It's only a job, he said, trying to soothe me.

owthoroughly trenchant was his ability to sort contradictory signals, I have nodoubt that he must have already suspected something.

Like all caubois, she said: theyknow everything there is to know about food, because they can’t hold aknife and fork properly. Gourmet aristocrats with plebian manners. Feedhim in the kitchen.

It was not only thenational hymn of their southern youth, but it was the best they could offerwhen they wished to entertain royalty.

One day I saw Oliver sharing the same ladder with the gardener, tryingto learn all he could about Anchise’s grafts, which explained why ourapricots were larger, fleshier, juicier than most apricots in the region.

Don't prefer A = not prefer A Disprefer A = prefer not-A

I disagree. What is expressed is an attempt to solve X by making something that should maybe be agnostic of time asynchronous. The problem is related to design: time taints code. You have a choice: either you make the surface area of async code grow and grow or you treat it as impure code and you lift pure synchronous logic in an async context. Without more information on the surrounding algorithm, we don't know if the design decision to make SymbolTable async was the best decision and we can't propose an alternative. This question was handled superficially and carelessly by the community.

virtually every sentence of the critique 00:04:20 presents difficulties attempts have been made to provide commentaries comprehensively illuminating uh comprehensively illuminating each individual section of the work 00:04:33 and some of these run to several volumes without getting near its end and then one commentator com noting what it's like to read the critique of pure reason says it is quote 00:04:46 a disagreeable task because the work is dry obscure opposed to all ordinary notions and long-winded as well who said that 00:04:59 kant

You can find some benefits and limitations of each kind of space organization below.

by using symbols as keys, you will be able to use the implicit conversion of a Mash via the #to_hash method to destructure (or splat) the contents of a Mash out to a block

Try to make the Dockerfile easy to understand/read.

Do yourself and your peers a favor, write code with them in mind.

Writing Code for Humans — A Language-Agnostic Guide…because code which people can’t read and understand is easy to break and hard to maintain.

Write code for human, not for God

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

To see if you are writing good code, you can question yourself. how long it will take to fully transfer this project to another person? If the answer is uff, I don’t know… a few months… your code is like a magic scroll. most people can run it, but no body understand how it works. Strangely, I’ve seen several places where the IT department consist in dark wizards that craft scrolls to magically do things. The less people that understand your scroll, the more powerfully it is. Just like if life were a video game.

This is so clear that you don’t even need comments to explain it.

Another type of comments are the ones trying to explain a spell.

The rule of thumbs is, never use code that you do not understand.

PRs will introduce various mechanisms step by step. Some of these have issues already. A possible breakdown could be: Annotation collection using instance values (links also does this) Defining annotations to which multiple keywords contribute (this is new, see Need more details of annotation collection #530) Defining subschema and keyword processing results to include annotations Processing sequence for keywords that dynamically rely on the results of static keywords The actual definition of unevaluatedProperties An example of unevaluatedProperties

The discussion here can get very fast-paced. I am trying to periodically pause it to allow new folks, or people who don't have quite as much time, to catch up. Please feel free to comment requesting such a pause if you would like to contribute but are having trouble following it all.

This leads to duplicated effort and ultimately small differences between common interactions.

4.3 Understand the great brain battles and how to control them to get what “you” want.

4.1 Understand the power that comes from knowing how you and others are wired.

4 Understand That People Are Wired Very Differently

3.6 Understand how you can become radically open-minded.

2.7 Understand your own and others’ mental maps and humility.

1.6 Understand nature’s practical lessons.

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

“As a neonatologist, ... prior to COVID, I had maybe attended two to three deliveries in the medical ICU because it’s not common for women of childbearing age in their 20s and 30s to be critically ill and sick,” she said. Now, she said, “I truly cannot remember the last time I was on call at night and did not have to attend a COVID delivery. We’re just seeing a lot more complications in moms who you would expect to be healthy.”

Utah Department of Health reports that 81% of the state’s coronavirus deaths were patients who were “high risk,” only 52% of hospitalizations were of people deemed to have risk factors for serious illness.

Now thousands of people have shared their own stories about living through the pandemic with chronic illness — and about coping with remarks from media personalities and even health officials that minimize the human toll of COVID-19 because deaths and hospitalizations disproportionately affect people who are old or have underlying medical conditions.

There's a problem with 401 Unauthorized, the HTTP status code for authentication errors. And that’s just it: it’s for authentication, not authorization. Receiving a 401 response is the server telling you, “you aren’t authenticated–either not authenticated at all or authenticated incorrectly–but please reauthenticate and try again.” To help you out, it will always include a WWW-Authenticate header that describes how to authenticate.

So, for authorization I use the 403 Forbidden response. It’s permanent, it’s tied to my application logic, and it’s a more concrete response than a 401. Receiving a 403 response is the server telling you, “I’m sorry. I know who you are–I believe who you say you are–but you just don’t have permission to access this resource. Maybe if you ask the system administrator nicely, you’ll get permission. But please don’t bother me again until your predicament changes.”

(Note that lowering the intermediary fees can have a multiplier effect on creator disposable income. For example, if you make $100K in revenue and have $80K in costs, cutting out a 50% take rate increases your revenue to $200K, multiplying your disposable income 6x, from $20K to $120K.)

Node Sass does not yet support your current environment indicates that the version of node-sass you are trying to run is not compatible with the version of node installed.

Instead if this anchor was nested in frames it would open in a sandbox mode of sorts, meaning only in that frame.

It might be worth moving the latest updates to the top of this answer. I had to go through the whole thing to get to the best answer, flexbox.

function strictIsDog<T extends Dog extends T ? unknown : never>( // like <T super Dog> candidate: Dog | T // if Dog extends T then Dog | T is T ): candidate is Dog { // compiler recognizes that Dog | T can narrow to T return "bark" in candidate; } if (strictIsDog(animal)) {} // okay if (strictIsDog(dog)) {} // okay if (strictIsDog(mixed)) {} // okay if (strictIsDog(cat)) {} // error! // ~~~ <-- Cat is not assignable to Dog

[K in keyof User]-?:

which looks like complete nonsense if you don't really know what's going on

Adding to the accepted answer, if you happen to need to use a type guard against a mixin, you'll get this error too, since the is operator doesn't behave as an implements would.

the generic means "give me one of each function a -> Boolean" so if any of those functions doesn't exist, then the generic doesn't exist.

For better understanding of something that is complicated, just make it more simplier. In this example, just split the word into atoms, like these: Update - UP_DATE - make it up to date; Upgrade - UP_GRADE - move it to the upper (or next) grade (or level).

要给程序员这样的灵活性，Go必需支持指向分配在堆中对象的指针，我们将这种指针称为内部指针。上文的例子中X.buff字段保存于struct之中，但也可以保留这个内部字段的地址。比如，可以将这个地址传递给I/O子程序。在Java以及许多类似的支持垃圾回收的语音中，不可能构造象这样的内部指针，但在Go中这么做很自然。这样设计的指针会影响可以使用的回收算法，并可能会让算法变得更难写，但经过慎重考虑，我们决定允许内部指针是必要的，因为这对程序员有好处，让大家具有降低对（可能实现起来更困难）回收器的压力的能力。到现在为止，我们的将大致相同的Go和Java程序进行对比的经验表明，使用内部指针能够大大影响arena总计大型、延迟和回收次数。

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

Another problem was the ambiguity of RFC 3066 regarding the generative syntax. The idea of "language-dash-region" language tags was easy enough to grasp; most users didn't read RFC 3066 directly or consider the unstated-but-realized implication that other subtags might sometimes occur in the second position.

Thanks, @Kapsonfire-DE for better understanding the original issue.

--tag-rename '':'my-module-' (the single quotes are unnecessary, but make it clearer to a human that we are replacing the empty string as a prefix with my-module-)

Very slow, very cheap shipping via Royal Mail. Royal Mail advertises an ‘online’ international 12 week ’no rush’ service (not trackable). The price of the service is dependant on weight. It may be possible for international shipping to be achieved for around £15 GBP, may be even less! (This is not a typing error).  If you are interested in this service you will need to contact us before the campaign ends.

2 out of 3 people in my household do not find it easy to understand. Maybe that is is not representative, but keep in mind that something you yourself understand (or in this case think you understand) always seems easy.

Yet, it certainly is important to make the proper choices when picking up style. Similarly to fashion, code style reflects our credo as developers, our values and philosophy. In order to make an informed decision, it’s mandatory to understand the issue at stake well. We all have defined class methods many times, but do we really know how do they work?

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.

Microlibraries are easier to understand, develop and test. They make it easier for new people to get involved and contribute. They reduce the distinction between a “core module” and a “plugin”, and increase the pace of development in D3 features.

The way we do it currently is by calling load from inside of load, via different "pipelines" and processors which is quite elegant and completely impossible to work with.

I don't myself understand what's going on, it clearly has something to do with source maps, but may also have to do with other sprockets changes.

I don't really understand what's going on. Clearly source maps have something to do with it -- a source map feature that doesn't handle SCSS very well, apparently.

It is much easier to track what is going on within the activity. Instead of transporting additional state via ctx, you expose the outcome via an additional end event.

So why the over-complication? What we got now is replicating a chain of && in the former version. This time, however, you will know which condition failed and what went in by using tracing. Look at the trace above - it’s impossible to not understand what was going on.

Defaults names are given to steps without the :id options, but these might be awkward sometimes.

step :default_name

step Subprocess(DeleteAssets), id: :delete_assets

That’s pretty gnarly. While the name of the constant LOOSE_APP_ASSETS gives me some idea of what it does, it still takes a second to wrap your mind around. If you were trying to figure out what assets are being precompiled and you did a puts config.assets.precompile that lambda object would be utterly baffling.

However, you don’t need to have an extensive knowledge of monads to use ROP in your code.

It's hard to say why people think so because you certainly don't need to know category theory for using them, just like you don't need it for, say, using functions.

As you can see, we end up with a lot of boilerplate if-statements. The code is more verbose. And it’s difficult to follow the main logic.

The rsync and sleep commands (the sleep is just an example) are run through exec to prevent the creation of zombie processes if I kill the parent script while they're running, and each potentially-long-running command is wrapped in its own subshell so that when exec finishes, it won't terminate the whole script.

@adisos if reform-rails will not match, I suggest to use: https://github.com/orgsync/active_interaction I've switched to it after reform-rails as it was not fully detached from the activerecord, code is a bit hacky and complex to modify, and in overall reform not so flexible as active_interaction. It has multiple params as well: https://github.com/orgsync/active_interaction/blob/master/spec/active_interaction/modules/input_processor_spec.rb#L41

I don't think seeing it in Rails PRs naturally means we should do it blankly. Put it another way, what's the justification in those PRs for doing it?

If you don't understand both sides of an issue, you cannot make an intelligent choice; in fact, if you don't understand all the ramifications of your actions, you're not designing at all. You're stumbling in the dark.

never care and try to understand design standards

The code is far simpler and easier to understand/verify

Slots can already be pretty confusing to comprehend, I think it is better to stick to what people (may) already know.

Just to reiterate the discussion on the RFC, there was a suggestion that we change <svelte:slot slot="foo"> to <svelte:fragment slot="foo">, since it's the counterpart to a <slot> rather than an equivalent to it

Got a bit sidetracked into refactoring the Element visitor code, so haven't actually started on the event handler stuff per se, but that'll come soon. Element stuff is starting to feel a bit more logical and easier to follow.

Chevy tried an all-emoji press release about a new car that came across as very forced, proving that less is more when it comes to using emojis in emails. Not to mention, it’s almost impossible to decipher the message they’re trying to communicate.

In the context of software engineering, I've always used "dependent" and "dependee".

Oops, I had not read your original description closely enough.

One of the significant differences between the two is that a call to a partially applied function returns the result right away, not another function down the currying chain; this distinction can be illustrated clearly for functions whose arity is greater than two.

I know where you're coming from, and to a degree, I think you're right.

The only "issue" it has is that its unfamiliar. People have been working with HTML for years and are comfortable with it. That's basically the only reason that people find it more readable. If you make an effort to spend sometime with hyperscript, it becomes as familiar and readable as jsx.

the code is a bit verbose/convoluted

I'm not sure I understand the problem, everything you are describing is already possible.

Unfortunately people lack the the time to invest to really understand those things

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

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

As a result, I end up quoting multiple people, sometimes quoting several people back-to-back, before even writing my reply. In those instances it feels like I'm not properly citing those individuals. I feel like it might seem I'm not providing new readers appropriate context for a given quote. It might also be implied that separate quotes are from the same person, leading to mis-attribution.

“allow/deny are simply clearer terms” — now that’s an actual, technically useful argument.

To understand and be understood, those are among life’s greatest gifts, and every interaction is an opportunity to exchange them.

Many also question how the average user with little knowledge of the GDPR will react to being asked so many questions regarding consent. Will they be confused? Probably at first. It will be up to each business to create a consent form that is easy to understand, while being at the same time comprehensive and informative

Be clear and unambiguous. The average user should be easily able to understand what they’re consenting to;

Add-ons must function only as described, and should provide an appealing user experience. Based on the description of the add-on, a user must be able to understand and use the add-on’s features without requiring expert knowledge.

"users are not able to fully understand the extent of the processing operations carried out by Google and that ‘the information on processing operations for the ads personalization is diluted in several documents and does not enable the user to be aware of their extent."

One of the main threads of the GDPR is providing clear and transparent information to individuals about data collected, how it is processed, and the lawful basis for this processing.

Blair lceds the popular desire for rules of taste, guidelines for writing and speaking, and well-digested, if not predigested, samples of proper liter• ature.

LSB (least significant bit):  The rightmost bit MSB (most significant bit):  The leftmost bit