Of course that the simplest answer to the question on the title of this article is: “you get to see a web site?”. But on this case let’s try to go deeper into the concept and find out the details within the entire process that happens between you type your web site address (and in this article and for exemplifying purposes we will be using https://holbertonschool.com), hit the “Enter” key and you finally get to see the web site of your choice.

www.holber… what?

Holberton School is a software learning institution based in San Francisco and I am writing this blog as a requirement for their curricula. Here´s a screenshot of the main page from Microsoft Edge:

Web browsers such as Edge, Chrome or Firefox take text strings (because at the end of the day www.holbertonschool.comor any other web site name is a text string) and directs you to the web site that corresponds with that string.

Now, in order to match the text string it receives with a corresponding web site (with the web site IP address in fact, more about that later), what the browser will do is to parse the text string and divide it in smaller chunks it can identify and relate to something else. The break up goes like this:

In the case of the complete addresswww.holbertonschool.com, the different components are broken down in this way:

https— This is the PROTOCOL, spcifically HTTPS (HyperText Transfer Protocol Secure). This is the data transfer method used between the client and server.

www.holbertonschool.com- the DOMAIN name that matches the web site specific IP address.

The PORT is the specific port of the server where the request will be sent. As in the example we are not actually metioning an specific port, HTTPS will use the default assigned one which is port 443.

PATH AND FILE NAME of the file we are requesting within the server. As it is also being left blank in the example this means that we are querying the server at its root.

We could, of course, provide the browser with the exact IP (Internet Protocol) address of the server we want to access, but human brains are notoriusly bad at remembering large combinations of numbers, while we can easily remember text strings as long as they match actual words from the human-used languages.

DNS (Domain Name System) is what we use to make the text strings we use as domain names, to match specific IP addresses on the server side.

So, again, when we type www.holbertonschool.com and press Enter, we are telling our browser that we want to access the file located at the root directory of the server that hosts www.holbertonschool.com. Moreover, we are also indicating the browser to contact the server using HTTPS protocol through port number 443.

A remarkable feature of browsers, is that they have a cache memntlyreory that allows them to “remember” the information they have previously processed. This cache memory stores recently called domain numbers, along with the matching IP addres for each one.

If the browser already has the domain name stored in its own cache, it will bring up the IP address with no further steps, but if the domain name is not then teh browser will search for it within the main Operating System cache. If the domain name is not here neither, then something called the DNS resolution process must start.

DNS resolution process.

Having failed to match the received domain name in both, its own cache and the operating system’s cache, the browser then sends the domain name off to the nearest resolver server, which most of the times will be your ISP or Internet Service Provider, to be resolved into its IP through the Domain Name System.

Now, DNS is a complex process on itself. If you´d like to learn more about it, I highly recommend the extremely effective yet funny explanation on this link.

The resolver contacts both the top-level domain server (.com, in our case) and domain registrar before successfully matching the domain name into its corresponding IP address. At the end of the process, the browser finally knows the specific IP address that corresponds to our web site www.holbertonschool.com.

TCP/IP.

Having figured out the IP address of the web site, the browser will start communicating with the server. This communication will most likely be based on TCP/IP, which stands for Transmission Control Protocol/Internet Protocol, as this protocol is the standard in use on applications where instant delivery (such as streaming) IS NOT required. This is because TCP guarantees delivery regardless of it taking longer than instant protocols such as UDP (User Datagram Package).

SSL

Now that the browser has established communication with the IP address, the first thing it does is sending a message containing its Transport Layer Security (TLS) version. TLS is an encryption method used to keep the privacy and reliability of the trasferred data. While nowadays TLS is the new standard, the original and traditionally used method was SSL which stands for Secure Socket Layer. Even though TLS is being used now, we keep using the “S” from SSL to complete the HTTPS acronym.

After receiving the TLS version from the browser, the server will choose its preferred TLS algorithm and method and respond with a security certificate that includes the server TLS public key. The browser then uses this public key to encrypt a pre-master key that is sent back to the server.

When the server receives the browser´s pre-master encrypted key, it will try to decrypt it using its own private key. By being able to perform this decryption, the server can then assume that the communication being received is a valid, reliable one, certified by its own public key that was first sent. The browser and the server have now set up a trusted connection.

This security process is known as the TLS handshake. Browsers show a lock icon on the address bar as indication of having established a secure connection.

HTTPS.

Breaking down the acronym, the first four letters: HTTP stands for HyperText Transfer Protocol, and it is the standard protocol for Internet communications. HTTP defines how computers interact with each other.

Following up with the TLS handshake process, after completion of it, the browser sends a HTTP request message to the server. This message must follow a pre-defined format.:

The first line will define what kind of request message we are talking about. On this case this is a GET message, which means it retrieves web content from a server to a client.

In the header section the browser can specify details of the request, such as if the connection to the server should be terminated immediately or not, or whether the server should store cookies (information that would remain on the browser´s cache even after the session is terminated).

The request body is optional, and mostly irrelevant to request messages.

LOAD BALANCER.

Web sites, in particular those that have a heavy traffic, divide their work load between more than just one single physical server. With over half of the world population accessing the Internet and with some hughe web sites that have a semi-monopoly of some internet functions, it is clear that the load must be balanced between multiple servers.

A load balancer is an intermediary software which, well… balances the incoming requests and directs them according to a load balancing algorithm, in the way that the designers of the back end have decided that their servers will respond in the most efficient way. It can be installed on the same server that hosts the requested web content or on a server of its own.

There are many load balancing algorithms being the most commonly used the one called round-robin which sends requests to servers in turn according to a queue.

In real world, web sites are configured with multiple load balancers that are able to back up each other in the event of one of them failing. This is done in order to avoid having what is known as single point of failure, as if there is only one load balancer, the entire system would collapse if it fails.

FIREWALL.

Before the GET request is finally received by the server, the message goes through one last security check: the firewall.

Firewalls are hardware, software, or an implementation of both that filter all traffic coming into and out of a server. TLS is effective for preventing data from being intercepted mid-transmission. Yet, it assumes that received data is coming from a trusted source. Firewalls make no such assumptions, and utilize a combination of packet filters, application gateways, circuit-level gateways and proxy servers to make certain that a packet does not contain viruses or malicious hardware.

HOST SERVER.

The final destination of the GET request. Host servers are web stack consisting on multiple parts. Let´s break them down:

Operating system: the operating system on which the host server runs. According to this article, at this moment (April 2021) 96.3% of the top 1 million web servers in the world run on some distribution of Linux.

HTTP Web Server: This is the software that handles HTTP request/response messages and ultimately delivers the static web page. The most popular and widely used are Apache and Nginx.

The database server: This is the database software, typically SQL-based, that stores information such as user accounts. A typical website will be configured with multiple database servers, with one configured as a “primary” database having exclusive write privileges whose changes are echoed out to “replicant” databases only having read privileges. This setup is referred to as a “primary-replica” model. MySQL is one of the most typically used database software.

Application Server: Application servers are network computers that store and run an application for client computers. Application servers, whatever their function, occupy a large chunk of computing territory between database servers and the end user. Most broadly, this is called “middleware” which tells us something about what application servers do. First and foremost, application servers connect database information (usually coming from a database server) and our browser. PHP and Python are two high-level languages supported by web servers that can handle dynamic content.

It is extremely common that a typical setup would make use of popular open source solutions to build their web stacks. The combination of the most widely used open source solutions for each component: Linux, Apache, MySQL and PHP/Phyton, has given name to what is known as the LAMP model.

Recap:

• A GET request is received by the web server. The web server pulls up the file configured at the given location (in our example, the HTML file configured at the root (/) of the machine).
• If the file contains dynamic content, the application server is run (in a LAMP model the corresponding Python or PHP scripts are run). The result of these scripts is inserted into the web page.
• If the dynamic content involves stored data, the Python scripts queries from the database server.
• The web server delivers the web page.

After pulling up the HTML file configured at the root of www.holbertonschool.com, the host server sent it back to the web browser in a HTTP response message formatted as follows:

“200 OK” in the first line indicates the status code of the request (a succesful request in this case). Other common status codes include 301 (page redirection) and 404 (page not found).

In the response header, the host server states information about the delivered page such as its type (HTML, in our case) and size.

Finally, in the response message body, the host server delivers the actual, entire HTML code itself. Now, utilizing its HTML and CSS engines to parse the code, break it down into its Document Object Model, and render the page. Any JavaScript scripts written in the file are run. Finally the browser displays the Holberton School website home page.

References:

• How DNS works. What is DNS? Learn how step by step.
• ​Can the Internet exist without Linux? | ZDNet
• What Is a Firewall? A Starting Guide to Firewalls and Whether You Need One
• How To Install Linux, Apache, MySQL, PHP (LAMP) stack on Ubuntu 18.04 | DigitalOcean

Historians recognize four different industrial revolutions along history, or at least four different stages in a larger process identified as “the” Industrial Revolution.

The first three are related to the massive use of coal along with steam power, gas and fossil fuels and electronics and nuclear power.

A fourth Industrial Revolution seems to be happening at this very moment empowered by what has been called IoT (Internet of Things). Let’s work out this concept in further detail.

You can learn more about the concept of the fourth industrial revolution from this article in the World Economics Forum website.

So, IoT?

The Internet of Things is about the entire constellation of devices that can connect to The Internet. And every day we figure out ways in which being connected the Internet can optimize the functionality of devices that were traditionally non-internet related, such as a washing machine, a refrigerator, a car or medical care devices.

By being able to connect to The Internet, these devices have the possibility to enhance their capabilities as they can share and receive information from similar devices and control centers from virtually anywhere in the planet.

CCII — Consumer, Commercial, Industrial, Infrastructure.

These are the categories in which the IoT devices are normally classified in.

Consumer:

The range of these products is endless and grows by the minute, but some remarkable examples are home assistants such as Google Nest or Amazon Alexa. These devices are able to interpret voice commands in order to interact (through IoT of course) with a variety of other systems such as a music playlist from a music streaming service or the IoT connected light bulbs in your home if you want to dim your lights.

Another rather recent addition to IoT are cars. In Latin America, the newest line of Brazilian-produced Chevrolet cars include the On-Star system which monitors in real time the current condition of the car including fluid levels, tire conditions and engine temperature. It also allows the user to request emergency assistant in the event of an accident and can schedule service and repair instances as well as order spare parts for the shop to receive them in advance of the scheduled service date.

Some other worth mentioning examples are wearable devices such as the Apple watch or the much more economic Xiaomi Band that can monitor body functions such as your heart rate, blood pressure and even the quality of your sleep. Nowadays we even have “smart” washing machines, which can download washing programs for specific types of clothing based on the world-wide experience of every user in the World. They can also be programmed from anywhere in the planet by accessing a smart phone app or a web-site. You could start your washing machine in one specific program when you are on vacations in the other side of the World.

Commercial:

Public services benefit from IoT by automatizing tasks that were traditionally performed by human operators or analogic systems that were unable to recognize a change in the conditions in which the service needs to be performed.

Think on an automatized toll collection system. The booth can recognize the specific car that comes in, either by reading the license plate or a special tag label on the car windshield and connects to a pre-set payment system to collect the fee and then raises the barrier. This optimizes the traffic flow making it way more agile than if the fee was collected by a human operator through cash payment.

Going back to consumer wearable IoT products such as smart watches that monitor the user’s health, there is the notion of applying the data collected from these devices to feed commercial-oriented medical databases. This application, called the internet of Medical Things, has the potential to revolutionize health care by integrating IoT devices into medical practices. While the information collected by the wearable devices is limited in its applicability, if the same information could be transferred over to a the user medical records accessible by the health care provider, then the scope of the potential uses for the same information expands exponentially.

While consumer IoT devices aim to improve our everyday life, the commercial IoT is becoming increasingly important for public welfare.

Industrial:

The objective of Industrial IoT is to improve the productivity, efficiency and reliability of the industrial process, resulting in economic benefits. By connecting the operational technology, such as the robots that manufacture cars in a factory assembly line, with machine learning and data analytics through IoT, all the industrial supply chain can be optimized as well as the manufacturing process itself, resulting in an improved cost-effective equation. Using industrial IoT platforms, companies connect, monitor, analyze, and act on data in new ways.

One example of successful industrial IoT application is the experience of the oil giant Royal Dutch Shell. The company installed smart monitor sensors on some of their oil extraction fields located in West Africa. These fields were on particular hard-to-access locations with very limited local infrastructure. By being able to perform remote monitor, the company was able to dramatically cut the investment in site visits for maintenance.

An investment on the IoT technology of $87.000 produced an estimated return of over 1 million dollars.

The industrial applications of IoT is what has inspired the historians to define the so called Fourth Industrial Revolution, or Industry 4.0 as it is often referred to. The term Industrie 4.0 is also used as the term originated in Germany. The potential for increased productivity and correlational revenue is appalling, being estimated in several trillion dollars of increased benefits within the next decade alone.

To learn more about Industry 4.0 you might want to check this article from the specialized European media site i-scoop.

Infrastructure:

Considering how IoT can be applied to optimize contained scale projects, if you consider it, there is no reason why it cannot be applied in a larger scale to optimize the administration of an entire city or a country power grid.

This is achieved by using environmental monitoring systems to monitor the quality of air and water, integrating traffic control systems that optimizes traffic flow adapting to the different times of the day and level sensors that monitor the sewage system heights and open and close valves accordingly, in an “smart” optimized way to better adapt to the system capabilities.

Understanding IoT:

IoT or the act of connecting to The Internet through devices that did not originate as internet-enabled requires three different technologies:

- Wireless data protocols.

- Hardware.

- IoT platforms.

Wireless Data Protocols:

Most internet-enabled devices connect to the internet through wireless transmission of data, mainly, but not limited to, through WIFI or Bluetooth.

Hardware:

It is the part of the devices that allow the interaction, either with a user or the internet itself. The hardware may consist of sensors, microphones or network connection unit.

IoT platforms:

IoT platforms manage the data thet IoT devices share with each other. IoT platforms are software solutions that organize the flow of information within specific networks of IoT devices. Some of the most popular IoT platforms today are Microsoft Azure IoT, Google Cloud IoT solutions or Amazon’s AWS IoT.

Considering the appalling amount of interconnected devices available today, the amount of data being shared is beyond huge. This fact is actually the fundamental issue of Big Data, or the limitations of technology to manage incredibly large and complex databases. The response to the challenge of Big Data has been the implementation of cloud computing, or the delivery of computing services over the internet.

Ethical concerns about IoT:

While IoT is making our lives more comfortable, easy and fun and our businesses more efficient and profitable there are valid concerns that must be considered, particularly those referred to privacy and security.

The number of IoT devices is increasing exponentially raging from mobile phones to light bulbs and they all collect and share data which ultimately refers to how each of us live our personal lives. From what web pages you visit and how much time do you spend on each one, all the way to what kind of food you keep on your refrigerator or what kind of workout you enjoy the most. Even your general health condition or well or bad you are sleeping the last few nights. All of this is being shared through your IoT devices.

This is no minor issue. Companies that gather large amount of personal information must make a responsible and ethical use of it, while also making sure that the information they gather is safe and not available for third parties to use it for different reasons than those accepted when it was collected.

A shocking example of lack of security was seen in the 2016 US Elections when the British company Cambridge Analytics was able to harvest data from millions of Facebook users. This data was then used by Donald Trump’s campaign to identify, target and influence potential voters.

When you think about the amount of sensitive personal information that we share through our IoT devices it becomes clear that this kind of misuse of users’ data are simply not acceptable to happen.

While these are valid and very much real concerns, it must also been considered that IoT has been around only for the last decade, so there is a lot yet to do in terms of regulation and control. Ultimately, the unstoppable success of IoT lies in the fact of how it has delivered the intended objectives of this technology. IoT is making our lives more comfortable, easy and fun and we have more than justifiable reasons to believe that the growing rate of IoT will only continue. There are good reasons to be optimistic about the responsible future use of this technology.

References:

• The Fourth Industrial Revolution: what it means and how to respond
• Nest Audio
• 5 Big IoT Initiative Successes for Business Leaders
• Industry 4.0 and the fourth industrial revolution explained
• Android Things client library for Google Cloud IoT Core
• How Trump Consultants Exploited the Facebook Data of Millions (Published 2018)

In order to unfold the concept of recursion in an approachable way, let’s start by clarifying two concepts that need to be really clear before moving any forward: stack and heap.

What is stack?

Stack is a special area of the computer memory which stores temporary variables created by a function. Is stack, variables are declared, stored and initialized during runtime. It is a temporary storage memory. When the task is complete, the memory of the variable will be erased.

What is heap?

The heap is the actual memory space available for the computer’s CPU to use. It is restricted only by the actual physical limits of the computer you are working on.

Ok, and then, what is recursion?

Let’s make use of our good old mate Wikipedia:

“In computer science, recursion is a method of solving a problem where the solution depends on solutions to smaller instances of the same problem. Such problems can generally be solved by iteration, but this needs to identify and index the smaller instances at programming time. Recursion solves such recursive problems by using functions that call themselves from within their own code.”

And that is the key, a recursive function is a function that calls itself.

In order to further explain the concept, let’s use an example of a recursive function that calculates a number (x) taken to the power of a second variable (y).

float _pow_recursion(float x, float y)
{
    if (y == 0)
        return (1);
    if (y < 0)
        return (_pow_recursion(x, y + 1) / x);

    return (_pow_recursion(x, y - 1) * x);
}

For the purpose of this explanation, we will be calling the functions using 2 and 3 as x and y.

_pow_recursion(2, 3).

Let’s imagine four little girls playing throw and catch in a single row. Each girl will pass the ball to the next child down the row. Once the ball reaches the last girl, she passes it back to the girl from whom she received the ball. The ball then reverses all the way back to the beginning of the row up to the first girl again (hey, nobody said it was a fun game).

Forcing an analogy, we can think of the garden (or whatever surface these girls are using for their game) as the heap. This is the entire space available for the game to happen.

Again, forcing an analogy, when we call _pow_recursion(2, 3) the row of girls can be pictured like this:

The ball starts with the girl at the far left of the row and represents the variables passed over to the function: x = 2 and y = 3.

That first girl represents the instantiation of a new process with a stack storing the values of x and y.

Each time a girl passes the ball to the next girl at her right, we will imagine that we are calling again to the function, meaning, the instantiation of a new stack on the heap. Once a girl has received the ball and passed it over to the next, only then we could say that a process has finished and its corresponding stack has been cleared.

Now, this are complying girls. They have been instructed to carry on with the game until they are instructed otherwise and they mean to carry on their orders. As we wouldn’t really like to see them faint in exhaustion we better pass them an specific situation that, when met, it will mean to stop keep passing the ball again and again. As we are actually talking about a recursive function, this condition that would end the process is what we call the base case. Whenever the base case scenario presents itself, the recursive function will stop calling itself over. In the _pow_recursion function we are working with, the base case is represented by the first conditional (if):

if (y == 0)
 return (1)

On our scenario the base case represents the point at which the ball has reached the end of the row, all the way down to the last girl, and is backtracked.

Back to the girls playing in the garden, the starting point of the ball is in the hands of the girl at the far left. At this point the ball represents the variables ‘x’ and ‘y’ with the values 2 and 3 respectively. Which means that the base case scenario is not being met as y is not 0 and the ball is not at the end of the row. Therefore, the ball passes to the next girl.

Again, passing the ball to the next girl at the right is an analogy to calling the function again. Even before the first girl has thrown the ball, she has specified the variables it will pass. In our function, this corresponds to the next conditional (the second 'if’):

if (y < 0)
    return (_pow_recursion(x, y + 1) / x);return (_pow_recursion(x, y - 1) * x);

When the ball reaches the second girl, the function calls itself again, but, this new call will receive different parameters than previously. This is actually essential as, otherwise, if the parameters wouldn’t change, a base case would never be met and our girls would pass the ball over and over for all eternity.

When the ball is still at the hands of the first girl, ‘y’ is equal to 3. As 3 is greater than 0, the girl subtracts 1 from ‘y’ and passes the ball to the next girl. This calls the function again but in this case with the updated value of ‘y’ equals to 2, therefore: _pow_recursion(2, 2).

The process repeats itself for the second girl. As ‘y’ is still different than 0 and the ball has not yet reached the end of the row, the second girls substracts 1 to ‘y’ and passes over the ball to the third girl who will then call _pow_recursion(2, 1).

The ball reaches the third girl. The same process for player 3 is instantiated with a stack with the variables ‘x’ = 2 and 'y’ = 1. Again 'y’ is not 0, so the third girl substract 1 from it and pass the ball to the right

When the ball reaches the fourth girl, the base case is met (finally). The ball is at the end of the row and ‘y’ is now equal to 0.

Let’s remember:

if (y == 0)
 return (1);

Having reached the end of the row, the fourth girl sends the ball back from where it came, now representing the return value 1. A fourth process started when the fourth girl received the ball, but immediately terminates and clears after returning the baseball back the other way.

The ball, now representing 1, is received for a second time by the third girl. Let’s remember the expression within which the third girl 3 threw the ball the first time:

return (_pow_recursion(x, y — 1) * x);

Once she receives 1 from the previous girl, the third girl is ready to terminate. She multiplies the received value by its known x (still accessible within her stack) and keep the game going, throwing the ball back with a return value of 2. The third girl has now thrown the ball in both directions, so her process terminates and stack clears.

The second girl receives the ball for the second time and goes through the same process. She multiples the 2 by their known x (2), and send it to the left again, now with the return value 4. The second girl stack is now cleared.

Finally, the ball gets back to the hands of the first girl. It now has gone the entire length of the game row forth and back. The first girl receives the value 4, multiplies it by its known x (2), and returns the final result 8. The first girl’s stack is cleared, and the entire process is over. The girls can now play something else (hopefully funnier), and the garden where they were playing (heap) can be used for something else.

Wrapping up:

While the example we used here was quite simple, the core concept could be applied to much more complicated functions and would still be valid. A recursive function WILL continue to call itself until a base case is met. This lead us to the evident conclusion that we should be really careful about memory usage when implementing recursive functions, as if the base case is not met, the function will keep keep calling itself causing what is known as stack overflow (which is also the name of probably the favorite website for all programmers in the world). When this happens, our computer, which ultimately has physical boundaries regarding the amount of information it can process, will eventually crash and the process will terminate without returning the expected result.

For further clarity here’s the flowchart to the function we used in this article:

Moving forward into learning software engineering, will inevitable put you against the concept of Object Oriented Programming, or OOP for short.

From Wikipedia:

“Object-oriented programming (OOP) is a programming paradigm based on the concept of “objects”, which can contain data and code: data in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).”

Referring specifically about Python, it is an extremely versatile programming language and that versatility comes from its object-oriented nature. As the title says, everything in Python is considered an object. Everything.

But what does this actually mean for real life purposes? That is what I will be trying to cover next. How objects are actually used to represent values in Python and what actually objects are in Python?

Let’s try to find out.

Types:

An object in Python is, well, an object, a thing. While this doesn’t seem too accurate it is actually true because remember: everything is an object in Python! In a little bit more technical explanation, we could say that an object represents a value that can be referred to by a variable. In the example below, the variable “a” refers to an object representing the value “1”.

>>> a = 1

In Python, all objects have a specific type which can be checked by using the built-in method called, well, type. Going back to the previous example, the type of “a” as it refers to the value “1” is the numeric type “int”:

```>>> a = 1

>>> type(a)

<class ‘int’>

By changing the value of “a” to another type of data, such as a string, the return of the type entry will obviously change to reflect the new type:

>>> a = “pepe”

>>> type(a)

<class ‘str’>

In this case the return is the sequence type “str”.

Identity:

Each object exists within the computer memory somewhere. Therefore, each object exists within a physical memory address. In order to see the memory address of an object, the built-in method “id()” can be used.

>>> a = 1

>>> id(a)

2149256685872

The memory address is shown as a unique integer value which is considered as the identity of the object as long as the object exists.

While any physical memory address is, of course, unique, it is worth mentioning that, in Python, it is possible for two different variables to share the same identity. Comparing memory locations of two different objects can be done by using the “is” operator.

“is” will return “True” if the two compared variables have the same identity and “False” otherwise.

>>> a = 12

>>> b = 21

>>> a is b

False

In this example “a” refers to the physical address of an “int” object (12), while “b” refers to a different memory location of another “int” object (21), therefore, both variables have different identities and the return result is “False”. The same statement could be seen the other way around:

>>> a = 12

>>> b = 21

>>> a is b

False

>>> a is not b

True

While it could be assumed that the operator “==” does exactly the same as “is”, they are not the same as while “is” compares the physical address of two variables, “==” compares their values.

This is also explainable by referencing the difference between assignment and referencing. Assigning a value to a variable is not the same than referencing a variable to another variable which is at the same time assigned to a value.

Immutable objects.

Whenever an instance of an object is created, Python checks if such instance already exists in memory. If it does, the previously existing instance will be re-used. This is much easier to appreciate by using an example:

>>> a = 10

>>> b = 10

>>> a is b

True

>>> id(a)

1469277170256

>>> id(b)

1469277170256

“a” is being assigned to an instance of the “int” object 10. Instead of creating a new instance when assigning “b”, Python checks if a previous instance already exists and then “b” is assigned to it. That is why the “id” operator returns exactly the same identity for both “a” and “b”. This is pretty much the same than assigning “a” to “b”.

>>> a = 13

>>> b = a

>>> a is b

True

>>> id(a)

1573613824688

>>> id(b)

1573613824688

This process of object instantiation in which an instance is “recycled” is only applicable when we are talking about immutable objects.

An immutable object as the name suggests, cannot be changed without changing the identity of the object itself.

All numeric object types (such as int or float) are immutable types in Python. The same goes for strings.

As explained before, immutable objects can be used by more than one variable to refer to them. Take this string example:

>>> a = "Pepe"

>>> b = "Pepe"

>>> a is b

True

>>>

Both “a” anb “b” refer to the same “str” object “Pepe”. This is called aliasing. Whenever two or more variables refer to the same object it can be said that the object is aliased.

The value of immutable type objects cannot change without changing the object identity. Because of that, whenever we change the value that a variable refers to, we are actually changing the object of reference of that variable for a new one.

```>>> a = 15

>>> id(a)

1573613824752

>>> a = 15 + 1

>>> id(a)

1573613824784

Python keeps an internal counter on how many references an object has. Once the counter goes to zero — meaning that no reference is made to the object — the garbage collector in Python removes the object , thus freeing up the memory.

Mutable objects:

Mutability, also as the name suggests, implies that mutable objects can change over time while keeping the same identity than originally.

An example of a mutable type in Python are lists:

>>> list_1 = [1, 2, 3]

>>> list_2 = [1, 2, 3]

>>> list_1 is list_2

False

>>> list_1 == list_2

True

>>> id(list_1)

1573654126208

>>> id(list_2)

1573654942080

On this example we can see in a pretty clear fashion that while list_1 and list_2 have exactly the same value, they are in fact not the same instance (remember that the “==” operator compares values while “is” compares identities). You can see that both lists have different identity values.

Unlike immutable types, when creating an instance for a mutable object type, Python will not do a memory search looking for similar values but will simply create the new instance with a fresh identity.

A mutable object can afterwards, be altered, as many times as you wish, which will not change the object’s identity, as this is not tied to its value.

By using the “append()” method we can modify an existing list. See below:

>>> list = [1, 2, 3]

>>> id(list)

1573654931968

>>> list.append(4)

>>> print(list)

[1, 2, 3, 4]

>>> id(list)

1573654931968

You can see that, even though the list was altered in order to append “4” to it, the identity value remains the same than before the change. This is the main point here. Changing the value of a mutable object will NOT change its identity.

A word about Tuples.

The immutable/mutable distinction in which changing the object’s value will change it identity or not is consistent for all object types but one: tuples.

Tuples are similar to lists, but unlike those, they are immutable objects and you cannot modify the values within a tuple… unless one of the values contained within a tuple is itself a list, which is in fact a mutable object. Something like this:

>>> tuple = (1, [2, 3])

Again, we could use the “append()” method to modify the “[2, 3]” list within the tuple.

>>> tuple = (1, [2, 3])

>>> id(tuple)

1573654891712

>>> tuple[1].append(4)

>>> print(tuple)

(1, [2, 3, 4])

>>> id(tuple)

1573654891712

See that while the list did was modified, the identity of the tuple was not, as it should because remember, it is an immutable object.

Tuples are instantiated as mutable objects. This is done to consider the possibility that values contained in a tuple could change.

Why should I care?

Exactly. What difference does it make the mutable/immutable nature of an object? Quite a lot actually.

Take this function, for instance. It increments a number by 1:

>>> def increment(n):

>>> ... n += 1

If we pass an integer to the function, that “int” value would keep its identity value regardless of being used by the function or not, because “int” objects are immutable — the reference to 1 passed to n in “increment” becomes a new object within the scope of the function, while the variable x retains the identity of 1 beyond it:

>>> x = 1

>>> n = x

>>> n += 1

>>> x

1

>>> n

2

This means that changes made to immutable objects within functions do not register beyond the scope of that function while changes made to mutable objects within functions DO register beyond the scope of the function.

Whenever you are writing a Python program, it is important to keep in mind the mutability properties of the objects that the variables passed to your functions will refer to.

Finally:

As repeated several times along this article, whenever there’s an immutable objects instantiation, Python searches for previously existing objects with the same values before creating new instances. This explain this already seen example:

>>> x = 256

>>> y = 256

>>> x is y

True

So, what about this?:

>>> x = 257

>>> y = 257

>>> x is y

False

>>>

What on Earth is going on here???

This behavior has to do with a specific characteristic of the CPython virtual machine. CPython is the reference implementation of Python. Written in C and Python, CPython is the default and most widely used implementation of the language.

Python is actually checking for pre-existing objects, but it is just searching within a PRE-DEFINED range of objects.

The idea is that certain values are more repeatedly used in programming. By being able to keep in cache these values, CPython reduces significantly the amount of time and memory consumed.

For integers, the range expands from -5 to 256, included, which explains the system reaction when 257 was used.

The pre-definition of these ranges occurs through an assignment of these values to the macros NSMALLPOSINTS and NSMALLNEGINTS.

RECAP:

- Everything is an object in Python.

- Immutable objects cannot change their values without changing their identity.

- When instantiating an immutable object, Python first checks if an object of the same value already exists in memory before instantiating a new instance.

- Mutable objects can change their values without modifying their identity.

- Mutable objects are created with no previous memory check for similar values and have a unique identity.

- Tuples are the only object type that, while immutable, can potentially modify their values.

- Changes made to immutable objects within functions do not register beyond the scope of the function.

- Changes made to mutable objects within functions do register beyond the scope of the function.

What is a class?

A class is a code template for creating objects along with related data and functions. Objects have variables and behavior associated with them. In Python a class is created by the keyword class.

An object is created using the constructor of the class. This object will then be called the instance of the class. In Python we create instances in the following manner

Instance = class(arguments)

Attributes and Methods in class:

A class by itself has no purpose unless there is some functionality associated to it. These functionalities are defined by setting attributes, which act as containers for data and functions related to those attributes. Functions within classes are called methods.

Instance Attribute

An instance attribute is a Python variable that belongs to one specific object. It is only accessible when working from within the object itself and it is defined inside the constructor function of a class.

For example, __init__(self,..).

Class Attribute

A class attribute is a Python variable that belongs to a class instead than to an specific object. Class attributes are shared between all objects within the same class and are defined outside the constructor function __init__(self,…), of the class.

Differences Between Class and Instance Attributes

As mentioned before, class attributes are common to all instances within the class, thus, changing the value of a class attribute will affect every instance of the class that have that attribute. The attribute of an instance on the other hand is unique to that instance.

What are the advantages and drawbacks of each of them

While class attributes are more flexible to declare and call, the downside is that they are available to the entire class. That means that after being called and given different values, it’s final value when called as a return value may be unexpected, as their may be side effects that you were not counting on.

With instance attributes, since they are only available in the scope of the object that created it, it is encapsulated (protected) but the use of the instance attribute is far less flexible than the class attribute.

__dict__

A __dict__ is a dictionary containing the module’s symbol table, or in other words, used to store an object’s attributes. It is created by the execution engine along with the class it belongs to.

How does Python deal with the object and class attributes using the __dict__ ? Basically it contains all the attributes which describe the object in question and it can be used to alter or read the attributes.

The __dict__ documentation says the following:

A dictionary or other mapping object used to store an object’s (writable) attributes.

In fact, if you print out__dict__ for the following example:

#!/usr/bin/python3
class Person:
    """Defines Person class"""

#Class Variable
    class_variable = "Class variable content"

def __init__(self, name, last_name):
        """Constructor method __init__"""

# Instance properties
        self.name = name
        self.last_name = last_name

#str method definition
    def __str__(self):
        """Defines string to return"""

str = self.name + self.last_name
        return(str)

#instance creation
person1 = Person ("Kurt", "Cobain")

#dir print
print("Person __dict__:", Person.__dict__)
print("")
print("person1 __dict__:", person1.__dict__)

You will be able to actually see how the variables are stored in the dictionary for both class and instance

Person __dict__: {'__module__': '__main__', '__doc__': 'Defines Person class', 'class_variable': 'Class variable content', '__init__': <function Person.__init__ at 0x0000028833B58820>, '__str__': <function Person.__str__ at 0x0000028833B588B0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}

person1 __dict__: {'name': 'Kurt', 'last_name': 'Cobain'}

Creating Classes and Instance Pythonic and non-Pythonic

A non-Pythonic way would be like this:

class Square:
    def __init__(self, size=0):     
        if not isinstance(size, int):     
            raise TypeError("size must be an integer") 
     
        if size < 0:           
            raise ValueError("size must be >= 0")     
 
        self.__size = size * size    def area(self):    
       return self.__sizet__width()

The disadvantage comes when we need to modify the code. The pythonic way of doing it would be to use getter and setter property methods.

class Square:
    def __init__(self, size=0):        
        self.size = size    @property    
       def size(self):    
           return self.__size         @size.setter  
       def size(self, value):       
           if not isinstance(value, int):        
               raise TypeError("size must be an integer")    
           if value < 0:          
               raise ValueError("size must be >= 0")   
           self.__size = value        def area(self):      
        return self.__size * self.__size

The advantage of using property allows us to attach code to the self.size attribute and any code assigned the value of size will be called with size in def size.

The more code we write, the more we realize that some parts or chunks of code are repeatedly used in many programs. Something as repetitive like a mathematic operation can be re-used over and over in virtually every program we write.

A library allows us to have those repetitive functions outside the specific programs and be able to utilize them whenever we need. There are huge advantages associated to that, being the most evident not having to re-write the code over an over again every time we need to use the same function.

Libraries are already-compiled and usage-ready functions to be used by any program we write.

In order to insert our code in a library, it must be organized in the following way:

• One or more .c source files containing the code for our functions.
• One or more .h header files containing the types (typedefs, structs) and prototypes of the functions we want to have available for utilization.

library1.c

int sum (int a, int b)
{
 return a+b;
}
int sub (int a, int b)
{
 return a-b;
}

library1.h

#ifndef _LIBRARY_1_H
#define _LIBRARY_1_H
int sum (int a, int b);
int sub (int a, int b);
#endif

Static and dynamic.

In Linux we can create two types of libraries: statics and dynamics.

An static library is “copied” into our program when we compile it. Once we have the executable file for our program, the library is no longer used by it. In fact, we could even delete it and the program would continue to work properly as it has copied everything it requires from the library. By the way, the program would only copy what it requires from the library. If the library contains two functions but only one is called by the program, that would be the only one copied over.

A dynamic library is NOT copied into the program. Whenever we are running our executable, each time the code requires something from the library it will go and get it from there. If the library is deleted, the program will return an error.

What are the advantages and disadvantages of each type of library?

• A program compiled with static libraries is larger, as a copy of everything required from the library is created. For static libraries memory footprints are also larger.
• A program compiled with static libraries can even be moved over to a different computer without the need to move the libraries along with it. In static libraries, once everything is bundled into your application, you don’t have to worry that the client will have the right library (and version) available on their system.
• A program compiled with static libraries is (at least on paper) faster on its execution. When it calls a function from the library, it is actually on its own code. Therefore, there is no need to access the library file to retrieve information from it.
• One drawback of static libraries is, for any change in the static libraries, you have to recompile the main program every time.
• If we change or even remove a static library, already created executables are not affected. However, if we change a dynamic library, executable will be affected. This could be an advantage, if we have amended the library in order to correct an error (as the error will be fixed in all executables).
• Dynamic libraries will conserve memory since each program can access the library without creating an individual copy of the functions.

Ultimately, deciding what type of library will be used is a negotiation between the advantages and inconveniences of each one, affected by the purpose of the software we are designing.

For smaller, simpler programs, static libraries are often used. Dynamic libraries are commonly used for larger programs or system libraries.

In Unix, static libraries are normally named libname.a and dynamic libraries are named libname.so.

Creating static libraries using GNU.

Let’s assume we have a (very) simple C program called lib_mylib.c:

#include <stdio.h> 
void fun(void) 
{ 
  printf("fun() called from a static library"); 
}

We also have a header .h file with the function prototype on it:

#ifndef LIB_MYLIB_H
#def LIB_MYLIB_H

void fun(void);

#endif

In order to create a library (regardless of it being static or dynamic), we must first obtain the .o files from our .c files. The .o or object code files contain the compiled content of the corresponding .c file.

So, in order to create the .o file from the lib_mylib.c program, we must do the following entry:

gcc -c lib_mylib.c -o lib_mylib.o

In order to create the static library we must use the command ar (ar as in archive). This step is to bundle multiple object files in one static library:

ar rcs lib_mylib.a lib_mylib.o

From this point on the library can be called from another program. In order to test this, let’s create a program called driver that uses the newly created static library:

#include "lib_mylib.h"

void main()

{
fun();
}

Let’s then compile it:

gcc -c driver.c -o driver.o

We must link the compiled driver program to the static library. Note that -L. is used to tell that the static library is in current folder.

gcc -o driver driver.o -L. -l_mylib

In the above command it is worth noting that the source code, driver in this case, needs to be listed before the -l flag. The expression, -l combined with _mylib tells the compiler to look for an archive called lib_mylib.a. This is why is so important to use the standard format for naming the libraries.

Finally, we can execute the driver program:

./driver 
fun() called from a static library

Creating dynamic libraries using GNU.

The process starts in a similar way than before, by creating the .o files out of the source .c files. That is done quick and easy with the following command:

gcc *.c -c -fPIC

The -fPIC flag is an instruction for the code to be position-independent. This means that the generated machine code is not dependent on being located at a specific address in order to work. The -c flag ensures that each .o file is not linked yet.

Next step is to enter this command:

gcc *.o -shared -o libname.so

The -shared flag specifies that you intend to create a dynamic library.

Finally we must export the path for libraries for programs to know where to look for the specific library. This is done by using this command:

export LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH

Let’s go a little deeper on this last step.

In Linux, the environment variable LD_LIBRARY_PATH is set of directories where libraries should be searched for first. It tells the dynamic link loader where to search for the dynamic shared libraries an application was linked against. The directories specified in LD_LIBRARY_PATH get searched before the standard locations.

A few useful tools when working with libraries:

The nm command will list symbols from object files, or when used when -D (“D” as in “dynamic”), it will basically show you the content of the library:

$ nm -D libholberton.so
0000000000000b1c T _abs
0000000000000b4f T _atoi
0000000000202048 B __bss_start
                 w __cxa_finalize
0000000000202048 D _edata
0000000000202050 B _end
0000000000000bf4 T _fini
                 w __gmon_start__
0000000000000910 T _init
0000000000000b13 T _isalpha
0000000000000b2e T _isdigit
0000000000000b0a T _islower
0000000000000b25 T _isupper
                 w _ITM_deregisterTMCloneTable
                 w _ITM_registerTMCloneTable
                 w _Jv_RegisterClasses
0000000000000a75 T main
0000000000000ba9 T _memcpy
0000000000000b97 T _memset
                 U printf
0000000000000ae0 T _putchar
0000000000000b37 T _puts
0000000000000b59 T _strcat
0000000000000bba T _strchr
0000000000000b89 T _strcmp
0000000000000b41 T _strcpy
0000000000000a9f T _strlen
0000000000000b67 T _strncat
0000000000000b78 T _strncpy
0000000000000bd7 T _strpbrk
0000000000000bc9 T _strspn
0000000000000be5 T _strstr
                 U write

The ldd command will list the shared libraries required by each program or shared library specified on the command line. You can do this simply by typing ldd and the name of your executable file:

$ ldd len
        linux-vdso.so.1 =>  (0x00007ffd391b8000)
        libholberton.so => /home/vagrant/holbertonschool-low_level_programming/0x18-dynamic_libraries/libholberton.so (0x00007f91da758000)
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f91da388000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f91da960000)

