Arizona Constructivist

Welcome to the Arizona Constructivist website! My name is Raymond Stone and I am the creator of this Arizona Constructivist website. The first thing that should be established here is: What is a constructivist? The term constructivist comes from a certain philosophy of mathematics where purely intellectual, abstract mathematical forms including numbers, operators, functions, geometric shapes, etc. are looked at as being tools for accomplishing something with physical, tangible objects.

I have to state here that I am a passionate Mac enthusiast. This website was developed completely from my MacBook Pro and one of the goals of this website is to teach you how to create your own website using the industry standard web markup languages HTML, CSS, and JavaScript using the cross-platform text editor Pulsar. Within Pulsar you will first create a file called index.html. HTML is used to create a sort of skeleton structure for how your new website looks. Both HTML and especially CSS dictate how your new website looks. JavaScript is the other web development language but it is different in that it adds all sorts of logic that your website can perform that goes far beyond superficial things.

This website makes profuse use of a macOS utility called the Terminal command-line utility showing many examples of its use in many applications.

The Terminal command-line utility can be brought up within the Pulsar text editor by clicking on Packages in the Pulsar menu bar, then clicking on the Open Package Manager drop-down menu item and then entering terminal into the search bar that comes up. This will open a command-line that will be used to install many different software development tools including the tools for generating the first form of your new website.

At the top of this webpage are links to eight other pages of this site with each page offering a set of software development tools, useful code and many full program files, with each page having a description of the tools and code. Two of the last three webpage links, Mathematical Background and Relation to Arizona Education, are primarily for young people in High School or at the University of Arizona or Arizona State University. Finally, the Contact webpage link gives you, the visitor of this site the opportunity to contact me with any questions for free or...

This website makes extensive use of a software development tool available only on Unix-based operating systems called the Terminal command-line utility. It is extremely important to know that the command-line interfaces directly with the macOS operating system. It is also important to know that the macOS operating system was built by Steve Jobs and Apple and was built on top of the Unix operating system. A user of the command-line is called a power user. This means that, by using the command-line, you are a coder and, since the command-line works by entering code input, pressing enter, and generating output you are also an engineer, since engineers, by definition and default, work with I/O (input and output).

Now we have established that the job of an engineer is to work with I/O I would like to say here that, when working with actual computer program files(i.e., C or C++ files for example), the job of a Mac engineer is first, not to write code or programs or even to read code or programs, but, along with those things, and even more than those things, the job of a Mac engineer is to run computer program files. Running computer program files is done on macOS from either the Terminal command-line with specialized commands (i.e., gcc, g++, pdflatex, etc.) or from an IDE (integrated development environment) like Xcode. The Xcode application is by far and wide the biggest and most powerful application that macOS offers. On macOS Sequoia it is 11.58 GB which is massive. The second biggest app that I have installed on my MacBook Pro is Final Cut Pro which is 6.98 GB which is a little more than half of the size of Xcode. Almost all of the other apps on my Mac are a lot less than 1 GB.

If you would like to learn more about Xcode see the Objective-C, Objective-C+ and Swift parts of the C, C++, Objective-C, Objective-C++, and Swift webpage link at the top of this website, but I recommend that you read at least some of the below first since Xcode is extremely complicated and advanced compared to the Terminal command-line.

See Command Line Tools for... this should make you much more productive, constructive, and effective when using your Mac.

Installing Homebrew:

Homebrew is an extremely powerful command line tool and software package manager used for a lot of different types of software development.

To install Homebrew and Macports see their respective websites at:

# Download and install Homebrew:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Installing the Pulsar Text Editor Using Homebrew:

To install the Pulsar text editor using Homebrew enter the following command:

brew install --cask pulsar

Installing Vercel:

Vercel is used for...

# Install Vercel using Homebrew:
brew install vercel

Installing Vercel CLI (Command-Line Interface):

The Vercel CLI is used for...

