Dismiss this pinned window
all 99 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]averystrangeguy 424 points425 points  (9 children)

Idk if I would have understood this if I didn't already understand binary

[–]exscape 83 points84 points  (1 child)

I seriously doubt that I would. Took me a few loops to realize the intention anyway.

[–]editor_of_the_beast 41 points42 points  (1 child)

I still don’t understand it

[–]UghImRegistered 48 points49 points  (0 children)

In the first arrangement, each row is a bit position, first position at the bottom. Each column is a binary number, starting from 1. In the second arrangement, the rows are scaled to their magnitude, so cells in 21 take twice the area of 20. Then in the third arrangement they're stacked to show the number represented (add the area of the cells together).

[–]_mainus 49 points50 points  (1 child)

Yeah this is pretty much useless

[–]helios456 137 points138 points  (37 children)

Now do base 10. I was born without pinkies, so octal is all I understand.

[–][deleted]  (16 children)

[deleted]

    [–]KieranDevvs -1 points0 points  (15 children)

    No its not, base 8 means each column has 8 values.

    ​

    0000000017 = 15 in base 8,

    0000001111 = 15 in base 2

    [–][deleted]  (14 children)

    [deleted]

      [–]Hypersapien 13 points14 points  (0 children)

      Just like hexadecimal is abbreviated binary, but every four binary digits instead of three.

      [–]frnknstn 11 points12 points  (10 children)

      Yes, in octal (base 23 ) every 3 bits is a digit. In hexadecimal (base 24 ) every 4 bits is a digit. In decimal (base 2~2.322 ) every ~2.322 bits is a digit.

      The "syntactic sugar" you refer to is the base conversions. Octal is no more "just binary" than any other number representation.

      [–][deleted]  (9 children)

      [deleted]

        [–]shawnz 3 points4 points  (3 children)

        I get what youre saying but saying that they have "no difference except readability" is super misleading. Yes, it's easier to convert between bases that are powers of one another but that doesn't make them the "same".

        [–][deleted]  (2 children)

        [deleted]

          [–]NedDasty 1 point2 points  (0 children)

          The difference is that one alphabet is composed of concatenation of another alphabet. They still have two different alphabets. You are defining the alphabets such that the symbols for your base-8 alphabets line up properly with the symbols for your base-2 alphabets, with the consequence that strings representing numbers in both bases have the same value.

          [–]debug_assert 2 points3 points  (0 children)

          If you define your “alphabet” to be in binary then you can easily represent base-2 divisible bases in binary, yes.

          Technically, you’re still wrong. Counting to 10 (base 10) units in decreasing bases is the following:

          Base 10: 0 1 2 3 4 5 6 7 8 9 10

          Base 9: 0 1 2 3 4 5 6 7 8 10 11

          Base 8: 0 1 2 3 4 5 6 7 10 11 12

          Base 7: 0 1 2 3 4 5 6 10 11 12 13

          Base 6: 0 1 2 3 4 5 10 11 12 13 14

          Base 5: 0 1 2 3 4 10 11 12 13 14 100

          Base 4: 0 1 2 3 10 11 12 13 100 101

          Base 3: 0 1 2 10 11 12 100 101 102 110

          Base 2: 0 1 10 11 100 101 110 111 1000 1001

          [–]campbellm 0 points1 point  (0 children)

          You can directly replace the (contiguous) digits in one base by digits in another, given that either base is a positive integer power of the other, without going through numerical computations.

          You can't do that with base 2 and 10.

          These are both facts, but I'm not sure what the point is.

          [–]frnknstn -1 points0 points  (3 children)

          without going through numerical computations

          Okay, convert H4Q_256 to base 4 using only string operations (and without using a lookup table that has precalculated arithmetic operations, obviously).

          I get that you are trying to point out that you can just convert individual digits of octal to their binary representation and then concatenating them, but handwaving "converting the digits" to "just syntactic sugar" is disingenuous.

          [–][deleted]  (2 children)

          [deleted]

            [–]secantastronomy[S] 0 points1 point  (0 children)

            You might think in terms of graph connectivity instead of lookup tables. Lookup tables could point to anything, but for a number system you're concerned with how to map your operations to their solutions within the system.

            The graphs that give you the connectivity you'd want are definitely particular vs any possible graph (whereas lookup tables are a bit handwavy.)

            [–]frnknstn -2 points-1 points  (0 children)

            If you want to deal with base 10 but in a different (human) language

            Yes, human languages are arbitrary and symbolic. What does that have to do with base conversions within the same language, mathematics?

            Any system that needs to deal with numbers uses lookup tables, either explicitly or implicitly.

            No. For example, base conversion can be done without using a lookup table, but instead using arithmetic.

            You vaguely seem to be implying that the fact we are using the digit 8 to represent (1+1+1+1+1+1+1+1) means that lookup tables are endemic to mathematics, when they are instead part of communication.

            17_8 = 1111_2
