Transform Mapping: Turning Data Flow into Architecture

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

Transform Mapping: Turning Data Flow into Architecture

Software Engineering · Chapter 8: Object-Oriented Design and ArchitectureSection 8.6 · lesson 60 of 1036 min · free with a free account

← Architectural Styles, Archetypes, and Building Blocks for Robust Software SystemsNext lesson: Connecting Data Flow Diagrams to System Architecture →

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

From a data flow diagram to a structure chart.

  • Recognize a transform-flow DFD by its 3 regions
  • Explain how first-level factoring builds the top of a structure chart
  • Explain how second-level factoring places each process
  • Derive a simple structure chart from a transform-flow DFD

Transcript

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

Object-Oriented Design and Architecture

Transform Mapping: Turning Data Flow into Architecture

Object-oriented design is one path from analysis to a buildable structure. It is not the only one. This section covers transform mapping, a technique for deriving a structure directly from a data flow diagram of the right shape.

Another Path

Before Object-Oriented Design

Long before object-oriented design became the dominant approach, transform mapping offered a different path. Instead of starting from classes and use cases, it starts from a data flow diagram. Given a diagram of the right shape, transform mapping turns it into a structure chart. A structure chart is a hierarchy of modules, showing which modules call which others. And here, it is derived almost mechanically from the diagram's own structure.

The Right Shape

What Makes a DFD Transform-Flow

Transform mapping only works on a D F D with a particular shape, called transform flow. First, data enters from outside in a raw form, and moves through processes that make it progressively more meaningful. That is the incoming flow. Then it reaches a central point, where the real transformation happens. That is the central transform. Finally, it moves through processes that make it progressively more concrete again, until it leaves as formatted output. That is the outgoing flow. A D F D shaped around routing a transaction, down one of several paths, is handled by a different technique.

Flow Boundaries

Finding the Flow Boundaries

The first step is finding two boundaries. The incoming flow boundary marks where data stops being raw external input, and becomes meaningful, processed information. The outgoing flow boundary marks where information stops being internal, and starts being formatted for delivery. Everything between them is the central transform. Here is a sensor-reading example. Reading raw sensor data, and validating it, are incoming flow. Converting to standard units, and computing an adjusted value, are the central transform. And formatting a report, and displaying the reading, are outgoing flow.

First-Level Factoring

The Top of the Structure Chart

With the boundaries found, first-level factoring creates the top of the structure chart. There is a single top-level module, representing the system as a whole. Beneath it are three subordinate modules. One coordinates the incoming data, one coordinates the central transform, and one coordinates the outgoing result. These three modules correspond directly to the three regions the boundaries marked out.

Second-Level Factoring

Every Process Becomes a Module

Second-level factoring then works through each region, one at a time. Every process bubble in the D F D becomes its own module in the structure chart. Each one is placed beneath whichever first-level module matches the region it came from. So factoring does not invent new organization. It carries the D F D's existing organization over, into a module hierarchy.

Figure 8.6B

The Resulting Structure Chart

Here is the resulting structure chart for the sensor-reading system. At the top is the system as a whole. Beneath it are the three first-level branches. Get input, transform, and produce output. Under get input are read raw sensor data, and validate reading. Under transform are convert to standard units, and compute adjusted value. And under produce output are format report, and display reading. Every bubble from the D F D reappears as a module.

A Starting Point

Not a Finished Design

The structure chart is a starting point, not a finished design. It still gets reviewed and refined using the same general design principles that apply to any structure, like cohesion, coupling, and modularity, however it was first derived. Here is a question to think about. Picture a D F D for generating a paycheck. It reads raw timesheet data, validates hours, calculates gross pay, applies deductions, formats the pay stub, and prints it. Which bubbles would fall in the incoming flow, which in the central transform, and which in the outgoing flow?

Apply It

The Paycheck, Mapped

Here is one reasonable answer. Reading the raw timesheet data, and validating the hours, make up the incoming flow. The data becomes meaningful. Calculating gross pay, and applying deductions, are the central transform. That is where the real work happens. And formatting the pay stub, and printing it, are the outgoing flow. Each region becomes one first-level branch of the structure chart, with its bubbles as modules beneath.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. Transform mapping is a technique for deriving an initial structure chart from a transform-flow D F D, one shaped around incoming, central transform, and outgoing regions. The incoming flow boundary is where raw data becomes meaningful. The outgoing flow boundary is where formatting for delivery begins. A structure chart is a hierarchy of modules, showing which modules call which others. First-level factoring creates the top module and its three branches. Second-level factoring places each bubble beneath the branch for its region.

Key Takeaways

What to Carry Forward

To pull this together. Transform mapping turns a transform-flow D F D into a structure chart. Two flow boundaries divide the D F D into three regions. First-level factoring creates a top module, with three branches, one for each region. Second-level factoring places each bubble as a module under its region's branch. And the result is a starting point, still refined using general design principles.

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 Transform Mapping: Turning Data Flow into Architecture

What is transform mapping in software design?
Transform mapping is a technique for deriving an initial structure chart from a data flow diagram that has transform flow. A structure chart is a hierarchy of modules showing which modules call which others. The technique predates the dominance of object-oriented design and offers a different path from analysis to structure, starting from a DFD rather than from classes and use cases, and deriving the hierarchy almost mechanically from the diagram's shape.
What are the incoming flow, central transform, and outgoing flow in a DFD?
They are the three regions of a transform-flow DFD. Incoming flow is where raw external data is made progressively more meaningful, the central transform is where the real processing happens, and outgoing flow is where results are formatted for delivery. In a sensor system, reading and validating raw data are incoming flow, converting units and computing an adjusted value are the central transform, and formatting and displaying a report are outgoing flow.
What is the difference between first-level and second-level factoring?
First-level factoring builds the top of the structure chart: one top-level module for the whole system and three subordinate modules that coordinate incoming flow, the central transform, and outgoing flow. Second-level factoring then turns every process bubble in the DFD into its own module and places it under the first-level branch for its region. Factoring carries the DFD's existing organization into a module hierarchy rather than inventing a new one.
How do you map a payroll data flow diagram into a structure chart?
Divide the DFD into its three regions, then build one branch per region. Reading raw timesheet data and validating hours form the incoming flow branch. Calculating gross pay and applying deductions form the central transform branch. Formatting and printing the pay stub form the outgoing flow branch. The resulting chart is a starting point, still refined using general principles such as cohesion, coupling, and modularity.

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 →