How Distributed Computing Works: Principles and Environments

UPI Study › Courses › Software Engineering › Free lessons › Lesson 14.9 Free with a free account

How Distributed Computing Works: Principles and Environments

Software Engineering · Chapter 14: Project Estimation, Configuration, and Change ControlSection 14.9 · lesson 94 of 1036 min · free with a free account

← Reusable Software at Scale: Component-Based Engineering RevisitedNext lesson: Middleware: The Glue Between Software Layers →

Earn 3 college credits for Software EngineeringRecommended for credit by NCCRS · Computer Science 301 · self-paced · one payment, lifetime access
Enroll in Software Engineering · $250 →Download the syllabus (PDF)

In this lesson

Principles and environments: many networked machines, behaving like 1 system.

  • Define distributed computing, and why single machines reach a limit
  • Describe transparency, and what it hides from a user
  • Explain why concurrency is unavoidable across machines
  • Distinguish horizontal from vertical scaling

Transcript

Everything said in the video, section by section (735 words). Read along, or search it.

Project Estimation, Configuration, and Change Control

How Distributed Computing Works

Almost everything so far in this course has quietly assumed that a system runs as one thing, in one place. This section covers what happens when it does not, and the principles that make many machines behave like one.

Beyond 1 Machine

Not 1 Thing in 1 Place

Most real systems today do not run on a single machine. That is not a preference. A single machine eventually cannot deliver the scale, reach, or reliability a modern system needs. A distributed system consists of independent components running on separate, networked computers. They coordinate by exchanging messages, rather than by sharing memory directly. And done well, the whole thing presents itself to users as a single, coherent system.

Transparency

The Illusion of a Single System

Transparency is the principle that a distributed system should hide its distributed nature, as much as possible. The user interacts with one simple interface. Behind it, three things stay hidden. Location transparency means not needing to know where a resource physically resides. Replication transparency means not needing to know whether multiple copies of the data exist. And failure transparency means the system keeps operating, or fails gracefully, when one of its pieces stops working. All without the user needing to notice.

Concurrency

Many Things at Once, by Default

Once a system spans multiple machines, concurrency stops being an occasional edge case. It becomes the normal condition. Many users and many components may act on shared resources at the very same moment, on different machines. And there is no single point where everything naturally happens one thing at a time. So a distributed system has to be built with this assumption from the start, not treat simultaneous activity as something unusual to guard against later.

Scalability

Growing by Adding, Not Rebuilding

Scalability is a system's ability to handle growing demand, like more users, more data, and more load, by adding resources rather than redesigning. There are two ways to grow. Vertical scaling makes one machine bigger and more powerful. But that eventually runs into a hard physical and economic ceiling. Horizontal scaling adds more machines to share the load. It does not have that kind of ceiling. And that is exactly the capability distributed computing exists to provide.

Figure 14.9B

Bigger vs. More

Here are the two approaches side by side. On one side, a single server keeps getting bigger, until it runs into a hard ceiling. On the other, the system simply adds another server of the same size, and then another. A single machine can only be made so much bigger. A distributed system just adds another machine instead.

Where You'll See This

4 Common Environments

These principles show up across several common environments. Client-server systems, where distinct client and server roles divide the work. Cloud computing, where computing resources are provisioned over a network, on demand. Peer-to-peer systems, where machines share responsibilities more equally. And clusters of machines, working together on a shared task. Each applies the principles a little differently. The client-server model is developed in full next.

Table 14.9

3 Core Principles at a Glance

Here are the three core principles at a glance. Transparency keeps the distributed nature hidden from the user, so a complex system feels simple to use. Concurrency means many things happen at once, across machines, by default. It has to be designed for, not treated as an exception. And scalability handles growth by adding resources, avoiding the hard ceiling that a single machine eventually hits.

Think About It

If 1 Server Failed Right Now

Think about an app you use that almost certainly runs on many servers somewhere. If one of those servers failed right now, what would you, as a user, actually notice? If the honest answer is nothing, that system is achieving failure transparency well.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. A distributed system is made of independent components on separate networked computers, coordinating by exchanging messages, and ideally appearing as one coherent system. Transparency is the principle of hiding a system's distributed nature from its users. Concurrency is many activities happening at once, across machines, as the normal condition. Scalability is a system's ability to handle growing demand by adding resources, rather than redesigning. And horizontal scaling adds more machines, while vertical scaling makes a single machine more powerful, until it hits a ceiling.

Key Takeaways

What to Carry Forward

To pull this together. Distributed computing spreads a system's components across networked machines, ideally appearing to users as one coherent system. Transparency hides location, replication, and failure from the user. Concurrency is the normal condition, so it has to be designed for from the start. Horizontal scaling avoids the hard ceiling that vertical scaling eventually hits. And client-server systems, the cloud, peer-to-peer systems, and clusters each apply these principles in their own way.

About Software Engineering at UPI Study

