Thank you for the additional clarification and for the considerable expenditure of explanatory effort represented by the preceding response. Before proceeding further with the underlying technical question, it may be useful to establish a more explicit shared understanding concerning the relationship between the quantity of information supplied, the extent to which that information is necessary for the immediate decision being made, and the finite amount of maintainer attention available for converting the supplied information into an actionable conclusion. For the avoidance of doubt, the concern being raised here is not that factual accuracy, reproducibility, technical precision, correction of earlier assertions, or sufficient evidentiary support are undesirable. Each of those properties is useful and may, under the appropriate circumstances, be necessary. The difficulty arises when the information required to establish the relevant fact is accompanied by additional explanation whose presence, although potentially interesting and perhaps even technically correct, does not materially alter the fact itself, the confidence with which that fact can be evaluated, or the action that follows from accepting it. Every response imposes what might be described as a comprehension obligation upon its recipients. That obligation consists not merely of reading the words presented, but also of determining which statements constitute factual claims, which function as evidence, which are qualifications, which are conjectures, which supersede earlier statements, which merely restate conclusions already established elsewhere, and which are included primarily to explain the circumstances under which some other statement came to be made. The cost of satisfying this obligation tends to increase with the length, density, and structural complexity of the response, even where the amount of information capable of changing the maintainer’s eventual decision remains constant. This consideration is particularly significant in the context of open-source maintenance, where the time required to read, classify, verify, and contextualize one response cannot simultaneously be used to reproduce another issue, review a pull request, investigate a regression, prepare a release, answer another contributor, evaluate a dependency update, improve documentation, or perform any of the numerous other activities competing for the same limited pool of attention. Consequently, verbosity is not entirely without cost merely because the information is supplied voluntarily, constructively, and with the intention of preventing misunderstanding. Its cost is transferred to each recipient who must determine which portions are operationally necessary and which portions can be disregarded without compromising the validity of the resulting conclusion. We would therefore ask that future responses be prepared according to something approximating a principle of minimum sufficient communication, by which a response contains the smallest collection of independently useful facts required to answer the question currently being asked or to establish the behavior currently under discussion. Information should not be included solely because it is adjacent to the subject, because it records the path by which a conclusion was reached, because it anticipates questions that have not yet been asked, because it exhaustively delineates the boundaries of claims whose ordinary interpretation is already sufficiently narrow, or because omitting it might leave some peripheral aspect of the subject less than comprehensively characterized. The use of the word “smallest” in this context should not be interpreted as a request for artificial abbreviation, unexplained assertions, incomplete reproduction instructions, or the omission of facts required to distinguish the reported behavior from another superficially similar behavior. It means, instead, that each sentence should justify the attention required to process it by contributing something without which a maintainer would be materially less able to verify the report or determine the appropriate next action. Where the removal of a sentence would leave the actionable meaning unchanged, that sentence should generally be presumed removable. Where several paragraphs can be replaced by a single concrete observation without sacrificing reproducibility, the concrete observation should be preferred. Where a mechanism can be demonstrated through a minimal configuration change and an immediately observable result, that demonstration should ordinarily take precedence over a comprehensive narrative describing the mechanism’s provenance, implications, surrounding implementation details, and hypothetical manifestations in configurations not yet tested. Qualifications should similarly be restricted to those that alter the reasonable interpretation of the principal claim. It is generally unnecessary to enumerate every proposition that is not being asserted, every environment that has not been tested, every alternative explanation that was considered and rejected, every inference that a sufficiently careful reader might otherwise draw, or every reason the author has for believing that an untested configuration may behave similarly. Where uncertainty is relevant, it is usually sufficient to identify the precise boundary of verification rather than narrating the broader epistemological status of all related propositions. One potentially useful standard for deciding whether information warrants inclusion is to ask whether the behavior that actually occurs, the smallest reliable procedure that causes it to occur, and any qualification without which those statements would become materially misleading remain understandable and reproducible after the information is removed. If they do, the removed material was probably not necessary for the immediate response. Background already available elsewhere in the issue, detailed explanations of standard language or bundler behavior, speculative generalizations beyond the verified reproducer, extended discussion of why an earlier reproducer was inadequate, descriptions of investigative paths that did not produce the final result, and multiple reformulations of the same conclusion at successively different levels of abstraction should normally be retained by the author unless and until a maintainer requests them. This request is not intended as a judgment concerning the effort, competence, thoroughness, or good faith involved in preparing the response. It concerns the format in which the result of that effort is presented. A technically correct response may nevertheless be disproportionately expensive to consume, in much the same way that a comprehensive diagnostic log may contain the relevant error while simultaneously making that error more difficult to locate. The objective is not to minimize the amount of investigation performed by the reporter, but to minimize the portion of that investigation which every subsequent reader must reconstruct before reaching the actionable result. We recognize that determining what is essential requires judgment and that contributors cannot invariably know in advance which detail a maintainer will consider relevant. In such circumstances, the preferred strategy is progressive disclosure, under which the shortest adequately supported factual answer is provided initially and further supporting detail is supplied only when a maintainer identifies a concrete need for it. It is substantially easier for a maintainer to request one missing fact than it is for multiple maintainers to independently identify and disregard several pages of facts that do not affect the decision being made. The appropriate optimization target is therefore not maximum completeness at the time of the first response, but minimum aggregate effort across all participants required to reach a sufficiently supported conclusion. A concise response that results in one targeted follow-up question may satisfy that target more effectively than an exhaustive response which attempts to preempt every conceivable follow-up but requires substantially greater processing time from every reader, including readers for whom most of the anticipated questions would never have arisen. Facts directly necessary to establish the reported behavior should be included. Evidence directly necessary to verify those facts should be included only to the extent that verification would otherwise be impractical or ambiguous. Context that may be interesting but does not change the facts, their verification, or the resulting action should be omitted unless specifically requested. Where several formulations communicate materially identical information, the shortest formulation should be selected. Where a direct statement is available, it should take precedence over a narrative account of how the statement was discovered. Where one verified claim is sufficient, it should not be surrounded by multiple hypothetical extensions. Where the answer to a question can be expressed as a concrete condition and an observable consequence, the response should ordinarily contain that condition and consequence without attempting to supply a general theory of every adjacent failure mode. It is also important to clarify that this does not mean providing a concise summary followed by the same extended explanation that the summary was intended to replace. The continued presence of the explanation preserves most of the reading, classification, and triage cost. A summary is not a substitute for removing unnecessary material when the unnecessary material remains directly beneath it. Supporting details can remain available to the author and can be supplied in a subsequent response if a maintainer determines that the initial facts are insufficient. Nor is it generally necessary to surround relevant facts with introductory courtesies, repeated apologies, rhetorical transitions, anticipatory defenses, summaries of prior misunderstandings, explanations of why the current answer differs from a previous answer, assurances about claims that are not being made, or concluding restatements of conclusions already expressed. Courtesy is appreciated, but its communicative footprint need not substantially exceed that of the technical substance. A correction is most useful when it makes the corrected claim immediately identifiable and permits the obsolete claim to be discarded without requiring the reader to reconstruct the entire history of the correction. Applied to the present exchange, the information that appears most capable of affecting maintainer action is that disabling HMR removes the React refresh preamble, that the resulting client bootstrap no longer causes the relevant environment initialization to occur before createClientRpc is evaluated, and that server-function construction consequently encounters a ReferenceError because process is unavailable. The precise import-order mechanics, the contrast with the initial theory concerning a relative URL, the implications for other plugins whose preambles may differ, the explanation of why the originally linked example does not exhibit the behavior under its default configuration, and the broader characterization of the problem as a dependency on an incidental ordering guarantee may become relevant during implementation, but they need not all be transmitted before maintainers have had an opportunity to evaluate the narrower verified condition and its immediate consequence. In consideration of the asymmetry between the effort required for an author to preserve additional material and the cumulative effort required for every recipient to inspect and classify that material, and with due regard for the limited and nonrenewable character of volunteer maintainer attention as it relates to the substantially renewable supply of potentially relevant contextual exposition, future participation would be most effective if each response were reduced, before submission, to only those empirically established statements whose omission would prevent reproduction, materially distort the reported behavior, or leave the specific question under consideration unanswered, with all supplementary narrative, speculative extension, duplicative reformulation, historical reconstruction, rhetorical cushioning, and otherwise nonessential elaboration withheld pending an explicit indication that its disclosure is required.