Finally ldconfig is used to create the necessary links and cache to the most recent shared libraries found in the directories specified on the command line, in the file /etc/ld.so.conf, and in the trusted directories (/lib and /usr/lib).

ldconfig checks the header and filenames of the libraries it encounters when determining which versions should have their links updated.

“ls” it is probably the first and most often used command you will learn whenever you start working on a Linux based shell.

In the simplest possible way to say it, the “ls” command is used to list the contents of a directory. When used with no extra arguments within the command line (meaning when you type only “ls” and hit enter), the system response will display a list with whatever files (and sub-directories) exist at that moment within the current directory you are positioned at.

However, as mentioned before, it is possible to customize the “ls” command response by adding arguments to the command line. That’s it, by typing “ls” along with something else before hitting enter. Some (and just some)of the most common arguments that can be passed along with “ls” are shown on the image below:

As the purpose of each single argument that could be used along with “ls” escapes the scope of this article, we will be merely focusing on the instance when “-l” is added to the “ls” command line. The system response to this command + argument (ls -l) concatenation, will be to list the files in the working directory in “long format”.

As seen on the image above, the long display view, displays not only the information on different alignment, but also displays way more information about the directory content, than the regular, no arguments, view.

This is a breakdown of the information shown in the long format response:

• File Name -The name of the file or directory.
• Modification Time -The last time the file was modified. If the last modification occurred more than six months in the past, the date and year are displayed. Otherwise, the time of day is shown.
• Size -The size of the file in bytes.
• Group -The name of the group that has file permissions in addition to the file’s owner.
• Owner -The name of the user who owns the file.
• File Permissions -A representation of the file’s access permissions. The first character is the type of file. A “-” indicates a regular (ordinary) file. A “d” indicates a directory. The second set of three characters represent the read, write, and execution rights of the file’s owner. The next three represent the rights of the file’s group, and the final three represent the rights granted to everybody else. File permissions is a complex topic that would deserve an article of its own.

