curl -o ~/.config/direnv/helpers.sh

SvelteKit offers a very elegant solution for this — the load function. The load function can run both on the client and on the server side and in both cases will be executed before the component renders.

You can do this elegantly with throw/catch, like this:

In most languages, there is no clean equivalent for breaking out of a recursive algorithm that uses a recursive function. In Ruby, though, there is!

Any tips on how to make it exclusive (for any generic situation, not just OP's)?

x = -3 "++-"[x <=> 0] # => "-" x = 0 "++-"[x <=> 0] # => "+" x = 3 "++-"[x <=> 0] # => "+"

Bash is a wonderful and terrible language. It can provide extremely elegant solutions to common text processing and system management tasks, but it can also drag you into the depths of convoluted workarounds to accomplish menial jobs.

It’s easy to create bugs because the environment is a somewhat degenerate settings database.

I don't think it is too clever. I think it solves the problem idiomatically. I.e., it uses reduce, which is exactly correct. Programmers should be encouraged to understand what is correct, why it is correct, and then propagate. For a trivial operation like average, true, one doesn't need to be "clever". But by understanding what "reduce" is for a trivial case, one can then start applying it to much more complex problems. upvote.

Non-solutions Start replacing process.env[ with ({})[ if you're sadistic

Before we dive into the details of the actual migration, let’s discuss the theory behind it.

Every time filter-repo is run, files are created in the .git/filter-repo/ directory. These files overwritten unconditionally on every run.

That image only contains 200 pixels horizontally, but the browser stretches it to 400px wide or even farther!Luckily, you’ll see there’s an easy “fix” there at the end: our old good friend the width attribute!<img src="example.gif", srcset="example.gif 200w" sizes="(min-width: 400px) 400px, 100vw" width="200" /* <=== TA-DA! */ class="logo">As long as you can specify the width attribute so it reflects the true maximum size of your largest image, you won’t run into this problem of having sizes make your image wider than it naturally should go.

class AuthConstraint def initialize(&block) @block = block || ->(_) { true } end def matches?(req) user = current_user(req) user.present? && @block.call(user) end def current_user(req) User.find_by_id(session[:user_id]) end end This is a flexible approach to defining route access based on any desired variable (roles, auth, etc...)

A proposal to specify the path for bury with classes as values of a hash arg: {}.bury(users: Array, 0 => Hash, name: Hash, something: 'Value') # {user: [{name: {something: 'Value'}]} So all absent nodes could be created via klass.new

{}.bury(users: Array, 0, 'Value')

{}.bury(users: Array, 0 => 'Value')

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"}}}}

I think the issues/problems specified in the comments are not present with a Hash-only implementation. :) I would be supportive of re-considering this feature just for use with a Hash, where I believe 80% of the real-life use cases would (and do) exist. I have encountered this need before in the wild, but not with Arrays.

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

Given the deskopen script, you can use a reference to it as the shebang line in a .desktop file

This is the only answer that does not require manually parsing the .desktop file, so it's the most sane (and safe) approach.

(xdg-open seems to be supposed to be the universal one...)

xdg-open should do the same thing - actually, it will call gnome-open, or kde-open, or whatever, depending on your desktop environment. Thus it's more portable.

The advantage is that you can use gnome-open for almost all file-types, URIs and directories. It's one command to learn, instead of trying to remember about obscure commands like sensible-browser

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

Refactoring is a means of addressing the problem of software rot. It is described as the process of rewriting existing code to improve its structure without affecting its external behaviour.

PyPy uses a technique known as meta-tracing, which transforms an interpreter into a tracing just-in-time compiler.

Maybe it would be simple to always add that line, and always shift the source maps by 1.

richard.schneeman+no-recruiters@gmail.com

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.

We’re not really using placeholder in our demo, but a value of a single space works:

:placeholder-shown is super useful for us here! It’s basically the secret selector for testing if an input currently has a value or not.

var md = require('markdown-it')('commonmark');

import markdownIt from 'markdown-it'
let md = markdownIt('commonmark')

Best Payment Solutions To Manage The Marketplace in 2021

It is based on the idea that each validation is encapsulated by a simple, stateless predicate that receives some input and returns either true or false.

Adding ends to an activity is a beautiful way to communicate more than two outcomes to the outer world without having to use a state field in the ctx. It also allows wiring those outcomes to different tracks in the container activity.

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.

One way to alleviate this configuration fatigue is by making configuration consistent and composable. That’s what Sprocket’s new “manifest.js” seeks to do.

Not all cases can be covered and easily restored. And sometimes when we will reuse this function for different use-cases we will find out that it requires different restore logic.

But why do we return 0? Why not 1? Why not None? And while None in most cases is as bad (or even worse) than the exceptions, turns out we should heavily rely on business logic and use-cases of this function.

So, the sad conclusion is: all problems must be resolved individually depending on a specific usage context. There’s no silver bullet to resolve all ZeroDivisionErrors once and for all. And again, I am not even covering complex IO flows with retry policies and expotential timeouts.

Monads provide an elegant way of handling errors, exceptions and chaining functions so that the code is much more understandable and has all the error handling, without all the ifs and elses.

One thing I really like about this style is the elegance and readability it provides to your codebase.

I wanted to keep reviewing restaurants, but I didn’t want to go back into their dining rooms both because of the risk and because I was afraid readers would take it as an all-clear signal. When the governor halted indoor dining again in December, my selfish reaction was relief. Then I briefly got depressed. How would restaurants survive? And how would I keep writing about them?One answer had already started to appear on sidewalks and streets in the form of small greenhouses, huts, tents and yurts. Inside these personal dining rooms, you can (and should) sit just with people from your own household. If the restaurant thoroughly airs the space out between seatings, any germs you breathe in should be the same ones that are bouncing around your home. Many restaurants instruct their servers to stay outside the structures as much as possible, though some don’t.

It requires an account to update, but the other inputs are optional. If they're missing, it'll ignore those attributes. If they're present, it'll update them.

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.

It makes me happy to see people actually think about things and not just accept a shitty API.

I do think it's a common pattern that should be solved, and I am probably going to try and solve it as a Gem as opposed to simply writing code that we use in our code base

while ActiveForm currently fits 99% of my use cases, I do sometimes make modifications based on the product requirements

I will continue to use form objects and push changes into the repo when I feel they are universally relevant and valuable.

I typically save everything I can first, and then call the side-effects afterwards. If the side-effects fail I can handle them elsewhere and retry when necessary.

As with other software patterns, MVC expresses the "core of the solution" to a problem while allowing it to be adapted for each system.

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

Most importantly, let us support all of those who are using sport as a force to advance equality and opportunity;

Not only are successful sportswomen showing girls that they can excel on the field; many are using their status to start important conversations about gender equality and to advocate for women’s rights more widely.

We also need more male athletes to step up with us, and model a culture that reflects equality, respect for diversity and non-violence, within and beyond sport.

Even when laws and policies are in place, deep-seated attitudes about gender roles can hold back substantive change

In November 2018, Fenerbahçe Sports Club, one of the oldest and most popular multi-sports clubs in Turkey, joined forces with HeForShe in an ’Equal together’ initiative involving its male football players, and seen by its global fan base of 25 million. They aim to achieve gender equality transformation through sport, with women- and children-friendly stadium practices, and a zero-tolerance approach to all sorts of discrimination against women and girls

Universal Links allow you to register a series of domains that are allowed to interact with an installed application. If the application is not installed, the universal link is opened with Safari, allowing you to inform the user of the existence of an application or whatever is necessary.

Flatpak as a truly cross-distro application solution that works equally well and non-problematic for all

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.

Moving DOM elements around made me anxious and I wanted to preserve natural tab order without resorting to setting tabindex, so I also made a flexbox version that never moves DOM elements around. I think it's the superior solution, at least for the layouts I was going for. https://github.com/wickning1/svelte-components/blob/master/src/FlexCardLayout.svelte

Or just watch the value with a reactive statement instead of an event handler on the input like: $: inputValue, onInput() This is a good solution and seems to work in all cases.

A Svelte component that monitors an element enters or leaves the viewport/parent element. Performant and efficient thanks to using Intersection Observer under the hood. Can be used in multiple projects including lazy loading images, infinite scrolling, playing/pausing the video when in the viewport, tracking user behaviour firing link pre-fetching and animations and many many more.

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.

A cleaner approach could be the use:action API.

Popper for Svelte with actions, no wrapper components or component bindings required! Other Popper libraries for Svelte (including the official @popperjs/svelte library) use a wrapper component that takes the required DOM elements as props. Not only does this require multiple bind:this, you also have to pollute your script tag with multiple DOM references. We can do better with Svelte actions!

Jbuilder gives you a simple DSL for declaring JSON structures that beats manipulating giant hash structures. This is particularly helpful when the generation process is fraught with conditionals and loops.

The Web Storage API provides mechanisms by which browsers can store key/value pairs, in a much more intuitive fashion than using cookies.

Like JSON.stringify, but handles

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:

I think the main difference between the two are the way API are served. Some smelte components need you to input big chunk of json as props, while i prefer keep props as primitive types and in the other hand give you different components tags to compose.

Instead of waiting for a magic fairy to appear and eliminate your problem so that you can enjoy life again, you might want to start adding those little positive events back onto your agenda despite the problem still being present

If you need to imagine in concrete detail how you would notice that a problem disappeared, you are challenged to leave vague descriptions like “I’ll be happy”, “I’ll be less annoyed” behind.Vagueness in the end is a cognitive avoidance mechanism. It is easy to ruminate on general emotions and thoughts but very hard to imagine concrete outcomes and changes. We would rather not face precise thoughts, emotions or memories because they can be painful. Better to stay at a safe but vague distance.

The answer should be: you write a language that compiles to Go’s IR.

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.

Another difference is that context in Svelte does not insert anything into the visual component tree. There is no <Context.Provider> element like in React

For now, I'm still seeking a more satisfactory solution.

that's the only really accurate answer to the question: all the others propositions run an "almost same" container, but they forget the volumes, env, UIDs,

memoize

A resource route maps a number of related requests to actions in a single controller.

I'm still hoping for a nicer solution.

An even more general version that allows using find options:

The make install task installs the following files:

You can determine which openssl.cnf is being used by adding a spurious XXX to the file and see if openssl chokes.

We could broadcast a warning if we find the variable to be set in the environment, but that is more likely than not to annoy people who intentionally set it.

for (var member in myObject) delete myObject[member]; ...would seem to be pretty effective in cleaning the object in one line of code

for (var prop in obj) { if (obj.hasOwnProperty(prop)) { delete obj[prop]; } }

I don't want Svelte to go out of its way to try to catch all these edge cases. It would require lots of fragile heuristics in the compiler. I want a solid compiler I can trust, not something magic but often out of service. I want it the simplest possible.

In the many projects I have maintained so far, sooner or later I always run into the same issue: circular module dependencies. Although there are many strategies and best practices on how to avoid circular dependencies. There is very little on how to fix them in a consistent and predictable way.

This is how I solve circular dependency issues nowadays.

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.

Perhaps we should detect URLSearchParams objects differently (using duck typing detection instead of instanceof window.URLSearchParams, for example) but the solution isn't adding a specific polyfill to Axios (as it'd increase the bundle size and still won't work with other polyfills).

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.

Once again, this isn’t good or bad, it’s just the most efficient way to create something that is similar to something else

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.

The first rule of standard is no configuration. Whatever the outcome of this thread, adding options is the wrong solution.

Here is how you could emulate an if-else-block:

It would be cool though to have a framework that does not add any specific limitations

As we've briefly seen already, you can listen to any event on an element with the on: directive:

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.

But this is starting to become rather verbose at what could be a much simpler and more elegant solution if only there were another template helper that could do variable assignment.

Example with fantasy syntax:

Here's a proxy store I wrote to derive the value of a store nested within other stores, it plays nice with typescript and can go infinitely deep

but everything they were doing started to make sense

MobX - for me personally MobX is a far better way to manage state than React Hooks. It doesn't care about the UI layer so it can be used outside the React ecosystem, and it's simple to mutate data.

How much will it cost to build a car wash mobile app?

This library exports a single React Hook, useMethods, which has all the power of useReducer but none of the ceremony that comes with actions and dispatchers.

Insisting on a specific implementation, rather than proposing a clear problem, suggesting a possible solution, and “not being married” to your initial preferred solution.

Unfortunately, many third party libraries, even though they are written in ESM, are published to npm as CJS modules, so we still need to concatenate them.

There are work arounds, but nothing clean. I just feel like this should be functionality that should be part of the slot feature.