Explore how computer systems store, manipulate, and convert various data types like text, images, and videos through integrated software and hardware. Gain insights into accessible data representation.

Computer systems do not understand human instructions, nor can they perceive real-life data in its raw form. Therefore, computer systems require a way to store and represent information in an accessible way. They use software and hardware components combined to help retrieve information, store it, manipulate it, and convert it back to a human-accessible format. If you want to learn how computer systems perform complex tasks such as storing and manipulating textual data, videos, music, images of your cat, and much more, this course is meant for you.

Information Representation in Computer Systems

# How is data stored in memory?
To store one bit of data in memory, we use a circuit, called a latch, that remembers or stores the previous input unless it is reset. We can create such a circuit in many different ways, shown below.

The S-R latch, or a set-reset latch stores one bit of memory, i.e., 0 or 1. It uses two NOR gates that are attached in a way that the output of one feeds back to the input of another. The truth table for an S-R latch is given in Table 1. Q and Q$'$ are complementary outputs. When one is 0, the other is 1 and vice versa. Q represents the bit being stored by the latch, while Q$'$ is its complement. 

| R  |  S |  Q |  Q' |
| - | - | - | - |
|  0 |  0 | Latched  | Latched  |
|  0 |  1 |  1 | 0  |
|  1 |  0 | 0  | 1  |
|  1 |  1 | Not stable  |  Not stable |
Table 1. Truth table for an S-R Latch.


