The need for flow control arises in any system, whenever an entity produces items and another entity consumes them. That is, there should be a balance between the rate of production and the consumption to ensure that the sender can’t overwhelm the receiver. This is important in networking protocols as well.

Need for flow control in HTTP/2

In HTTP/2, each request/response message that is exchanged between a client and a server is associated with a stream and a single HTTP/2 connection is capable of handling multiple concurrent streams. Therefore, to ensure that streams in a single connection won’t interfere with each other, the flow control is supported, both at the connection and at the stream level.

HTTP/2 provides flow control via WINDOW_UPDATE frame and remember only DATA frames are subject to flow control. With the WINDOW_UPDATE frame, both the client and the server can independently advertise the number of octets that they are ready to receive and then the peer must respect this imposed value. That is the basic theory behind HTTP/2 flow control.

Flow Control Window

Flow control window is just nothing more than an integer value indicating the buffering capacity of the receiver. Each sender maintains a separate flow control window for each stream and for the overall connection.

WINDOW_UPDATE Frame

WINDOW_UPDATE frame indicates the number of octets the sender can transmit in addition to the existing flow control window. The legal range is 1 to 2³¹ -1 octets.

Initial Flow Control Window Size

According to the HTTP/2 specification, the initial value for the flow control window is 65,535 octets for both the new streams and the overall connection.

However, during the HTTP/2 connection establishment phase, both endpoints can adjust this window size by changing the value of SETTINGS_INITIAL_WINDOW_SIZE property in the SETTINGS frame. But keep in mind that this only applies to streams and not to the connection window. Connection flow control window can only be changed using a WINDOW_UPDATE frame.

When this SETTINGS_INITIAL_WINDOW_SIZE value changes, the receiver must adjust the flow control windows by the difference between the new value and the old value.

Maintaining Flow Control Window Size

Since the flow control is directional, both endpoints maintain stream level and connection level windows. The basic mechanism to maintaining the flow control windows, defined by the spec, is as follows.

1. When the sender sends a flow controlled frame(DATA frame), it reduces the space in both windows(stream and connection window) by the length of the transmitted frame.
2. When the receiver consumes data, it can send WINDOW_UPDATE frames to the sender to free up flow control windows. The receiver should send separate WINDOW_UPDATE frames for the stream and the connection.
3. When the sender receives the WINDOW_UPDATE frames it should update the corresponding windows by the specified value in the frame.

An example of flow control is depicted in the following figure.

However, please note that implementors are free to choose any algorithm they see fit, to decide when to send the WINDOW_UPDATE frames.

Now let’s see an example of HTTP/2 flow control in action.

HTTP/2 Flow Control in Action

I’m going to use ballerina language to build a simple HTTP service(we can get it up and running with a few lines of code) and it will be configured to use HTTP/2 as its protocol. I’ll use nghttp as my test HTTP/2 client.

Following is the simple HTTP echo service that retrieves the incoming payload from the request and sends it back to the caller.

We can start this service by issuing the following command.

ballerina run http2-flow-control-test.bal

Once it is started, you will see a log similar to the following.

[ballerina/http] started HTTP/WSS endpoint 0.0.0.0:9090

We are all set now. So let’s use nghttp to send a request to this service. I’m going to send an 82.6kB size of a JSON file via this request to the backend service. Here’s the command.

nghttp -v -d payload.json --cert myapp.pem https://localhost:9090/echo

Now let’s observe the nghttp log and analyze the HTTP/2 flow. Here, I’m only going to show you the relevant parts of the logs for clarity.

Figure 1

First, the client sends the SETTINGS frame with the initial window size value as 65535 octets. This tells the server, the number of octets, the client is ready to receive and it is followed by a few priority frames (we are not gonna talk about that right now. That’s a whole other topic) after which the client immediately starts to send headers and data frames to the server.

