This is a non-exhaustive list of other things I love;

Designing and writing code get me money so I can have food so they get a lot of my attention.

If you don't control your schedule, it will control you.

For instance, when faced with a 60% off, 12 hour only coupon that reduces a $1,200 winter coat to $400, you can’t help but rush to the store to buy it, even if it is 95 degrees out. A few things are happening here. For one, the $1200 acts as an anchor price that psychologically forces you to realize you’re getting an enormous deal at the $400 price point. Plus, the promotion limiting the time the offer is available forces you into an impulse.

Here's the last issue where source maps were discussed before the beta release.

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.

Our mission is to allow people to make money via educational efforts and to dedicate the rest of their time to creating great open source products.

let's be honest, print-and-play is A LOT of work (printing, cutting, laminating, sleeving, etc) and it is not everyone's cup of tea.

They fail to recognize the value of an initial investment of time in future productivity.

For mobile phones, technologies like SMS, MMS and data access were historically usually considered value-added services, but in recent years SMS, MMS and data access have more and more become core services, and VAS therefore has begun to exclude those services.

Trailblazer (TRB) is an Open-Source project. Since we want to keep it that way, we decided to raise awareness for the “cost” of our work - providing new versions and features is incredibly time-consuming for us, but we love what we do.

The new 2.1 version comes with a few necessary but reasonable changes in method signatures. As painful as that might sound to your Rails-spoiled ears, we preferred to fix design mistakes now before dragging them on forever.

It’s so simple that I sometimes wonder why it took years to develop it!

time has become personalized

No one has requested it before so it's certainly not something we're planning to add.

To give a little more context, structures like this often come up in my work when dealing with NoSQL datastores, especially ones that rely heavily on JSON, like Firebase, where a records unique ID isn't part of the record itself, just a key that points to it. I think most Ruby/Rails projects tend towards use cases where these sort of datastores aren't appropriate/necessary, so it makes sense that this wouldn't come up as quickly as other structures.

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?

A sequence diagram shows object interactions arranged in time sequence.

