# data[].attributes.body
There are many ways, but the paper binary calculator that we learned to make in class is one of the best and simplest examples.

# data[].attributes.body
The binary system is much simpler than, for example, the english language. There is no rule of grammar or punctuation, so it's an abstract form of a language. You are breaking down the text into something that is easier, and therefore more abstract, for the sake of the computer.

# data[].attributes.body
If a computer reaches the limitations, the results would be similar to a human reaching their physical limit. The computer would be unable to process information/perform operations any further.

# data[].attributes.body
Binary numbers are sort of the universal language of computers. Every process on a computer includes binary, because the computer wouldn't understand what to do otherwise. Although we see images, numbers and letters, the computer interprets all of those things as strings of binary numbers.

# data[].attributes.body
This is an image I found illustrating bits and bytes

# data[].attributes.body
The best way to convert decimals to binary and binary to decimals is using the chart that goes from 128 to 1.

# data[].attributes.body
Computers store texts in binary (1 and 0s). It's interesting that it has only 1s and 0s but we can see so many different things. The colors, texts, shapes, and everything else is stored in binary codes.

# data[].attributes.body
Limitations of storing numbers impact computing because when it reaches its limit, it can overflow or fail to run.

# data[].attributes.body
Binary numbers' significance to computers is that it's the only language computers cab understand. For example if you download a picture, computer saves it in binary codes but you see the actual image. The computers don't recognize any type of data like how you see it.

# data[].attributes.body
Here is what I found on the internet. 1 byte=8 bits

# data[].attributes.body
the best way to convert decimals to binary and binary to decimal is by on a piece of paper divide the decimal number continuously by 2 until you get 0 

# data[].attributes.body
storing text in binary illustrates abstraction because the binary 1 to 0 shows every single bit of information

# data[].attributes.body
because of limitations of storing numbers it impacts computing because there can be roundoff, overflow, or precision of of numeric variables

# data[].attributes.body
binary numbers significance to computers is that computers operate using binary numbers which means that they store data  using these numbers

# data[].attributes.body
So far I like the binary calculator using paper. It is easier because you are able to visualize it.

# data[].attributes.body
Storing text in binary is significant because it take computing to another level. It creates an illusion when the numbers match letters which then create words. I honestly find this interesting because its a code and being able to understand which letter and eventually word, forms is satisfying.

# data[].attributes.body
Limitation of storing numbers impacts computing because it restricts so much from the computers way of operating and can create failures, shutting down the whole system. Which is why binary is an efficient system that allows computers to store data and programming.

# data[].attributes.body
Binary is a system of counting, it is more efficient when it comes to computers because we can express more numbers and it’s a way for the computer to work and allows us to understand and communicate with computers.

# data[].attributes.body
Basic information on Bits and Bytes

# data[].attributes.headline
Binary Numbers are significant to computers because computers operate by using binary numbers.

# data[].attributes.subject
Binary Numbers are significant to computers because computers operate by using binary numbers.

# data[].attributes.body
-Rosa Zapeta Lux

# data[].attributes.body
This image shows how bits and bytes are stored

# data[].attributes.body
the best way to convert decimals to binary and binary to decimal is by on a piece of paper divide the decimal number continuously by 2 until you get 0

# data[].attributes.body
because of limitations of storing numbers it impacts computing because there can be roundoff, overflow, or precision of of numeric variables

# data[].attributes.body
binary numbers significance to computers is that computers operate using binary numbers which means that they store data  using these numbers

# data[].attributes.body
Despite working with computers, there are some things that could be done on paper and in your head. One of my new personal favorites in terms of binary conversion is the usage of a paper calculator that we made in the class together. It allows for simple visualization of the concepts and you can even learn it completely in you dedicate it enough time.

# data[].attributes.body
The beauty of abstraction is that it’s virtually invisible. Due to the way the code is hidden in another code allows for a more neat and good looking code. The way it works is through the conversion of information Into 0 and 1, which is a binary code that represents every bit of information. Beautiful system and example of how our brains can make the complicated concepts simple.

# data[].attributes.body
the computer has its abstractions of 1 or 0

# data[].attributes.body
write down decimal continually divide by 2. then u get a result or remainder of 1 or 0 until the final result equals 0

# data[].attributes.body
it can create failures in the program or overflow the system. This can cause problems with the computer

# data[].attributes.body
Computers operate in binary meaning they store data and perform calculations using only zeros and ones

