As a bonus, you have the option of choosing a particular version of JavaScript to target when compiling, so you can use updated JavaScript features, but still, maintain legacy browser support (if you're into that sort of thing)!

React, on the other hand, often requires a fair amount of boilerplate code, even for simple interactions.

The current supported languages out-of-the-box are Sass, Stylus, Less, CoffeeScript, TypeScript, Pug, PostCSS, Babel.

svelte-preprocess doesn't do any kind of type-checking, it just transpiles your ts into js (see it here). If you want to fail your build when a type error is found, you can use svelte-check.

Note: If you want to transpile your app to be supported in older browsers, you must run babel from the context of your bundler.

// No need for babel to resolve modules modules: false,

due to the fact that the pre-processor handles sections independently this cannot reliably be done there.

It is advised to inline any css @import in component's style tag before it hits css-loader. This ensures equal css behavior when using HMR with emitCss: false and production.

hotOptions

while we figure out how to best include HMR support in the compiler itself (which is tricky to do without unfairly favoring any particular dev tooling)

Webpack's resolve.mainFields option determines which fields in package.json are used to resolve identifiers. If you're using Svelte components installed from npm, you should specify this option so that your app can use the original component source code, rather than consuming the already-compiled version (which is less efficient).

Code that is needed to create the output and the output itself is hard to read because of all the workarounds we have to use, especially around shadowed variables and control flow

Any idea what release this will be a part of?

This is the greatest PR I've ever seen in my life (well, in the last month anyways)

Couldn't start client Svelte

Look at local job ads and see what they want.

Do you have practical skills? Can you build useful things?

Don't get me wrong, you need to know your stuff technically. But at the end of the day, the interviewer is asking themselves, “would I like to work with this person ?”

I would suggest focus on interview skills. It doesn't matter how good you are if you can't communicate that to the interviewer.

I was able to secure my current full time job because I was the best communicator and had one of the best interviews. I know my coding skills were no where near other candidates but I was told that they couldn’t communicate well.

They are deliberately dumbing the browser down further and further and it'll probably end up eventually becoming completely unuseable because of this.

(They blame Chrome's "feature" addition treadmill, where "they keep adding stupid kitchen sinks for the sole and only purpose to make others unable to keep up.")

"types": ["node", "svelte"

I think, if <svelte:body> is for adding events, it should apply actions too.

I have never seen the @Stale bot or any directly equivalent to it achieve a net positive outcome. Never. It results in disgruntled people, extra expenditure of effort (for reporters and maintainers), real stuff getting lost when people get fed up with poking the bot (I have no intention of poking it further), and more extensive filing of duplicates. You say a simple comment dismisses it, but it doesn’t—it only does this time. Next time, it continues to annoy. This is an issue tracker. Use labels, projects, milestones and the likes for prioritising stuff. Not sweeping stuff under the carpet.

It is an issue tracker but we don't have a backlog, or planning sessions, or a project board. Or the resources to even triage and tag effectively. If it is important someone will respond / reopen, popular issues are exempt from the bot, we can't fix everything and this is pretty much our only view on stuff that need to be addressed. We need to make some attempt to make sure that everything is still relevant and reduce the noise to a degree where we can actually manage it. I understand the trade-offs with stale bots but we don't have many options. I appreciate your experiences but that doesn't make them a fact. We have discussed this internally and this is what we are doing. If you have any other actionable alternatives outside of saying the bot is bad then we are all ears.

Closing issues doesn’t solve anything. Closing issues in GitHub just sweeps them under the carpet and helps everyone to forget about them, which is just not what you want—the fact that GitHub search excludes closed items by default is a large part of the problem with it. As applied to software projects with general-purpose issue trackers, the @Stale bot is fundamentally phenomenally bad idea, a road paved with good intentions. I presented an actionable alternative: labels. Possibly automatically applied, but it’s certainly better to spend a little bit of time on manual triage. It honestly doesn’t take long to skim through a few hundred issues and bin them into labels. 609 open issues? That’s honestly not a problem. Not at all. There’s nothing wrong with having a large number of issues open, if they do correspond to real things—even things that you may not expect to get to for years, if ever, because that might change or someone might decide they want to deal with one. Closing issues that aren’t dealt with is bad. Please don’t do it.

This is the wrong place for this conversation though.

Most issues have been manually labelled as stale rather than automated and closure will be manual too, so we have time to think.

What steps did you take to get to that point? Did you create a project from a template? Which template?

"paths": { "@/*": ["*"]}

From my point of view, this approach will help you to write cleaner code. Also, it will help to maintain the project. For instance, moving a file from the current directory to another will cause fewer problems, because every file uses an absolute path instead of a relative one. Last but not least, it helps you during development.

alias: { '@': path.resolve(__dirname, 'src'),}

Use this to load modules whose location is specified in the paths section of tsconfig.json when using webpack. This package provides the functionality of the tsconfig-paths package but as a webpack plug-in. Using this plugin means that you should no longer need to add alias entries in your webpack.config.js which correspond to the paths entries in your tsconfig.json. This plugin creates those alias entries for you, so you don't have to!

Notice that the plugin is placed in the resolve.plugins section of the configuration. tsconfig-paths-webpack-plugin is a resolve plugin and should only be placed in this part of the configuration. Don't confuse this with the plugins array at the root of the webpack configuration object.

The declarations you make in the tsconfig.json are re-stated in the webpack.config.js. Who wants to maintain two sets of code where one would do? Not me.

When I look at the tsconfig.json and the webpack.config.js something occurs to me: I don't like to repeat myself. As well as that, I don't like to repeat myself. It's so... Repetitive.

Let's not get over-excited. Actually, we're only part-way there; you can compile this code with the TypeScript compiler.... But is that enough?I bundle my TypeScript with ts-loader and webpack. If I try and use my new exciting import statement above with my build system then disappointment is in my future. webpack will be all like "import whuuuuuuuut?"You see, webpack doesn't know what we told the TypeScript compiler in the tsconfig.json.

import * as utils from '../../../../../../../shared/utils';

Which do you prefer? If the answer was "the first" then read no further. You have all you need, go forth and be happy.

webpack-bot commented on Nov 13, 2020 For maintainers only: webpack-4 webpack-5 bug critical-bug enhancement documentation performance dependencies question

This is not dumb at all. It is exceedingly common to use aliases. It's not about being lazy, it's about writing portable code.

Saying that web devs used to be fine with relative imports is like saying that human beings used to be fine living without refrigerators. Sure we did. But was it better than it is now? No. No, it wasn't.

config: path.resolve(__dirname, '../config'), vue: 'vue/dist/vue.js', src: path.resolve(__dirname, '../src'), store: path.resolve(__dirname, '../src/store'), assets: path.resolve(__dirname, '../src/assets'), components: path.resolve(__dirname, '../src/components'), '@': path.resolve(__dirname, '../src'),

alias: { _self: path.join(__dirname, 'src/web'), _shared: path.join(__dirname, 'src/shared'), _components: path.join(__dirname, 'src/web/components'), _helpers: path.join(__dirname, 'src/web/helpers'), _layers: path.join(__dirname, 'src/web/layers'), _mutations: path.join(__dirname, 'src/web/mutations'), _routes: path.join(__dirname, 'src/web/routes') }

alias: { '@components': path.join(srcDir, 'components'), '@modules': path.join(srcDir, 'modules'), '@store': path.join(srcDir, 'store') }

Aliases are absolute nonsense for resolving imports. If you don't want to type ../ consider using something like path.resolve(__dirname, '../src') so you can do import Stuff from 'client/components/stuff'; // relative to root of project instead of: import Stuff from 'COMPONENTS/stuff'; // this is dumb

alias: { '@shared': path.dirname(require.resolve('app')), '~': path.join(fs.realpathSync(process.cwd()), 'app'), },

In this example, @shared is the package, ~ is the project. I wouldn't do it this way in the future, but I know this configuration works.

This particular project has a differentiation between a package's app/ folder and the current project's app/ folder.

alias: { Library: path.resolve(__dirname, "root/library/"), Single: path.resolve(__dirname, "root/test.js"), },

alias: { Single$: path.resolve(__dirname, "root/test.js"), },

Gems use a period and packages use a dot

(Gems use a period and packages use a dot between the main version number and the beta version.)

Update API usage of the view helpers by changing javascript_packs_with_chunks_tag and stylesheet_packs_with_chunks_tag to javascript_pack_tag and stylesheet_pack_tag. Ensure that your layouts and views will only have at most one call to javascript_pack_tag or stylesheet_pack_tag. You can now pass multiple bundles to these view helper methods.

If you fail to changes this, you may experience performance issues, and other bugs related to multiple copies of React, like issue 2932.

Webpacker used to configure Webpack indirectly, which lead to a complicated secondary configuration process. This was done in order to provide default configurations for the most popular frameworks, but ended up creating more complexity than it cured. So now Webpacker delegates all configuration directly to Webpack's default configuration setup.

Webpacker has become a slimmer wrapper around Webpack

What's the reasoning behind this change?

TylerRick

Yeah I don’t think we will find something that works for everyone in all cases. But Webpacker is quite flexible with the setup it has now. Easy to change!

I feel like app/packs (or something like it) is a good name because it communicates to developers that it's not just JavaScript that can be bundled, it's also CSS, images, SVGs — you name it. I realize what can be bundled is wholly dependent on the bundler you use, but even esbuild supports bundling CSS. So couldn't this possibly be confusing?

Analytics modules that run in the background, monitor user interaction, and send the data to a server.

Many jQuery plugins attach themselves to the global jQuery object.

A polyfill for example, might not do anything, because it finds that the feature that it enables is already supported by the browser.

A module with side-effects is one that changes the scope in other ways then returning something, and it's effects are not always predictable, and can be affected by outside forces (non pure function).

Import a module for its side effects only Import an entire module for side effects only, without importing anything. This runs the module's global code, but doesn't actually import any values.

The important part I have come to notice is <script type="module"></script> make sure you add that otherwise you will get that error.

I still don't understand the difference between a script and a module

Tailwind automatically removes all unused CSS when building for production

I’ve written a few thousand words on why traditional “semantic class names” are the reason CSS is hard to maintain, but the truth is you’re never going to believe me until you actually try it.

If you can suppress the urge to retch long enough to give it a chance, I really think you'll wonder how you ever worked with CSS any other way.

Upgrade to Webpacker 6

Class constructor ServeCommand cannot be invoked without 'new'

In 3.1.0, we used oneOf option which solved this problem but then loaders which were using multiple transformation started failing (erb loader) since it was using first matching loader from the list.

Thanks @gj ! That's the best config help response I've ever gotten--changed the regex as you outlined, removed the md.js file I had added, and updated environment.js you post and it worked perfectly.

WARNING in ./app/javascript/components/ComponentLibrary/Docs/Intro.md Module parse failed: Unexpected character '#' (1:0) You may need an appropriate loader to handle this file type.

though we recommend Jest as our preference, the library works with any framework

Thanks for the collaboration!

considering this is just going to the alpha branch I'm going to go ahead with the merge

Guiding Principles

The more your tests resemble the way your software is used, the more confidence they can give you.

Cleanup the code

No need for "me too"s. Please add a thumbs up on the original issue if you want to do that.

the bug is actually in webpack, related to fs in the web target.

Why can you remove it? The loader will first try to resolve @import as a relative path. If it cannot be resolved, then the loader will try to resolve @import inside node_modules.

Using ~ is deprecated and can be removed from your code (we recommend it)

ℹ️ We highly recommend using Dart Sass.

⚠ Node Sass does not work with Yarn PnP feature and doesn't support @use rule.

Webpack 5 no longer polyfills Node.js core modules automatically which means if you use them in your code running in browsers or alike, you will have to install compatible modules from npm and include them yourself. Here is a list of polyfills webpack has used before webpack 5:

You can help make Node.js and browsers more unified. For example, Node.js has util.promisify, which is commonly used. I don’t understand why such an essential method is not also available in browsers. In turn, browsers have APIs that Node.js should have. For example, fetch, Web Streams (The Node.js stream module is awful), Web Crypto (I’ve heard rumors this one is coming), Websockets, etc.

This sucks!I agree. Go complain on the Webpack issue tracker. They caused this.

The main reason I love Node.js is that I don’t have to deal with the awfulness that is JS front-end tooling.

I am not going to do Webpack support. I’ve been pretty lenient in the past and answered most Webpack support questions, but it takes a lot of my time that I could have spent on more important things. I will instead refer users to the Webpack support channels.

Users think every Webpack tool/config problem is a problem with a specific package and opens an issue asking for support on the package instead of Webpack. In the past year alone, I’ve had to deal with hundreds of Webpack issues on my repos.

The problem is that Webpack created convenience by automatically polyfilling and then now suddenly took it away.

To enable PostCSS, Sass or Less support, add CSS support first and then add the relevant pre-processors:

The Rails server will also compile your assets if the dev server is not running, but this is much slower vs running separate processes and not recommended.

Run the Rails server (bin/rails s) and the Webpack Dev Server (bin/webpack-dev-server) via your preferred method. Two terminal tabs will work or create a Procfile and run via overmind or foreman.

Please consider sharing 🙏

This page has changed since first posted, refer to the changelog at the bottom.

I think it's very confusing to overload common executables, such as yarn, in the /bin directory as I often put that bin directory first in my path. Thus, I'd unexpectedly get the bin/yarn rather than my system yarn, which I manage with yvm.

I don't understand why we want to stub out yarn

Breaking Changes

The upgrade instructions recommend yarn upgrade @rails/webpacker --latest

Some would argue that the phrase ''survival of the fittest'' is tautological, in that the fittest are defined as those that survive to reproduce.

Click below to download free plans for building my Dado Engine jig. It lets you safely rout dado grooves for cabinets and shelves with the perfect width of groove to match your sheet material.

Cut a dado groove with a 3/4” diameter router bit and you’ll almost certainly have a too-loose joint when you try to plug some 3/4” plywood in place. Under the guise of metrification, sheet material thicknesses have all shrank enough to cause problems with joinery if you rely on the old, Imperial thickness designations. And besides, material thickness varies enough from sheet to sheet that it can make a difference when it comes to prominent joinery. This is even true in the USA that still uses Imperial more or less exclusively. Sheet goods remain thinner than their name specifies.

Unfortunately, it's too late to make the question more specific as this would invalidate some of the (good) answers.

This question is broad and not very clear -- with the result that the following answers cover quite different scenarios and use cases.

My silly mnemonic for this is the longer the method name the stricter the comparison: eq < eql < equal

The differences are subtle

it means that 42.0 == 42 produces true and 42.0.eql? 42 produces false

It is a descendent of the "Object Mother" pattern for creating objects for testing, and is related to the concept of an "object exemplar" or stereotype.

I first learned to love the functionality of Dave Thomas' annotate_models plugin (you can find a repo for it here). Later, when it became un-maintained and broke, I switched over to ctran/annoate. Then, when work on it waned and broke as well, I decided to write my own as an exercise.

One good use for /dev/tty is if you're trying to call an editor in a pipeline (e.g., with xargs). Since the standard input of xargs is some list of files rather than your terminal, just doing, e.g., | xargs emacs will screw up your terminal. Instead you can use | xargs sh -c 'emacs "$@" </dev/tty' emacs to connect the editor to your terminal even though the input of xargs is coming from elsewhere.

An extensible plugin architecture allows for customizing your workflow or even making Yarn a package manager for non-JavaScript projects.

(Yeah, npm 7 has these too, but Yarn 2’s implementation is more expressive.)

Workspaces make monorepo-style projects more manageable.

This is no different from other popular libraries or frameworks making huge architectural changes (think React 16.8 with hooks or Python 3). The longer you wait to make the switch, the more painful it will be for your project when you finally do. And in the meantime, you’ll be missing out on valuable improvements to a fundamental part of the workflow of every single project you work on.

it’s time to reconsider that decision. Here are three reasons you might have waited to make the switch — and why those reasons are out of date in 2021.

If you don't learn from history, you're doomed to rebase it.

Continue with Quora+Unlock this answer and support creators like Mark Jones by joining Quora+

Quora+ is a subscription to the best of Quora.Access great writing, straight-from-the-source knowledge, and stories you can’t find anywhere else while supporting creators who matter to you.

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.

NodeJS Supported node-sass version

My understanding is that the caret is the answer for traditional SemVer, i.e., there will be breaking changes prior to 0.1.0, there may be breaking changes between minor versions prior to 1.0.0, and there may only be breaking changes between major versions above 1.0.0.

I find it much simpler to use a partition label with LABEL=.... It is shorter, easier to remember, and also has the advantage that should the partition go bad and need to be replaced you can create a new partition, give it the same label provided the old partition is either removed or at least changed to be unlabelled and fstab will never know the difference.

sudo apt-get autoclean sudo apt-get autoremove sudo apt-get clean sudo apt update sudo apt-get dist-upgrade --fix-missing sudo apt-get dist-upgrade --fix-broken sudo apt full-upgrade sudo apt -f install dpkg --configure -a

But it is always important to remember that those are not language concepts. Those are community concepts that only exist in our heads and in the names of some library methods.

have a philosophy that if someone can provide any more meaningful information to a problem even if it indirectly solves the problem, I think that should also be rewarded.

Note: when I wrote above that "there is no such thing as X", what I meant was that "there is no such thing as X in the Ruby language". That does not mean that those concepts don't exist in the Ruby community.

The important thing to understand is that there is no such thing as a class method in Ruby. A class method is really just a singleton method. There is nothing special about class methods. Every object can have singleton methods. We just call them "class methods" when the object is a Class because "singleton method of an instance of Class" is too long and unwieldy.

Class methods are actually instance methods defined on the singleton class of a class.

The question is similar but its in a Rails context. The solutions would answer my question, but I'm almost certain that he could probably leverage Arel to solve his problem. The question I posted was designed purely as a Ruby question so that it was easier to search for. You might want to suggest an edit of the title of his question because it didn't show up when I searched for a solution to my problem.

Yes, unfortunately the other question has a misleading and completely irrelevant Rails context and might be harder to find for some people. IMHO, it's still a perfect content duplicate, although not a topic one. Answers are also equal. Anyways, still a good question of yours.

Side note: When I flagged yours as a dupe during review, the review system slapped me in the face and seriously accused me of not paying attention, a ridiculous claim by itself since locating a (potential) dupe requires quite a lot of attention.

Thanks to Rack Middleware and Rails 3 you can output pretty JSON for every request without changing any controller of your app. I have written such middleware snippet and I get nicely printed JSON in browser and curl output.

This is a really frustrating problem.

One solution is to run this command to reset your keyring password: rm ~/.local/share/keyrings/login.keyring

I am being told my Login Keyring Password "no longer matches" my login. I am confused - I provided a password as I was setting this up, and so I don't know what this is about and how I can fix it. Thanks for the help.

Usually you get this error if you change your password by some other means which fails to update the password for the keyring.

Scripts for disabling/enabling laptop keyboard

Probably you should change the password using GNOME Settings to keep it synced.

This topic was automatically closed 28 days after the last reply. New replies are no longer allowed.

I prefer legacy to UEFI because it's easier to move the OS from the installation SSD to the mdadm RAID0

I keep detailed records of my installation and configuration process so that I can quickly find out where something went wrong.

Indeed yes, but sometimes it is necessary to change one's password, even if one is not 'mucking about with' or 'tweaking' or 'customising' any other system settings.

It seems to me (N.b. what do I know about this? Nothing!) that the best solution would be to tweak the 'Change Password' process so that it also updates the 'Passwords and Keys'>Passwords>Login folder's properties.

this isn't a question, it's a warning for the unwary new Mint user (i.e. people like me)

We understand that new bugs often occur when bugs are fixed and we want to leave the project in a stable state.

most recently the release of ActiveStorage in Rails 5.2

I don't recommend the game, but since it is very inexpensive, you can try it for yourself and not be out a lot of money, so this review might not be necessary, but I'm writing it anyway because I have lots of thoughts that I don't see reflected in the first reviews I see on this first Store Page of Squidlit, although I haven't read every review, which would require a lot of time.

Remote Access is something that we are really excited about because it will allow our support team to give you a seamless and high level of support that is truly unmatched. When you need extra help, you can enable the Remote Access toggle with a single click. This will send a secure token to the Elegant Themes support staff that they can use to log in to your WordPress Dashboard. No passwords are shared and there is no need to send the token to our team yourself. It all works seamlessly in the background. While remote access is enabled, our team will be able to log in to your website and help explore whatever problems you are experiencing. You can even enable it preemptively before chatting with our support team so that we can jump right in if necessary. By default, our support staff will have limited access to your website using a custom WordPress support role. You can also enable full admin access if requested. Remote access is automatically disabled after 4 days, or when you disable Divi. You can also turn it off manually after an issue has been resolved, and of course, Remote Access can only be enabled by you, the website owner, and not by Elegant Themes or anyone else. The Remote Access system is wonderful because it saves tons of time during support chat, and it saves you the hassle of having to debug certain complicated issues yourself. It allows us to take a hands on approach to solving problems quickly, instead of wasting hours or days chatting back and forth.

One workspace.platform.source of truth.Endless solutions.Orchestrate powerful business solutions with a single source of truth. The only limit is your imagination.

From day one, your team will love the familiarity of a spreadsheet, and the power of a database.

Airtable evolves with you and your team, so you can build a solution with increasing sophistication and capability.

As criticisms go, “it was too addictive and I finished it in a few hours” isn’t exactly the worst thing you can say about a game. In fact, as someone who prefers quality over quantity,

founded on the principles of the free speech, independent thought and rejecting political censorship and “cancel culture”.

The choice of stacking attributes should be based on:Do the attributes make sense when stacked vertically? and,When stacked vertically, does it save horizontal space?

since table data is essentially an ordered collection of items, it seems natural to use ordered lists.

to layout tables

Three days before Labor Day, on Friday, September 2, 1921, the U.S. Army intervened on the side of coal companies against striking coal miners, marking the end of the Battle of Blair Mountain in southern West Virginia. The battle was the climax of two decades of low-intensity warfare across the coalfields of Appalachia, as the West Virginia miners sought to unionize and mining companies used violent tactics to undermine their efforts. The struggle turned deadly.

a class of attacks that were enabled by Privacy Badger’s learning. Essentially, since Privacy Badger adapts its behavior based on the way that sites you visit behave, a dedicated attacker could manipulate the way Privacy Badger acts: what it blocks and what it allows. In theory, this can be used to identify users (a form of fingerprinting) or to extract some kinds of information from the pages they visit

How can I make a link that will go directly to a specific location in the iFrame

If you are riding a bicycle, you can get through the roundabout two ways: Get off your bike and go through a crosswalk like a pedestrian, or ride around it like a vehicle.

target="_blank" which opens the anchor in a new window(which has been redirected to tabs by browser settings usually)

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

In thermodynamics, a diathermal wall between two thermodynamic systems allows heat transfer but do not allow transfer of matter across it

There is a huge explanation about why the dot is important quoting issues about DNS and character encoding

But I realized after a lot of research that the problem was that I did not copy the right URL address from the iTunes API documentation. It should have been https://itunes.apple.com/search?term=jack+johnson. not https://itunes.apple.com/search?term=jack+johnson Notice the dot at the end There is a huge explanation about why the dot is important quoting issues about DNS and character encoding but the truth is you probably do not care. Try adding the dot it might work for you too. When I added the "." everything worked like a charm.

Mod note: This question is about why XMLHttpRequest/fetch/etc. on the browser are subject to the Same Access Policy restrictions (you get errors mentioning CORB or CORS) while Postman is not. This question is not about how to fix a "No 'Access-Control-Allow-Origin'..." error. It's about why they happen.

Applying a CORS restriction is a security feature defined by a server and implemented by a browser.

When you are using postman they are not restricted by this policy. Quoted from Cross-Origin XMLHttpRequest: Regular web pages can use the XMLHttpRequest object to send and receive data from remote servers, but they're limited by the same origin policy. Extensions aren't so limited. An extension can talk to remote servers outside of its origin, as long as it first requests cross-origin permissions.

Please stop posting: CORS configurations for every language/framework under the sun. Instead find your relevant language/framework's question. 3rd party services that allow a request to circumvent CORS Command line options for turning off CORS for various browsers

The 2 stars this show received on average is really an inaccurate and lazy way to characterize the hard work of the cast and crew. The filmography is amazing and scenery beautiful, the characters are rich and complete, the people are beautiful. Few shows engage me, this one did.

To ensure that our rating mechanism remains effective, we do not disclose the exact method used to generate the rating.