Foundations of Computer and Python Programming

I recently had a conversation with someone who's always been fascinated by computers and software, curious about what it all entails. Thinking back to my own journey, especially my early days studying to become a security engineer, I realized how much foundational knowledge clicked into place with those first few chapters. So, I thought I'd put together some notes, blending what I learned from my own studies with my practical understanding, to explain what computers are and how they really listen to us. This is for anyone like that person I met, perhaps someone who's spent their career in nursing, meticulously managing patient care plans, or in social work, orchestrating complex support systems. You already understand structured processes, and that's exactly what programming is all about.

What Computers Really Do

At its heart, a computer is an incredibly versatile tool, capable of doing almost any job we tell it to. It achieves this through something called a program. Think of a program as a highly detailed care plan or a precise social work protocol: it's a step-by-step set of instructions that a computer follows to perform a specific task. We commonly refer to these collections of instructions as software. The person who designs, creates, and tests these instructions is known as a programmer or software developer. Just as a nurse develops a care plan to guide patient recovery, or a social worker devises an intervention strategy, a programmer builds software to guide a computer's actions.

The Inner Workings

Every computer, whether it's the device you're reading this on or a complex server I monitor for security, is made up of two main parts: hardware and software.

Hardware refers to all the physical devices that make up the computer system. It's a collection of components working together, much like a well-organized medical team or a coordinated social service agency. The main parts include the Central Processing Unit, main memory, secondary storage, and devices for input and output.

The Central Processing Unit (CPU): This is often called the "brain" of the computer, but it's important to understand it's not truly "smart" in a human sense. The CPU is the crucial part that actually runs programs, executing each instruction. Without it, no software can run. What used to be massive machines filling entire rooms are now tiny microprocessors etched onto small chips. The CPU is designed to perform very simple operations on data, like reading information, adding numbers, subtracting, multiplying, dividing, moving data between locations, or comparing values. It has a specific instruction set, which is the complete list of operations it knows how to do. Each brand of CPU has its own unique instruction set, so an instruction for one type might not be understood by another.
Main Memory (RAM): This is where the computer temporarily stores a program while it's actively running, along with any data the program is currently using. It's called Random Access Memory, or RAM, because the CPU can quickly access data from any location in it. Think of it like a nurse's immediate workspace: notes for the current patient, medication charts, and active patient data are all at hand, but they're only there for the shift. RAM is volatile memory, meaning its contents are erased as soon as the computer is turned off. For a security engineer, understanding RAM's temporary nature is key when dealing with active system processes and volatile memory forensics.
Secondary Storage Devices: Unlike RAM, secondary storage can hold data for much longer periods, even when the computer has no power. Programs are typically stored here permanently and then loaded into main memory when they need to run. This is like keeping patient archives in a secure, long-term records facility rather than just on the current shift's clipboard. Common types include disk drives (which store data magnetically on spinning disks), solid-state drives (faster, with no moving parts, storing data in solid-state memory), and flash memory (portable, like USB drives).
Input Devices: These are the components that collect data from people or other devices and send it to the computer. Examples familiar to anyone are keyboards, mice, touchscreens, scanners (perhaps for digitizing patient forms), and cameras. Even disk drives can act as input devices when they load programs or data into main memory.
Output Devices: Once the computer processes data, it needs to present the results. Output devices format and display this data for people or other devices. This could be text, images, audio, or a raw data stream. Think of a video display showing a patient's vital signs, a printer generating discharge summaries, or a disk drive saving a completed social work report.

Software, on the other hand, is the collection of programs that control everything the hardware does. There are two broad categories:

Application software: These are the programs that make a computer useful for everyday tasks. For a nurse, this might be charting software or an email program; for a social worker, it could be a case management system or a web browser. Games, word processors, and spreadsheets are other common examples.
System software: These programs control and manage the basic operations of the computer itself.
- The operating system is the most fundamental set of programs, controlling the hardware components (like Windows, macOS, or the system running a hospital's network).
- Utility programs perform specialized tasks to enhance computer operations or safeguard data, such as virus scanners (crucial for a security engineer!), file compression, or data backup programs.
- Software development tools are the programs programmers use to create, modify, and test other software, including things called assemblers, compilers, and interpreters.

How Computers Store Information

Every piece of data stored in a computer, whether it’s a patient's name, a case number, or a complex security log, is ultimately converted into sequences of just two symbols: 0s and 1s. This is the binary numbering system.

A computer's memory is divided into tiny storage spots called bytes. One byte is just enough memory to store a single letter or a very small number. Each byte is further divided into eight even smaller components called bits. A bit is like a tiny electrical switch that can be either "on" (representing a 1) or "off" (representing a 0). So, when you see a series like 10011101, that's how a computer stores a number like 157. Each position in a binary number has a value based on powers of 2 (1, 2, 4, 8, and so on), and you add up the values for every position that has a '1' to find the total. To store larger numbers, computers simply use more bytes.

For text, characters are first converted to a numeric code, and then that code is stored in memory as a binary number.

ASCII (American Standard Code for Information Interchange) was historically the most important coding scheme, defining codes for 128 characters, primarily for English letters, punctuation, and other symbols. For instance, the uppercase letter 'A' is stored as the number 65.
Because ASCII was limited, Unicode was developed. It's an extensive encoding scheme compatible with ASCII but capable of representing characters from many of the world's languages, becoming the industry standard today.

Beyond basic numbers, computers use special encoding techniques for more complex data. Negative numbers are stored using a method called two's complement, and numbers with fractional parts (like 3.14159) are stored using floating-point notation. Anything that stores data as binary numbers is called digital. Digital images are made of tiny colored squares called pixels, each converted to a binary number representing its color. Digital music is composed of samples, each converted to a binary number. From a security standpoint, understanding these low-level data representations is foundational for analyzing raw data, encrypted files, or network packets.

The Life of a Program

When we write a program, we're giving the CPU a list of instructions. Since the CPU only understands machine language (those sequences of 0s and 1s), and writing directly in machine language is extremely tedious and prone to error, other languages were invented to make our lives easier.

Early on, assembly language was created. Instead of binary numbers, it uses short, easy-to-remember words called mnemonics for instructions (like add for addition, mul for multiplication). A special program called an assembler then translates this assembly language into machine language for the CPU to execute. Assembly language is considered a low-level language because it's still very close to machine language and requires a deep understanding of the CPU's internal workings.

Thankfully, high-level languages emerged. These languages use words and structures much more intuitive and closer to human language, allowing us to create powerful programs without needing to know the intricate details of how the CPU works. Python is one such language, renowned for its readability and simplicity. For example, to display "Hello world" in Python, you just write print('Hello world'). Doing that same task in assembly language would involve many more lines and a detailed understanding of how the CPU interacts with display hardware.

Every programming language, including Python, has its own structure:

Keywords (or reserved words) are predefined words that have a specific meaning in the language and cannot be used for anything else (like print, if, for).
Operators are symbols that perform operations on data, such as the + sign for addition.
Syntax refers to the strict set of rules that must be followed when writing a program. Just like in social work, specific protocols must be followed for certain interventions; if you misspell a keyword or miss a punctuation mark, the program won't run. A mistake in these rules is called a syntax error.
An individual instruction in a high-level language is called a statement.

Since the CPU only understands machine language, our high-level language programs need to be translated. This is done by either a compiler or an interpreter.

A compiler translates the entire program into a separate machine language program (called an executable file) all at once. This machine language program can then be run directly whenever needed.
Python uses an interpreter, which is a program that both translates and executes the instructions in a high-level language program. As the interpreter reads each individual instruction, it converts it to machine language and immediately executes it. This process repeats for every instruction in the program. The instructions a programmer writes are called source code. If the interpreter encounters a syntax error, it stops and tells you exactly where the mistake is.

The Fetch-Decode-Execute Cycle: The CPU's Rhythm This cycle is fundamental to how a CPU operates, like the continuous assessment-intervention-evaluation loop in nursing or social work. When a program is run, it must first be copied from secondary storage (like your hard drive) into the computer's main memory (RAM). The CPU then repeatedly performs three core steps for each instruction in the program:

Fetch: The CPU reads the next instruction from memory and brings it into its internal workings. Imagine a nurse fetching the next step from a patient's printed care plan.
Decode: The CPU then decodes this fetched instruction to figure out exactly what operation it needs to perform. This is like the nurse interpreting a medical abbreviation or a social worker understanding a specific policy clause.
Execute: Finally, the CPU performs the operation that the instruction specifies. This could be adding two numbers, moving data, or sending a signal to an output device. This is the action, like administering medication or making a referral. This cycle repeats millions of times per second, allowing the computer to carry out even very complex tasks by breaking them down into these simple, rapid steps. From a security standpoint, understanding this cycle is critical for analyzing malware execution, identifying unusual process behaviors, or understanding how an exploit manipulates CPU instructions.

Setting Up Your Workspace

Before you can write any programs, Python needs to be installed on your computer. Without the Python language interpreter on your computer, none of the code we've discussed, or any program you write, can actually run. Once it's there, you can interact with Python in a couple of ways:

Interactive mode: This is fantastic for quick tests. When you start the Python interpreter in this mode, you'll see a >>> prompt, indicating it's ready for you to type a Python statement. You can type an instruction, press Enter, and get an immediate result. It's like having a quick conversation with your computer, testing a hypothesis on the fly.
Script mode: For anything beyond a quick test, you'll write your Python instructions in a text file, usually ending with the .py extension (e.g., my_program.py). This file contains all your source code. You then tell the Python interpreter to execute this entire file. These saved files are often called "scripts".

This video explains this initial setup. It guides you through downloading Python 3.9 or a later version from the official www.python.org/downloads website. The instructions are primarily tailored for MacOS.

Once Python is installed, you need a comfortable place to write and test your code. This is where IDLE (Integrated Development and Learning Environment) comes in. IDLE is not a separate download; it is automatically installed along with the Python language. IDLE is a single program that provides everything you need to write, execute, and test your Python code.

IDLE offers several features to make your coding life easier. One noticeable feature is color coding: Python keywords appear in orange, comments are displayed in red, and string literals show up in green, while the names of functions and classes are in blue . This visual distinction helps make your code much easier to read and allows you to quickly spot potential errors. IDLE also provides automatic indentation, which helps keep your code organized and correctly structured . This is especially important in Python, where indentation is not just for neatness but actually defines how your code runs. Should you make a mistake in your code's grammar, called a syntax error, IDLE will report it, guiding you to correct the issue . This immediate feedback is invaluable, much like an alert on a patient monitor signaling an issue or a flag in a system indicating an incomplete form.

Expanding Your Toolkit

As you progress in programming, you will quickly realize that Python's basic features, while powerful, cannot do everything. To handle more specialized tasks, you need to bring in additional sets of code, called modules. A module is essentially just a file that contains Python code, often a collection of related functions and/or classes. Importing a module is how you make its contents available for use in your current program. For example, when we used the random module for generating random numbers or the math module for advanced calculations, we had to import them first. This concept is fundamental to building any non-trivial application. As a security engineer, I frequently import modules for network communication, cryptography, or parsing complex file formats. It is like a nurse needing to access a specific medical device's library of functions or a social worker needing to pull up a set of guidelines from a specialized legal module.

While many useful modules come built into Python (like random or math), many other incredibly powerful modules are created by the Python community and are not part of Python's standard installation. This is where the pip utility becomes indispensable. pip is a command-line tool that allows you to easily download and install third-party modules from the Python Package Index (PyPI), which is a vast repository of Python software. For instance, when we wanted to create charts and graphs in my part 7 notes, we needed to install the matplotlib module using pip. The process typically involves opening your command prompt or terminal and typing pip install package_name . After installation, you can verify that the package was correctly installed by trying to import package_name in IDLE; if no error message appears, it means you're ready to use it. For me, pip is a constant companion for acquiring new tools for vulnerability scanning, penetration testing, or forensic analysis. For a new programmer, it is akin to a medical professional learning to order new specialized equipment for a rare condition or a social worker accessing new, specialized software for a particular client demographic. It vastly expands what your programs can achieve.

Presenting Your Findings

After you have written your code, processed data, and used various modules, the final step is often to present the results in a clear, readable, and professional manner. This is where formatting numeric output becomes important.

The format() function allows you to use special "format specifiers" to dictate things like:

Comma separators: To make large numbers easier to read, you can add commas for thousands, like displaying 123,456 instead of 123456.
Minimum field width: You can ensure a number takes up a specific number of spaces, which is helpful for aligning columns of numbers in reports.
Alignment: You can specify if a value should be left-aligned, right-aligned, or centered within its allocated space.
Decimal places: For floating-point numbers, you can control how many digits appear after the decimal point.

These formatting capabilities are crucial for making your program's output understandable. As a security engineer, I often need to present statistical data on incidents or resource usage in a precise, aligned format to avoid misinterpretation. For a nurse, this is vital for clearly displaying a patient's lab results, fluid intake, or medication dosages to prevent errors. For a social worker, accurate and well-formatted financial figures or demographic statistics are essential for grant applications or program effectiveness reports. This appendix provides the tools to ensure that your program's results are not just correct, but also clearly communicated.

In essence, these topics are not just suggestions; they are critical foundational guides. Installing Python provides the engine, IDLE gives you the driver's seat, pip lets you upgrade your vehicle with specialized parts, import is the ignition key to use those parts, and format() ensures your journey's logs and reports are perfectly legible. Together, they empower you to move beyond basic concepts and build real-world applications with confidence and professionalism, much like a seasoned expert in any field masters their tools and meticulously presents their finding