<!DOCTYPE html>
<html>
  <head>
    <script src="https://unpkg.com/konva@7.0.5/konva.min.js"></script>
    <meta charset="utf-8" />
    <title>Not Gate</title>
    <style>
      body {
        margin: 0;
        padding: 0;
        overflow: hidden;
        background-color: #ffffff;
      }
    </style>
  </head>
  
  <body>
    <div id="container"></div>
    <script>
      
      var width = window.innerWidth;
      var height = window.innerHeight;

      //Draw image on the container
      function drawImage(imageObj) {
        var stage = new Konva.Stage({
          container: 'container',
          width: width,
          height: height,
        });

      //Layer
      var layer = new Konva.Layer();

      var background = new Konva.Image({
          width: 600,
          height: 180,
          x: 125,
          y: 20,
          image: back,
          opacity: 0.3,
        });
      layer.add(background);

      var nor_gate1 = new Konva.Image({
          width: 60,
          height: 36,
          x: 402,
          y: 47,
          image: nor,
        });
      layer.add(nor_gate1);

      var nor_gate2 = new Konva.Image({
          width: 60,
          height: 36,
          x: 402,
          y: 138,
          image: nor,
        });
      layer.add(nor_gate2);
      
      function createRect(x, y, fill, t, p) {
        var rectangle = new Konva.Rect({
          x: x,
          y: y,
          width: 32,
          height: 32,
          fill: fill,
          stroke: 'black',
          strokeWidth: 2,
        });
        layer.add(rectangle);

        var textNode = new Konva.Text({
          x: x+p,
          y: y+10,
          text: t,
          fontSize: 14,
          fontFamily: 'Calibri',
          fill: 'black',
        });
        layer.add(textNode);
        
        return rectangle;
      }
      
      input1 = createRect(219, 49, '#FFFFFF', 'R', -30);
      input2 =  createRect(219, 140, '#FFFFFF', 'S', -30);

      output1 = createRect(596, 49, '#FFFFFF', 'Q', 55);
      output2 =  createRect(596, 140, 'yellow', 'Q\'', 55);

      input1.on('click', function () {
        var fill = this.fill() == 'yellow' ? '#FFFFFF' : 'yellow';
        this.fill(fill);
        layer.draw();

        var fill2 = this.fill() == '#FFFFFF' && output2.fill() == '#FFFFFF' ? 'yellow' : '#FFFFFF';
        output1.fill(fill2);
        layer.draw();

        var fill3 = input2.fill() == '#FFFFFF' && output1.fill() == '#FFFFFF' ? 'yellow' : '#FFFFFF';
        output2.fill(fill3);
        layer.draw();
      });

      input2.on('click', function () {
        var fill = this.fill() == 'yellow' ? '#FFFFFF' : 'yellow';
        this.fill(fill);
        layer.draw();

        var fill2 = this.fill() == '#FFFFFF' && output1.fill() == '#FFFFFF' ? 'yellow' : '#FFFFFF';
        output2.fill(fill2);
        layer.draw();

        var fill3 = input1.fill() == '#FFFFFF' && output2.fill() == '#FFFFFF' ? 'yellow' : '#FFFFFF';
        output1.fill(fill3);
        layer.draw();
      });

      input1.on('mouseover', function () {
          document.body.style.cursor = 'pointer';
          this.strokeWidth(4);
          layer.draw();
        });
        input1.on('mouseout', function () {
          document.body.style.cursor = 'default';
          this.strokeWidth(2);
          layer.draw();
      });

      input2.on('mouseover', function () {
          document.body.style.cursor = 'pointer';
          this.strokeWidth(4);
          layer.draw();
        });
        input2.on('mouseout', function () {
          document.body.style.cursor = 'default';
          this.strokeWidth(2);
          layer.draw();
      });
      
      function createLine(obj1, obj2, x1, y1, x2, y2) {
        var arrow = new Konva.Line({
          points: [obj1.getX()+x1, obj1.getY()+y1, obj2.getX()+x2, obj2.getY()+y2],
          pointerLength: 10,
          pointerWidth: 10,
          fill: 'black',
          stroke: 'black',
          strokeWidth: 1,
        });
          layer.add(arrow);
      }

      i1_nor1 = createLine(input1, nor_gate1, 32,9,0,10.5);
      i2_nor2 = createLine(input2, nor_gate2, 32,25,0,26.5);      

      nor1_o1 = createLine(nor_gate1, output1, 50, 18.5, 0 ,16);
      nor2_o2 = createLine(nor_gate2, output2, 50, 18.5, 0 ,16);

      var loop1 = new Konva.Line({
          points: [nor_gate1.getX(), nor_gate1.getY()+26, nor_gate1.getX(), nor_gate1.getY()+40, 504, 146, 504, 157],
          pointerLength: 10,
          pointerWidth: 10,
          fill: 'black',
          stroke: 'black',
          strokeWidth: 1,
        });
      layer.add(loop1);

      var loop2 = new Konva.Line({
          points: [nor_gate2.getX(), nor_gate2.getY()+11, nor_gate2.getX(), nor_gate2.getY(), 504, 76, 504, 65],
          pointerLength: 10,
          pointerWidth: 10,
          fill: 'black',
          stroke: 'black',
          strokeWidth: 1,
        });
      layer.add(loop2);

      function createConnector(x1, y1, x2, y2) {
        var arrow = new Konva.Line({
          points: [x1, y1, x2, y2],
          pointerLength: 10,
          pointerWidth: 10,
          fill: 'black',
          stroke: 'black',
          strokeWidth: 1,
        });
          layer.add(arrow);
      }

      i1 = createConnector(199, 65, 219, 65);
      i2 = createConnector(199, 156, 219, 156);

      o1 = createConnector(628, 65, 648, 65);
      o2 = createConnector(628, 156, 648, 156);



      stage.add(layer);
      }

      var back = new Image();
      back.onload = function () {
        drawImage(this);
      };
      back.src = '/udata/1QxzbB5Qpkg/background_latch.png';

      var nor = new Image();
      nor.onload = function () {
        drawImage(this);
      };
      nor.src = '/udata/Mw9ER0YQo5y/NOR.png';
      
      var xor = new Image();
      xor.onload = function () {
        drawImage(this);
      };
      xor.src = '/udata/nPV0MLV5mwy/XOR.png';
      

    </script>
  </body>
</html>

codemirror

To store 0, set the reset signal to 1 and the set signal to 0. That's when the value of Q$'$ turns to 1 (switched off). Likewise, to store 1, set the reset signal to 0 and the set signal to 1. That's when the value of Q is set to 1 (switched on).

Once the reset $(R)$ state and set $(S)$ state are both turned to 0, the data is latched or stored inside the memory. In the initial state shown on the circuit below, the memory has stored $0$ since Q$'$ is on.

When both the reset and set signals are set to 1, the circuit enters an *unstable state*. While it initially sets both Q and Q$'$ to 0, if you now enter the latch state with reset and set state both equal to 0, you will get different results.

In this lesson, you will learn how to store one bit and eight bits of data in memory.

Computer basics

Hardware and Software Components of a Computer

Data Representation in Python

Image, Audio, and Video Representation in Python

Data Compression

Storage Unit

How is data stored in memory?

S-R latch