Take 3, Previously attempted in 2012 (#8189) and 2015 (#19709). This new version uses ActiveModel Attributes API.

Sorry for the delay, life got in the way. I should have some time to pick this up again next week.

I apologize for the slow development of Reform after the "explosion" when I released it initially. The reason for this is I changed jobs and didn't use Reform (yet).

Cache invalidation is hard because: Everything in life we want to know, changes.Those changes are non-deterministic.

never care and try to understand design standards

Trust me, I'm not trying to stress you right now, but I just wanted to do a friendly bump in case you forgot about this. (I know how it is sometimes) If you get this notification and feel "Ugh, I really don't have time" you don't have to comment here and I'm sorry. I'm just sending you a notification in case you forgot. If not, feel free to archive the email and not click/tap on anything.

At work, I cannot maintain this project. At home, I'd rather spend time with my children and on projects that I'm currently passionate about.

The ground-water compo- nent of streamflow was estimated from a streamflow hydrograph for the Homochitto River in Mississippi,

The length of the Ark gives him occasion to discussthe membership of the Church (who are the occupants of the different chambers of thetriple-decked Ark) through three divisions of time: the age of nature, the age of law, andthe age of grace, in a concise chronological summary of spiritual history (paras. 11–13).

You can afford to make a proper PR to upstream.

I hit enter and then was not fast enough on my edit

We are the species that has invented itself the most, by creating the exogenetics of language and culture which carry our continual further inventions to each other over time and space to invent and reinvent our futures.

At the start this is hard to get right, and bad practices will sneak into the codebase.

I'd say it's better overall because it replaces paths at compile-time. It means there is no runtime dependency or any performance overhead.

Loaders use a mapping configuration to map module names to files at run-time, see RequireJs documentation and SystemJS documentation.

Lead Time for Work Items: The lead time graph shows how much time developers spend working on something before it is released. The graph caught the attention of the product management because, when translated to a business context, the increased lead times mean a longer time to market. The variability in lead times (the shaded, green area in the graph) was also a concern since it indicates low predictability during development or inappropriately scoped work items, often both.

When you email me, please include a minimal bash script that demonstrates the problem in the body of the email (not as an attachment). Also very clearly state what the desired output or effect should be, and what error or failure you are getting instead. You are much more likely to get a response if your script isn't some giant monster with obtuse identifiers that I would have to spend all afternoon parsing.

It took us a long time for everyone to get on the same page about the requirements spanning frameworks, tooling and native implementations. Only after pushing in various concrete directions did we get a full understanding of the requirements which this proposal aims to meet.

I think it is indeed important that we get this right but I'd prefer to hold off on implementing such a system until we have grown contributors and until the project is successful. I expect that after the initial open source release and before the end of the year we'll want to move pretty quickly on this project and I recommend revisiting the RFC based model early next year. Does that sound like a good plan?

In Rust, we use the "No New Rationale" rule, which says that the decision to merge (or not merge) an RFC is based only on rationale that was presented and debated in public. This avoids accidents where the community feels blindsided by a decision.

I'd like to go with an RFC-based governance model (similar to Rust, Ember or Swift) that looks something like this: new features go through a public RFC that describes the motivation for the change, a detailed implementation description, a description on how to document or teach the change (for kpm, that would roughly be focused around how it affected the usual workflows), any drawbacks or alternatives, and any open questions that should be addressed before merging. the change is discussed until all of the relevant arguments have been debated and the arguments are starting to become repetitive (they "reach a steady state") the RFC goes into "final comment period", allowing people who weren't paying close attention to every proposal to have a chance to weigh in with new arguments. assuming no new arguments are presented, the RFC is merged by consensus of the core team and the feature is implemented. All changes, regardless of their source, go through this process, giving active community members who aren't on the core team an opportunity to participate directly in the future direction of the project. (both because of proposals they submit and ones from the core team that they contribute to)

web applications embed too much code. This is a reality and it has a big impact on their performances. The time lapse before a possible interaction with the web application you want to access, the famous "time to interactive", is not only related to the network time needed to download the application's content but also to the time spent by the JavaScript engine to parse and interpret the code.

I guess I was just waiting for some interest from a maintainer, since there's not much point in wasting my time on developing this if the maintainers aren't even interested in this feature.

Furthermore, how come there's a PR open since 3 months, at what seems to be the authoritative repo for Svelte?

webpack sure wastes a lot of time when things go wrong.

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

Obviously we shouldn't rush into anything. But changes like these are best made earlier on in a project's lifecycle, so I'm eager to hear what people think so that we can start making some progress.

Win back your calendar and stop wasting time in meetings. Our screen recorder can provide the context and connection of a meeting without the time commitment.

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!

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

Doing so also means adding empty import statements to guarantee correct order of evaluation of modules (in ES modules, evaluation order is determined statically by the order of import declarations, whereas in CommonJS – and environments that simulate CommonJS by shipping a module loader, i.e. Browserify and Webpack – evaluation order is determined at runtime by the order in which require statements are encountered).

This PR replaces nested require statements in files in vendor/postcss with import declarations, so that they can be properly resolved at build time.

there's a major problem with all of this instantaneous communication:  It doesn't leave time to think.

And now it won't let me edit my comment. (I always find that time limit for editing annoying.)

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

Moreover, React team even removed the “highlight updates” feature from dev tools because people used to obsessively haunt wasted renders with no reasoning behind it

The perdurantist view is that an individual has distinct temporal parts throughout its existence.

I’d still be interested in Svelte making things easier so I’ve opened a feature request for Reactive statement cleanup functions.

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

30-min pre-incubation of inhibitors and BTK

As programmers, we’re kind of inherently built to want the ABSOLUTE BEST HIGHEST FIDELITY FORMATS OF ALL TIME. Like dammit, I need the timestamp down to the micromillinanosecond for every cheeseburger that gets added to my bespoke Watch-The-BK-Throne app. If I do not have this exact knowledge to the millisecond of when I consumed this BBQ Bacon WHOPPER® Sandwich From Burger King® I may die.

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

Over time Adam, Surplus' creator, had less and less time to spend on the project and I decided to take my own shot.

Although I also work with solid in my day job at inrupt, I wrote this guide in my spare time.

“Yes. My objection is, that your proposal obliges us to wait.”

But when you’re using Svelte within a larger Rails app, you probably already have a CSS system in place and there’s no reason to change that. You can just use the same CSS classes as you do elsewhere in your app, and everything will be fine.

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.

This has already forced me to forgo Svelte Material because I would like to add some actions to their components but I cannot and it does not make sense for them to cater to my specific use-case by baking random stuff into the library used by everyone.

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