black

I’m not gonna deny it’s frustrating to see quality of life stuff like “don’t refactor stuff from packages!” unaddressed year after year. ...but I think it is a tricky problem. For example Black[1] is a very carefully crafted project that does an excellent job, but it fails at refactoring files just to apply lints with “inconsistent code generated” on some projects and files; and that’s just apply limiting rules. ...but, I for whatever reason, the JetBrains refactoring for static languages (c#, Java, kotlin) does seem significantly superior. [1] https://github.com/psf/black

The same can be said for a linter. You can just ignore the lint warning and have it not block the build as well. Most linters also don't require manual changes but do automatic fixing, ie: black[0]. Non-user initiated updates to QA tools will only lead to alert fatigue because people will write it off as an update to to tool. [0] https://github.com/psf/black

This looks interesting! I think the approach where a typed subset of Python is used to compile a fast extension module is the way forward for Python. This would leave us with a slow but dynamic high-level-variant (CPython) and typed lower-level-variant (EPython, mypyc & co) to compile performant extension modules, which you can easily import into your CPython code. The most prominent of such projects I know of is mypyc [0], which is already used to improve performance for mypy itself and the black [1] code formatter. I think it would be interesting to see how EPython compares to mypyc. [0] https://github.com/python/mypy/tree/master/mypyc [1] https://github.com/psf/black/pull/1009

If you’re into python, check out black https://github.com/psf/black

Interestingly, the question whether this particular choice of code formatting in black adheres to pep8 is still an ongoing discussion[1][2][3][4]. Guido, for example, thinks that black's choice is not compatible with pep8 and I think he described the situation quite well on Python's Discourse[5]: > So the root of this argument is that Black produces code that isn’t always in compliance with PEP 8. I say this is fine – if you use Black you don’t need PEP 8 to tell you how to format your code. (PEP 8 is still useful for other things like naming things.) > Black optimizes for a different goal than PEP 8; PEP 8 optimizes for readability while Black sometimes compromises readability in order to satisfy other goals such as minimizing lines changed as code evolves. > I don’t want to compromise PEP 8 though. [1]: https://github.com/psf/black/issu

Hard forking a project to make use of the hard work the maintainers put in to it, then writing a post doing nothing but insulting those maintainer's decisions / preferences, is not a good look. Neither is throwing temper tantrums in issue threads: https://github.com/psf/black/issues/1178#issuecomment-565383... Also if this developer wasn't so obsessed with bikeshedding, they could just edit the one bit of formatting code and republish. That way they could even rebase off of upstream if they wanted. Personally, I much prefer black's indentation scheme. I also like spending as little time as possible agonizing over minutia like this.

I really like the fastai abstractions and their attention to detail. Also their callbacks are amazing. I always look at their implementations for inspiration. But my main issue with it is the code formatting (https://docs.fast.ai/dev/style.html#layout). Maybe I am too used to PEP-8 and black (https://github.com/psf/black) formatted code, but honestly I cannot stand the code format.

Precisely why I use them and why I'm uncomfortable with Black refusing to add the option (https://github.com/psf/black/pull/513).

Akin to his adventure, black [0] for Python does one thing and does it very well: It formats my code. It's pretty, it's legible, it's consistent, it works; and you cannot customise it. Has been a great experience since the day I switched from autopep8. [0] https://github.com/psf/black