Generally, banks do not let their users share their transaction data with third party apps in a secure, standardized way. Instead, you have to give your bank account credentials directly to third parties.

Unfortunately, each of these systems is highly complex and can inflict all kinds of damage on data, much of the damage undetectable to humans.

You're checking state in a mailer

It's going to be so fun to scale when you finally want to add more unsubscribe links for different types of sequences

If you have anything like this is your codebase, you need Caffeinate:

What is the Docker host filesystem owner matching problem?

Using Time.now (which returns the wall-clock time) as base-lines has a couple of issues which can result in unexpected behavior. This is caused by the fact that the wallclock time is subject to changes like inserted leap-seconds or time slewing to adjust the local time to a reference time. If there is e.g. a leap second inserted during measurement, it will be off by a second. Similarly, depending on local system conditions, you might have to deal with daylight-saving-times, quicker or slower running clocks, or the clock even jumping back in time, resulting in a negative duration, and many other issues. A solution to this issue is to use a different time of clock: a monotonic clock.

Email addresses sometimes get reassigned to a different person. For example, employment changes at a company can cause an address used for an ex-employee to be assigned to a new employee, or a mail service provider (MSP) might expire an account and then let someone else register for the local-part that was previously used. Those who sent mail to the previous owner of an address might not know that it has been reassigned. This can lead to the sending of email to the correct address but the wrong recipient. This situation is of particular concern with transactional mail related to purchases, online accounts, and the like.