So far so good? Great, but the original question stands. What REALLY happens when you type “ls -l” and hit enter?

It is a fair question, because so far we have only covered what we get to see on the screen as system response, and that is only half of the answer. There is a whole process waiting to be explained, running on the background.

Once you type the command and hit enter, the system will recognize that you have entered something, which needs interpretation. Have you entered “ls -l” or have you typed “asdasdjkgjiii -156465” which, of course wouldn’t mean anything that the Shell can interpret?

In order to “realize” this, your system will start by creating a single string of characters from your text entry. This is done by using the getline() function. Shell is written mostly in the C programming language. The getline() function is a standard C function that “reads” the command line and creates the resulting string. This string will be then separated using prefixed delimiters, which in the case of “ls -l” is going to be the blank space between “ls” and “-l”. Each resulting individual element recognized after removing the delimiters is now known as a token. All tokens will then be placed in an array of strings. This whole process is known as tokenization.

Alias?

Each token will have to be checked for previously assigned aliases. An alias is a shortcut to a longer command created by the user and not built-in into the shell. It would make a lot of sense not to assign an alias to “ls” as the alias will have priority over the original purpose of the function.

Once checked that “ls” is not an alias, next, the computer checks if tokens are built-in functions or not. A built-in command is a Linux/Unix command which is built into the shell interpreter itself. These commands will always be available in the RAM memory, so that accessing them is bit faster than compared to external commands which are stored on the hard drive.

