Terms most directly tied to the Chapter 7 review questions.

An operating system is not just a technical tool — it is a strategic platform. When a well-designed OS is paired with an open developer ecosystem, it can trigger powerful network effects that create winner-take-all dynamics.

• The platform move: Apple provided developers with a common set of standards (APIs) and a distribution channel (the App Store) on top of iOS — making it easy to build and install apps on iPhone, iPod Touch, and iPad.
• Network effects in action: More developers meant more apps; more apps attracted more users; more users attracted more developers. This is a textbook example of a platform triggering network effects — each new participant makes the platform more valuable for everyone else.
• Scale of impact: 50,000 apps appeared in the App Store within the first year; over 2 million apps are available today.
• Competitive result: iOS became the most versatile mobile computing platform available, establishing a durable competitive moat through its software ecosystem — not just its hardware.
• Managerial takeaway: A well-designed OS and developer platform can catalyze explosive growth. The strategic implications of software architecture decisions extend far beyond IT — they shape markets, competitive positioning, and industry structure.

The software layer stack — each layer depends on the one below it.

Software is the layer that turns hardware into business capability. A manager who understands software can make better decisions about what to build, buy, or integrate — and can anticipate risks when systems change. Software influences competitive and organizational factors in several key ways:

• Competitive advantage — Proprietary software can be a source of sustained differentiation. Firms like Amazon and Netflix built custom platforms that competitors cannot easily replicate.
• Switching costs and lock-in — Once a firm adopts a software platform (especially ERP or SaaS), switching is expensive and disruptive. Managers need to weigh long-term dependency when choosing vendors.
• Operational efficiency — Well-integrated software reduces manual processes, errors, and redundancy across functions like inventory, HR, and finance.
• Data and decision-making — Software captures and processes data that drives strategic decisions. The quality of that software directly affects the quality of managerial insight.
• Agility and speed — Firms with modern, flexible software architectures can respond faster to market changes than those locked into legacy systems.
• Security and compliance — Software vulnerabilities expose the firm to breaches and regulatory risk. Managers bear responsibility for understanding these exposures even if they don't write code.

An operating system (OS) is the foundational software layer that sits between hardware and all other software. Without it, every programmer would need to write custom instructions for every piece of hardware their application might run on — an impossibly complex task.

• Hardware abstraction — The OS manages the CPU, memory, storage, and peripherals, presenting a standardized interface so applications don't need to communicate with hardware directly.
• Process management — Allocates CPU time across multiple running programs so they don't interfere with each other.
• Memory management — Controls which programs get access to which areas of RAM at any given time.
• File system management — Organizes data on storage devices and controls read/write access.
• Security and access control — Enforces user permissions and isolates processes to prevent unauthorized access.
• Device drivers — Acts as a translator between generic OS commands and the specific language of hardware devices (printers, keyboards, GPUs, etc.).

• Provides standardized APIs (Application Programming Interfaces) so developers write code once and it runs on any compatible hardware — they don't need to know the specifics of each chip or device.
• Handles low-level tasks (memory allocation, I/O operations) automatically, letting developers focus on application logic rather than hardware management.
• Provides development tools, debuggers, and runtime environments built on top of the OS layer.

• Provides a consistent graphical interface (GUI) — icons, windows, menus — so users interact with the computer without knowing underlying commands.
• Enables multitasking — running a browser, spreadsheet, and music app simultaneously without conflict.
• Manages software installation, updates, and security patches transparently in the background.
• Standardizes file management so users can save, find, and organize data across applications.

Software can be classified along four distinct dimensions. These are not mutually exclusive — a single piece of software can be described by all four simultaneously.

An Enterprise Resource Planning (ERP) system is a unified software platform that integrates data and processes across an entire organization into a single system of record. Rather than each department running its own disconnected software, an ERP creates one shared database that all functions draw from and contribute to in real time.

Terms marked ★ are flagged as especially important in the course outline.

When comparing OSS to proprietary software, the sticker price is rarely the full story. TCO captures every cost associated with adopting and running a technology over its entire lifespan — and is essential for making sound managerial decisions.

• What TCO includes: Licensing fees (or lack thereof), implementation and customization costs, training, ongoing maintenance, support contracts, security patching, and eventual migration costs.
• The OSS trap: OSS is free to acquire but not free to run. A firm may save on licensing only to spend heavily on internal expertise, custom development, or third-party support.
• The proprietary trap: Vendor licensing fees can seem modest upfront but compound over time — especially as user counts or module needs grow. Switching costs make it hard to leave.
• Why it matters: A firm that chooses Linux over Windows Server based on license cost alone may underestimate the cost of staff retraining, compatibility work, and lost productivity during transition. TCO analysis forces a complete picture.
• Managerial takeaway: Always compare software options on TCO, not just purchase price. The "free" in free software refers to freedom, not necessarily cost.

Software is one of the most economically attractive businesses ever created. Once code is written, the marginal cost of distributing it is essentially zero — there is no factory, no raw materials, no shipping. This creates powerful economics:

• Near-zero marginal cost: Microsoft writes Windows once; distributing it to 100 million users costs almost nothing more than distributing it to one. Margins expand dramatically at scale.
• Establishing a standard: When a software product becomes the dominant standard (Windows, iOS, SAP), it creates network effects — the product becomes more valuable as more people use it. Competitors face an enormous disadvantage trying to displace an entrenched standard.
• Switching costs: Once users invest time learning a platform, migrate data to it, and integrate it with other systems, switching to a competitor is expensive and disruptive. This locks in customers and protects revenue.
• Winner-take-all dynamics: Network effects combined with switching costs often produce markets where one or two players dominate entirely. This is why software firms invest so heavily in early adoption and market share, sometimes at a loss.

• Volunteer developers — Programmers who contribute for reputation, learning, ideological commitment to open software, or to scratch their own itch (solving a problem they personally face).
• Corporate contributors — Large firms like Google, Meta, Microsoft, and IBM contribute heavily to OSS projects they depend on. Contributing improves the software they use and lets them influence its direction.
• Foundations — Non-profits like the Linux Foundation, Apache Software Foundation, and Mozilla Foundation steward major projects, provide legal cover, and coordinate contributions.

• Support and services: Give the software away free; charge for installation, customization, training, and enterprise support. Red Hat (now IBM) built a billion-dollar business this way on Linux.
• Open core: Release a basic version as OSS; sell a premium version with enterprise features as proprietary software. Examples: MySQL, GitLab, Elasticsearch.
• SaaS on OSS: Host OSS in the cloud and charge subscription fees for managed access. AWS, Google Cloud, and Azure all generate enormous revenue running open source software as a service.
• Dual licensing: Offer OSS under a free license for non-commercial use; require a paid commercial license for business use.

• Cost: No licensing fees — significant savings at scale, especially for server infrastructure.
• Flexibility and customization: Access to source code means firms can modify software to fit their exact needs, not just configure it.
• Vendor independence: No single vendor can raise prices, discontinue the product, or hold the firm hostage. Avoids proprietary lock-in.
• Security through transparency: Public source code allows global security researchers to audit and fix vulnerabilities — often faster than a proprietary vendor's internal team.
• Community support: Large OSS projects have vast communities, documentation, and forums that rival or exceed proprietary vendor support.
• Innovation access: Firms benefit from continuous improvements made by contributors worldwide without paying for R&D.

• Hidden TCO: No license fee doesn't mean no cost — implementation, training, and internal support can be substantial.
• No guaranteed support: Unlike proprietary software with SLAs, OSS support depends on community activity. If a project loses momentum, the firm is on its own.
• Security risks from obscure bugs: The Heartbleed bug (2014) in OpenSSL — a critical piece of OSS used by most of the internet — went undetected for years despite being open source.
• License compliance complexity: OSS licenses vary (GPL, MIT, Apache) and have different requirements. Using GPL code in a commercial product may require releasing your own code — a legal and competitive risk.
• Integration challenges: OSS components may not integrate smoothly with existing proprietary systems, requiring costly custom development.

This phrase, attributed to Eric Raymond in The Cathedral and the Bazaar, is one of the core arguments for OSS reliability. It means that when source code is publicly visible, a large enough community of developers will inevitably find and fix any bug — no matter how obscure.

• The logic: Proprietary software is reviewed only by a company's internal team. OSS can be reviewed by thousands of developers worldwide, dramatically increasing the probability that vulnerabilities are spotted and patched quickly.
• Why it matters for firms adopting OSS: It suggests that widely-used OSS projects (Linux, Apache, MySQL) may actually be more secure and reliable than proprietary alternatives — because more people are looking at the code.
• The caveat: The phrase assumes enough eyeballs are actually looking. Obscure or less popular OSS projects may have few active reviewers, making them less safe than the principle suggests. Heartbleed showed that even critical OSS can harbor serious bugs.
• Managerial implication: Adoption decisions should favor well-maintained, widely-used OSS projects with active communities. Niche or abandoned projects carry higher risk regardless of their open source status.

• OSS eliminates software licensing costs, making hardware purchases relatively more attractive — firms can deploy more servers without proportional software cost increases.
• Linux and OSS enabled the commoditization of server hardware. Rather than buying expensive proprietary Unix systems, firms now run Linux on cheap commodity x86 servers — dramatically reducing infrastructure costs.
• Cloud providers (AWS, Google, Azure) built their entire infrastructure on OSS, allowing them to deploy millions of servers at scale — something impossible with per-seat proprietary licensing.

• Dramatically lower startup costs: A startup can now build on Linux, Apache, MySQL, Python, and React — a full production-grade tech stack — for zero licensing cost. This was unthinkable 30 years ago.
• Level playing field: Small firms access the same enterprise-grade infrastructure as Fortune 500 companies. AWS running on OSS means a two-person startup can scale to millions of users.
• Faster innovation: Entrepreneurs build on existing OSS components rather than reinventing the wheel, compressing time-to-market dramatically.
• New business models: OSS has enabled entire categories of businesses — managed OSS services, consulting, training — that didn't exist before.

LAMP stack (Linux, Apache, MySQL, PHP/Perl/Python) and MEAN stack (MongoDB, Express.js, Angular, Node.js) — two dominant OSS application stacks.