Hacker News Reader

Comment by milliams | Hacker News Reader

Or, in Python

    a, b = b, a

Or Rust:

    (a, b) = (b, a);

View on HN

For what it's worth, the Python example isn't too relevant since it's hiding a number of intermediate variables (that said, swapping without intermediate variables tends to be more of a curiosity anyway -- and a motivated person can "well actually" the whole concept into oblivion). What it does is push a and b onto the interpreter stack, then (in the version of Python 3 I'm running, though the more recent one should be similar) it pops those into two local C variables and pushes them in a different order, then it pops them and stores them into local python variables.

  import dis
  
  def swap(a, b):
      a, b = b, a
      return a
  
  dis.dis(swap)

Output:

  4           0 LOAD_FAST                1 (b)
              2 LOAD_FAST                0 (a)
              4 ROT_TWO
              6 STORE_FAST               0 (a)
              8 STORE_FAST               1 (b)

  5          10 LOAD_FAST                0 (a)
             12 RETURN_VALUE

Implementation of ROT_TWO https://github.com/python/cpython/blob/bc85eb7a4f16e9e2b6fb7...

These aren't algorithms. The language is still doing something under the hood to do the swap.

Was that the problem statement? Come up with an algorithm to swap two numbers?

Some people seem to forget that in high-level programming languages, lines of code seldom map 1-to-1 to processor instructions.

The downvotes on the OP comment and the negativity in the replies is totally baffling to me. The OP's post was interesting and relevant, despite being non-algorithmic examples. Non-algorithmic examples are not required by the title of the article, and are only implicitly the topic of the article's body, and even if it were explicit, that still wouldn't render the OP comment unrelated. It would have been enough to simply talk about the difference between an algorithmic and language-feature solution without implying something is wrong with even posting the latter.

Indeed, both the algorithm in the article, the rust suggestion, and even the naive solution compile to the same instructions[1].

[1] - https://godbolt.org/z/1P98ss37P

That uses 4 registers and a stack!

You can't do better with a non-inlined function.

And on a modern CPU the machine code does not map 1-to-1 to what actually happens when this is executed, the phrase "out-of-order execution" ought to give away that even though your machine code says A, then B, then C, the CPU may decide it was better to do A, then C, then B instead.

Express your actual intent, if your chosen language has a "swap" intrinsic, use it, if not write the swap in a natural and idiomatic way, and let other people do the lifting.

And then the compiled code is doing something under the hood to do whatever the language thought it said.

And then the cpu is doing something under the hood to do whatever the assembly code thought it said.

Where do you think the intermediate results of doing math on the two variables are kept?

Even in C++

  std::tie(a, b) = std::tuple(b, a);

Or, you know,

  std::swap(a, b);

JS: [b,a] = [a,b];

or with a static variable

Congratulations, your program is now thread-unsafe because you thought using a temporary variable is expensive :-p using mutable static variables is a terrible idea in most situations.

Reply on news.ycombinator.com