# Install Vercel using Homebrew:
brew install vercel-cli

What It Means To Be A Constructivist

The title constructivist comes from a way of looking at purely mathematical objects and forms as tools for the construction and manipulation of physical objects with practical applications that all take place on your personal computer. This constructivist approach stands in contrast to pure mathematics which looks at mathematical objects as abstract entities where the studier of mathematical objects strictly recognizes mathematical objects with no intention on practical applications at all.

...math is pure intellect, meaning that all mathematical thought exists separate from the physical world. Realizing this, as a constructivist, it is important to know that when you are attempting to accomplish anything at all with mathematical intellectual forms and objects, say, for example on your Mac,...

The purpose of this Arizona Constructivist website is to make functioning, effective coders and engineers out of both young people considering a career in engineering and people with little to no prior experience in any field of mathematics or engineering.

It should be noted here that a mathematician who studies calculus, where the word calculus literally means calculations and is also called functions theory studies functions including primitive functions denoted by f(x) where x is the input and the mathematical function that it is equal to dictates what the output is...

Shell Commands as Mathematical Functions

At a fundamental level, a CLI (Command Line Interface) is a live implementation of Functional Composition. In mathematics, a function f(x) takes an input x and produces an output y. In the shell, a command acts as that function. The Pipe (∣) as Function Composition In algebra, if you have two functions f(x) and g(x), you can compose them as (g∘f)(x), which means g(f(x)). You take the result of the first and plug it into the second. In the shell, this is exactly what the pipe symbol (|) does:

cat MortgageLoans.tex | grep "Mortgage" | wc -l

(Outputs "3" because the word "Mortgage" comes up 3 times in the MortgageLoans.tex file)

If we translated that shell command into math notation, it would look like this:

Count(Search(Read(file.txt),"Apple")) Comparison Table: Math vs. Shell Mathematical Concept Shell Equivalent Description Domain Standard Input (stdin) The set of possible data the command can accept. Range Standard Output (stdout) The resulting data sent to the screen or next command. Function f(x) Command / Utility The transformation logic (e.g., sort, uniq). Composition The Pipe | Passing the output of f(x) to become the input of g(x). Mapping Variables Just like in math where x=10, shells allow Variable Assignment: set x = 10 (in csh) or x=10 (in zsh). When you run a command like echo $x, the shell performs a substitution, replacing the symbol with its value before the "function" (the command) is even executed. Is it a "Pure" Function? In "pure" mathematics, functions have no side effects—f(x) always returns the same value for the same x. Shell commands are often impure. For example, the command rm file.txt doesn't just return a value; it changes the state of your hard drive. This is why terminal work feels more like "System Engineering" than "Pure Math."

Commands as Mathematical Functions:

To understand commands as mathematical functions, it helps to think of the terminal as a data processing pipeline. In this world, your files are the "sets," and the commands are "transformations" applied to those sets. Here are several command examples that map directly to mathematical concepts, using the pipe (|) to compose them.

Set Theory: Union, Intersection, and Difference

If you have two lists (sets), you can perform set operations using sort and uniq. Union (A∪B): Combine both lists and remove duplicates.

cat listA.txt listB.txt | sort | uniq

Intersection (A∩B): Find only the elements present in both lists.

sort listA.txt listB.txt | uniq -d

Difference (A−B): Find elements in A that are not in B.

comm -23 <(sort listA.txt) <(sort listB.txt)

Aggregation Functions: Sum, Average, and Count

The command awk is essentially a programming language designed for math on text columns. It acts as an integrator or aggregator. Summation (∑x): If you have a file prices.txt with one number per line:

cat prices.txt | awk '{sum += $1} END {print sum}'

Counting (n): The wc (word count) command with the -l flag is a function that returns the cardinality of a set (the number of lines).

ls -l | wc -l

(Math: f(Set)=∣Set∣)

Transformation and Mapping: f(x)→y