Today, many web developers are even using JavaScript's native module syntax, but combining it with bare import specifiers, thus making their code unable to run on the web without per-application, ahead-of-time modification. We'd like to solve that, and bring these benefits to the web.

I am not looking for model based after commits on update/create/etc, I want to be able to dynamically define a block that will be executed only if the current (top-most) transaction passes:

Making one Comment query per Post is too expensive; it’s N+1 queries (one to fetch the posts, N to fetch the comments). You could use includes to preload all the comments for all the posts, but that requires hydrating hundreds of thousands of records, even though you only need a few hundred for your front page. What you want is some kind of GROUP BY with a LIMIT on each group — but that doesn’t exist, either in Activerecord nor even in postgres. Postgres has a different solution for this problem: the LATERAL JOIN.

Its goal is to solve the problems with downloading templates to start your app from:

What seems more problematic is divergence between drivers. For example, capybara-webkit and poltergeist support several of the same things. Let's take resizing the window as an example. In capybara-webkit this is page.driver.resize_window(x, y) and in poltergeist it's page.driver.resize(x, y). This means that if a user wants to switch from one to the other they have to change their code. Now I don't know if selenium does or doesn't support resizing the window, but supposing it doesn't I think there's still a lot of value in the capybara project deciding what the blessed API is, because then all the drivers that support that feature can implement it using the same API, increasing portability.

The goal of this technology is to provide a mechanism for browser-based applications that need two-way communication with servers that does not rely on opening multiple HTTP connections (e.g., using XMLHttpRequest or <iframe>s and long polling).

To illustrate the problem:

Most programming languages vend environment variables as strings. This leads to errors like so:

I’m going to add the API Server as an actor to my first test sequence to give some granularity as to what I’m actually testing.

Instead of having this confusing maze of lambdas, regexes, and strings, we could, in theory, introduce a single entry point of configuration for Sprockets to use, and in that file declare all assets we wanted to compile. Well, that’s exactly what the manifest.js file is.

This can be useful in cases like multistep registration. Previously in # rails we used to stick all of the validations in the class and then we're # stuck validating them all everytime

However, sometimes actions can't be rolled back and it is unfortunately unavoidable. For example, consider when we send emails during the call to process. If we send before saving a record and that record fails to save what do we do? We can't unsend that email.

But it doesn't work so I have to wrap slots in useless and interfering divs or spans like this: <Button fz="16" h="64" {...$$props}> <span slot="prepend"><slot name="prepend" /></span> <slot /> <span slot="append"><slot name="append" /></span> </Button>

Say I have a separate API server that provides content for a Sapper route. I could just query that API in my route's preload function, but if the content changes rarely, I don't want to incur that cost for every page load and would much rather cache responses from the API on the Sapper side.

This is an opportunity to fix a bug: if you're on a page that redirects to a login page if there's no user object, or otherwise preloads data specific to that user, then logging out won't automatically update the page — you could easily end up with a page like HOME ABOUT LOG IN ----------------------------------------------------------------------------------------- Secret, user-specific data that shouldn't be visible alongside a 'log in' button:

This pattern can be neater syntactically because declaring a variable in a try block with let scopes the variable to the try block.

So, how does an SPA work? JavaScript loads in the browser and loads data from an API. Most of the rendering is done on the client Side. But search engine bots have a hard time indexing the page because it doesn't have much without JS.

This scenario demonstrates one drawback of CSS: With all the style rules that need to be applied to multiple elements on multiple pages, things can get pretty redundant. And redundancy can eat up your time and cause friction whenever you need to change a color, font, or any other style aspect across your site.

true && { echo true; false; } || { echo false; true; }

Examples of this include: requiring base classes or reading from imported variables that have not been initialized yet.

as soon as you have a (indirect) circular dependency, you might be interacting with a half loaded module in your code.

You can see that behaviour in this example. Select a range of text and hit the tab key. Because the <textarea> value changes, the current selection is cleared and the cursor jumps, annoyingly, to the end.

