Software and Applications

Week of 2026-10-06 · Download .docx

Objectives

Distinguish system software from application software and compare licensing categories: proprietary, freeware, open source, shareware.
Identify common productivity and business applications (Office suite, CRM, ERP) and explain SaaS vs. locally installed software.
Compare interpreted and compiled languages, describe the SDLC phases, and explain the purpose of version control with Git.
Explain virtualization vs. containers, and describe Agile sprint methodology vs. Waterfall's sequential phases.

Key terms

System Software: Software managing hardware and providing services for application software: OS, device drivers, firmware, and utilities.
Application Software: Software solving specific user tasks: word processors, spreadsheets, CRM, games, web browsers.
Freeware: Software distributed at no cost but with source code kept private and restrictions on modification — distinguished from open source.
Firmware: Software permanently stored in non-volatile chips on hardware devices, providing low-level initialization and control.
SaaS: Software as a Service — fully managed applications delivered over the internet. Vendor handles all infrastructure, updates, and availability.
IDE: Integrated Development Environment — software combining a code editor, debugger, and build tools in one application (VS Code, PyCharm, IntelliJ).
Git: Distributed version control system that tracks every file change, stores complete project history, and enables team collaboration through branching and merging.
SDLC: Software Development Life Cycle — the phases of software creation: Requirements → Design → Implementation → Testing → Deployment → Maintenance.
Agile: Iterative development methodology using short sprints (1–4 weeks) with cross-functional teams, continuous testing, and regular stakeholder feedback.
Waterfall: Sequential SDLC methodology where each phase must complete before the next begins — requirements, design, development, testing, deployment.
Virtualization: Using a hypervisor to run multiple isolated virtual machines (each with its own OS) on a single physical host.
Container: Lightweight application packaging (Docker) that shares the host OS kernel, starting in seconds and using far less memory than VMs.
API: Application Programming Interface — a set of rules allowing one software application to request services from another.

The concept

Software is the set of instructions that tells hardware what to do. Understanding how software is classified, developed, and deployed is central to every IT role.

**Software Categories**

System software operates at the layer between hardware and user applications. The operating system (Windows, macOS, Linux) is the most important system software — it manages all hardware resources and provides APIs for applications. Device drivers translate OS commands into hardware-specific instructions. Firmware is software stored in non-volatile chips on hardware devices, running before the OS loads.

Application software solves specific user problems: word processors for document creation, spreadsheets for data analysis, CRM (Customer Relationship Management) for managing sales relationships, ERP (Enterprise Resource Planning) for integrating business processes, and IDEs for software development.

**Licensing**

Proprietary software retains source code and IP with the vendor — Microsoft Office, Adobe Photoshop. Freeware is free to use but source code is closed — VLC Media Player. Open-source software provides publicly available source code — Linux, LibreOffice. Shareware is a trial model where full features require payment after a trial period.

**How Software is Built**

Interpreted languages (Python, JavaScript) execute line-by-line through an interpreter at runtime. Compiled languages (C, C++, Rust) are translated to machine code before execution, typically resulting in faster runtime performance. The SDLC (Software Development Life Cycle) defines standard phases: Requirements gather stakeholder needs. Design creates the architecture and interfaces. Implementation is where developers write code. Testing verifies correctness against requirements. Deployment releases to production. Maintenance addresses bugs and evolving requirements.

Git tracks every change to every file, maintains the complete project history, and enables multiple developers to work on separate branches simultaneously without overwriting each other's work. GitHub and GitLab host remote repositories that teams share.

**Waterfall vs. Agile**

Waterfall follows sequential phases — requirements must be complete before design begins, design must be complete before development begins. This is predictable for well-understood, stable requirements but inflexible when requirements change. Agile breaks work into short sprints (1–4 weeks), delivering a working increment at the end of each sprint and incorporating feedback before the next sprint. Agile is more responsive to change but requires continuous stakeholder involvement.

**Virtualization and Containers**