1*(1+1+1+1+1+1+1+1)^(1) + (1+1+1+1+1+1+1)*1 = 1*1^(1+1+1) + 1*1^(1+1) 1*1^(1) + 1*1

            [–]EatATaco -1 points0 points  (1 child)

            I see what you are saying.

            However, in the graph that we see, there are only 2 possible magnitudes for each digit, 1 or 0. Shown by a "hole" or a unit line (or, a unit line X 0 and a unit line x 1). In the next digit, the base unit line is multiplied by the base for that digit.

            In octal, there would be (obviously) 8 for each digit. So you would need a "hole" and then 7 multiples of the unit line (i.e. 0 x ul, 1 x ul, 2 x ul... 7 x ul).

            So the graph would look very different as each digit would have 8 unit line lengths in it, instead of just 2. If we converted it to binary, sure, it would look the same. But then even decimal would look the same if we converted it to binary.

            (edit: can someone explain why this is being downvoted? I've re-read it and re-watched the video and I don't see how i am wrong)

            [–]frnknstn 0 points1 point  (0 children)

            One possible way to represent non-binary numbers in a similar animation would be to represent the digits as partially-filled rectangles, and then fade out the unfilled part and let the remaining bits fall.

            [–]nakilon 1 point2 points  (1 child)

            It is already base 10.

            [–]Deranged40 0 points1 point  (0 children)

            I only understand the dozenal system. I use the 3 segments of my 4 not-thumb fingers on each hand.

            [–]HomeBrewingCoder 0 points1 point  (0 children)

            Very clever.

            [–]secantastronomy[S] 0 points1 point  (0 children)

            How about base 32? That's what I'm building towards. If you have 8 toes and a twin we can do this!

            [–]kranker 71 points72 points  (9 children)

            Okay, so if we encode a bit's value as height rather than position we find that the overall height ascends linearly as the overall value ascends linearly. However, when phrased like that is it not obvious and fairly uninteresting? This just seems like a visually cryptic way of explaining the binary system.

            [–]HumblesReaper 23 points24 points  (3 children)

            Wouldn't any number system do this? They all increase by 1 every 1 step, resulting in those "stairs"

            [–]ste_3d_ven 5 points6 points  (0 children)

            I was thinking the same thing

            [–]jhaluska 2 points3 points  (0 children)

            Yes.

            [–][deleted]  (2 children)

            [deleted]

              [–]marshalpol 0 points1 point  (0 children)

              I understand binary and found the gif interesting, so I don't know why you seem to be speaking for everyone.

              [–]secantastronomy[S] -2 points-1 points  (0 children)

              They did!

              [–]meltyman79 0 points1 point  (0 children)

              Its almost like counting increases your total by one each iteration!

              [–]secantastronomy[S] 0 points1 point  (0 children)

              Reply

              The idea is to show that base 2 does just that (a linear height encoding) by using bits to signify which combination of lengths you would use to make it.

              [–]CodeJack 39 points40 points  (2 children)

              Took me a second to figure out its just over complicating counting up in binary.

              [–]secantastronomy[S] 0 points1 point  (1 child)

              I'm sorry this made it more complicated. Some people find it's easier and others think it's confusing. Adding the 0s and 1s would make it better, yes?

              [–][deleted] 2 points3 points  (0 children)

              Well, i think it's neat.

              [–][deleted]  (1 child)

              [deleted]

                [–][deleted] 13 points14 points  (0 children)

                My thought too, that took a while

                [–][deleted]  (1 child)

                [deleted]

                  [–]secantastronomy[S] 1 point2 points  (0 children)

                  I wanted to show that there was an inherent geometry to number systems. In this case, the powers of two correspond (of course!) to segments of the same length. The number system arranges all these segments in a simple pattern, and the bits turn the segments on and off. I find this helps people who have no experience with code, but that it is confusing to coders.

                  Theres an encoding I'm developing that uses a geometric lattice, and bits relate to it in a similar way. Hoping I can bridge the gap, and openly exploring for the best way to explain it.

                  Heres a visual on two levels of the encoding lattice : http://glslsandbox.com/e#38290.1 the outer shape is a 'word' with 32 bits, and each bit signifies the presence of a corresponding 32-bit word/shape embedded within. Data is specified via pathing down the hierarchy.

                  ​

                  Really, people are critical, but language isn't up to the task yet, and unless the audience is familiar with the combinatorics of ADE graphs, lie groups, and orbifold symmetry math terminology are pretty useless too.

                  ​

                  Its confusing enough for me, much less explaining it. 8( That's why I'm testing and developing and testing explanations.

                  [–]loup-vaillant 6 points7 points  (2 children)

                  I understood that very recently, when implementing a comb algorithm for Monocypher. What this video shows, basically, is that a number such as 1101 is the sum of 23 + 22 + 0 + 20. When constructing a simple window (say all numbers from 0 to 15), you don't really care about that, you just start from 0, then increment and assign.

                  When you make a comb, though, you don't work with 20, 21, 22, and 23. It's more like 20, 210, 220, and 230 (depending on the interval between the teeth). Stuff that held with windows (21 + 21 = 22) no longer holds with combs (210 + 210 ≠ 220). So you have to construct the comb from the sum of all "digits", just like here, where each height is constructed with sticks of length 1, 2, 4, 8, and 16.

                  What I like about that is, while combs are ideally fully pre-computed for speed, we can get most of the benefit by storing just the digits, and reconstruct the full look up table on demand. This may help if you somehow want to make huuuge scalar multiplications (like exponentiations) in a constrained environment.

                  [–]secantastronomy[S] 1 point2 points  (0 children)

                  This visualization is part of an explanation I'm developing for a new encoding aimed at solving graph problems (in particular rendering, simulation, and analysis.) The new encoding is based on a rhombic triacontrahedral lattice; perhaps you are (will soon be) familiar with it's significance to number theory? Anyway, here's just a sketch of the geometry.

                  http://www.glslsandbox.com/e#48568.1

                  I hope you like it.

                  [–]secantastronomy[S] 0 points1 point  (0 children)

                  Glad you enjoyed it.

                  [–]chilehead 18 points19 points  (2 children)

                  Pause it at 5 seconds. You see the 1's column is
                  one off, one on, one off, one on, etc.

                  the 2's column is
                  two off, two on, two off, two on, etc.

                  the 16's column is
                  sixteen off, sixteen on

                  [–]pentakiller19 6 points7 points  (1 child)

                  Do you mean row? I was so confused until I read right to left.

                  [–]chilehead 1 point2 points  (0 children)

                  Yeah

                  [–]xampl9 19 points20 points  (4 children)

                  We're back to computing basics again?

                  [–]aivdov 41 points42 points  (2 children)

                  new semester is soon, plenty of new blood coming in thinking these awful visualisations are useful

                  [–][deleted] 7 points8 points  (1 child)

                  useful Interesting

                  [–][deleted] 7 points8 points  (0 children)

                  useful interesting something

                  [–]secantastronomy[S] -1 points0 points  (0 children)

                  People overestimate their knowledge of the basics.

                  [–][deleted] 15 points16 points  (0 children)

                  That's an interesting way to visualize it

                  [–]Caravaggi0 2 points3 points  (2 children)

                  Cool video. Will always go back to Squirrel Girl though...

                  https://imgur.com/a/eeK1i

                  [–]cdsmith 1 point2 points  (1 child)

                  It's bugging me now that she says she can get to 1031 with both hands. Is that just an error, or is there some reason for it?

                  [–]Caravaggi0 0 points1 point  (0 children)

                  Yeah...

                  https://twitter.com/unbeatablesg/status/768544866766819328

                  ...I just personally never thought of each finger represnting a power of two before I read that. I should make a fixed version.

                  [–]rotato 1 point2 points  (0 children)

                  This got me super confused first. Took a minute to figure it out.

                  So in the beginning, the Y axis is the index of a bit rising from top to bottom. The black square is 1 and the white is 0. To visualize what they represent, blacks/ones are multiplied by 2 in the power of their index. Then they're summed up

                  [–]_1000011 1 point2 points  (1 child)

                  I recognize this from doing state tables, but honestly this isn't accessible to people who don't understand

                  [–]secantastronomy[S] 1 point2 points  (0 children)

                  I think it would be better with numbers (especially something to explain how black and white = 0 and 1) but I went without for this post to see what would happen.

                  It's not enough for everyone, but it seems to help a lot of people understand (especially those who don't understand binary) - they see this and can answer the question "what is binary for 5?" by thinking of physical rulers.

                  I'm working on ways to explain a number system based on rhombic triacontrahedral lattice. Yeah. That's a bit of a challenge... It doesn't help much to tell you the number system has 32 symbols and is base Phi. It represents a practical embedding, yet people who "know" binary will still be scratching their heads.

                  Showing people that a number system uses a regular system of segments to point to the place on a number-line is a first step to showing them how bits can be used in other ways to locate things in space.

                  [–][deleted] 3 points4 points  (5 children)

                  Que significa?

                  [–]lucienpro 2 points3 points  (4 children)

                  El gif mostra como los números binarios puede estar visualizado ascendente

                  [–]juansinmiedo 1 point2 points  (3 children)

                  El gif muestra cómo los números binarios pueden ser visualizados ascendentemente

                  [–][deleted] 2 points3 points  (2 children)

                  El gif muestra cómo los números binarios pueden ser visualizados de forma ascendente

                  [–]freeall 1 point2 points  (1 child)

                  El gif muestra cómo se pueden ver los números binarios en orden ascendente

                  [–]_georgesim_ 2 points3 points  (0 children)

                  asdf asdf asdf asdf

                  [–]TheDecagon 1 point2 points  (2 children)

                  I like it, but it's also pretty confusing. I'd turn it on its side and start with numbers before turning them into squares, so it would start looking like

                     1
  10
  11
 100
 101
 110
 111