# data[].attributes.body
KAyla Flores

# data[].attributes.body
The limitation on storage impacts computing. There is only a certain limit of information that a bit can process. If the computer stores a bit over what it can handle it will result in an “overflow”. Which will stop the whole program from working at all because it is at its limit.

# data[].attributes.body
This illustrates Abstraction because Abstraction is the code that the computers store that we don't see. This is fitting because while we see numbers like 234 on our computer screen the numbers we don't see are the binary numbers of 1s and 0s that the computer stores.

# data[].attributes.body
The best way for me is using the calculator we made because it gives me a visual on what numbers I am using whether the top numbers like 128,64,32,16,8,4,2,1 or 00001111.

# data[].attributes.headline
For me it is using calculator  that we made in class.

# data[].attributes.subject
For me it is using calculator  that we made in class.

# data[].attributes.headline
When computer programs store numbers in variables, the computer needs to find a way to represent that number in computer memory. Computers use different strategies based on whether a number is an integer or not. Due to limitations in computer memory.

# data[].attributes.subject
When computer programs store numbers in variables, the computer needs to find a way to represent that number in computer memory. Computers use different strategies based on whether a number is an integer or not. Due to limitations in computer memory.

# data[].attributes.headline
 To start simple, let's imagine a computer that uses only 4 bits to represent integers. It can use the first bit to represent the sign of the integer, positive or negative, and the other 3 bits for the absolute value.

# data[].attributes.subject
 To start simple, let's imagine a computer that uses only 4 bits to represent integers. It can use the first bit to represent the sign of the integer, positive or negative, and the other 3 bits for the absolute value.

# data[].attributes.headline
Computers operate in binary, meaning they store data and perform calculations using only zeros and ones. However, multiple binary digits can be used to represent large numbers and perform complex functions.

# data[].attributes.subject
Computers operate in binary, meaning they store data and perform calculations using only zeros and ones. However, multiple binary digits can be used to represent large numbers and perform complex functions.

# data[].attributes.headline
A bit is a binary digit, the smallest increment of data on a computer. Bits are usually assembled into a group of eight to form a byte. A byte contains enough information to store a single ASCII character, like "h".

# data[].attributes.subject
A bit is a binary digit, the smallest increment of data on a computer. Bits are usually assembled into a group of eight to form a byte. A byte contains enough information to store a single ASCII character, like "h".

# data[].attributes.body
For a computer to work it needs to have programming and data, the binary system helps to create that, excess data can generate failures in the program.

# data[].attributes.body
For me, the best way to convert binary to decimals and decimals to biant is by using the binary calculator which has 1,2,4,8,16,24,63,128 though 0 and 1.

# data[].attributes.body
In computers, abstraction is a way to hide codes and programs. Through binary you can infuse and include texts within the codes using 1 and 0.

# data[].attributes.body
It is important to know the limitations of the computer as it can lead to overflow and cause issues.

# data[].attributes.body
abstraction in computers, is to hide those codes and programming language that manages to create and look great a page, the binary code helps to create symbols and letters, in order to help create programming languages, the primary code would be like the language mother of computers.

# data[].attributes.body
Read from left to right (from 128 to 1), in each space that is the "1" take into account that these values are what you are going to add with the other vouchers that is represented in 1, example if the 1 It is in the area where it is represented by "2" and in "1", they add it and it would equal 3 bits.

# data[].attributes.body
Try to solve this, (use alphabet) write in the comments.

# data[].attributes.body
The best way for me to convert decimals to binary and binary to decimals is using the binary calculator with the  number of 1, 2, 4, 8, 16, 32, 64, 128 on the top of it, with that I don't have to put everything in my head, all I need to do is either subtracted from the number question gave or added with the top numbers when converting either decimal to binary or binary to decimal, and flipping around the small piece of paper to show 1 or 0

# data[].attributes.body
As we know that the computers store everything in binary,  each letter you type in or picture that shown on the screen were running by the number of 1 and 0, when you type A in the computer, it's ASCII Code is 065, which can be represent by 01000001, but the computer won't show you that, all you see is that when you press the letter A in keyboard, it just shows up when you searching or typing in the word file, which is a type of abstration that computer hides the details and complexity that you cannot see it but it's inside the computer.

# data[].attributes.body
I have to remake it