The tr (translate) and sed (stream editor) commands are used for mapping—taking every element in a domain and transforming it into a new range. Case Mapping: Transform all lowercase letters to uppercase.

echo "hello" | tr 'a-z' 'A-Z'

(Math: f(x)=X) Substitution: Replace every instance of "dog" with "cat."

cat story.txt | sed 's/dog/cat/g'

Logical Filters: The "Predicate"

In math, a predicate is a condition that returns true or false. In the shell, grep acts as a filter that only allows data through if it satisfies the predicate. Filtering: Find all lines containing "Error."

cat logs.txt | grep "Error"

(Math: {x∈Logs∣x contains "Error"})

Higher-Order Composition

You can chain these together to solve complex "equations." For example, to find the 3 most frequent words in a document:

cat document.txt | tr ' ' '\n' | sort | uniq -c | sort -nr | head -n 3

The Mathematical Breakdown: tr: Maps spaces to newlines (Tokenization). sort: Groups identical elements together. uniq -c: A transformation that replaces a group of identical elements with a single element and its count (x→(count,x)). sort -nr: Sorts the new pairs numerically in reverse. head -n 3: A "slicing" function that takes the top 3 elements of the resulting set. Comparison of Operators Operator Mathematical Equivalent Purpose | ∘ (Composition) Passes output of f to input of g. > Output Assignment Writes the result of a function to a file (variable). >> Append / Addition Adds the result to an existing set without overwriting. < Input Injection Feeds a set (file) into a function (command).

Python Vs. Shell Scripting Using The Above Commands

Python treats data as objects with structure, whereas the shell treats everything as a stream of characters. When you move from shell scripting to Python, you are moving from string manipulation to data science. Python generally wins for anything beyond simple file piping:

Since Bash and Zsh share the same lineage (Bourne-based), the way they handle external commands like grep, sort, and awk is nearly identical. Python, however, treats these as "System Calls," where it acts as a manager orchestrating external processes. Below is a script that performs a "Top 3 Word Count" analysis using the logic we discussed: Tokenize (Split into words) Filter (Remove small words) Count & Sort (Aggregate)

Bash / Zsh Script (analyze.sh)

In shell scripts, the pipe | is the star of the show. It handles the "mathematical composition" automatically. Bash

#!/bin/bash

# Define the input string (our "Set")
DATA="apple banana apple orange banana apple"

echo "--- Shell Analysis ---"

# The Pipeline:
# 1. echo: The Source
# 2. tr: Map spaces to newlines f(x)
# 3. grep: Filter out words shorter than 5 chars (Predicate)
# 4. sort | uniq -c: Aggregate counts
# 5. sort -nr: Sort by count descending
# 6. head -n 3: Slice the top 3
echo $DATA | tr ' ' '\n' | grep '.....' | sort | uniq -c | sort -nr | head -n 3

To run: chmod +x analyze.sh && ./analyze.sh

Python Script (analyze.py)

In Python, we use the subprocess module to mimic the shell. This is a great way to see how the "Functions" are explicitly connected. Python

import subprocess

data = "apple banana apple orange banana apple"

print("--- Python Subprocess Analysis ---")

# We simulate the pipe by passing the output of one process to the input of the next
# f(x) = tr
p1 = subprocess.Popen(['echo', data], stdout=subprocess.PIPE)
p2 = subprocess.Popen(['tr', ' ', '\n'], stdin=p1.stdout, stdout=subprocess.PIPE)

# g(f(x)) = grep
p3 = subprocess.Popen(['grep', '.....'], stdin=p2.stdout, stdout=subprocess.PIPE)

# h(g(f(x))) = sort | uniq -c
p4 = subprocess.Popen(['sort'], stdin=p3.stdout, stdout=subprocess.PIPE)
p5 = subprocess.Popen(['uniq', '-c'], stdin=p4.stdout, stdout=subprocess.PIPE)

