Computer Hardware
Mix.install([
{:jason, "~> 1.4"},
{:kino, "~> 0.9", override: true},
{:youtube, github: "brooklinjazz/youtube"},
{:hidden_cell, github: "brooklinjazz/hidden_cell"}
])Navigation
Home Report An Issue Start HereCommand LineReview Questions
Upon completing this lesson, a student should be able to answer the following questions.
- How does the processor, memory, and storage device of a computer affect the performance of our programs?
- How are program instructions executed on the Stack?
Overview
Computers are composed of several parts. As programmers, we are primarily concerned about the processor, and the memory.
The processor determines the computer’s speed when performing calculations.
Memory or RAM (random access memory) determines the amount of data we can store during a calculation.
In software terms, this translates to the speed and memory consumption of our program. Generally as you build software, those are your main performance concerns.
It’s not within the scope of the course to provide an indepth understanding of computers and computer hardware. Here’s a great primer by Tom Scott to understand more about what your computer is doing under the hood.
YouTube.new("https://www.youtube.com/watch?v=Z5JC9Ve1sfI")Memory
We store information in memory. We can think of memory as a series of cells that can each store some value.
The string “hello” might be stored in memory like so.
Under the hood, memory is stored in electrical signals called bits.
Each bit represents 1 or 0 as an on or off value for an electrical signal.
Eight bits are grouped together to make bytes. See Strings and Binaries for more.
Memory is generally measured in kilobytes (1024 bytes) megabytes (1024 kilobytes) and gigabytes (1024 megabytes).
Since they use the metric system, you might expect each to increase by 1000 instead of 1024.
However, computers use binary numbers, so hardware is built based on powers of 2.
Stack Vs Heap
Memory is divided into several parts.
The stack holds functions and variables as they execute.
The heap is a free memory resource where we can put pretty much any value that we want.
For example, when you define the variable hello and bind it to "world", hello is stored
on the stack and it points to the location of memory in the heap.
hello = "world"
Stack Frames
The stack is a LIFO (last in first out) queue. Instructions stored on the stack create stack frames.
As we execute functions, they are stored in a stack frame.
The last function to be added onto the stack will be the first one executed and removed from the stack.
That’s why in the code below, three/0 executes, then two/1, then one/1.
one = fn _ -> IO.inspect("one") end
two = fn _ -> IO.inspect("two") end
three = fn -> IO.inspect("three") end
one.(two.(three.()))Stack Overflow
The stack has a limited amount of memory allocated to it. When we over-allocate memory on the stack we get stack overflow. For example, if we continued executing functions in functions eventually the stack would (generally) run out of space.
Memory Consumption
Whenever we create a value it is stored in memory. If the value is too large, it can consume more memory than is available on the heap (or is allocated to the program).
For example, loading a large file’s contents into memory is a performance concern.
You can see the memory this livebook consumes in the Runtime Settings panel. Press s then r to open
the settings panel.
Uncomment the line below and evaluate the cell. You’ll notice that the amount of memory consuption
by Processes should increase. That’s because the list must be stored in memory.
Comment the line again and re-evaluate the cell and you’ll notice that the memory consuption
goes down because the list is no longer in memory.
# list = Enum.to_list(1..1000000)
For more on Memory, there is a more indepth video by Crash Course Computer Science.
YouTube.new("https://www.youtube.com/watch?v=fpnE6UAfbtU")Storage
Generally, we are more concerned about the memory consumption of our program. However, if our application requires that users download large files onto their computer, it’s useful to be aware of storage.
Files can be saved to the hard drive (or solid state drive in more modern computers) of a computer. The hard drive is a slower (but generally larger) storage device. Unlike memory, it is often used for persistent values rather than values which only exist during the runtime of the program.
For more on memory and storage, you can watch this video by Crash Course Computer Science.
YouTube.new("https://www.youtube.com/watch?v=TQCr9RV7twk")CPU
The CPU (Central Processing Unit) executes the instructions that you create in your program.
When you perform any operation such as 2 + 2 it is handled by the CPU.
The more instructions you provide to your program, the more work the CPU has to perform. If there are too many instructions, then the program will take longer to execute.
For example, it’s far faster to perform ten addition operations than it is to perform ten million.
Try evaluating the two cells below and notice how the first is far faster (nearly instant).
> You don’t need to understand the specifics of Enum and that works yet. The only important difference between these examples is the size of the data. The first is for 10 elements, the second is for 10_000_000.
Enum.map(1..10, fn each -> each + 2 end)Enum.map(1..10_000_000, fn each -> each + 2 end)For more on the CPU there is an great video by Crash Course Computer Science.
YouTube.new("https://www.youtube.com/watch?v=FZGugFqdr60")Conclusion
Performance issues can significantly impact a program, leading to slowness or even crashing. Always consider your program’s processing and memory constraints and how this might affect your users.
In addition, performance issues generally have a more significant impact on lower-quality computers. Thus, your program may be performant on your personal computer but cause problems on lower-performance hardware.
Commit Your Progress
DockYard Academy now recommends you use the latest Release rather than forking or cloning our repository.
Run git status to ensure there are no undesirable changes.
Then run the following in your command line from the curriculum folder to commit your progress.
$ git add .
$ git commit -m "finish Computer Hardware reading"
$ git pushWe’re proud to offer our open-source curriculum free of charge for anyone to learn from at their own pace.
We also offer a paid course where you can learn from an instructor alongside a cohort of your peers. We will accept applications for the June-August 2023 cohort soon.