the 2 hardest problems in computer science are essentially the 2 hardest problems of life in general, as far as humans and information are concerned.

The non-determinism is why cache invalidation — and that other hard problem, naming things — are uniquely and intractably hard problems in computer science. Computers can perfectly solve deterministic problems. But they can’t predict when to invalidate a cache because, ultimately, we, the humans who design and build computational processes, can’t agree on when a cache needs to be invalidated.

Sometimes humorously extended as “cache invalidation, naming things, and off-by-one errors.”

There’s only one hard thing in Computer Science: human communication. The most complex part of cache invalidation is figuring out what the heck people mean with the word cache. Once you get that sorted out, the rest is not that complicated; the tools are out there, and they’re pretty good.

Well, I'm glad they did, because Turbolinks is a much better piece of software than jquery-pjax ever was. It's actively maintained and doesn't require jQuery at all! So we're one step closer to our dream of ditching $.

Flexbox and grid play well together, and are a huge step forward from the float & table hacks they replace.

First, the frame and frameset elements are not deprecated in HTML5, they're obsolete (i.e., they've been removed entirely).

systemd has such huge documentation. systemd.unit Did you try searching for explanation yourself? What did you find?

http://letmegooglethat.com/?q=How+to+change+the+default+search+engine+in+chromium&l=1

Well, that user can safely stay with Windows. Hiding these things from me makes wish that.

I wanted to use GitHub Gists which are a wonderfully low friction way of sharing code

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.

If there’s a lot more to aligning icons to text than you expected, then you are not alone.

Heading hierarchy. Don't skip heading levels. In order to solve this problem, you need to separate the semantics from the style.

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.

Maybe something more neutral just meaning a virtual element / no-element container would better express the intention? And regarding the syntax, maybe it would also feel less repetitive / boilerplaty than <svelte:slot slot="name" />... Maybe something like <svelte:fragment slot="name"> or <svelte:virtual slot="name">?

Yet another comment with why is this not implemented is not helpful for devs.

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.

These are sequential because build:ssr imports the public/index.html that build:dom produces.

Please follow these steps before attempting to return a Pump or Sprayer: Download the Pump & Sprayer Return Form (PDF) Refer to page 2 to verify that your product SKU or item number is listed – if not, it can be returned to a store Complete the form and email to pumps_sprayers@harborfreight.com All required fields must be filled in or we may be unable to fulfill your request

Traditional online funnels — more often than not — require you to have a separate:Content management system (ex. WordPress, Joomla)Web host (ex. SiteGround, Bluehost)Page builder (ex. Elementor, Beaver)Email autoresponder (ex. MailChimp, Aweber, GetResponse)Order formShopping cartWeb analyticsOther marketing tools

As was mentioned in the comments above, the material design spec for buttons specifies that the text should be uppercase, but you can easily override its CSS property: paper-button { text-transform: none; }

enables passive event listeners by default for some events (see list below). It basically will set { passive: true } automatically every time you declare a new event listener.

After i've stabilized the library i can start to discuss about adding new components and features!