If the command is a built-in, the shell runs the command directly, without using another program. For example, “cd” is a built-in, however, “ls” is not, so the system needs to find the specific executable file for it.

Once the built-in option has been discarded out, the Shell looks for an executable “ls” file in the “$PATH” variable. “$PATH” is a variable that stores a list of directories that Shell looks through whenever a command is entered. Each path in the “$PATH” variable is searched for the executable that corresponds with the command “ls”. The system will then, invoke the function stat() to check if there is a matching executable in each path.

When the “ls” executable file is located (normally within usr/bin/ls), the Shell invokes the execve() command to run or execute it.

With the execve() function the shell will know the command and arguments required for the execution, as well as where to find them.

This example will execute the “ls” command found in “/usr/bin/ls”, with the “-l” argument.

The function gets executed within a child process by using the fork() function. fork() will create a “child” process and return the output to STDOUT . The “child” process is created by duplicating the calling process. This means that at the time the fork happens, both processes (calling or parent and child) are identical but have different PIDs (process id, a number that identifies each process within the system).

While this occurs, the parent process waits for execution to be completed and the child process is terminated, after which memory is cleared, and the parent process takes over again and waits for the next input from the user.

We can summarize the entire process like this:

1. Shell interprets the command.
2. Shell creates a child process and executes the command on the child process.

