The idea of encapsulation is fundamental to computers in a number of ways. Generally speaking, “encapsulation” refers to the idea of building a container around something, as if that thing were contained in a capsule. When it comes to computers, there are a couple of slightly different ways the term might be used.<\/p>\n
Commonly in computer programming, encapsulation refers to the idea of hiding away the details of code. For example, you may write a bit of Python code that takes three coefficients for a quadratic equation a, b, and c, and calculates the real roots (solutions) of that equation:<\/p>\n
a = 2\r\nb = 4\r\nc = -5\r\nroot1 = (-b + ((b * b) - (4 * a * c)) ** (1 \/ 2)) \/ (2 * a)\r\nroot2 = (-b - ((b * b) - (4 * a * c)) ** (1 \/ 2)) \/ (2 * a)<\/pre>\nIf you were having to write lots of programs to calculate quadratic roots, or if you wanted to be able to use those lines of code other places, you might very well write them into a small function or method called something like
quadratic_solver<\/code> that you could use in lots of different places. You might call that function like this:<\/p>\n
roots = quadratic_solver(2, 4, -5)<\/code><\/p>\nIn this single line of code, the messy details of multiplying, dividing, and square-rooting have all been hidden away from the main program. The details of that calculation have been “encapsulated” in the function.<\/p>\n
Any time you import a library into your program–
import java.util.Scanner;<\/code> in Java, for example, orimport random<\/code> in Python–you are bringing in complicated bits of code that will be available for you to use without having to worry about some of the arcane, or mundane, or complex details that are contained in that code. The concept of encapsulation is extraordinarily powerful.<\/p>\nProgramming languages: Machine code, Assembly, High-level<\/h2>\n
A second way of considering encapsulation is less obvious, but one that we use all the time.<\/p>\n
High-level languages<\/h3>\n
You have almost certainly seen computer programs written in some “high-level” language like Python or Java. These languages are called high-level because they, for the most part, consists of syntax that might be recognized and understood.<\/p>\n
Here’s a program that’s written in C, which adds up the numbers from 0 to 255 and prints out the result:<\/p>\n
# include\r\n\r\nint main(void)\r\n{\r\n int x, sum;\r\n sum = 0;\r\n x = 1;\r\n while (x < 256)\r\n {\r\n printf(\"%d \",x);\r\n sum = sum + x;\r\n x = x + 1;\r\n }\r\n printf(\"\\nSum = %d\\n\", sum);\r\n}<\/pre>\n You may not understand everything in this program, but it certainly has a few English words in it, and even a programmer who doesn’t know C might be able to work their way through this program to identify how it works.<\/p>\n
We have a serious problem, however. You may have heard that computers don’t understand English: they only work in binary digits, or “bits,” the zeroes and ones that are represented by a billion switches being turned “off” or “on.”<\/p>\n
So how does the computer run this program?<\/i><\/p>\n
It doesn’t. But there is another program on the computer–a compiler–that is able to take this program and convert it to something called Assembly Language.<\/p>\n
Assembly Language<\/h3>\n
In Apple’s macOS, if you have the Developer Tools installed, you can use the gcc<\/b> compiler in the Terminal to output a compiled version of the program.<\/p>\n
$ gcc -o sum sum.c<\/code><\/p>\nWhat does this new version of the program look like? We can see the Assembly Language version by using the otool<\/b> program:<\/p>\n
$ otool -tv sum
\nsum:
\n(__TEXT,__text) section
\n_main:
\n0000000100000f10\tpushq\t%rbp
\n0000000100000f11\tmovq\t%rsp, %rbp
\n0000000100000f14\tsubq\t$0x20, %rsp
\n0000000100000f18\tmovl\t$0x0, -0x4(%rbp)
\n0000000100000f1f\tmovl\t$0x0, -0xc(%rbp)
\n0000000100000f26\tmovl\t$0x1, -0x8(%rbp)
\n0000000100000f2d\tcmpl\t$0x100, -0x8(%rbp)
\n0000000100000f34\tjge\t0x100000f65
\n0000000100000f3a\tleaq\t0x65(%rip), %rdi
\n0000000100000f41\tmovl\t-0x8(%rbp), %esi
\n0000000100000f44\tmovb\t$0x0, %al
\n0000000100000f46\tcallq\t0x100000f84
\n0000000100000f4b\tmovl\t-0xc(%rbp), %esi
\n0000000100000f4e\taddl\t-0x8(%rbp), %esi
\n0000000100000f51\tmovl\t%esi, -0xc(%rbp)
\n0000000100000f54\tmovl\t-0x8(%rbp), %esi
\n0000000100000f57\taddl\t$0x1, %esi
\n0000000100000f5a\tmovl\t%esi, -0x8(%rbp)
\n0000000100000f5d\tmovl\t%eax, -0x10(%rbp)
\n0000000100000f60\tjmp\t0x100000f2d
\n0000000100000f65\tleaq\t0x3e(%rip), %rdi
\n0000000100000f6c\tmovl\t-0xc(%rbp), %esi
\n0000000100000f6f\tmovb\t$0x0, %al
\n0000000100000f71\tcallq\t0x100000f84
\n0000000100000f76\tmovl\t-0x4(%rbp), %esi
\n0000000100000f79\tmovl\t%eax, -0x14(%rbp)
\n0000000100000f7c\tmovl\t%esi, %eax
\n0000000100000f7e\taddq\t$0x20, %rsp
\n0000000100000f82\tpopq\t%rbp
\n0000000100000f83\tretq<\/code><\/p>\nThis version of the program contains a series of commands–
push<\/code>,move<\/code>,jump<\/code>,add<\/code>,call<\/code>,pop<\/code>,return<\/code>–that manage the data in the program, addresses in memory (listed along the left side), and registers (like%esi<\/code>). Some people program in assembly language, but you can see that it’s a much more complicated affair. The process of storing the value1<\/code> in the variablex<\/code> is, in assembly language<\/p>\n
movl\t$0x1, -0x8(%rbp)<\/code><\/p>\nWe can say that the assembly language instructions are “encapsulated,” or hidden away, so that we don’t have to worry about those implementation details. We can write our high-level code, and rest assured that the compilation process will take care of the dirty work for us.<\/p>\n
Of course, we still haven’t gotten down to the 0s and 1s that the computer needs to run a program. Let’s go one step farther down.<\/p>\n
Machine Language<\/h3>\n
In the process of compiling, we actually created a binary version of the program, with nothing but 0s and 1s. We can use the
xxd<\/code> program in the terminal to view that code:<\/p>\n
$ xxd -b sum | cut -c 11-64
\n11001111 11111010 11101101 11111110 00000111 00000000
\n00000000 00000001 00000011 00000000 00000000 10000000
\n00000010 00000000 00000000 00000000 00001111 00000000
\n00000000 00000000 10110000 00000100 00000000 00000000
\n10000101 00000000 00100000 00000000 00000000 00000000
\n00000000 00000000 00011001 00000000 00000000 00000000
\n01001000 00000000 00000000 00000000 01011111 01011111
\n01010000 01000001 01000111 01000101 01011010 01000101
\n01010010 01001111 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000001 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00011001 00000000 00000000 00000000
\n11011000 00000001 00000000 00000000 01011111 01011111
\n01010100 01000101 01011000 01010100 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000001 00000000 00000000 00000000 00000000 00010000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 00000000 00010000 00000000 00000000
\n00000000 00000000 00000000 00000000 00000111 00000000
\n00000000 00000000 00000101 00000000 00000000 00000000
\n00000101 00000000 00000000 00000000 00000000 00000000
\n00000000 00000000 01011111 01011111 01110100 01100101
\n01111000 01110100 00000000 00000000 00000000 00000000
\n.
\n.
\n.
\n<\/code> <\/p>\nIt is this code–these 1s and 0s–encapsulated several layers below our original version, that the computer uses to run the program.<\/p>\n
These 0s and 1s are used to operate the digital hardware, the memory locations and the logic gates, that produce a given output. In fact, before we had keyboards, mice, and monitors, the personal computer was simply a set of switches with lights above them. Computer code was entered using the individual switches–a long, painful, error-prone process–and output was read from the computer as a series of flashing lights.<\/p>\n
Here’s a programmer entering a program by hand onto such a machine<\/a>. The resulting program displays (in binary, of course!) the prime numbers between 2 and 255.<\/p>\n
Fortunately, we don’t have to enter binary logic instructions by hand. Those codes are encapsulated well beneath our high-level languages.<\/p>\n","protected":false},"excerpt":{"rendered":"
The idea of encapsulation is fundamental to computers in a number of ways. Generally speaking, “encapsulation” refers to the idea of building a container around something, as if that thing were contained in a capsule. When it comes to computers, there are a couple of slightly different ways the term might be used. Hiding code … Continue reading Demo: Encapsulation<\/span>