It is a perfectly cromulent word. :)

Nice use of “embiggen” as a class name!

Chris, to address your “magic number” concern, instead of doing line-height: 0.5, you can use percentage-based positioning (top: 50%) on the pseudo-element.

Maybe there’s a technical term that I’m not aware of for this type of centered line-splitting heading.

Melamine is considered the black sheep of the sheet goods’ family by most carpenters. Typically because it creates a lower quality cabinet than other materials. But, also because it is so darn hard to construct with without getting chips. However, melamine does have a place and a purpose, and if you know how to build with melamine, you can produce some budget-friendly spaces.

Some components may be substituted if you can’t source them.  Use your best MacGyvering skills to figure it out.

When we describe a language as type-checked, we mean that the language won't let you perform operations invalid for the type. Neither statically nor dynamically typed languages will let you multiply strings together, call a number in the place of a function, etc. A language without type checking would let you do all of those things without complaint.

At the same time, details about programming language semantics are quite precise and when articles like this get things sort of wrong, it just leads to more confusion.

Conversely, the more dynamically typed the language is, the less I am using an IDE and the more I am using a text editor. Of course, my productivity plummets at that point. Refactoring becomes more difficult and more (completely) reliant on unit tests to ensure they are done properly.

Forwarding events from the native element through the wrapper element comes with a cost, so to avoid adding extra event handlers only a few are forwarded. For all elements except <br> and <hr>, on:focus, on:blur, on:keypress, and on:click are forwarded. For input and textarea, on:input and on:change are also forwarded. For audio and video, on:pause and on:play are also forwarded.

Instead of bind:this={ref}, use bind:el={ref}. this points to the wrapper component, el points to the native element

This works in my application where there's only one shadow-dom at the time, but it's not a generic solution.

As a work-around I know add a listener to the document-head and move what gets added to the shadow-root.

Can you make Svelte create an open shadowRoot? You can then move it yourself (client-side)

The devs clearly took a very conscious choice that broad, wandering exploration should be core to the game - to the extent that they want you to regularly have no idea where you're supposed to go (or indeed, what you're supposed to do when you get there), within environments that are often vastly sprawling. I've rarely seen a game with such minimal, indistinct signposting (sometimes nothing at all) to nudge players in the right direction.

An #each tag can loop anything with a length property, so: {#each {length: 3} as _, i} <li>{i + 1}</li> {/each} will also work, if you prefer.

Note:

this implies an array of arrayLength empty slots, not slots with actual undefined values

Array.from(Array(10).keys()) //=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

https://hypothes.is/search?q=tag:'0-origined+index'

Sigh why was such a standard feature like resizable columns that have been super simple to do in desktop apps for 15+ years not added to css3/html5

mRNA vaccine effectiveness of full immunization (≥14 days after second dose) was 90% against SARS-CoV-2 infections regardless of symptom status

The vaccines aren't a force field that ward off all things COVID-19. They were given the greenlight because they greatly lower your chance of getting seriously ill or dying. But it was easy for me — and I'm not the only one — to grab onto the idea that, after so many months of trying not to get COVID-19, that the vaccine was, more or less, the finish line. And that made getting sick from the virus unnerving.

I had a breakthrough case of COVID-19 — despite my two shots of the Pfizer vaccine, the second one in April.

the realities of our still-raging pandemic, where even the vaccinated can get sick

Whether this game is ever finished or not isn't entirely relevant, the game is vastly inferior to Spore or any of the games from the Sparkle series, but costs more!

I hope this validates (😉) the use of TypeScript and Svelte enough to entice you to try it out for yourself!

and later use Sanity to store our data

The classic SPA example is a to-do list. But, you know what? I don't like to-do lists. They make me think about all the things I have to do, many of which I don't want to do.So why don't we make a To-Don't List app? That way we can list all the things we're not going to do. Ever.

TypeScript is an extension of JavaScript. You can think of it as JavaScript with a few extra features. These features are largely focused on defining the type and shape of JavaScript objects. It requires that you be declarative about the code you're writing and have an understanding of the values your functions, variables, and objects are expecting.While it requires more code, TypeScript is a fantastic means of catching common JavaScript bugs while in development. And for just that reason, it's worth the extra characters.

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.