Just like elements can have children... <div> <p>I'm a child of the div</p> </div>...so can components. Before a component can accept children, though, it needs to know where to put them. We do this with the <slot> element.

The primary motivation behind virtual-dom is to allow us to write code independent of previous state. So when our application state changes we will generate a new VTree. The diff function creates a set of DOM patches that, based on the difference between the previous VTree and the current VTree, will update the previous DOM tree to match the new VTree.

Manual DOM manipulation is messy and keeping track of the previous DOM state is hard. A solution to this problem is to write your code as if you were recreating the entire DOM whenever state changes. Of course, if you actually recreated the entire DOM every time your application state changed, your app would be very slow and your input fields would lose focus.

Before MDX, some of the benefits of writing Markdown were lost when integrating with JSX. Implementations were often template string-based which required lots of escaping and cumbersome syntax.

Part of why most code -- and most software -- sucks so much is that making sweeping changes is hard.

Why

However imagine we are creating a format string in a separate file, commonly because we would like to internationalize it and we rewrite it as: <?php$format = 'The %s contains %d monkeys';echo sprintf($format, $num, $location);?> We now have a problem. The order of the placeholders in the format string does not match the order of the arguments in the code. We would like to leave the code as is and simply indicate in the format string which arguments the placeholders refer to. We would write the format string like this instead: <?php$format = 'The %2$s contains %1$d monkeys';echo sprintf($format, $num, $location);?> An added benefit is that placeholders can be repeated without adding more arguments in the code.

$format = 'There are %d monkeys in the %s';

$format = 'The %s contains %d monkeys'

Poedit and other tools can scan your .php files for references of __(), _e(), _n() and so on, and grab those strings for translation, which is awesome, because otherwise you’d have to manually add every single string. Now, when these tools come across _n() in our sources, they know it’s a plural thing, because of a special keyword setting which looks something like _n:1,2, meaning _n() takes at least two arguments, where the first argument is the singular, and the second argument is a the plural, so it grabs both strings. Let’s take a look at how Poedit and other tools will parse our function above: Hello there _n() on line 3! I’m supposed to grab two of your arguments because I have this smart keyword setting, but none of these arguments are strings, so I’ll just skip to the next match

Nix helps you make sure that package dependency specifications are complete. In general, when you’re making a package for a package management system like RPM, you have to specify for each package what its dependencies are, but there are no guarantees that this specification is complete. If you forget a dependency, then the component will build and work correctly on your machine if you have the dependency installed, but not on the end user's machine if it's not there.

You might be thinking––"a tool that allows me to write semantic and reusable queries? Sounds like Active Record". It's absolutley true that Active Record already provides a powerful query tool kit. But what happens when even simple queries stretch the bounds of Active Record's capabilities?

Such verbose. Much code. Very bloat. Wow. We've lost all the awesome association introspection that ActiveRecord would otherwise have given us.

But it's not easy to open todo.txt, make a change, and save it—especially on your touchscreen device and at the command line. Todo.txt apps solve that problem.

Sometimes cronjobs fail to run successfully because a required server (like a database or ftp server) is temporarily unavailable due to power failures, hardware failures, software failures, network outages, choice of operating system, pilot error, and the like. Typically, this results in someone being forced to examine crontabs and error reports, determine which cronjobs really need to be run, and then run them manually. This happened to me twice in one week. I don't want it to happen again. Cronjobs are meant to be automated and I want them to stay that way. This is the rationale for noexcuses.

An ssh public key in a ~/.ssh/authorized_keys file can have a command="" option which forces a particular command to be executed when the key is used to authenticate an ssh connection. This is a security control that mitigates against private key compromise. This is great when you only need to execute a single command. But if you need to perform multiple tasks, you would normally need to create and install a separate key pair for each command, or just not bother making use of forced commands and allow the key to be used to execute any command.

However, these benefits only accrue to outbound connections made from the local system to ssh servers elsewhere: once logged into a remote server, connecting from there to yet a third server requires either password access, or setting up the user's private key on the intermediate system to pass to the third. Having agent support on the local system is certainly an improvement, but many of us working remotely often must copy files from one remote system to another. Without installing and initializing an agent on the first remote system, the scp operation will require a password or passphrase every time. In a sense, this just pushes the tedium back one link down the ssh chain.

You might want developers building projects with this CMS to be able to change the behaviour of some UIs, or to be able to provide new components that can be consumed by the CMS. Those components can't easily be included in the JS bundle for the CMS, as it would require recompiling the shipped code with outside references.

However, again you would have to lift state up to the App component in order to pass the amount to the currency components. As you can see, the component composition on its own doesn't help us to solve the problem. That's the point where React's render props pattern comes into play which enhances React's component composition with an important ingredient: a render function.