A hypervisor runs multiple virtual machines (VMs) on a single physical host — each VM has its own OS, consuming significant memory and startup time. Containers (Docker) share the host OS kernel, packaging only the application and its dependencies. Containers start in seconds, use far less memory, and enable consistent application environments from development to production.

Worked examples

Example 1: Choosing between Waterfall and Agile: A student government wants a website to display club events. The full requirements are known upfront (a calendar, sign-up forms, event photos). Waterfall is appropriate — the requirements are stable and well-understood. Compare to a healthcare startup that does not know exactly what features will work for patients until they test with real users — Agile allows rapid feature experimentation and user feedback incorporation after each 2-week sprint. The key question: Are the requirements stable and fully known upfront, or will they evolve based on user feedback?

Example 2: Choosing containers vs. VMs: A development team needs to run four different web applications on one server. VMs: each VM needs its own OS, consuming 2–4 GB of RAM per VM for the OS alone. Containers: each container shares the host Linux kernel, adding only the application dependencies — perhaps 50–200 MB per container. For uniform Linux applications, containers are far more efficient. VMs are preferred when applications need different OSes (Windows app alongside Linux app) or maximum security isolation.

Common mistakes

Calling Python a 'fast language' and C++ a 'slow language' to write. Python is slower to execute but faster to write — its clean syntax and large standard library reduce development time. C++ is faster to execute but requires more lines of code and careful memory management. The right choice depends on whether execution speed or development speed matters more.
Thinking Git and GitHub are the same tool. Git is the version control system — a command-line tool you run locally. GitHub is a web hosting service for Git repositories with collaboration features. You can use Git without GitHub (local repo), but GitHub requires Git.
Believing all open-source software can be used commercially for free. The GPL requires any derivative work to also be GPL — you cannot incorporate GPL code into proprietary commercial software. MIT and Apache 2.0 licenses are permissive and do allow commercial use. Always check the specific license.
Confusing SaaS with PaaS. In SaaS you use a fully managed application (Microsoft 365, Salesforce). In PaaS you deploy your own code on a managed platform (Heroku, App Engine). The distinction: who wrote the application running on the service?
Assuming containers and VMs are interchangeable. Containers share the host OS kernel — if that kernel has a vulnerability, all containers are exposed. VMs have fully isolated OS instances. For multi-tenant cloud security or running different OSes, VMs provide stronger isolation despite higher overhead.

Self-check

Try each question before reading the answer. Answers at the bottom of this page.

1. What is the primary difference between freeware and open-source software?

Freeware costs money; open source is free
Freeware closes source code; open source makes source code available
Freeware is faster; open source is more secure
They are the same thing

2. In the SDLC, during which phase do developers write code?

Requirements
Design
Implementation
Testing

3. What advantage do containers have over virtual machines?

Each container runs its own full OS
Containers share the host kernel — far lighter and faster to start
Containers provide more security isolation
Containers require a Type 1 hypervisor

4. Which software license requires that all derivative works also be released under the same open-source license?

MIT License
Apache 2.0
GPL (Copyleft)
Freeware

5. Git primarily helps development teams by:

Compiling code automatically
Tracking every file change and enabling branching for parallel development
Testing applications in production
Deploying applications to cloud servers

Self-check answers

1. B — Freeware = free to use, source code private. Open source = source code publicly available under a license permitting modification.
2. C — Implementation is the phase where developers write the actual source code based on the design specifications.
3. B — Containers share the host OS kernel rather than running full guest OSes, making them significantly lighter, faster to start, and more memory-efficient.
4. C — The GPL uses copyleft — any derivative work must also be distributed under the GPL.
5. B — Git tracks changes with full history, enables branching so developers work in parallel, and merges completed work — preventing overwriting each other's changes.

Canvas is the official record. This companion enhances the PGCC curriculum; it does not replace it. Last name and class year only. Students with a 504 plan or IEP: your accommodations apply.

↑ Back to top