# data[].attributes.attachment_link.description
Get access to files anywhere through secure cloud storage and file backup for your photos, videos, files and more with Google Drive.

# data[].attributes.body
One of the main limitations of bits in particular is the limitation on storage. There’s only a certain limit of information that a bit can process. If a bit were to store an integer that is greater than the one it can process it will result in an error known as “overflow”. Which will stop the whole program from working.

# data[].attributes.body
computer can't store an infinite sequence, the computer has to end the number somehow, either by chopping it off or rounding to the nearest floating point number, which can cause roundoff error. Rounding error is the difference between a rounded-off numerical value and the actual value.

# data[].attributes.body
Personally the easiest way for me to convert decimal into binary is by using subtraction. You take your number and subtract it by the highest possible number (128,64,32,16,8,4,2,1), then you continue subtracting by the highest number until you are left with zero and every number you subtracted with gets to turn into a 1 and every number that was not subtracted from the total will stay zero.

To convert binary to decimal you use addition. Every number that has been marked by a 1 must be added together and then you will find your decimal number.

# data[].attributes.body
Computers need many transistors to accomplish what they have to accomplish. But through binary numbers, it became easier and less expensive.what that means is that there is less needed of circuitry, less space, energy consumption, and cost.

# data[].attributes.body
The reason Bits and Bytes are so crucial for computer operations is because is the foundation of computer language. Specifically, these tiny bits of information store tiny bits of information using binary code. That code is what makes computers computers and allows us to communicate with computers.

# data[].attributes.body
Binary can encode more they just numbers but also letters and symbols. Storing text in binary shows abstraction by converting a high level programming lanuage into a lower lever one. When you store text you do so by having binary numbers assigned to specfic  number patterns and that wayy you can turn the word CHEF into
1000011100100010001011000110

# data[].attributes.body
Here’s a small educational research by Stanford university, one of the leading technological universities in the country.

# data[].attributes.attachment_link.readable_text
At the smallest scale in the computer, information is stored as bits and bytes. In this section, we'll learn how bits and bytes encode information.

Bit

a "bit" is atomic: the smallest unit of storage

A bit stores just a 0 or 1

"In the computer it's all 0's and 1's" ... bits

Anything with two separate states can store 1 bit

In a chip: electric charge = 0/1

In a hard drive: spots of North/South magnetism = 0/1

A bit is too small to be much use

Group 8 bits together to make 1 byte

Everything in a computer is 0's and 1's. The bit stores just a 0 or 1: it's the smallest building block of storage.

Byte

One byte = collection of 8 bits

e.g. 0 1 0 1 1 0 1 0

One byte can store one character, e.g. 'A' or 'x' or '$'

How Many Patterns With N Bits? (demo)

How many different patterns can be made with 1, 2, or 3 bits?

Number of bits

Different Patterns

1

0 1

2

00 01 10 11

3

000 001 010 011
100 101 110 111

3 bits vs. 2 bits

Consider just the leftmost bit

It can only be 0 or 1

Leftmost bit is 0, then append 2-bit patterns

Leftmost bit is 1, then append 2-bit patterns again

3-bits has twice as many patterns as 2-bits

Number of bits

Different Patterns

1

0 1

2

00 01 10 11

3

000 001 010 011
100 101 110 111

In general: add 1 bit, double the number of patterns

1 bit - 2 patterns

2 bits - 4

3 bits - 8

4 bits - 16

5 bits - 32

6 bits - 64

7 bits - 128

8 bits - 256 - one byte

Mathematically: n bits yields 2n patterns (2 to the nth power)

One Byte - 256 Patterns (demo)

1 byte is group of 8 bits

8 bits can make 256 different patterns

How to use the 256 patterns?

How to store a number in a byte?

Start with 0, go up, one pattern per number, until run out of patterns

0, 1, 2, 3, 4, 5, ... 254, 255

One byte can hold a number between 0 and 255

i.e. with 256 different patterns, we can store a number in the range 0..255

Really good for storing characters/letters.

Bytes

"Byte" - unit of information storage

A document, an image, a movie .. how many bytes?

1 byte is enough to hold about 1 typed character, e.g. 'b' or 'X' or '$'

All storage is measured in bytes, despite being very different hardware

Kilobyte, KB, about 1 thousand bytes

Megabyte, MB, about 1 million bytes

Gigabyte, GB, about 1 billion bytes

Terabyte, TB, about 1 trillion bytes (rare)

