#polyfill

Stuffing is responsible for 70% of how good the final toy looks, make sure you’re using it to accentuate the shapes in the doll you want. 

When you’re stuffing the face, start on the perimeter and move in. Starting from the center tends to make the face bulge out unnaturally against the rest of the face

Make sure the ratios on the toy are correct, for lack of better words? Adding stuffing is a 3D game- while you’re adding to fill out the toy vertically, if you don’t position it correctly it also adds width to the toy, which might not be something you want- especially in thin fins/wings. It’s rather akin to sculpting. 

THIS IS A BIG ONE. IF YOU’RE USING POLYFILL, FLUFF UP AND TEAR OFF CHUNKS OF THE FILL AND LAYER THAT IN. YOU WILL THANK ME I PROMISE IT MAKES THE TOY SO MUCH SOFTER FEELING WITHOUT SACRIFICING THE WEIGHT + IT MEANS THE STUFFING COALESCES LESS TOO AS A BONUS AND IS EASIER TO SHAPE OVERALL.

Keep the amount of stuffing relatively even, or at least consistent in broad shapes, ESPECIALLY in extremeties like noses/fingers and paws/tails. If it isn’t even, the stuffing tends to clump together and leave strange pockets of air + hard feeling balls in the toy. 

Again, you really want to layer the stuffing and be gentle with it, it takes very little pressure when pushing  Another reason not to be rough with stuffing: it can stretch the fabric and force stuffing through the holes, which is really tedious to clean up

Less can be more with stuffing: overstuffing your toys can give them a totally different feel, sometimes to the detriment of the toy. Imo you want toys to be squishable but not limp/floppy, it can help to put a little more overall in as stuffing tends to lose volume over time, but never so much that the toy becomes stiff or hard. 

dear god tight seams are so important, nothing can help sink a project than having stuffing poking out of the seams. Be really careful of this with sewing as well as you can accidentally trap polyfill in your stitches so it permanently pokes out

Black stuffing is really good for darker toys, my local Michaels sells it so I assume it’s at least purchasable at Michaels?? It’s so good though you don’t realize how weird white polyfill being barely visible under the stitches makes the toy look until after it’s gone

My son.

BREAKING CHANGE: webpack < 5 used to include polyfills for node.js core modules by default. This is no longer the case. Verify if you need this module and configure a polyfill for it.

https://stackoverflow.com/a/65556946

Positional-Only Arguments

In Python >=3.8, the native way to do positional-only arguments looks like this:

def foo(bar, qux, /, *args, **kwargs):

    ...

Here is a good general way to emulate this behavior on earlier versions, which

still avoids collisions with named arguments and

still errors if those arguments are not given

by raising the right type of exception

with the native exception message:

def foo(*args, **kwargs):

    def foo(bar, qux, *args):

        return bar, qux, args

    bar, qux, args = foo(*args)

    ...

First this ensures that named arguments cannot collide with the positional arguments. Then it makes the Python implementation use its own built-in logic and errors. Python will split the required positional arguments from the rest. If there is not enough arguments, Python will raise its own native error with all the normal helpful bells and whistles like the function name, the missing argument name(s), and so on.

Once you've learned this pattern, it's very simple and easy to recognize it, tune it out, or fully verify it for correctness.

The main downsides are:

it is less obvious if you're not familiar with it (this is true of many good patterns which are not obvious until learned, and not in itself a reason to reject a pattern, but like any other clever pattern, it is an accessibility cost), and

the traceback ends up having one weird extra line because of the nested function of the same name (seems unlikely to be a problem in practice, and I think regularity of error type and string are far more important than this irregularity of traceback, but it does create edge cases like someone jumping to the conclusion that your function tried to call itself recursively but had a bug, or if someone expects that the traceback looks like it would with native positional-only arguments).

A couple more negligible downsides which only apply if you care about obscure incomplete or minimal Python implementations:

On some Pythons native error messages are not as helpful, so a manual error message can be more helpful, and in simple cases like one positional-only argument, that helpful error can be trivially manually implemented. (But generally I would rather be consistent with native errors of that Python than mimick a helpful error from another Python, and you probably don't know or care about the Pythons where this would even matter.)

You could make the argument from portability conservatism, that other simpler and more obvious solutions are more likely to work, and work predictably as expected, on as many different implementations of Python as possible. (I don't like being thusly limited, but I've seen several browser-based Pythons mess up try/except/else/finally logic, I've seen Python implementations raise different exception types in certain cases than CPython, and I can imagine a simple Cython-like compiler struggling with nested functions.)

Finally, there is an edge case with applying this pattern to generators and async functions: the nested function will not run until the result is iterated or awaited (this is true of any solution which has no collisions with arguments passed by name). If you want to emulate the behavior in those cases, you'd need to wrap the generator or asynchronous function with a regular function, where you do the argument splitting. So for example, if you have

async def foo(bar, qux, /, *args, **kwargs):

    ...

to more perfectly emulate the behavior we would need to do:

def foo(*args, **kwargs):

    def foo(bar, qux, *args):

        return bar, qux, args

    bar, qux, args = foo(*args)

    async def foo():

        ...

    return foo()

The downsides of taking it this far for async and generator functions are that:

the backwards-compatible version of the code now has worse type hinting unless the return type of the outer `foo` is inferred from the inner `return foo()`,

now any tracebacks from what used to be the body of `foo` come from a nested `foo`, and

the implementation has now been complicated with more weirdness, which is even less visibly and obviously motivated than the original pattern.