Understanding is translation

I feel like you've taken a useful insight ("We can help people understand things more easily if we can translate them into a form they're already familiar with") and gone way too far with it, or, at the very least, failed to sufficiently explain your reasoning. You've provided a lot of examples, but the analogy you provided in the first few paragraphs doesn't necessarily work with all of them, so the reader is left to fill in the blanks and guess at what you mean.

A self-taught singer can translate from heard notes to sung notes, but can't translate either to notes on a staff; a self-taught guitarist is missing a different subset of those skills.

What skills? "Music skills"? Knowing how to play a guitar and knowing how sing are both subsets of "music skills", and neither requires the ability to read music, but could you really argue in good faith that someone with an extensive voice performance education doesn't "understand" music just because they don't know how to play a guitar?

You can be good at translating other people's facial expressions to emotional states, but lousy at translating them to pencil sketches; your friend is the opposite; which of you "understands" human faces better?

I do, because I can extract more information from them. I think you would be hard-pressed to convincingly argue that the ability to recreate something in a different medium demonstrates "understanding".

A bilingual person can translate a Japanese sentence with the word "integral" to English, without knowing what integral means.

This is a fairly trivial assertion, and I'm not exactly sure how it contributes to your overall point.

I'd be interested to read more about this in the event you were to flesh out and expand on your thoughts a bit more.

This post struck me as exceptional because it conveyed a pretty core concept in very few words, and it just kind of ended up sticking with me. It's not like I hadn't previously thought of the search for isomorphisms as an important part of understanding, but this post allowed me to make that more explicit, and provided a good common reference to it. 

What should I translate this post into, in order to understand it?

Yes! Thank you!

I've had similar ideas for a long time. I've translated three books and find that I think of many acts of communication as translations. In particular, I find it useful to think of misunderstandings as mistranslations.

To think of thinking/speaking styles as languages just plain makes sense, and I feel that when people "are on the same wavelength" what is really happening is that they're (somewhat unusually) actually speaking the same language.

I don't use this concept for processes inside a single mind, though. Might be worth thinking about, but a term that denotes work with explicit communications does not seem like a good fit for processes that are almost entirely implicit.

I think there is something wrong in this understanding of understanding. Claiming understanding is translation seems to impliy that everything can be compared in some universal reading grid. However understanding has to happen in subjective contexts, or reading grids. Sense happens through the choice of a point of view, which may not be comparable to another. The subjectivity means that translation has to be interpretation, therefore it can't be the whole story.

In particular I would say that this idea lacks the fact that translations may not be relevant; and that what is good translations may not even be knowledgable. These aspects of translation by the way do not seem to be understandable in terms of translation

This idea has stuck in my head since it was posted, and I've been thinking of understanding being (or at least involving) translation ever since.

FWIW, looking at an actual compiler, we see zero jumps (using a conditional move instead):

julia> function test(n)
          i=0
          while i<n
              i += 1
          end
          return i
          end
test (generic function with 1 method)

julia> @code_native test(10)
    .text
    Filename: REPL\[26\]
pushq %rbp
movq %rsp, %rbp
    Source line: 3
xorl %eax, %eax
testq %rdi, %rdi
cmovnsq %rdi, %rax
    Source line: 6
popq %rbp
retq
nop

edit: Sorry for the formatting. I don't understand how source-code markup is supposed to work now?

edit2: Thanks, the markup works now!

edit3: So, to tie this into your greater point:

If you don't ask "how would I code this in assembly" but rather "how should my compiler reason about this code", then it is clear that the loop can be obviously eliminated: You place a phi-node at the end of the loop, and a tiny bit of inductive reasoning makes the loop body obviously dead code if n is an integer type. Slightly more magical (meaning I'm not a compiler expert) is the fact that the compiler (LLVM) can completely eliminate the following loop (replacing it with an explicit formula):

julia> function sumN6(lim)
   s=0
   i=0
   while i<lim
       i+=1
       s+= i*i*i*i*i*i
   end
   return s
   end

Here's how I understand this post: When we "understand" parts of a skill/framework/encoding X, we can translate it into our own mental model U, then translate anything U captures into any other form Y. Ideally we would just communicate U. But it's more precise and useful to describe Y than to describe U, which may be nebulous from the inside or filled with idiosyncracies, and it's even worse to give up and just say "I understand X".

I think this is a good insight, but it seems less useful in the following cases:

• Most people understand X the same way up to idiosyncracies of U, so they can do the same thing with the knowledge, and it gives enough information to say they understand X. The typical mind fallacy can persist when people have similar commonly observed abilities, but vastly different subjective experiences.
• The skill X is made of abstract skills that combine into a whole and don't correspond to translating to different Y. Take X = abstract problem solving. Subskills include factoring into subproblems, gaining intuition, solving subproblems, and combining subproblem solutions into a whole. One could technically say that a person who is good at problem-factoring is good at translating problems into lists of smaller problems, but this doesn't seem meaningful.

Well, you can recreate the behavior of the example loop with just one (conditional) jump because we already know that 0<10. Though admittedly a compiler would probably not use that shortcut. Also, this seems to be something specific to the "while" loop, e.g. you can do a "for" loop with just one jump.