fork()
execve()

3. Shell waits for the child process’s completion.

wait()

So, that is pretty much it. Hope it helps somebody out there. Please let any of the authors know if you have any question.

But, what’s an integer?

According to Wikipedia “An integer (from the Latin integer meaning “whole”) is colloquially defined as a number that can be written without a fractional component.”

That means that numbers such as “21”, “189” or “-1824” are integers, while “8.5” , “13 1/2” or “√4” are not. The number “0” (zero) is also an integer.

As we know, computers, in order to understand and store data (such as integer numbers) have to encode such data as binary numbers, which are numbers expressed in the base-2 numeral system. This system is known as base-2 because it only uses two symbols (typically 0 and 1), instead of the 10 symbols used by the decimal system.

A binary number is a sequence of bits. The specific position of the 0’s and 1’s within the sequence of bits creates the representation of the number’s value.

Bit what?

Now, a bit is the most basic unit of the computer memory. Going back to Wikipedia: “The bit is a basic unit of information in computing and digital communications. The name is a portmanteau of binary digit. The bit represents a logical state with one of two possible values. These values are most commonly represented as either “1”or”0", but other representations such as true/false, yes/no, +/−, or on/off are common.”

Physically, there are several ways to store a bit, but ultimately, it depends on the physical device capability to differentiate between two states. Whatever the physical implementation, the important thing to know about a bit is that, like a switch, it can only take one of two values: it is either “on” or “off”.