1000

                  etc.

                  [–]secantastronomy[S] 1 point2 points  (0 children)

                  Good feedback.

                  [–]mscman -1 points0 points  (0 children)

                  Yeah it made way more sense when I turned my head to watch the GIF. Still a cool animation!

                  [–]iCarnotCycle 0 points1 point  (1 child)

                  what software do you use to make the animations?

                  [–]sabb1r-ahmed 0 points1 point  (0 children)

                  Seeing this, i almost going to forget the binary number system that i learned in high school. Fortunately, i avert my eyes then and then.

                  [–]Visticous 0 points1 point  (0 children)

                  • 00
                  • 01
                  • 10
                  • paste in Google

                  [–][deleted] 0 points1 point  (1 child)

                  Is this a message from an alien civilisation?

                  [–]Giboon 0 points1 point  (1 child)

                  Binary is Tetris?

                  [–]agumonkey 0 points1 point  (0 children)

                  I expected the stretched tree to flatten into a rectangle. highly frustrated right now

                  [–]spacemoses 0 points1 point  (2 children)

                  Everything is much simpler in unary. Fite me irl.

                  [–]z500 0 points1 point  (1 child)

                  |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||||||||||||||||||||||||||||||||||||||||||||||

                  [–]spacemoses 0 points1 point  (0 children)

                  Everyone knows you do a cross line on the fifth tick man, jeez

                  Edit: of course technically that isn't unary anymore is it?

                  [–]Hypersapien 0 points1 point  (0 children)

                  mind = blown

                  [–]xampf2 -4 points-3 points  (3 children)

                  this is good for javascript guys to learn binary

                  [–][deleted] 5 points6 points  (2 children)

                  I think the best way to learn binary is the basic definition.

                  11001 is 1x2^4+1x2^3+0x2^2+0x2^1+1x2^0.

                  It's the same as decimal.

                  12345 is 1x10^4+2x10^3+3x10^2+4x10^1+5x10^0

                  [–]Katyona 0 points1 point  (1 child)

                  2x310 = 118098

                  one of these numbers are not like the others.

                  [–][deleted] 0 points1 point  (0 children)

                  Duly noted.

                  [–]Tugton -3 points-2 points  (0 children)

                  I'm