Software Engineering (Computer Science 301) is a self-paced online course of 103 video lessons in 15 chapters, from process models and agile to requirements, design, user interfaces, reliability, security and project management. It carries a NCCRS credit recommendation for 3 semester credits.

Every lesson transcript is free on pages like this one, and the videos are free with a free UPI Study account. Enrolling adds a practice quiz after each lesson, the graded work and final exam that earn the credit, lifetime access, and an official transcript on completion. UPI Study has helped over 130,000 students with college credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Enroll now → Course details Download the syllabus All Computer Science courses Every course with PRO →

Compare: Software Engineering vs Systems Analysis

Why take it here

Why students take Software Engineering with UPI Study

How professional software gets builtSoftware Engineering covers how teams turn requirements into working, maintainable software: process models, agile, requirements, design, testing, reliability and project management. It is a core course in computer science and software degrees.
Credit at a fraction of the priceThe same 3 credits can cost $750 or more at a US college. Here it is one payment, self-paced, with lifetime access.
Finish your degree soonerTransfer credits reduce the courses you still owe, so you can graduate earlier or lighten a heavy semester.
Strengthen an applicationA completed college-level course on an official transcript shows admissions and scholarship committees you can do the work.
Study on your own scheduleNo start dates, no deadlines. Watch the lessons, practice, and take the final when you are ready.
130,000+students helped with college creditsACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Where the credit goes

Universities that work with NCCRS

Software Engineering carries a NCCRS credit recommendation. These universities work with NCCRS; some are UPI Study's signed partners. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Thomas Edison State UniversityThomas Edison State UniversitySigned partnerUniversity of the PeopleUniversity of the PeopleSigned partnerCharter Oak State CollegeCharter Oak State CollegeSigned partnerStrayer UniversityStrayer UniversitySigned partnerColumbia Southern UniversityColumbia Southern UniversitySigned partnerIndiana TechIndiana TechSigned partnerPenn StatePenn StateWorks with NCCRSSouthern New Hampshire UniversitySouthern New Hampshire UniversityWorks with NCCRSSUNYSUNYWorks with NCCRS +many more cooperating universitiesFind my college →

Find my college → Not listed? Ask Athena in the corner of this page, or book a 15-minute call.

FAQ

Questions students ask us

About How Distributed Computing Works: Principles and Environments

What is a distributed system?
A distributed system is made of independent components running on separate, networked computers that coordinate by exchanging messages rather than by sharing memory directly. Done well, it presents itself to users as a single, coherent system. Most real systems today are distributed because a single machine eventually cannot deliver the scale, reach, or reliability a modern system needs.
What is transparency in distributed systems?
Transparency is the principle that a distributed system should hide its distributed nature from users as much as possible. Location transparency means users need not know where a resource physically resides, replication transparency means they need not know whether multiple copies of data exist, and failure transparency means the system keeps operating, or fails gracefully, when one piece stops working.
What is the difference between horizontal and vertical scaling?
Vertical scaling makes a single machine bigger and more powerful, while horizontal scaling adds more machines to share the load. Vertical scaling eventually hits a hard physical and economic ceiling, because one machine can only be made so large. Horizontal scaling avoids that kind of ceiling, and providing it is a central reason distributed computing exists.
Why is concurrency unavoidable in distributed systems?
Once a system spans multiple machines, many users and components may act on shared resources at the same moment, and there is no single point where everything naturally happens one at a time. Concurrency is therefore the normal condition, not a rare edge case. Distributed systems must be designed for simultaneous activity from the start rather than guarding against it later.

About the Software Engineering course

How many college credits is Software Engineering?
Software Engineering (Computer Science 301) carries a NCCRS credit recommendation for 3 semester credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.
How much does Software Engineering cost and what is included?
$250, paid once, with lifetime access: all 103 video lessons, a practice quiz after each, the graded work and final exam, and an official transcript when you finish. Students who want several courses choose UPI Study PRO instead.
Which universities accept UPI Study credits?
UPI Study has signed partner agreements with universities such as Thomas Edison State University, University of the People and Charter Oak State College, and works with universities such as Penn State, SNHU and SUNY. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities. Use "Find my college" on this page to check yours.
How long does Software Engineering take?
It is self-paced with no deadlines. The 103 lessons total about 11 hours of video; most students add reading and practice time and finish in a few weeks to a few months, on their own schedule.
How are the exams done?
Quizzes and assignments are online in the course. The final exam is taken online with proctoring; a person on the UPI Study team checks assignments, usually within two days.
How do my credits reach my college?
When the course shows 100% complete, request the official transcript from your dashboard. It is sent to the college you name, and you can send it to more than one. Check your college first with "Find my college" on this page, or ask Athena.

Ready for the full course? Earn 3 credits in Software Engineering.

103 video lessons, a quiz after each one, and the graded work that earns the credit. Recommended for credit by NCCRS.

Enroll in Software Engineering →Download the syllabusEvery course with PRO →
Software Engineering
3 credits · NCCRSEnroll →