Eight bits placed together are called a byte. In a 32-bit or 64-bit computer, an integer value is stored in a collection of 4 bytes, or 32 bits.

So, if we consider the integer value “50”, the computer will store it in memory within a collection of bits of value 0 or 1.

The image of the Windows calculator above is actually filtering out all the leading 0’s in the binary value. The actual value stored would be something like this:

00000000 00000000 00000000 00110010

But what happens when representing negative integers such as -50?

Well, negative and positive are the two possible states of an integer value. In binary, each state can be represented by what is called the Most Significant Bit (MSB). The MSB will be the value of the first bit to the left of the binary number. If the integer number is positive, the MSB will have a value of 0, but if the number is negative, the bit is 1.

So -50 will be:

10000000 00000000 00000000 00110010

The problem is that using MSB to represent negative numbers has some important disadvantages, starting with the fact that reserving one bit to represent the negative/positive value of the number reduces the amount of available numbers by one half.

At the same time, using MSB would allow us to represent a value that actually doesn’t exist on decimal numeration such as “-0”. Like this:

10000000 00000000 00000000 00000000

Enters one’s complement:

A possible work around to the reduction of the range of numbers is to utilize the method called one’s complement.

This method represents negative numbers by inverting the values of bits of the number magnitude. In plain English this means to flip all the bit values within the binary number to its opposite. A 1 is placed whenever there was a 0 and vice versa. The signed binary number obtained from the inversion is called complement.