# Final transformation: Sort and Head
p6 = subprocess.Popen(['sort', '-nr'], stdin=p5.stdout, stdout=subprocess.PIPE)
output = subprocess.check_output(['head', '-n', '3'], stdin=p6.stdout)

print(output.decode())

The Logical Difference Feature Shell (Bash/Zsh) Python Composition Simple ` ` operator. Data Flow Stream-oriented: Data flows bit-by-bit through the pipe. Object-oriented: Usually requires managing process handles. Error Handling Often ignores errors in the middle of a pipe. Very strict; will raise exceptions if a "function" fails. Why use one over the other? Use Shell Scripts when your task is 90% moving data between existing programs (like grep and sort). It is mathematically concise. Use Python when you need to perform complex logic inside the script (like hitting an API or doing advanced math that awk can't handle easily). Does seeing the Python version make the "Function Composition" idea feel more like building a machine, or does it make the Shell version look simpler by comparison?

A bash/zsh script file that uses some Unix operators on .txt, .tex, .csd, .html, and .cpp files

Here is a robust script that uses the most essential file testing, logical, and redirection operators to process those specific file extensions.

Here is a script that iterates through your directory, identifies those file types, and performs operations based on their properties.

The File Processor Script (process_files.sh) Bash

#!/bin/bash

# Define the target extensions
EXTENSIONS=("txt" "tex" "csd" "html" "cpp")

echo "Starting file processing..."

# Loop through all files in the current directory
for file in *; do
    # 1. Extract extension (String manipulation)
    ext="${file##*.}"

    # 2. Check if the extension is in our target list (Logical OR and String comparison)
    if [[ " ${EXTENSIONS[@]} " =~ " ${ext} " ]]; then

        echo "------------------------------------------"
        echo "Processing: $file"

        # 3. File Test Operators
        # -f: exists and is a regular file
        # -s: exists and has a size greater than zero
        # -r: exists and is readable
        if [[ -f "$file" && -s "$file" ]]; then
            echo "Status: Found a non-empty file."

            # 4. Redirection & Pipe Operators
            # '|' pipes output, '>' redirects/overwrites, '>>' appends
            grep -c "^" "$file" | xargs echo "Line count:"

            # 5. Conditional Execution Operators (&& and ||)
            # Only run 'head' if the file is readable
            [[ -r "$file" ]] && head -n 3 "$file" > /tmp/preview.tmp || echo "Cannot read file"

            # 6. Case logic for specific file types
            case "$ext" in
                html)
                    echo "Action: Scanning for tags..."
                    grep -o "<[^>]*>" "$file" | wc -l >> tag_report.log
                    ;;
                cpp|csd)
                    echo "Action: Checking for includes/imports..."
                    grep "#include" "$file" || echo "No standard includes found."
                    ;;
                *)
                    echo "Action: General text processing."
                    ;;
            esac
        else
            echo "Status: File is empty or not a regular file."
        fi
    fi
done

echo "------------------------------------------"
echo "Process Complete."

Breakdown of Operators Used Operator Type Operators Used Description File Testing -f, -s, -r Checks if a file exists, isn't empty, and is readable. Logical &&, ||, ! Control flow: "And", "Or", and "Not". Redirection >, >>, < Directing output to files or appending data. Piping | Passing the output of one command as input to the next. Comparison ==, =~ String equality and Regex matching. Expansion ${file##*.} Shell parameter expansion to strip filenames. How to use it: Create the file: touch process_files.sh Paste the code: Open it in your favorite editor (vim, nano, code) and paste the block above. Make it executable: Bash

chmod +x process_files.sh

Run it: Bash

./process_files.sh