Bytes and Characters - ASCII Code

ASCII is an encoding representing each typed character by a number

Each number is stored in one byte (so the number is in 0..255)

A is 65

B is 66

a is 96

space is 32

"Unicode" is an encoding for mandarin, greek, arabic, etc. languages, typically 2-bytes per "character"

32 space
33 !
34 "
35 #
36 $
37 %
38 &
39 '
40 (
41 )
42 *
43 +
44 ,
45 -
46 .
47 /
48 0
49 1
50 2
51 3
52 4
53 5
54 6
55 7
56 8
57 9
58 :
59 ;
60 <
61 =
62 >
63 ?
64 @

65 A
66 B
67 C
68 D
69 E
70 F
71 G
72 H
73 I
74 J
75 K
76 L
77 M
78 N
79 O
80 P
81 Q
82 R
83 S
84 T
85 U
86 V
87 W
88 X
89 Y
90 Z
91 [
92 \
93 ]
94 ^
95 _
96 `

97 a
98 b
99 c
100 d
101 e
102 f
103 g
104 h
105 i
106 j
107 k
108 l
109 m
110 n
111 o
112 p
113 q
114 r
115 s
116 t
117 u
118 v
119 w
120 x
121 y
122 z
123 {
124 |
125 }
126 ~

Typing, Bytes, and You

Each letter is stored in a byte, as below

100 typed letters takes up 100 bytes

When you send, say, a text message, the numbers are sent

Text is quite compact, using few bytes, compared to images etc.

Numbers in Computers

One byte works well for individual characters, but computers are also good at manipulating numbers.

Integers are typically stored with either 4 or 8 bytes
4 bytes can store numbers between -2147483648 and 2147483647
8 bytes can store numbers between -9223372036854775808 and 9223372036854775807

Adding in binary is just like normal addition with carrying
But when you run out of bits you can't carry anymore
Leftmost bit indicates sign, so carrying to the leftmost bit changes a number ffrom positive to negative.
So adding 1 to 2147483647 goes to -2147483648!
Called Integer Overflow
Integer Overflow and Gangam Style

# data[].attributes.attachment_link.description
At the smallest scale in the computer, information is stored as bits and bytes. In this section, we'll learn how bits and bytes encode information. a "bit" is atomic: the smallest unit of storage A bit stores just a 0 or 1 "In the computer it's all 0's and 1's" ...

# data[].attributes.body
Explanation about bits and bytes

# data[].attributes.attachment_link.readable_text
The reason computers use the base-2 system is because it makes it a lot easier to implement them with current electronic technology. You could wire up and build computers that operate in base-10, but they would be fiendishly expensive right now. On the other hand, base-2 computers are relatively cheap.

So computers use binary numbers, and therefore use binary digits in place of decimal digits. The word bit is a shortening of the words "Binary digIT." Whereas decimal digits have 10 possible values ranging from 0 to 9, bits have only two possible values: 0 and 1. Therefore, a binary number is composed of only 0s and 1s, like this: 1011. How do you figure out what the value of the binary number 1011 is? You do it in the same way we did it above for 6357, but you use a base of 2 instead of a base of 10. So:

Advertisement

(1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (1 * 2^0) = 8 + 0 + 2 + 1 = 11

You can see that in binary numbers, each bit holds the value of increasing powers of 2. That makes counting in binary pretty easy. Starting at zero and going through 20, counting in decimal and binary looks like this:

 0 =     0
 1 =     1
 2 =    10
 3 =    11
 4 =   100
 5 =   101
 6 =   110
 7 =   111
 8 =  1000
 9 =  1001
10 =  1010
11 =  1011
12 =  1100
13 =  1101
14 =  1110
15 =  1111
16 = 10000
17 = 10001
18 = 10010
19 = 10011
20 = 10100

When you look at this sequence, 0 and 1 are the same for decimal and binary number systems. At the number 2, you see carrying first take place in the binary system. If a bit is 1, and you add 1 to it, the bit becomes 0 and the next bit becomes 1. In the transition from 15 to 16 this effect rolls over through 4 bits, turning 1111 into 10000.

Bits are rarely seen alone in computers. They are almost always bundled together into 8-bit collections, and these collections are called bytes. Why are there 8 bits in a byte? A similar question is, "Why are there 12 eggs in a dozen?" The 8-bit byte is something that people settled on through trial and error over the past 50 years.

With 8 bits in a byte, you can represent 256 values ranging from 0 to 255, as shown here:

  0 = 00000000
  1 = 00000001
  2 = 00000010
   ...
254 = 11111110
255 = 11111111

In the article How CDs Work, you learn that a CD uses 2 bytes, or 16 bits, per sample. That gives each sample a range from 0 to 65,535, like this:

    0 = 0000000000000000
    1 = 0000000000000001
    2 = 0000000000000010
     ...
65534 = 1111111111111110
65535 = 1111111111111111

Next, we'll look at one way that bytes are used.

# data[].attributes.attachment_link.description
The reason computers use the base-2 system is because it makes it a lot easier to implement them with current electronic technology. You could wire up and build computers that operate in base-10, but they would be fiendishly expensive right now. On the other hand, base-2 computers are relatively cheap.

# data[].attributes.body
The significance of binary number sis that it is the basic structure of computer/computing,

# data[].attributes.body
A binary digit (or a bit) is the smallest data unit in computers. Computers operate in binary, meaning they store data and do calculations using only 0s and 1s.

# data[].attributes.body
Converting binary to decimal. I hope this helps a bit

# data[].attributes.body
explains binary data

# data[].attributes.attachment_link.readable_text
In this post I'm explaining data as it truly exists in our computers. If you've ever wondered how a sequence of 1 and 0 results in meaningful information, this article is for you.

All data in a computer is represented as a sequence of ones and zeros. Depending on where the data lives - RAM, SSD, HDD, DVD etc. - ones and zeros are encoded differently physically, but conceptually it's two distinguishable states - and that's all there really is.

Hard drives and computer memory just stores ones and zeros. Photo by Patrick Lindenberg on Unsplash

One such piece of data - a zero or one - is called a . Eight bits make a . Bytes are relevant as a unit, because - generally speaking - they are the smallest addressable units of memory.

Suppose you have 40 bits of data, so 5 bytes:

01001000 01100101 01101100 01101100 01101111

You can request to read or write data in one of those bytes by specifying an offset from the starting point. You always read or write one whole byte at a time, not individual bits. Therefore most information - barring compression mechanisms - is encoded in bytes as basic units, not bits.

By the way, at the end of the article you'll be able to get back to the 40 bits above, and figure out what they mean. When you get there, try coming back and look at it. You'll figure it out. I promise.

A mixture of historical and practical reasons.

I'll try and hint at underlying practical concerns. Let's take a step back for a second: for us, multiplying or dividing by powers of 10 is trivial by just appending zeros or shifting the decimal point, right?
3.1415 ✕ 100 = 314.15
That's true in our decimal system - a numeric system based on powers of 10.

Computers do binary arithmetic internally. Binary arithmetic is based on powers of 2. In binary arithmetic, powers of 2 like 8 = 2³ are equally convenient.

Let's look at an example in binary arithmetic:

13 ✕ 8 = 104 corresponds to 00001101 ✕ 1000 = 01101000

It is just shifting the input by three bits to the left. Don't try to understand the encoding yet. Just observe that the result was trivially computed by shifting digits to the left.

In summary: if the size of data units is a power of 2, such as 8 = 2³, many internal calculations a computer needs to do are much simpler than they would be otherwise.

Good question. There was no official standardization regarding kilobytes, megabytes, gigabytes, etc. until 1998. Nevertheless, these units were widely used among tech people and consumers alike. You bought a hard drive, the size of it was given in gigabytes.

People in tech were counting 2¹⁰ = 1024 bytes per kilobyte, 1024 kilobytes per megabyte, 1024 megabytes per gigabyte and so on. As we learned, powers of 2 is the practical thing to use when you're working with computer memory.

Famously, marketing people selling hard drives had the ingenious idea that lacking an official standardization, they could just claim that 'their' units are based on 1000, and therefore 'their' gigabyte is 1000³ = 1,000,000,000 bytes - instead of 1024³ = 1,073,741,824, so they could shortchange you on space. The bigger the drive, the more of a difference.

You bought your 500GB hard drive and kept wondering why your computer kept claiming it was only 465.66 GB.

Well, standardization eventually happened in 1998. Unfortunately, corporate greed became the official standard, and the original units based on 2¹⁰=1024 became 'bi' units: kibibytes, mebibytes, gibibytes, etc. To make matters worse, the usual short forms, KB, MB, GB, etc. got absorbed as well. The original base-2 units are now KiB, MiB, and GiB.

It's kibibytes, not kilobytes. You're a professional. Sound like a Teletubbie!

Outside academia most tech folks still understand a kilobyte to be 1024 bytes. The software world got split, and some companies started adopting this 'standard', some did not. Some let you choose.

But I digress.

Let's look at a sample byte value: 01101101

Read the value out loud and repeat it from memory. Not super easy, is it?

When communicating binary data to humans, ones and zeros are terribly inefficient. Let's divide a byte value into two groups of 4 bits each- these groups are called nibbles - and assign a symbol to all bit patterns a nibble can take.

Instead of the bit pattern, we can start using the symbols. Our byte value 01101101 becomes 6D.

This is called hexadecimal notation - hex for short - because there's 16 different symbols. Also, since there is the potential of ambiguity with decimal numbers, hex values are often prefixed with 0x to remove that ambiguity. So we're looking at 0x6D.

That's not an interpretation yet, just a more compact way of writing - and saying - the value.

Whatever the ones and zeros stand for depends entirely on context.

"So what is the information content of 0x6D?"

"It's a pattern of ones and zeros"

"Yeah, but what does it mean?"

"It's just ones and zeros"

"I see"

If you were to interpret 0x6D as an ASCII character, it would be m. If you were to interpret it as a two's complement number, it would be 109. If you were to interpret it as a fixed point number with 3 fractional digits, it would be 13.625.

When given a piece of binary data, you generally have to be given the context to make any sense of it. For text files, it's the encoding, which these days is mostly UTF-8 - an ASCII-compatible encoding for text characters. For other types of files, say a PNG file, you have to look up the meaning of the data in a corresponding file format specification.

The first and default interpretation of a byte - or a sequence of bytes - is as a positive integer. When interpreting byte values, the documentation will often imply that you know how to read bytes as integers.
From the PNG file format spec:

"The first eight bytes of a PNG datastream always contain the following (decimal) values:

137 80 78 71 13 10 26 10"

So ... what is the bit pattern for these decimal values? Let's stick to our 0x6D value for a while. We'll find out. The hex value 0x6D is the number 109, but how do I know this?

We're used to our base 10 decimal system. But the choice of 10 as base and 0-9 as digits is totally arbitrary.

We're just animals with 10 fingers on our hands, and that's making the quantity both familiar and mechanically convenient when counting - say livestock or sacks of rice. The number 10 is not inherently special, it's just practical to us as human beings.

The decimal system

When we write numbers down, we write a digit in range of 0-9 for each power of our base 10, starting with 10⁰ on the right. We're adding digits to the left for additional powers of 10 as long as we need them to express our number.

numbers in the decimal system

The octal system

We could go with a smaller base of 8 instead using digits 0-7. It's called the octal system. It's not a totally dreamed up example. It's actually used. Maybe you've seen it in the context of file permissions on Linux systems. Just as hex numbers are often prefixed with 0x to remove ambiguity, octal numbers are often prefixed by 0.

numbers in the octal system

The hexadecimal system

So we went from 10 down to base 8. We can also go up, to say base 16. We'll run into trouble with the digits, though.

We need digits for 0-15 and past 9 we don't have established conventions. Let's use the hex digits: A=10, B=11, C=12, D=13, E=14, F=15

numbers in the hexadecimal system

The binary system

The choice of base is entirely arbitrary as long as we have agreed-upon digits to hand. Let's go full minimalist and use base 2, with digits 0-1.

numbers in the binary system

Integer summary

Now you see how 01101101, 0x6D, and 109 are all different notations for the same integer. And now it should make sense how looking at an ASCII table like this, they are indexed using various formats. It's just a courtesy so you can look up the character using an index in whatever system you happen to have at hand.

Open a text edit editor, create a new file, put "Hello World" in it and save it as a simple text file.

Now get a hex editor. A hex editor is just a file editor that does not interpret the contents of a file for you -it just shows you the raw binary content. Any basic, free hex editor is fine. You can use an online hex editor as well.

Open your text file in your hex editor. It will show you the binary content of the file. It should look something like this.

A hex editor typically shows you three columns: the offset from the beginning of the file (usually in hex), the binary contents of the file (also in hex), and a third column shows the file's bytes interpreted as ASCII characters.

If your file contents have some additional bytes at the beginning, it's likely that your text editor saved a BOM in your file. Don't worry about it.

Remember our 40 bits from before? You now know everything yon need to figure out what that says.

01001000 01100101 01101100 01101100 01101111

We have the basics down. The following topics each deserve an article of their own. But we're already running short on space, time, and reader's attention, so I'm pointing you towards resources to peruse at a later time.

I know you still have questions! 🤓

So far we've talked about positive integers only, limiting ourselves to one byte at a time. But...

"How about encoding integers bigger than 255? There is not enough bits in a byte to store higher values. And what about negative numbers?"

Good questions. You use consecutive bytes of a fixed length - 2 bytes, 4 bytes, and 8 bytes are customary - and that extends the powers of 2 you have available. You use two's complement encoding for signed integers.

Most non-toy calculators come with normal, scientific and programmer views .Turn on the "programmer's view" on your calculator when looking into this stuff.

Once you start using more than one byte to represent a value, endianness becomes important, especially when reading bytes from files or the network, so keep that in mind.

So far we've been talking about whole numbers only. What about:

π=3.1415926535...

There's a standardized, hardware supported representation of floating point fractional numbers. The most commonly used versions are 4-bytes single precision, often called ' float', and the 8-bytes version which is commonly called ' double '.

The general idea is as follows:

The sign is stored in the leftmost bit. 0 stands for positive, 1 indicates a negative number. Our example number is positive.

Shaded red, a fractional number is given as 1 plus a sum of selected negative powers of 2 - so halves, quarters, eights, etc.... In the example above we have a bit set only in the quarters position. So the fractional number is 1.25

Note that the fractional number will always be between 1.0 inclusive and 2.0 exclusive.

In the next step you calculate an exponent given by the bits shaded green. Our exponent is 124. The standard dictates that we multiply our fractional number by 2^(exp-127), so in our case we multiply by 2^-3 = 1/8.

Finally he number encoded by our bit pattern is:
1.25 × 1/8 = 0,15625
You might be wondering how to effectively convert decimal numbers to floating point numbers with this encoding. In practice, you never have to do it manually, and the ecosystem - like your programming language standard library - takes care of it for you.

Oh, and regarding π, try interpreting this pattern:

0 10000000 10010010000111111011011

You might also be wondering just how precise the approximation to decimal fractions is, now that we're using halfves instead of tenths. Many people do, even the folks who make Excel.

Our data is just ones and zeros. The way it is grouped and interpreted makes it meaningful. In this If you're ever asked to work with binary data, you should now have enough information to properly understand the documentation that comes with it.

To test your understanding, try looking at the shape file format spec and see if it makes any sense.

# data[].attributes.attachment_link.description
In this post I'm explaining data as it truly exists in our computers. If you've ever wondered how a sequence of 1 and 0 results in meaningful information, this article is for you. All data in a computer is represented as a sequence of ones and zeros.

# data[].attributes.body
There arent many limitations when it comes to storing numbers but one of the main issues are integer overflow. Overflow refers to the binary number being equal to more then the largest positive integer. When it goes above the maximum integer it will either be capped and result as the maximum integer or it might wrap around and become 1.

# data[].attributes.body
Binary numbers is the language that use the computer, it created the words, symbols, and other things that we can write on any electronic/digital object, or picture using bits create colors on the electronic/digital object, is like one alphabet, with the alphabet can conjugate and create words and conjugate each other.

# data[].attributes.body
8 space (sequence) represent 1bit

# data[].attributes.body
There are each sequence that can have a word and a bit

# data[].attributes.body
Binary Numbers are extremly significant to computers. They make up the basis of computers and are the reason we are able to use them. Due to binary numbers we are able to see pictures,color and be able to write on a computer.

# data[].attributes.body
In Binary Date represent with 0 and 1, true and false, black and white etc... It can created pictures, sound and words, each sequence of numbers (0 and 1) created it, like this picture:

# data[].attributes.body
The significance to Binary numbers is its basically the backbone to every computer and what the computer reads and stores.

# data[].attributes.body
From the video I learned that any number, image, and sound can be changed into 1s and 0s which is the backbone to a computer.

# data[].attributes.body
We learned alot of infromation from the videos.
1 Byte=8 Bits
Everything can be singled down to binary numbers. Wether is data,pictures or sound. Pictures are made up of pixels which use binary for the number value of the pixel color.