So, again, 50 and -50:

00000000 00000000 00000000 00110010
11111111 11111111 11111111 11001101

While this significantly increases the amount of available numbers, it still has the issue of allowing the representation of a negative 0, which again, doesn’t actually exists:

11111111 11111111 11111111 11111111 (-0???).

What about two’s complement then?

Wikipedia (again): “Compared to other systems for representing signed numbers (e.g., ones’ complement), two’s complement has the advantage that the fundamental arithmetic operations of addition, subtraction, and multiplication are identical to those for unsigned binary numbers (as long as the inputs are represented in the same number of bits as the output, and any overflow beyond those bits is discarded from the result). This property makes the system simpler to implement, especially for higher-precision arithmetic. Unlike ones’ complement systems, two’s complement has no representation for negative zero, and thus does not suffer from its associated difficulties.”

But how?

In a nutshell:

1- Find the binary equivalent for any given decimal.
2- Find the one’s complement of the binary by inverting 0's and 1’s.
3- Add 1 to the one’s complement.

Let’s start again with the integer 50 in binary:

00000000 00000000 00000000 00110010

Now let’s calculate -50 with the one’s complement method:

11111111 11111111 11111111 11001101

Finally we are going to add one (+1 in binary, of course) to -50.

11111111 11111111 11111111 11001101 +

00000000 00000000 00000000 00000001 (this is the binary representation of the decimal integer “1”).

Result:

11111111 11111111 11111111 11001101

The fact that the first bit on the left is a “1” indicates that the number is negative.

The range of integers obtained from using the two’s complement method is the same as the obtained from the one’s complement, but by using the two’s method a negative zero value will not be represented, as “1” it is always added to the complement of zero.

Decimal “0” — 00000000 00000000 00000000 00000000

“-0” (not a thing) — 11111111 11111111 11111111 11111111

addition of 1 -00000000 00000000 00000000 00000001

Result: 00000000 00000000 00000000 00000000 (actually 0!).

So, that are the reasons why computers use two’s complements to deal with negative values.

Hope you enjoyed!

IOCCC (The International Obfuscated C Code Contest) is an annual programming contest for C “obfuscated” code.

Obfuscated code is machine code that is deliberately written to be hardly understood by humans. It can be used for different purposes but it is mainly done for security reasons, by making it obscure to avoid tampering, hide implicit values or conceal the logic used.

In 1986 the award for the category “worst abuse of the C preprocessor” was given to Jim Hague for writing the following piece of code:

Apart from the particular formatting, what jumps to the eye is the number of “unnecessary” macros and the repetitive use of DIT and DAT variations.

If we compile the code at this point we see many warnings. Among them, two for the implicit declaration of __DIT and _DAH. After that step, we can run the code, and as we provide sequences of ascii characters, it returns sequences of “.” and _.

$ ./a.out hello, world

.... . .-.. .-.. --- --..-- .-- --- .-. .-.. -..

This is actually Morse code (the one used in telegraph communications back in XIX century). When decoded it reverses back to HELLO, WORLD.

Let’s first try to perform the pre-processor job and replace the macros by their values. After a bit of reformatting, this is what we have:

char _DAH_[]=”ETIANMSURWDKGOHVFaLaPJBXCYZQb54a3d2f16g7c8a90l?e’b.s;i,d:”;
main()
{
char *_DIT, *DAH_, *DIT_, *_DIT_, *malloc (), *gets();
for (_DIT = malloc(81), DIT_=_DIT++; _DIT == gets(_DIT); __DIT(‘n’))
   for (DAH_=_DIT; *DAH_; __DIT(*_DIT_ ? _DAH(*DIT_ ) : ‘?’),__DIT(‘ ‘),DAH_++) 
     for (*DIT_ = 2, _DIT_ = _DAH_; *_DIT_ && (*_DIT_ != (*DAH_ >= ‘a’ ? *DAH_&223 : *DAH_ )); (*DIT_ )++,_DIT_++)
         *DIT_+= (*_DIT_>=’a’ ? *_DIT_ — ‘a’ : 0);
}
_DAH(DIT_)
{ 
__DIT(DIT_> 3 ? _DAH(DIT_>>1) : ‘’);
return DIT_ & 1 ? ‘-’ : ‘.’;
} 
__DIT(DIT_) char DIT_;
{
(void) write (1,&DIT_,1);
}