Note: Be careful with the > operator in scripts; it will overwrite the destination file without asking. If you're experimenting, it’s often safer to use >> to append until you're sure your logic is solid! Can I get a bash/zsh script file that uses all Unix operators on .html, .tex, .cpp, .csd, and .m (Octave/MATLAB files) files? Since you're looking for a script that hits the "greatest hits" of Unix operators while targeting specific file types like .html, .tex, .cpp, .csd, and .m, the best approach is a multi-purpose processor. This script demonstrates file test operators, logic operators, redirection, and arithmetic expansion while handling your specific extensions. The "All-in-One" File Processor (omnibus.sh) Bash

#!/bin/bash

# Define target extensions
EXTENSIONS=("html" "tex" "cpp" "csd" "m")

echo "--- Starting Unix Operator Demonstration ---"

# Loop through files in the current directory
for file in *; do
    # 1. Parameter Expansion (Extracting the extension)
    ext="${file##*.}"

    # 2. String Comparison & Regex Operator (=~)
    # Checks if the file's extension is in our list
    if [[ " ${EXTENSIONS[@]} " =~ " ${ext} " ]]; then

        echo "Found: $file"

        # 3. File Test Operators
        # -e (exists), -f (regular file), -s (not empty), -r (readable), -w (writable)
        if [[ -f "$file" && -s "$file" ]]; then

            # 4. Logical Operators (&& and ||)
            # Only runs 'ls -l' if 'test -r' (readable) is true
            [[ -r "$file" ]] && ls -l "$file" || echo "Read permission denied."

            # 5. Redirection & Pipes (|, >, >>, 2>)
            # Count lines, pipe to xargs, and append to a local log
            line_count=$(grep -c "^" "$file")
            echo "File $file has $line_count lines." >> process_log.txt

            # 6. Arithmetic Expansion ((...))
            # Calculate a 'weight' score for the file based on line count
            (( weight = line_count * 2 ))
            echo "Computed weight: $weight"

            # 7. Case Logic for File-Specific Operators
            case "$ext" in
                "html")
                    # Redirecting error to /dev/null
                    grep -i "href" "$file" > /dev/null 2>&1 && echo "  - Contains links."
                    ;;
                "cpp" | "m")
                    # Check for comments using Regex
                    grep -qE "^(//|%)" "$file" && echo "  - Contains top-level comments."
                    ;;
                "tex")
                    # Use Here-Strings (<<<) to pass data to a command
                    bc <<< "scale=2; $line_count / 10" | xargs echo "  - Complexity index:"
                    ;;
                *)
                    echo "  - Processed as generic data."
                    ;;
            esac
        fi
        echo "--------------------------------------"
    fi
done

# 8. Final Check using Command Substitution and exit codes
if [[ $? -eq 0 ]]; then
    echo "Script finished successfully at $(date)."
fi

Key Operators Explained Category Operators Used Purpose File Testing -f, -s, -r, -w Validates file type, size, and permissions before acting. Logic/Control &&, ||, !, [[ ]] Decides whether to run a command based on the success of the previous one. Redirection >, >>, 2>, &> Controls where output and error messages go (overwrite, append, or silence). Piping | Feeds the "Standard Out" of one program into the "Standard In" of another. Input Redir. <<< (Here-String) Passes a string directly into a command as if it were a file. Arithmetic (( )), $(( )) Performs integer math within the shell without needing external tools. Instructions for Use Save the file: Save the code above as omnibus.sh. Grant Permissions: Bash

chmod +x omnibus.sh

Execute: Run it in a directory containing your .m, .cpp, and other files: Bash

./omnibus.sh

Pro-tip for .m files: If you are using this to clean up or parse Octave/MATLAB scripts, the -q (quiet) flag on grep is your best friend—it allows you to use if grep ... logic without cluttering your terminal with the actual lines of code.

Can Unix operators like the ones above be used to do anything interesting with .aif, .png or .mov files or is that what imagemagick, ffmpeg, and sox do already?