@use "@material/theme" with (  $primary: #FEDBD0,  $on-primary: #442C2E);

For example, your application should work offline, but it doesn’t mean that you must set-up a background queue or store your data in a persistent storage – a offline message (e.g. “You’re offline, check your network status.”) is enough.

For future reference, webpack 2 removed everything but modules as a way to resolve paths. This means root will not work.

There was a major refactoring in the resolver (https://github.com/webpack/enhanced-resolve). This means the resolving option were changed too. Mostly simplification and changes that make it more unlikely to configure it incorrectly.

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.

However, this coalescing was very complicated, both in the specification and implementations, due to the dynamism of computed property names for accessors. Coalescing was a big source of overhead (e.g., in terms of code size) in polyfill implementations of "Stage 2" decorators.

In July 2010, Microsoft let go Jimmy Schementi, one of two remaining members of the IronRuby core team, and stopped funding the project.[19][20] In October 2010 Microsoft announced the Iron projects (IronRuby and IronPython) were being changed to "external" projects and enabling "community members to make contributions without Microsoft's involvement or sponsorship by a Microsoft employee".

{#key} was introduced in Svelte v3.28, before that you needed to use a keyed {#each} block with only one item When the key changes, svelte removes the component and adds a new one, therefor triggering the transition.

Svelte's advantage here is that it indicates the need for an update at the place where the associated data is updated, instead of at each place the data is used. Then each template expression of reactive statement is able to check very quickly if it needs to rerender or not.

Svelte slots are much easier to use and reason about than Angular transclude, especially in cases where you don't want an extra wrapper element around the slot content.

Things that cause the error to go away If I change any one of the following factors (which should not make any difference), then everything works fine:

We expect a certain pattern when validate devtool name, pay attention and dont mix up the sequence of devtool string. The pattern is: [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map.

This is Sass based, and therefore doesn't require Svelte components

If your Svelte components contain <style> tags, by default the compiler will add JavaScript that injects those styles into the page when the component is rendered. That's not ideal, because it adds weight to your JavaScript, prevents styles from being fetched in parallel with your code, and can even cause CSP violations. A better option is to extract the CSS into a separate file. Using the emitCss option as shown below would cause a virtual CSS file to be emitted for each Svelte component. The resulting file is then imported by the component, thus following the standard Webpack compilation flow.

overmind is basically foreman but done "well"

As of OpenSSL 1.1.1, providing subjectAltName directly on command line becomes much easier, with the introduction of the -addext flag to openssl req

"We should try to find a replacement for omgwtfssl, which is currently used to generate self-signed certificates. The name is inappropriate and unprofessional."

Instead of this, you can use a File type variable.

Previously, a common pattern was to read the value of a CI variable, save it in a file, and then use that file in your script:

there are superior ways to share environment variables

On the other hand, handling form validation on your own can be tempting, but you have to cover scenarios like:

You may want to execute validations in a given specific order (this can be tricky especially when you have got asynchronous validations).

If you want to implement a form with a superb User Experience, you have to take care of many variables:

Doing a HOC properly, as a library should, with hoisted statics and displayName and ref, etc., is a hassle and would add unnecessary bulk.

We could potentially have another flag that was your definition of dirty, but then we run into the hard problem in computer science: naming things.

And I'm all for not adding a gazillion flags to to an elegant library.

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.

Yeah I see what you're saying. In my case, I had a group of classes that relied on each other but they were all part of one conceptual "module" so I made a new file that imports and exposes all of them. In that new file I put the imports in the right order and made sure no code accesses the classes except through the new interface.

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

Specifically, since Root, Rule and AtRule all extend Container, it's essential that Container is evaluated (and therefore, in the context of a Rollup bundle, included) first. In order to do this, input.js (which is the 'gateway' to all the PostCSS stuff) must import root.js, root.js must import rule.js before it imports container.js, and rule.js must import at-rule.js before it imports container.js. Having those imports ensures that container.js doesn't then try to place Root, Rule or AtRule ahead of itself in the bundle.

Replaced nested `require` statements with `import` declarations for the sake of a leaner bundle. This entails adding empty imports to three files to guarantee correct ordering – see https://github.com/styled-components/styled-components/pull/100

Modules from the following layer can require anything from all the previous layers, but not vice versa.

Note that the <WarningEngine/> component must be at the bottom of the form to guarantee that all the fields have registered.

Sometimes we can’t implement a solution that’s fully spec-compliant, and in those cases using a polyfill might be the wrong answer. A polyfill would translate into telling the rest of the codebase that it’s okay to use the feature, that it’ll work just like in modern browsers, but it might not in edge cases.

Maintainable code is code that you don’t need to modify when the browser changes.

I'm okay with an overall design that allows people to plugin the parts they need in order to be able to generically support a compile-to-javascript language, but to bake in support for one singular solution because its popular is simply bad engineering.

Additionally, if we ever want to standardize more of JSX we need to start moving away from some of the more esoteric legacy behaviors of React.

We are very close to full inline components (with css, js logic, and templates).

I had this problem and figured out how to make something like this work with the compiler quirks.

Svelte should make something like useEffect part of the framework so that this could work better and be less verbose.

The Svelte compiler does the dependency tracking work for us, so there’s no dependency array like in React.

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

Svelte doesn't re-render, so you need to respond to component mount/dismount and prop changes separately as they are distinct concepts and never tied together, unlike in React.

Sometimes, you may be tempted to write that wrapper. Because all your (React or Vue or insert your reactive framework here) instincts tell you so.Resist the temptation. There is a better way. A svelter way. Introducing: the use-directive (a.k.a. “actions”).

However, especially when starting out, it’s very easy to fall into the “this is how I did things in my previous framework” trap.

Note how we have to duplicate the code between these two lifecycle methods in class. This is because in many cases we want to perform the same side effect regardless of whether the component just mounted, or if it has been updated. Conceptually, we want it to happen after every render — but React class components don’t have a method like this. We could extract a separate method but we would still have to call it in two places.

So while Solid's JSX and might resemble React it by no means works like React and there should be no illusions that a JSX library will just work with Solid. Afterall, there are no JSX libraries, as they all work without JSX, only HyperScript or React ones.

Solid keeps it simple

There's one downside to Reacts reactivity model - the hooks (useState and useEffect) have to always be called in the same order and you can't put them inside an if block.

createState and createSignal are improvements over React's useState as it doesn't depend on the order of calls.

However, if you want to create a backend API that is meant to be consumed only by your frontend, then you don't need REST nor GraphQL — RPC, such as Wildcard, is enough.

Those banners should really be reserved for the important stuff. Because they're not, I've developed a reflex to immediately close those banners without paying attention. It's almost the same as blocking it with an ad-blocker; which defies the (original) purpose of banners.

let:hovering={active}

let:active={hovering}

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.

Lets not extend the framework with yet another syntax

one problem with 'behavior' is that's the terminology we use to describe all of a component's encapsulated logic — methods, transitions, etc.

But what we should ask is "can we do better than the others".

Additionally it makes re-purposing/re-factoring/splitting up components far harder.

It gets worse when you're working on a team. No-one dares touch styles authored by someone else, because it's often unclear what they're doing, what markup they apply to, and what disasters will unfold if you remove them. The consequence of all this is the append-only stylesheet. There's no way of knowing which code can safely be removed, so it's common to undo some existing style with another, more specific style — even on relatively small projects.

If you can't understand where it's coming from in the stack traces, please post screenshots or create reproducing sandboxes and we'll try to help. Most of these are probably coming from a few libraries, so the most productive thing to do is to reduce these cases and then file issues with those libraries.

Customers care more about the value our application adds to their lives than the programming language or framework the application is built with. Visible Technical Debt such as bugs and missing features and poor performance takes precedence over Hidden Technical Debt such as poor test code coverage, modularity or removing dead code

In the real world — the time to pay off technical debt is scarce — in most of the time fueled by the fear of the unknown. The management loves to milk the cow but not to change the litter. The developers on another hand avoid modernizing legacy code — to avoid trouble in case anything breaks.

For example, to search for text occurrences, I used ack-grep. Later on, I found that there is a faster approach using ag. Then, there is an even faster alternative called ripgrep.

If you are a senior, try talking to a junior or someone less experienced than you. Many companies are running what is called ”reverse mentoring” programs where juniors coach senior members of a company. Senior’s experience is traded for a fresh perspective from a junior. You’d be amazed at how much you could learn and share.

The hype is something common in our industry. Remember NoSQL? Or when everyone went crazy over microservices? Or the AI / Machine learning burst? The list goes on and on. People get excited about new and breakthrough technologies and ideas.

The idea of having to learn something new is good, and I agree with that, but how often should you do that? Looking at the world of JavaScript, a new idea, blog post, library, framework, and whatnot pops up very often. Things become trending, and people quickly try to adopt that. I’m not saying you should not adopt new things and consider different approaches to a solution, not at all! I am trying to propose the idea of doing that less often.

Almost all mailing lists encourage you to avoid top posting and most help desk softwares force you to top post.

you could imagine my extreme disappointment after i came back after a year and a half to find that the entire exploration map was about 80% smaller, every different island was within clear view of your starting island completely decimating any sense of adventure or exploration you could have had.Almost all materials could be collected and all items built within four and a half hours. Islands are literally numbered one to five to display they're level of danger.not only that but you were practically spoon fed each advancement in the game, it feels like it was taken from a greatly ambitious open world, exploration survival game that would take months to finish and achieve everything in. To now being an arcade style iphone app game catered to ten year olds that would foolishly enter their parents card details in order to buy 10,000 roblox coins.

I have over 689 hours into this game and would like to talk about the changes made to the Exploration. In my opinion the Exploration which made this game amazing now stinks!. You know longer need a ship to hit the islands. The exploration has pretty much been removed. One of the things that made this game so amazing was grinding to make your ship and heading out to Explore and find the other islands. Now all the islands are really close to the spawn point, there are not that many and well they stink. There is no reason or need to make a ship because you can easily reach all the island with a raft.

"AOO is not, and isn't designed to be, the 'super coolest open source office suite with all the latest bells and whistles,'" Jagielski continued. "Our research shows that a 'basic,' functional office suite, which is streamlined with a 'simple' and uncluttered, uncomplicated UI, serves an incredible under-represented community.

Using !important in your CSS usually means you’re narcissistic & selfish or lazy. Respect the devs to come…

The meta charset information must also be the first child of the <head> tag. The reason this tag must be first is to avoid re-interpreting content that was added before the meta charset tag.

A simplified pricing and packaging (PnP) strategy serves customers in the optimal way per the industry best practice. More SKUs lead to a more complex PnP model as a company scales, which eventually causes huge confusion to customers.

First, let's make it clear that NODE_ENV has no explicit relationship to RAILS_ENV. Setting one of the ENV variables will have no effect on the other.

If people search through your website, will you guide them to topics first, or will they get a list of individual stories and updates to stories? Does your front page even hint at the fact that people can get more than just the daily news at your site?

For the longest time, whenever I read the news, I’ve often felt the depressing sensation of lacking the background I need to understand the stories that seem truly important. Day after day would bring front pages with headlines trumpeting new developments out of city hall, and day after day I’d fruitlessly comb through the stories for an explanation of their relevance, history or import. Nut grafs seemed to provide only enough information for me to realize the story was out of my depth.

Links can sidestep this debate by seamlessly offering context and depth. The journalist can break a complex story into a non-linear narrative, with links to important sub-stories and background. Readers who are already familiar with certain material, or simply not interested, can skip lightly over the story. Readers who want more can dive deeper at any point. That ability can open up new modes of storytelling unavailable in a linear, start-to-finish medium.

I don’t want the product with the best content overall, I want the product that is going to serve me up the best content every single time, regardless of whether or not it was created in-house.

I regularly get people coming to me and asking me to write a book. I always pass because I can’t imagine writing in a format that has an end. I can’t imagine writing in a format that doesn’t provide instant feedback. I can’t imagine writing in a format that requires a structure. I can’t imagine writing in a format that isn’t a stream of consciousness. I can’t imagine thinking about what I am going to write more than ten minutes before writing it. I can’t imagine killing trees to carry my words. So I will continue to write a blog. It’s the perfect format for me. AVC is way more than a book. It is a living breathing thing that sustains me and that is me.

“I blog in Spanish and English for different reasons. In English I blog to communicate my ideas and views, in Spanish, where for some unknown reason many more people comment, I write to learn. The collective intelligence of my commentators is greater than mine.” Martin Varsavsky Founder and CEO FON

As an engineer, it’s important to explore different technologies. It’s important to identify the tools available to tackle problems. And it’s important to expand your horizons because then you can look cool on your CV.

Because the conditional connectives thus complicate the formal reasoning about programs, they are better avoided.

doing the wrong thing quickly is a good way to bankrupt us and our customers

The order is important.

there’s 3 steps to building software: Make it work Make it right Make it fast

“Make it right” means that the code is maintainable and easy to change. Humans can read it, not just computers. New engineers can easily add functionality to the code. When there’s a defect, it is easy to isolate and correct.

Sometimes plugins can conflict with a theme or with each other.  Disable all your plugins and see if the problem persists. If everything is working once the plugins were disabled it means there's a conflict with a plugin or maybe even a set of plugins. Enable the plugins one by one to identify the one that is creating the conflict.