#unicodeipv6: The converter program

The url for the source code (#unicodeipv6) is :

https://github.com/r9al/ipv6unicode/

#unicodeipv6: Represent an IPv6 address in a 4X4 Matrix

Represent an IPv6 address in a 4X4 Matrix

Here are some of the valid ipv6 addresses written in 4X4 Matrix.

#unicodeipv6 : The Summary

#ipv6 #unicodeipv6

( Base64 Characters * 4 combinations ) = 256 Characters ;
16 Characters * 8 Bits = 128 Bits (IPv6 Address)

Facebook Page created

#unicodeipv6

Characters in #unicodeipv6

The above image show characters with values from 0-63.

The above image show characters with values from 64-127.

The above image show characters with values from 128-191.

The above image show characters with values from 192-255.

2 new slogans for #unicodeipv6

Support #unicodeipv6

Use the hashtag #unicodeipv6

If you like the idea then use the hashtag #unicodeipv6 on twitter or facebook.

The Idea

Anoop's Method : Representing IPv6 addresses in a new way

The Problem:

The biggest problem that is with the IPv6 representation is that 128bits requires a lot of characters representing it. A problem I thought of and came up with a unique solution, may not be a perfect solution but it a lot easier than the current one (Wikipedia Explanation) which only network admins can understand. This I feel is one of main reason why its adoption has been less.

With 128 bits for address you will need 32 characters to represent a single IPv6 address (each character representing 4 bits) if the current Base16 is Used. However you look at it, its going to consume that many characters. If the vast majority of the characters are going to be zeros then omitting them is a nice idea which is the current solution that IPv6 uses. What does that mean to the layman ? How does he configure the ip address of his machine ? The IPv4 itself is confusing for a simpleton but with IPv6 it changes the whole approach of thinking. Although it may appear as self-explanatory the simplcity of typing 192.168.0.1 or something similar is totally disregarded in the IPv6 representation. This doesn't mean that I am IPv4 fanboy or anything. I just love the idea of simplicity. In stark contrast I actually feel IPv6 should be adopted and soon. It will drastically change the world. The problem remains with the representation.


My Solution:
Base256 (or Anoop's Method)

The obvious question will be : it will require 256 different characters to represent each of the 256 values. Not to mention people have to remember them, and how is this supposed to help the anyone?

And that is where I would say "I beg to differ".

I said 256 different characters not 256 different characters to remember.

So let me explain, does anyone know base64 encoding ? it uses 64 characters to represent 64 values, I am just borrowing that idea.

The 64 Characters are ofcourse :
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
10 - numbers
26 - Small letters of english
26 - Capital letters of english
plus and slash (Atleast I think its + and /) - that makes it a total of 64 characters.

Personally I prefer having the following character set in this order:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-+

So how does 64 characters = 256 values. This is where you got to love the idea of simplicity.

Now how do I convert 64 values to 256 values ?
Rotate it Clockwise or Anticlockwise with marker indicating direction of the character (this is Method 2) or better yet put a line marker in the direction of North, East, South, West (Or Top, Right, Bottom, Left), making every single character have 4 possible combinations. That means 64X4 = 256 characters.

The picture above represents two ways of having 256 Values from 64 Characters. 

So an ip address would like this:

 

OR (Second Method, is to use the line marker with character rotation )

NOTE: These new 256 characters (first method) should be made available in Unicode characters list specifically for IPv6 Representation or 4 new Modifier characters have to be included in the Unicode characters list. The second method is a little more complex to read and has slight flaws depending on the font that is being used.

That would make it 8Bits * 16 = 128Bits
Representing IPv6 or IPv4 address would be a lot simpler using the this method.

Console Environment: (ASCII representation)

Since these alphabets with markers donot exist as of today, there has to be an ascii representation for console only machines. In that case we would require 32 characters as before. As we need a prefix for each character to identify whether it is South Marker Capital Letter 'A' ,  West Marker Capital Letter 'A', North Marker Capital Letter 'A'  or East Marker Capital Letter 'A' .

The same address would look something like this:
SAWBNCED.WENFEGSH.NIEJSKWL.EMSNWONP

Example:
S1S2S3S4.W1W2W3W4.N1N2N3N4.E1E2E3E4
NaNbNcNd.EeEfEgEh.SiSjSkSl.WmWnWoWp

Subnet Mask Example:
E+E+E+E+.E+E+E+E+.E+E+E+E+.E+E+E+S0

The prefix being S-SOUTH, W-WEST, N-NORTH, E-EAST . The prefix should always be capital letter and every letter has a prefix if you are using ASCII representation. The spaces are present to improve readability.

GUI Environment:
And for the GUI environment a Popup window that lists the primary base256 characters along with the marker type(NORTH, EAST, SOUTH, WEST) can be provided to configure an ipaddress/subnet... etc.


IPv4 Representation :
IPv4 also can be represented using this method, which requires only 4 characters.


Character Representation and its values:
Should the characters values be uncollated or collated as in do we assign values like this:

Method 1: (SWNE Method, SOUTH-WEST-NORTH-EAST)
S0 = 0, W0 = 1, N0 = 2,  E0 = 3, S1 = 4, W1 = 5,  N1 = 6,  E1 = 7

or

Method2:  (4S Method or SSSS Method, SOUTH SOUTH SOUTH SOUTH Method)
S0 = 0, S1 = 1, S2 = 2,  S3 = 3, S4 = 4, S5 = 5,  S6 = 6,  S7 = 7, ... , S- = 62, S+ = 63 , W0 = 64, ... so on and so forth.

Personally I think method 2 for value association is better and more readable.

Some common values:
0 = S0
1 = S1
255 = E+

Short Cut to Fast Typing of IPv6 Characters

A + CTRL + Arrow UP = NA
a  + CTRL + Arrow UP = Na
1  + CTRL + Arrow RIGHT = E1
... Etc