That is a great question. You’ve hit on the core philosophy of Unix: "Everything is a file." The short answer is: Unix operators handle the "plumbing" (moving, testing, and connecting), while tools like FFmpeg, SoX, and ImageMagick handle the "surgery" (manipulating the actual pixels or audio samples). However, because these binary files still have metadata and headers, you can use Unix operators to do some surprisingly powerful things without even opening a "real" media editor. 1. The Power of Redirection (>) and Appending (>>) In the binary world, you can actually use the append operator to hide data. Steganography-lite: You can "hide" a .zip file inside a .png. Bash

cat original.png secret_data.zip > mysterious.png

The .png will still open and look normal in most viewers, but the zip data is tucked away at the end of the file. 2. Piping to Media Engines (|) Unix operators are the glue that makes FFmpeg and SoX powerful. Instead of saving intermediate files, you can pipe raw byte streams. Example: Use cat to feed multiple .aif files into SoX for a quick merge: Bash

cat intro.aif loop.aif outro.aif | sox -t aiff - combined.aif

The - tells the tool to take its input from the Standard Input (stdin) pipe rather than a file on disk. 3. File Testing (-s, -nt) for Automation Unix operators excel at managing large libraries of .mov or .png files. The "Newer Than" Operator (-nt): Use this to only process videos that have changed since your last edit. Bash

[[ "raw_footage.mov" -nt "compressed_preview.mov" ]] && ffmpeg -i raw_footage.mov compressed_preview.mov

This is essentially how professional build systems (like make) decide what needs to be rendered. 4. Logical Operators (&&, ||) for Batch Safety When dealing with heavy media, you don't want a script to keep running if a conversion fails and fills up your hard drive. Bash

# Only delete the massive .mov if the conversion to .mp4 succeeded
ffmpeg -i high_res.mov output.mp4 && rm high_res.mov || echo "Conversion failed! Keeping original."

Comparison: Operators vs. Dedicated Tools Task Unix Operator Solution Dedicated Tool (FFmpeg/SoX/IM) Combine Files

cat file1.aif file2.aif > all.aif

(Dangerous for headers!)

sox file1.aif file2.aif all.aif

(Corrects headers) Check Metadata

`strings photo.png grep "Software"`

Batch Rename

for f in *.mov; do mv "$f" "vid_${f}"; done