We see the three functions we expected: main, _DAH, and __DIT. We also see an external variable __DAH__ , a long string. __DIT is like the putchar function from the standard library, printing a char at a time.

And what about _DAH ?

As long as the argument is a number that takes more than 2 bits to write, it calls the function again, stripping the number from its last bit. The output will be part of the argument printed as — and . masking for 1 and 0 , i.e. the number in binary format, and it will return the second leftmost digit. As an example, if we call _DAH(5) , 5 being 101 in binary, it will call _DAH(2) . That is the base case. it prints (nothing) and return 10 & 1 == 0 so . . Then it will print . and return 101 & 1 == 1 so -. If we want to print that we have to call __DIT(_DAH(5)) which outputs .- which actually corresponds to 3 written in binary. _DAH(n) is a rather obfuscated function, which will not print/return n in binary but n — 2 .

The main function

char code[]=”ETIANMSURWDKGOHVFaLaPJBXCYZQb54a3d2f16g7c8a90l?e’b.s;i,d:”;
main ( )
{
char *line, *letter, *value, *code_copy, *malloc ( ),* gets ( );
    for (line = malloc(81), value= line++; line == gets(line); putchar(‘n’))
     {
     for (letter = line; *letter; putchar(*code_copy ? _DAH(*value) : ‘?’), putchar(‘ ‘), letter++)
         {
         for (*value = 2, code_copy = code; *code_copy && (*code_copy != (*letter >= ‘a’ ? *letter & 2
23: *letter)); (*value)++, code_copy++)
             {
              *value += (*code_copy >=’a’ ? *code_copy — ‘a’: 0);
             }
         }
     }
}

The outer loop: Each time the user enters a new line, it creates a buffer, and reads a line from the standard input to the buffer. The function either returns the buffer it takes as an argument or NULL in this case. This loop also assigns an address to value which it will use in the inner loop. This loop will print a new line after completion of the two inner loops.

The middle loop: it will loop through each letter in the string obtained above. As it moves from one letter to another, it will either print it using _DAH seen above or print a ? and add a space. As we looked at _DAH above, we used integers as arguments. It works fine as letters, ASCII characters like *value to be more precise, and are small integers in C.

The inner loop: it sets the value of *value to 2, and look at the value of the letter at this point. ((*letter >= 'a') ? *letter & 223 : *letter) means if the letter is lower case, use its upper case version. The octal 233 or 10010011 serves as a mask to change the one bit that is different for a lowercase letter than an uppercase. Of course 223 is not the most obvious one 137 would more easily come to mind. Knowing this, we can realize this inner loop will iterate as long as the *letter variable does not have a match in the code string. As it iterates, it will increase *value by 1 and move on to the next letter in code . Interestingly, if at one point in this process, the letter in code is lowercase, the loop will increase *value by some special number.

Going from a letter to its Morse code: globally, the inner loop starts with a *value = 2 and increase it by 1 each time the iteration moves on to the next letter in code until the letter in code is the letter in my line. It will then print *value using _DAH . Let’s see some examples:

*letter = 'E' then *value = 2 and since E is the first letter in code it goes back to the middle loop and calls putchar(*code_copy ? _DAH(*value) : '?')` . Value of *code_copy == 'E' here so expression above becomes putchar(_DAH(2)) As seen above _DAH(2) returns/prints the binary value of 0as ‘.’ and ‘-’. The output of this expression will be . This is indeed the Morse code for E.

*letter = 'I' then to start *value = 2 , since I is the third letter in code the inner loop will exit with *value == 4 . putchar(_DAH(4)) will print out .. , the Morse code for I.

We can observe a pattern, as the order chosen for the letters in code is such that the letters have Morse codes that are equal to the binary values of their index in the code string plus 2. Of course, this is not perfect. Remember the inner loop special cases ? If *code == 'a' , the loop will skip that *value or said otherwise, this *value or index does not map any Morse code. If *code == 'b' , the loop will skip that *value and shift by 'b' — 'a' == 1 , which means from the on, the Morse code for the letters in code will map the value of their index in the string plus 3. An so on, next comes a d which will shift that new mapping by 'd' — 'a' == 3 .

(This article applies for UNIX systems only.)

What is a C static library?

A C library is just a set of named functions.

Static libraries (also known as archives) have been around as long as C itself. Like a .zip file, they’re just a bag of object files — containing functions, of course — with a table of contents in front giving the address of each name. Static libraries are created from object files using a librarian utility of some kind. One such programs is ar (ar as in archive).

Functions in static libraries are joined to a program’s main module by a static linker at build time to produce an executable program. The executable incorporates the libraries’ object code into its own body, making it completely self-sufficient.

Why using them?

One major advantage of static libraries being preferred even now is speed. There will be no dynamic querying of symbols in static libraries. Many production line software use static libraries even today.

There are several advantages to statically linking libraries with an executable instead of dynamically linking them. The most significant advantage is that the application can be certain that all its libraries are present and that they are the correct version. This avoids dependency problems, known colloquially as DLL Hell or more generally dependency hell. Static linking can also allow the application to be contained in a single executable file, simplifying distribution and installation.

With static linking, it is enough to include those parts of the library that are directly and indirectly referenced by the target executable (or target library). With dynamic libraries, the entire library is loaded, as it is not known in advance which functions will be invoked by applications. Whether this advantage is significant in practice depends on the structure of the library.

In static linking, the size of the executable becomes greater than in dynamic linking, as the library code is stored within the executable rather than in separate files. But if library files are counted as part of the application then the total size will be similar, or even smaller if the compiler eliminates the unused symbols.

How to create static libraries?

To create a static library, we need to specify to the compiler, which is GCC in our case, that we want to compile all library codes (*.c) into object files (*.o) without linking. To do that we are going to use the command below.

Note that the “*.c” matches all files in the current working directory with the “.c” extension.

For example, let us take two c files, add.c, and mul.c and a header file that contains the prototypes of these functions. The picture below shows the output generated after using the command.

Once we have object file(s), we can now bundle all object files into one static library.
To create a static library or to add additional object files to an existing static library, we have to use the ar (archiver) program. We can use a command like this:

This command creates a static library named “libname.a” and puts copies of the object files “add.o” and “mul.o” in it. The ‘c’ flag tells ar to create the library if it doesn’t already exist. The ‘r’ flag tells it to insert object files or replace existing object files in the library, with the new object files.

In order to actually use the newly created static library we can use the command below to create our final executable program:

When using GCC we must use the following flags to create the static library:

• -L : specifies the path to the library .We can use -L in order to point to the current directory and -L/home/tmp to point to the /home/tmp directory.
• -l : adds the library’s name to the list of object file names given to the linker.

This will create a program using the object file “main.o”, and any symbols it requires from the “name” static library.

After a library archive is created, or modified, there is a need to index it. This index is later used by the compiler to speed up symbol-lookup inside the library, and to make sure that the order of the symbols in the library won’t matter during compilation. The command used to create or update the index is called 'ranlib'.

Cheers!