Hacker News Reader

Comment by imglorp | Hacker News Reader

Nobody talks much about the original goal of "There should be one-- and preferably only one --obvious way to do it." -- PEP 20 (!)

Back when, I lurved me some Perl TMTOWTDI as much as the next guy--plenty of uses for such a thing in a Swiss army chain saw--but then Python had a good (or at least different) answer to that by reducing the language load and focusing more on the problem.

So tell me, how many string formatters do we have now? Could we please decruft and dump some of them while we're at it? % or f' or .format or whatever, but please just pick one and get the rest out of my face.

https://www.python.org/dev/peps/pep-0020/

https://en.wikipedia.org/wiki/There%27s_more_than_one_way_to...

View on HN

It's not that it's never been possible to do things other ways in Python. The obvious way to do stuff is to use the latest module or feature. The obvious way to do string formatting is now f-strings.

In an enterprise-y environment, it's not always possible to keep upgrading to the latest. So assuming someone creates a project based on f-strings, that would be python 3.6+ only. Whereas using string.format will work across entire python 3+. Is that worth the upgrade- I'm not convinced.

Yes, and? This still means that if someone gets the latest Python the f-strings should be used everywhere, because supposedly they solve every and all problems that the previous ones solved and some.

But in reality, you can't ( and shouldn't ) go back and change how the rest of the legacy codebase does things just because there's a new way to do it.

Right - They tried dropping legacy compatibility before, and people are still upset 10+ years later.

For something as essential as strings, it makes sense to recommend the "new" way, and continue to support the "old" way.

Until the newer way comes along and then there's n+1 ways.

The new ways come for a reason. And the new ways should respect PEP20, meaning they should work for the old use cases, so that everyone can start using the new ways as soon as they can upgrade to that version.

Now, of course Python is interpreted and packages are shipped as raw source code and this makes things harder for library authors, because were there a compile/transpile step, they could write using the new and shiny obvious ways, all the while providing compiled blobs (or transpiled libs) targeting multiple versions.

So what reason is there for adding a new string formatting syntax that looks nothing like string formatting syntax used in any other language, and obliges a non-insignificant userbase to adapt?

Technological purity or scratching some philosophical itch would be a poor reason, IMO, given how broad the externalized costs run.

So is it provably easier to reason around the new style? Reduce computing time by an order of magnitude (in the modern era where compute cycles and memory are hella cheap)?

Code is to be written so it’s understandable and useful for humans first, right?

How does a third syntax for a solved usecase offer real value to the user base?

Or are we just being sycophants of so-called experts, peddling some novel “look”. Experts who largely built a rep on first mover advantage, but have since seen that excuse for being deified evaporate as the rest of world learned all the same tricks?

> So what reason is there for adding a new string formatting syntax that looks nothing like string formatting syntax used in any other language

The new syntax is more like other modern languages, not less.

>that looks nothing like string formatting syntax used in any other language

PHP echo "There are $apples apples and $bananas bananas.";

Ruby puts "I have #{apples} apples"

TCL puts "I have $apples apples."

Typescript console.log(`I have ${apples} apples`);

Python print(f"I have {apples} apples")

Looks pretty similar to me, and if you like understand-ability by humans so much I think f-strings win hands down. But if you disagree, there's plenty of code out there still using % strings or .format() and they're not going anywhere any time soon.

Python's string format is also very similar to the "double mustache" convention widely used in web development. The following template string:

    "I have {{apples}} apples"

To my certain knowledge this works in Jinja2, Django templates, Vue.js, mustache.js, handlebars.js, and probably many others.

PEP 498 mentions that they did look at other languages to see what was supported:

https://www.python.org/dev/peps/pep-0498/#similar-support-in...

And they link to this Wikipedia article, which lists many examples:

https://en.wikipedia.org/wiki/String_interpolation

Scanning through that, my impression is that "there is nothing new under the sun" and aside from an occasional "$" or "#" prefix, or a willfully arbitrary deviation like ColdFusion, the conventions can all be traced the Bourne shell /bin/sh/ which was released in 1979. Prior to that, the prinf() syntax was presumably the most common, but it's obscure.

Does anyone know if the ${variable} convention was original with the Bourne shell, or if it can be traced back further?

I am surprised to find that the 6th edition shell had only $1 etc positional parameter expansion, and named shell variables are not described in its man page

http://man.cat-v.org/unix-6th/1/sh

Anecdotally, the only language in that list I encounter anymore is Python. TypeScript is a closest second.

I’m rather done with this interpreted, dynamic typed, language and the hell holes they dig us into.

DRY could be applied to more contexts than code logic: stop rewriting language features unless there is more than a subjective win of “looks nicer.” or performance is improved by an order of magnitude.

The conversations the Python community should be having are not “once again we must discuss and consider a solution to a solved problem.”

When that’s the sort of progress the language devs are prioritizing, it’s a sign to me they’re out of ideas or incapable of fixing the bigger flaws.

Could you please stop creating accounts for every few comments you post? We ban accounts that do that. This is in the site guidelines: https://news.ycombinator.com/newsguidelines.html.

HN is a community. Users needn't use their real name, but should have some identity for others to relate to. Otherwise we may as well have no usernames and no community, and that would be a different kind of forum. There are legit uses for throwaways, just not routinely.

Lots more explanation: https://hn.algolia.com/?sort=byDate&dateRange=all&type=comme...

Python string interpolation uses the same syntax as str.format(), and happens to be shared by c#’s string interpolation

Sure, but is Python better for having f-strings or worse?

> how many string formatters do we have now? Could we please decruft and dump some of them while we're at it? % or f' or .format or whatever

To me, there's a difference between "one way" and "one interface." I agree we should depricate %-formatting in strings, but .format / f"" are different interfaces on the same functionality - which seems fine.

Except that f-strings are not lazy evaluated so you cannot replace something like:

  log.debug("foo bar %s", foobar)

with fstrings. And you end up with part of your team enforcing f-strings because of cleaner look, the other half .format or '%' strings and the rest annoyed when their code is constantly rejected in reviews because they don't know/care which standard to use where.

My understanding was that you can use f-strings for the thing you outlined above, the f-string composition will just be evaluated as an expression whether or not log.debug is enabled. Personally I'd trade that for the %-string drawbacks.

Languages don't solve organizational issues. If you have a dysfunctional team without leadership then that will always show somewhere. A good team would establish some set of coding standards and then enforce those. Rejecting PRs for personal preference coding standards would result in a talk from the manager.

I don't think something like "foo bar %s".format(foobar) would work either in this situation. I think you're conflating format strings with the lazy evaluation associated with logging.

I am, however, in complete agreement that logging should adopt at least the same formatting used by .format

I was reading a recent bug report where they were going back and forth on this. f-strings were so performant there wasn't much difference between lazy evaluation (not evaluating them) and f-strings. The sticking points seemed to be a) if your f-string variable took unreasonably long to compute or b) if evaluating your variable caused an error.

I get all of these arguments. I see formatting errors so often in error handling code I would much prefer they'd get caught during normal execution. I can't see trusting a heavy query to lazy evaluation...or see it coming up all that often.

I see both sides, but really think using f-strings in logging is the right compromise for Python...but I just don't see them dropping c-style formatting.

Reply on news.ycombinator.com