Not what they are built for. Shrink Size Impossible (Operators don't "see" pixels).

magick input.png -quality 80% out.jpg

The Verdict Think of Unix operators as the conveyor belts and logic gates in a factory. They move the boxes (files) around, check if the boxes are empty (-s), and decide which room they go into (case). Tools like FFmpeg, SoX, and ImageMagick are the specialized machines inside those rooms that actually reach into the boxes to change what's inside. You almost always use them together! Do you have a specific batch of media files you're trying to organize or convert? No what does hiding a .zip file in a .png file do? It is a classic trick called Digital Steganography. At its simplest, it allows you to store a hidden archive of files inside a single image that still looks and functions like a normal picture. Here is exactly what is happening under the hood when you use the Unix cat (concatenate) operator: 1. How the "Merge" Works Most image formats, like .png or .jpg, have a specific marker in their binary code that tells an image viewer, "This is the end of the image data." For a PNG, that marker is called the IEND chunk. When you run: Bash

cat image.png secret.zip > hidden.png

You are physically gluing the binary data of the .zip to the end of the .png data. 2. Why the Image Still Works When you double-click hidden.png, your computer's Image Viewer starts reading the file from the beginning. It reads the pixels, reaches the IEND marker, and stops. It ignores everything after that marker because it assumes it’s just "junk" or "padding." The image displays perfectly. 3. Why the Zip Still Works When you try to open the same file with a Compression Tool (like WinZip, 7-Zip, or the Unarchive utility), it behaves differently. Zip utilities look for a specific "header" (the characters PK) to find where an archive begins. They scan the file, find the Zip header tucked behind the image data, and treat the file as a valid folder. Use Cases and Limitations The "Double Life" File: You can email someone a "vacation photo" that secretly contains 50MB of source code or PDF documents. Security (or lack thereof): This is not encryption. It is "security through obscurity." Anyone who knows the trick can see the file size is unusually large (e.g., a 100MB PNG is a dead giveaway) and can extract the data easily. Fragility: If you upload this "hidden" PNG to a site like Facebook, Instagram, or Discord, their servers will often re-compress the image to save space. This process strips away everything after the IEND marker, effectively deleting your hidden Zip file. How to "Unpack" it If you have a file like this, you don't even need special software on Unix/macOS. You can just use the unzip command: Bash

unzip hidden.png

The unzip utility will skip the "garbage" (the image) at the start and extract the files it finds at the end.

Using Google Gemini (Or Other AI Websites)

After entering Google Gemini into the Google search engine you will see the following Google Gemini website webpage:

Make no mistake about it, Google Gemini is an incredibly beautiful piece of culture (or, if you prefer ChatGPT, or Claude then that works too). AI is extremely useful and powerful. I use it every day and I highly recommend that you use it as often as possible too.

Apple Macintosh Computers vs. Windows-Based Computers

The operating systems (OSs) of all computers are made by two main companies: Apple, that makes Macintosh computers (like the desktop Mac, MacBook Pro, MacBook Air, etc.) and Microsoft that distributes it's operating systems to various companies that produce Windows-based computers (like Dell, Hewlett Packard, Lenovo, etc.).

It is extremely important to know that Macintosh computers run on macOS, which is a Unix-based operating system. This makes them distinct from Windows-based computers, which were developed on a DOS-based operating system.

It is important for us here at the Arizona Constructivist to state our opinion on operating systems and computer here. This website and all of the other software development that we do is done on Apple Macintosh computers. We feel that the Unix operating system is superior to the DOS operating system, that the command-line utility and Finder application are both, together, extremely useful for both software development and personal use in general. The macOS operating system is more robust and secure than DOS-based systems and computers. Finally, the applications that Macintosh computers runs are superior to the applications that DOS/Windows-based computers offer.

It must be stated here that what an engineer deals with, first and foremost, is I/O (Input/Output) operations.

Here are some of the main tools that out engineers work with:

1 - The Terminal command-line: where the input is the command and the flags or options that follow it. After the programmer of the code that is entered in the command-line presses enter the output is generated. This type of I/O that results in interfacing directly with the macOS operating system comes in an enormous amount of forms ranging from...rm, cd..., etc. to build sequence commands like make, cmake, make install,...

2 - Xcode IDE - where input is a source file in C,... or Swift, most often,... 3 - VS Code - ...use vercel CLI to take the project as input... and output a website... 4 - LaTeX - pdflatex takes .tex file as input and generates a .pdf as output... 5 - Csound - takes a .csd file as input and generates audio or an .aif file as output... 6 - Octave - takes .m file scripts as input and generates... as output... 7 - Pulsar - ...

A Quick Note on AI: At the time of this writing (March 2026) AI (artificial intelligence) has become ubiquitous and has revolutionized engineering. Writing code used to be a slow, difficult process but now with AI a person can just ask Google Gemini, OpenAI's ChatGPT, or Anthropic's Claude for a program on any application at all and AI will give brilliant (but not perfect) full programs that it's user can analyze and use.

The macOS File System

The file system is central to any computer's operating system. The macOS file system is a hierarchical structure that organizes and stores data on the computer's storage devices. Files are the basic units of data storage in the file system. Above is a screenshot of the macOS file system. If you enter the following command in the Terminal, you can view the file system structure:

open /

Above is a screenshot of an unused Terminal command-line interface window. To get some experience with what the command-line can do see the Command Line Tools page of this website.

The Finder Application and the Terminal Command-line Utility

The Finder application is located in the Dock, which is the row of applications at the bottom of the screen on your Mac. If you click on it it will open a Finder window. In the left panel of this Finder window you can access your Applications directory (a directory is a folder), your Documents directory, your Downloads directory, and the directory that shows a little picture of a house and the name of the person who owns the computer (also called the administrator). This directory is alsocalled your home directory.

The Applications directory contains many useful applications. In it there is a directory called Utilities. In this Utilities directory you will find the Terminal command-line utility, whose icon is shown above on the right. It is a good idea to click and drag that Terminal icon to the Dock so that you can easily access it in the future. If you click on the Terminal icon it will open a window with a command prompt. You can click and drag this window to reposition it on your screen anywhere you like. The Terminal command-line lets you interface directly with the macOS operating system.

Visual Studio Code

Visual Studio Code is an industry standard and the best application for writing and editing code specifically for the creation of websites. The three industry standard website development languages are: HTML, CSS, and JavaScript. It is important to know that HTML isn't actually considered a programming language; it is a markup language. A markup language tells a computer how something should look, while a programming language tells a computer what to do. A user of, especially HTML and CSS, but JavaScript also, should really look at themselves as a certain type of web visual artist or web graphic designer along with being a computer programmer or software developer.

Pulsar

Pulsar is a very powerful cross-platform text editor available for both Windows and macOS. It is fully hackable, great for the creation of new programming languages, and offers an immense amount of packages to extend and customize both it's look and functionality. You might be thinking, what, exactly, do you mean when you say that Pulsar is hackable? By hackable we mean that you can write code in Pulsar to change how Pulsar looks and functions. For example, you could write code to make Pulsar look like the Xcode IDE, or you could write code to make Pulsar look like the Visual Studio Code IDE, or you could write code to make Pulsar look like the BBEdit text editor.

Xcode

Xcode is Apple's integrated development environment (IDE) for macOS, used for developing software for Apple platforms such as iOS, macOS, watchOS, and tvOS. It provides a suite of tools for coding, testing, and debugging applications, making it an essential tool for developers working within the Apple ecosystem. It is important to know that Xcode is not a good tool for web development. As mentioned above, Visual Studio Code is much more well suited for web development.

LaTeX

LaTeX is a powerful typesetting system for generating the finest and most beautiful .pdf documents possible. LaTeX files can be created in BBEdit and other text editors with the file name extension .tex. If the created .tex file uses the proper commands and syntax a .pdf can be generated from it with the following Terminal command:

pdflatex MyFirstLaTeXFile.tex If the file MyFirstLaTeXFile.tex is created and saved to, say, the ~/Developer/LaTeXFiles directory in BBEdit or any other text editor you can cd ~/Developer/LaTeXFiles at a Terminal command-line and then enter the above command. Doing that will generate a MyFirstLaTeXFile.pdf along with two other files called MyFirstLaTeXFile.log and MyFirstLaTeXFile.aux that you just need to keep where they are to keep the LaTeX compiler happy.

C, C++, Objective-C, Objective-C++, and Swift

C, C++, Objective-C, Objective-C++, and Swift are all industry standard programming languages that are used for a vast number of purposes some of which will be described here.

C and C++...

Objective-C and Objective-C++ are programming languages common for macOS application development...

Swift is a new programming language common for new macOS application development...

Csound

Csound is the most commonly use computer music programming language...

Octave, MATLAB, Simulink, and GNU Radio

GNU Octave and MATLAB are high-level programming languages and environments used for numerical computing, data analysis, and algorithm development. They are widely used in academia, research, and industry for tasks such as signal processing, control systems, machine learning, and scientific computing. Simulink is a graphical programming environment that is often used in conjunction with MATLAB for modeling, simulating, and analyzing dynamic systems. The MATLAB Coder is a tool that allows users to generate C, C++, and HDL code from MATLAB functions and Simulink models enabling developers to deploy their algorithms on embedded systems and hardware platforms.