According to the log, we can see that the client has sent four data frames ( (16384 * 3 + 16383 = 65535 octets) to the server. After that client is not allowed to send any more data since the window is now full(flow control window is now equal to the number of octets the client has sent).

Figure 2

Then the client receives a SETTINGS frame from the server and the client immediately acknowledges that. Since that does not contain an initial window value, original 65535 will be used as the default. The client also receives the settings ACK from the server which tells the client that the server has received the settings frame, sent by the client(Figure 2).

Figure 3

So far the client has sent 65535 octets to the server and as I have mentioned before, it can’t send any more data until it receives a WINDOW_UPDATE frame from the server, freeing up its window.

So next the client receives two window update frames each with a size of 65535. Stream id 0 is for the connection window and the stream id 13, in this case, is for the relevant stream. Then the client sends the rest of the data to the server (16384+699 = 17083) in two DATA frames. Altogether now the client has sent 82618 octets which constitutes the full payload.

Figure 4

Next, the client starts to receive a response from the server.

Figure 5 & 6

First, it receives four DATA frames(8192 * 4 =32768 octets).

Then the client sends a window update frame to the server, telling it that the client has consumed 32768 octets and to free up the window space maintained by the server.

Figure 7 & 8

Then the client receives another 4 DATA frames, out of which 3 frames with the size 8192 and another DATA frame with the size 8191. (8192*3+8191=32767).

Then the client again sends back a window update with 32767 octets as its value to the server to make room in the server window so that the server is allowed to send more data to the client.

Figure 9 & 10

Finally, the client receives another two DATA frames with sizes 16384 and 699 respectively which makes up the whole response payload.

Then as the final step, we can see that the client has sent a GOAWAY frame to the server, to close the connection.

This is basically how the flow control works and you can try this out with different initial window sizes by using nghttp ’s -w flag.

Error Handling

Following are some of the error conditions that we have to taken into consideration when implementing flow control.

• WINDOW_UPDATE frame with a value 0 results in a stream error of type protocol error.
• Errors on the connection flow control window are treated as connection errors.
• Flow control window of the sender cannot exceed 2³¹-1 octets. If a sender receives a WINDOW_UPDATE frame that causes the flow control window to exceed this value then it should be treated as an error.

Other Subtle Facts

If you want to know more about the error handling and other subtle facts related to flow control, I suggest you read flow control and window update sections in HTTP/2 specification for a detailed explanation. That being said, this topic, most of the time does not directly concern the users or developers unless you want to develop your own HTTP/2 server or client. But knowledge about this might help you troubleshoot issues when working with HTTP/2.

References

• RFC 7540 - Hypertext Transfer Protocol Version 2 (HTTP/2)
• Nghttp2: HTTP/2 C Library - nghttp2.org

HTTP/2 Flow Control was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

These are just a few videos I have put together sometime back and thought to include in a blog, so I have everything in one place. I have originally published them here.

These few videos will introduce you to functions, linear functions, circles, parabolas and briefly talks about trigonometry.

Functions

Linear Functions

Circles and Parabolas

Trigonometry

In this post we are going to talk about how multiplexing and demultiplexing happens at the transport layer. Before we jump into the subject, let’s first jog our memory about what we already know about TCP/IP (Transmission Control Protocol/Internet Protocol), so that we are all in the same page.

Let’s start with processes.

What is a Process?

Think of a process as a program running within an end system. So how do processes on two different end systems communicate with each other? Well, by exchanging messages across a network and that’s where TPC/IP protocol suit helps us understand how the communication happens between hosts.

Following diagram roughly sketches out what happens when we send data across a network from one process to another.

As you can see here, TCP/IP protocol suit is made up of different layers and remember that each upper level protocol uses services provided by one or more lower level protocols.

Different Names for Packets?

Packets of information that passes through these layers are referred by different names in each layer. At the application level, data that needs to be exchanged is referred to as a message. Then the transport layer takes this message and adds transport layer headers to it. The resulting encapsulated packet is called a segment. When the segement is passed on to the network layer, it wraps the segment with its own network layer headers and it goes by the name of datagram. Then when the link layer takes over these datagrams, it adds link layer related headers and pass those packets which is then known as frames to the physical layer for transmission.

At the destination, the reverse process happens. Each layer decapsulates the receiving packets and handover the payload to the higher level layer until the message reaches the application level. One thing to keep in mind here is that, between the source and the destination, there can be many routers, link layer switches which can contain different set of layers depending on their functionality. For example, routers typically don’t have transport or application layers implemented within them.

Process to Process Communication

If you look at the network layer, it is only responsible for host to host communication. That is, it can only deliver messages to the destination computer. Once a message has been delivered to the destination, it still needs to be handed over to the correct process and transport layer has the responsibility to take care of that.

Suppose you have three application processes running in your machine. Now when your computer receives data from outside that message needs to be directed to the correct application process. This is where the sockets come into play and now it is a good time to introduce that.

Sockets

Transport layer actually does not directly deliver messages to processes. So, who does that? Well, there’s an intermediate software interface called a socket layer that does the transmission of messages between the underline network and the processes. Now remember that a process can have one or more sockets through which it can pass data to and from network and each of these sockets have a unique identifier.

So, What is Multiplexing and Demultiplexing?

Transport layer gathers chunks of data it receives from different sockets and encapsulate them with transport headers. Passing these resulting segments to the network layer is called multiplexing.

The reverse process which is delivering data to the correct socket by the transport layer is called demultiplexing. But this still doesn’t explain how the transport layer identifies the correct socket. Port numbers are the ones that do the trick.

Port Numbers

Each socket in a host can be assigned a port number. In TCP/IP protocol suit, port numbers are 16-bit numbers ranging from 0 to 65,535. Well known port numbers start from 0 to 1023 and they are reserved for well-known application protocols. For example, HTTP uses port number 80, FTP 21, etc…

Now let’s examine how these port numbers are useful in understanding the role of transport-layer multiplexing and demultiplexing. When packets arrive, the transport layer looks for the destination port number in the segment that is bound to that port number, but that alone is not enough for the TCP to demultiplex the incoming segment. It has to examine all the four elements(local host, local port, foreign host, foreign port) in the socket pair to uniquely identify the endpoint to which the receiving segment should be directed to. Then the data in that segment passes through the socket into the attached process.

Client and Server Processes

Finally about the client server paradigm. Earlier we briefly talked about process to process communication. In the context of the communication between these processes, remember that the process that initiates the communication is called a client and the process that waits to be contacted is called the server. To establish a connection between the client and the server, TCP suit needs both the IP address and the port number at each end and this combination of the IP address and the port is called a socket address.

What we have talked so far is just the theoretical stuff. Now to see all this in action you can read the following post which greatly explains these concepts with code snippets.

Blocking I/O and non-blocking I/O

References

• Computer Networking: A Top-Down Approach (6th Edition)
• Computer Networks: A Top Down Approach

Transport Layer Multiplexing and Demultiplexing was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

We write programs all the time using high level programming languages like Java, C etc... With these programs we can instruct the computer to do something useful. But have you ever wondered how exactly the computer is able to execute these instructions? Idea of this post is not to teach you how to program in a low level language or in worst case binary form but to show you what happens under the hood.

As you might already know, computers work with bits. A bit is something that just represents two states. An on or off, 1 or 0, true or false, plus or minus etc… We can use any two things to represent these two states but in general we use 1 and 0 to say the bit is on and off respectively. We know that computers can store words, pictures, sounds etc… But in reality all these are nothing but bits and we humans have grouped them and given it some meaning (a code). For examples let’s take a byte which is in fact 8 bits. How many patterns can we make up with 8 bits? With 1 bit there are only two possibilities, 1 or 0. With 2 bits, 4 patterns; likewise with 8 bits we have 256 possible ways of arranging bits. So what did people do? They got together and held some meetings and agreed on some code and made it a standard. Take ASCII for example,the bit pattern ‘01000001’ represents letter ‘A’. We just gave some meaning to a bit pattern. But keep in mind that how these patterns are interpreted is based on the context in which it is being used.

In a high level sense basically what happens when you run a program is, your program gets loaded into the RAM first and then the processor starts to execute the instructions in that program. An instruction is simply a sequence of one or more bytes and different processors follow different Instruction Set Architectures(ISAs) in their instruction encoding. (In Linux, you can use the following command to find out what ISA is being used by your machine. In my case it is x86_64)

uname -m

Let’s take a simple program written in C to print a “Hello World!” and see what exactly happens under the hood when we run it.

First we write our program in a particular high level language (I have written it in C) with ASCII characters and saved it in a file. Next we will use a special program called a compiler to translate this text file to assembly language statements. Assembly language represents the symbolic version of machine instructions that the hardware can understand and the binary version is called the machine language.

When I run the following command, it generates a binary file called ‘hello.o’ and if we open it in a text editor it would appear gibberish.

gcc -Og -c hello.c

Now to view the content of this generated machine code (hello.o), in Linux we have a program called ‘OBJDUMP’ which we can use to view the generated instructions in assembly format.

Now to generate the actual executable code we need a linker to run on this generated object file(hello.o).

gcc -o output hello.o

Now again if we disassemble this generated executable file (output) using objdump you will see the following.

If you look at the C program that we have written in ASCII, there we have used a printf function which actually is provided by the standard C library. What the linker has done here is, it merged the hello.o program with the pre-compiled printf.o and made an executable file called ‘output’. Main difference you can see here in the assembly code with that of the relocatable object file is that the linker has filled the proper address for callq instruction.

Now we are ready to load our executable file (output) into main memory and let the processor execute it.

References

• https://www.elsevier.com/books/computer-organization-and-design-mips-edition/patterson/978-0-12-407726-3
• http://www.buthowdoitknow.com/
• http://catalogue.pearsoned.co.uk/educator/product/Computer-Systems-A-Programmers-Perspective-Global-Edition/9781292101767.page

Machine Code was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

Numbers with fractions that can be put in the form,

can be represented as floating point numbers in computers.

These numbers are called floating points because the binary point is not fixed. Up until about 1980s different computer manufacturers used different formats for representing floating point numbers, but with the introduction of IEEE standard 754, nowadays almost all the computers follow the said standards which greatly increased the portability of floating point data.

IEEE Floating Point Representation

IEEE standard defines three formats for representing floating point numbers,

1. Single Precision (32 bits)
2. Double Precision (64 bits)
3. Extended Precision (80 bits)

and with this standard, floating point numbers are represented in the form,

s represents the sign of the number. When s=1, floating point number is negative and when s=0 it is positive. F represent the fraction (which is also called mantissa) and E is the exponent.

Structure of the two most commonly used formats are shown below.

Single Precision (32-bit)

Double Precision (64-bit)

Now let’s see how we can convert a given decimal number to a floating point binary representation. Lets take -4.40625 as an example.

Step 1:

First convert the integral part which is 4 to binary.

Step 2:

Then we can multiply the fractional part repeatedly by 2 and pick the bit that appears on the left of the decimal to get the binary representation of the fractional part. For example,

Step 3:

Now we need to normalize the number by moving the binary point so that it takes the form,

One very important thing to remember here is, that the leading 1 bit does not need to be stored since it is implied. That is a clever trick used by the standard to get additional space for fractional part. So for the fractional part(23 or 52 bits) we need only to save 0001101 in this case and fill the rest of the its bits on to the right with 0s.

Step 4:

Now the exponent is represented as a integer in biased form. So if the exponent has k-bits then the bias equals to,

Add this bias to the exponent and place it in the exponent section. With single precision, k has 8 bits so the exponent value in this example equals to,

Finally the sign bit is set according to the original sign of the number. That is 1 for negative and 0 for positive.

So the decimal value -4.40625 in binary form can be represented as,

Special Cases — Infinity and NaN

Infinity — When the exponent bits are all ones and the fraction bits are all 0 then the resulting value represents infinity.

NaN — When exponent bits are all ones but the fraction value is non zero then the resulting value is said to be NaN which is short for Not a Number. You get this value when you perform invalid operations like dividing zero by zero, subtracting infinity from infinity etc…

References

• http://sandbox.mc.edu/~bennet/cs110/flt/dtof.html
• https://www.amazon.de/Computer-Systems-Programmers-Perspective-Global/dp/1292101768
• https://www.amazon.com/Computer-Organization-Design-MIPS-Fifth/dp/0124077269
• https://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/0132916525

Floating Point Representation was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s get this clarified with a few examples.

Unsigned Addition

Let’s say that we have two 4-bit numbers, 12 (in binary 1100) and 7 (in binary 0111). Sum of these two numbers, 12+7 = 19 (in binary 10011) needs 5 bits to represent the result. If we truncate the bits with weight greater than 2³ that is if we discard the higher order bit, we are left with 0011 which is 3. This is actually equivalent to the value 19 mod 16 = 3.

In C and Java, overflows are not considered as errors.

Two’s Complement Addition

Since both the positive and negative numbers can be represented with two’s complement, we have to decide what to do when the resulting value of a two’s complement addition becomes too large or too small to represent with a given number of bits. As we have seen here, with w bits,

When a sum of two numbers exceeds the max value, we call that a positive overflow and when the result is less than min value, we call it a negative overflow. Let’s see this in action with 4-bits.

The maximum positive value that can be represented with 4 bits in two’s complement representation is 7 and the minimum value is -8. Following table shows two examples of overflow scenarios.

Unsigned Multiplication

Just like with addition, in multiplication also we have to deal with overflow scenarios. For example with 4-bits to represent numbers 4 (in binary 0100) and 5(in binary 0101), multiplication (expected value 20[in binary 10100]) gives 4 (in binary 0100) as the result. This is equivalent to, 4.5 mod 2⁴ = 20 mod 16 = 4.

Two’s Complement Multiplication

With two’s complement numbers, we can derive the multiplication result in following two steps.

Let’s say we have two numbers x and y each with w-bits, then

References

Computer Systems: A Programmer's Perspective

Integer Overflow was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

A byte usually consists of 8 bits and and a collection of bytes form a word. Therefore, the bytes in a word can be numbered either from left to right or right to left. This convention of ordering bytes by a machine is called its byte order.

Think of a variable of an int type which has 32 bits(4 bytes) stored in a contiguous sequence of memory locations 0, 1, 2, 3. Let’s imagine the value of this variable to be 20555768 (in hexadecimal notation 0x0139A7F8) and the binary representation of that number is,

Little Endian

Some machines store bytes ordered from least significant byte to the most significant and that is called little endian. Here, the least significant byte has the hexadecimal value 0xF8 and the most significant byte 0x01.

Big Endian

In big endian format, bytes are ordered from most significant to the least significant.

As programmers, we rarely worry about byte ordering, but this becomes a problem when a little endian machine tries to send binary data to a big endian machine over the network and vice versa. As a solution , TCP/IP requires you to order the bytes in network byte order (which is big endian) before any binary integers in TCP/IP headers are sent across the network.

References

https://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/812034720X/ref=asap_bc?ie=UTF8

Byte Ordering was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

Java and C uses 0x or 0X to represent hexadecimal numbers. Characters (‘A’ to ‘F’) in a hexadecimal number can be written either in upper case or lower case. For example, 0xa8b3d is same as 0xA8B3D.

Converting hexadecimal number to binary

Suppose we want to convert the number 0x39A7F8 to binary. This is how you do it.

Converting binary to hexadecimal

If we are given the binary 1001101110011110110101 to convert to hexadecimal, first split the binary digits into 4 bit groups and then if the number of bits is not a multiple of 4, padded the left most group with 0s.

Hexadecimal Notation was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

Computers use binary digits ( or in other words bits) to store and process information. A binary digit can be of one of the two values, 0 or 1.

For example, take the decimal number 59. Binary form of that decimal number 59 is 111011.

Word

Computer word is a unit of data with a defined bit length that a CPU can process at one go. In recent years, many machines have shifted from 32 bit word sizes to 64 bit word sizes.

Let’s represent 111011 as a 32 bit word.

Here the right most bit is called least significant bit and the left most bit, the most significant bit. With 32 bits, we have 2³² bit patterns which means we can represent numbers from 0 to 2³²-1 (4,294,967,295).

Computer programs use both the positive and negative numbers, so now we need a way to differentiate negatives from positives.

Unsigned encoding

If we assume that we have 32 bits, then with unsigned encoding every number between 0 and 2³² -1 has a unique encoding. That is each number in this range will map to a unique bit pattern.

With w bits, number range is,

Two’s complement encoding for signed numbers

To represent negative values, most computers use two’s complement encoding. With this encoding, most significant bit has a negative weight. So all negative numbers will have 1 in the most significant bit which is also known as the sign bit. Therefore, when the sign bit is 1 the value is negative and when it is 0 the value is positive.

For example, if we take the binary number 1011 which is a 4 bit word, now with two’s complement, its value can be calculated as follows,

With w bits, number range is,

• Minimum Value

• Maximum value (Sign bit 0 and all the other bits set to 1)

Zero extension

To convert an unsigned number with w-bits to a number with more than w bits, we simply add 0s to the left. Let’s say we have a 16-bit unsigned number and we want to convert this to a 32-bit number, we simply fill the leading 16 bits with 0s. This is called zero extension.

• 16-bit Version

• 32-bit Version

Sign extension

To convert a two’s complement number with w bits, to a word which has more than w bits, we can use sign extension.

For example, let’s say we have number -4 in a 16 bit word and we want to convert this to a 32-bit word.

[Shortcut to negate a two’s complement number is to invert every 0 to 1 and every 1 to 0, and then add one to the result.]

Now to convert this 16-bit version of -4 to a 32-bit version, we simply copy the sign bit 16 times on to the left.

Well, that’s it!

References

• https://whatis.techtarget.com/definition/word

Signed and Unsigned Numbers was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s explore few different number systems that are in use today and see how with simple three rules, we can build any number system we want.

In mathematics, a “base” or a “radix” is the number of different digits or combination of digits and letters that a system of counting uses to represent numbers. ~Wiki~

For example,

• Base 10 (Decimal) — Represent any number using 10 digits [0–9]
• Base 2 (Binary) — Represent any number using 2 digits [0–1]
• Base 8 (Octal) — Represent any number using 8 digits [0–7]
• Base 16(Hexadecimal) — Represent any number using 10 digits and 6 characters [0–9, A, B, C, D, E, F]

In any of the number systems mentioned above, zero is very important as a place-holding value. Take the number 1005. How do we write that number so that we know that there are no tens and hundreds in the number? We can’t write it as 15 because that’s a different number and how do we write a million (1,000,000) or a billion (1,000,000,000) without zeros? Do you realize it’s significance?

First, we will see how the decimal number system is been built, and then we will use the same rules on the other number systems as well.

So how do we build a number system?

We all know how to write numbers up to 9, don’t we? What then? Well, it’s simple really. When you have used up all of your symbols, what you do is,

• you add another digit to the left and make the right digit 0.
• Then again go up to until you finish up all your symbols on the right side and when you hit the last symbol increase the digit on the left by 1.
• When you used up all the symbols on both the right and left digit, then make both of them 0 and add another 1 to the left and it goes on and on like that.

If you use the above 3 rules on a decimal system,

• Write numbers 0–9.
• Once you reach 9, make rightmost digit 0 and add 1 to the left which means 10.
• Then on right digit, we go up until 9 and when we reach 19 we use 0 on the right digit and add 1 to the left, so we get 20.
• Likewise, when we reach 99, we use 0s in both of these digits’ places and add 1 to the left which gives us 100.

So you see when we have ten different symbols, when we add digits to the left side of a number, each position is going to worth 10 times more than it’s previous one.

How to read numbers?

Let’s take the same decimal number system. There are only two rules actually.

• You have a symbol to represent a quantity [0–9]
• Then the meaning of a digit based on its position — let’s get this clarified a bit.

Let’s take one digit number ‘8’. This simply means 8, in other words, it is exactly what it says it represents. What about 24? In case of two digits, right digit says what it means, but left digit means ten times what it says. That is, 4 is 4, 2 is 20. Altogether forms 24.

If we take a three digit number, rightmost digit means what it says, the middle one is ten times what it says, leftmost digit 100 times what it says. Simply if we take number 546, it means 6 + (10 * 4) + (5 * 100) = 546.

Binary

With binary, we have only two digits to represent a number, 0 and 1 and we are already out of symbols. So what do we do? Let’s apply the same rules that we used on the decimal system.

We make the right digit 0 and add 1 to left, that is, our next number is ‘10’. Then we go up until we used up all our symbols on the right side.So the next number in line is 11.

After ‘11’, we put 0s in both these places and add 1 to the left and we get 100.

Then 101, 110, 111 then 1000 …

This binary number system is based on two digits and each position is worth two times more than the previous position.

Reading a binary number is almost same as reading a decimal. Right digit says what it means, next one means two times the previous one, after that 4 times etc…

So 101 means 5 in decimal.

These same rules apply to octal and hexadecimal number systems as well. With octal, we have only 8 digits to represent numbers so once we get to 7 the next number is 10 and in hexadecimal, we have 10 digits and 6 letters to represent numbers. In that case, when we reach 9 next number is represented in the letter ‘A’. Next one ‘B’. Likewise, we go up to letter ‘F’ and after ‘F’ comes ‘10’.

I’ll just list down few numbers in these 4 different number systems and see whether you can apply the rules that we discussed above to get the next number.

To understand how computers represent positive and negative numbers, please read this and more on hexadecimal can be found here.

References

• http://www.buthowdoitknow.com/

Number Systems — Decimal, Binary, Octal and Hexadecimal was originally published in Coder's Corner on Medium, where people are continuing the conversation by highlighting and responding to this story.