WWDC Quick Look 💓 By SwiftGGTeam
中文 EN 日本語
Out of this world... on to Mars

Out of this world... on to Mars

DesignEssentials
Watch original video

Highlight

NASA engineer Tiera Fletcher used the design, testing and mission planning of the Space Launch System to illustrate that complex engineering requires putting design, data, manufacturing verification and multiple teams into the same product life cycle.

Core Content

When a young engineer wants to participate in rocket design, the real difficulties rarely appear in promotional videos.

Drawings are only the first step. After the parts are formed in computer-aided design (Computer-Aided Design) software, they need to be manufactured, assembled, transported, tested, and then connected to the real flight mission. Any misalignment of any link will affect the entire rocket.

Tiera Fletcher joined NASA’s Space Launch System program at age 22. She started with structural design and analysis and was responsible for designing rocket components and verifying structural integrity. She then went to the Michoud Assembly Facility in New Orleans to participate in the installation of these parts and confirm the assembly results with technicians.

No Apple APIs are released for this talk. It’s about a different kind of design problem: When a product is 322 feet tall and thrusts more than 8 million pounds, the design can’t stop at the screen. The design must enter the manufacturing site, accept test data, return to configuration management, and then serve the next task.

The goals of the Space Launch System are also clear. It first supports the unmanned flight of Artemis 1 and collects data; then allows Artemis 2 to bring four astronauts back to the lunar environment; and finally prepares for Artemis 3 and subsequent deep space missions.

Detailed Content

From hobby to engineering: turning paper designs into motion systems

（01:30）

Tiera entered the robotics program at age 11. She designs and builds the structure first, then programs the structure to move. In her speech, she described the process as moving from paper to product to movement.

This process is suitable to be represented by a minimum state model. It does not invent engineering facts outside of the session, but only organizes the three stages in the verbatim draft into data that the App can display.

struct LearningStep: Identifiable {
    let id: Int
    let title: String
    let source: String
}

let roboticsPath = [
    LearningStep(id: 1, title: "Paper", source: "design the structure"),
    LearningStep(id: 2, title: "Product", source: "build the structure"),
    LearningStep(id: 3, title: "Movement", source: "program the structure and make it move")
]

for step in roboticsPath {
    print("\(step.id). \(step.title): \(step.source)")
}

Key points:

  • LearningStepBreak down the learning path into demonstrable steps -idGive each stage a stable identity, suitable for a list or timeline -titleCorresponding to the three results of paper, product and movement in the speech -sourcePreserve factual sources and avoid rewriting the narrative into empty slogans -forLoop to output paths in order, suitable for debugging timeline data

This experience explains her later engineering roles. Large systems follow the same path: design first, then build, then verify true behavior.

Saturn V: Aerospace engineering has long relied on software automation

（03:00）

The talk starts with the Saturn V. It served in the Apollo program from 1969 to 1973, completing 13 launches, carrying 24 people into space, weighing more than 6 million pounds, and being taller than the Statue of Liberty.

Tiera stressed that Saturn V doesn’t just rely on thrust to get through the atmosphere. It was controlled by state-of-the-art avionics for the time, including a Launch Vehicle Digital Computer. As onboard computing increased, so did ground computing, and manual processes began to become automated.

struct RocketProgram {
    let name: String
    let launches: Int
    let peopleSentToSpace: Int
    let hasDigitalComputer: Bool
}

let saturnV = RocketProgram(
    name: "Saturn V",
    launches: 13,
    peopleSentToSpace: 24,
    hasDigitalComputer: true
)

if saturnV.hasDigitalComputer {
    print("\(saturnV.name) used onboard computing to support launch control.")
}

Key points:

  • RocketProgramOnly record the fact fields given in the verbatim draft -launchesUse the 13 launches from the speech -peopleSentToSpaceUse 24 people from the speech -hasDigitalComputerCompatible with Launch Vehicle Digital Computer -ifJudgment connects control capabilities and output copywriting

This gives developers a direct inspiration: the key turning points of complex systems often come from data collection and process automation. This is true for rockets, and the same goes for the release, testing, and rollback processes of software products.

SLS: Structural design must cover design, manufacturing, installation and configuration management

（06:22）

Tiera’s position changes in the Space Launch System project are representative.

She started as a structural design and analysis engineer, designing rocket components and verifying their structural integrity. After that, she became the engine section task lead, responsible for installing components at the Michoud Assembly Facility and confirming with technicians that the assembly was correct. Later, she worked as a configuration management and product integration engineer, ensuring that the engineering design was consistent with the actual installation.

enum EngineeringRole: String {
    case structuralDesignAndAnalysis = "design parts and verify structural integrity"
    case engineSectionTaskLead = "lead installation and verify assemblies"
    case configurationManagement = "align engineering designs with installations"
}

let slsRoles: [EngineeringRole] = [
    .structuralDesignAndAnalysis,
    .engineSectionTaskLead,
    .configurationManagement
]

let responsibilities = slsRoles.map(\.rawValue)
print(responsibilities.joined(separator: " -> "))

Key points:

  • EngineeringRoleUse enumerations to represent positions and prevent responsibility strings from being scattered in the code. -structuralDesignAndAnalysisCorrespond to design components and verify structural integrity -engineSectionTaskLeadCorresponding installation components and verified assembly -configurationManagementCorresponding design and installation alignment -map(\.rawValue)Convert an enum into displayable responsibility text -joined(separator:)Link job paths into a product life cycle

The point of this experience is to close the loop. Design documents, manufacturing site, assembly results and configuration status must be verified against each other. For the App team, requirements, design drafts, implementation, testing and online configuration can also be put into a traceable link.

Physics for SLS: Components, Thrust, and Green Run Testing

（08:33）

The Space Launch System is 322 feet tall. It consists of four RS-25 engines, a core stage, an upper stage (also called an interim cryogenic propulsion stage), solid rocket boosters on both sides, and an Orion crew capsule on the top.

It produces more than 8 million pounds of thrust, 15 percent more than the Saturn V. The core level recently completed Green Run testing. This test would see the engine fire simultaneously as a unit, completing multiple test cases in 8 to 9 minutes.

struct LaunchVehicle {
    let name: String
    let heightInFeet: Int
    let thrustInPounds: Int
    let components: [String]
}

let spaceLaunchSystem = LaunchVehicle(
    name: "Space Launch System",
    heightInFeet: 322,
    thrustInPounds: 8_000_000,
    components: [
        "four RS-25 engines",
        "core stage",
        "interim cryogenic propulsion stage",
        "solid rocket boosters",
        "Orion crew capsule"
    ]
)

print("\(spaceLaunchSystem.name): \(spaceLaunchSystem.components.count) major component groups")

Key points:

  • LaunchVehiclePut the quantifiable facts about rockets into the same structure -heightInFeetUse the 322 feet in your speech. -thrustInPoundsUsing more than 8 million pounds in the speech, here is the lower limit record -componentsSave verbatim listing of major components -components.countCan be used to display system complexity on the UI

（09:17）

After Green Run testing, the core stage will need to be transported from New Orleans to the Kennedy Space Center. It can withstand millions of pounds of force and still maintain structural integrity during transportation.

struct TestCase {
    let name: String
    let durationMinutes: ClosedRange<Int>
    let purpose: String
}

let greenRun = TestCase(
    name: "Green Run testing",
    durationMinutes: 8...9,
    purpose: "fire all engines as one whole structure"
)

print("\(greenRun.name): \(greenRun.durationMinutes.lowerBound)-\(greenRun.durationMinutes.upperBound) minutes")

Key points:

  • TestCaseRecord test name, duration and purpose separately -durationMinutesuseClosedRange<Int>means 8 to 9 minutes -purposeCorresponding engines are ignited simultaneously as a whole structure
  • Output text can directly enter the test timeline interface

This type of data structure is suitable for engineering science popularization apps. When users drag the timeline, they can see the relationship between design, testing, transportation, and assembly.

Artemis: Unmanned verification first, then manned return to the lunar environment

（10:55）

Tiera uses the Artemis program to illustrate the SLS mission path.

Artemis 1 is the drone of 2021. SLS works with Orion as an initial flight demonstration structure. Orion will fly to a distance of 40,000 miles from the moon, which is approximately 280,000 miles from the Earth’s surface. Approximately 1.4 million miles total. On reentry, Orion enters the atmosphere at about 24,500 mph and the crew cabin temperature reaches about 5,000 degrees Fahrenheit.

struct ArtemisMission {
    let name: String
    let crewed: Bool
    let year: Int
    let objective: String
}

let artemisMissions = [
    ArtemisMission(
        name: "Artemis 1",
        crewed: false,
        year: 2021,
        objective: "collect data before astronauts come on board"
    ),
    ArtemisMission(
        name: "Artemis 2",
        crewed: true,
        year: 2022,
        objective: "carry four astronauts back to the lunar environment"
    ),
    ArtemisMission(
        name: "Artemis 3",
        crewed: true,
        year: 2024,
        objective: "carry astronauts back into the space environment"
    )
]

let crewedMissions = artemisMissions.filter { $0.crewed }
print(crewedMissions.map(\.name).joined(separator: ", "))

Key points:

  • ArtemisMissionSeparate the mission year, whether it is manned and whether it is manned and the target -Artemis 1ofcrewedforfalse, corresponding to unmanned flight -Artemis 2Documenting the return of four astronauts to the lunar environment -Artemis 3Recording astronauts entering the space environment again -filter { $0.crewed }Select a manned mission -map(\.name)Extract task name for list or label display

（12:28）

Artemis 2 will be on a 10-day mission. Orion orbits the Earth twice before heading to the Moon. A temporary cryogenic propulsion stage will propel Orion into high Earth orbit, after which Orion is separated from the propulsion stage and astronauts verify performance and operational capabilities.

let artemis2Sequence = [
    "reach an initial insertion orbit",
    "complete the first orbit",
    "interim cryogenic propulsion stage propels Orion to high-Earth orbit",
    "Orion separates from the interim cryogenic propulsion stage",
    "astronauts verify performance and operational capabilities"
]

for (index, event) in artemis2Sequence.enumerated() {
    print("Step \(index + 1): \(event)")
}

Key points:

  • artemis2SequencePreserve the order of tasks in your presentation
  • The order of the array corresponds to the order of the task process -enumerated()Generate step number -index + 1Let the interface appear from step 1 -eventIt is a task event that can be directly displayed

The most useful thing about this part for developers is the way the tasks are broken down. Complex targets are first broken down into three steps: unmanned verification, manned verification, and capability expansion. Each step produces data before proceeding to the next step.

Diverse teams: Innovation requires expanding the source of participants

（13:48）

Tiera mentioned Mae Jemison. It was only after she saw the first black female astronaut that she could more easily imagine herself becoming an aerospace engineer. She also recounted how she was afraid to speak up in meetings because she was the youngest, the only woman, or the only African-American member of the team.

She and her husband founded Rocket with the Fletchers to do student outreach, aerospace engineering education and mentor support. She summarizes the key components of innovation as passion, data and diversity of mind.

let innovationInputs = ["passion", "data", "diversity of mind"]

func checklist(from inputs: [String]) -> [String] {
    inputs.map { "Include \($0) in the product discussion" }
}

print(checklist(from: innovationInputs).joined(separator: "\n"))

Key points:

  • innovationInputsUse the three key words given at the end of the speech -checklist(from:)Convert keywords into team check items -mapGenerate a discussion reminder for each input
  • Output results can be entered into team retrospective, project kickoff or design review templates

For software teams, this is part of the product process. People from different backgrounds are more likely to identify the real barriers to different users. When inclusion is incorporated into the process, product issues are exposed earlier.

Core Takeaways

  1. What to do: Make a space mission timeline app

    • Why it’s worth doing: The session gives continuous fact clues for Saturn V, Voyager, OSIRIS-REx, New Horizons, ISS, Perseverance, Artemis.
    • How ​​to start: Use firststruct MissionModel names, years, goals, and key figures with SwiftUIListorTimelineViewDemonstrate task sequence.

  2. What to do: Make a large product life cycle dashboard

    • Why it’s worth doing: Tiera’s positions cover design, structural verification, installation, assembly confirmation, and configuration management, which is exactly an end-to-end link.
    • How ​​to start: Build requirements, design, implementation, testing, and release configuration into a unified state model, usingenumPresentation phase, saving change records in local JSON.

  3. What to do: Make a Green Run test explainer

    • Why it’s worth doing: Run multiple test cases in 8 to 9 minutes, a high-density testing process suitable for interactive visualization.
    • How ​​to start: Use an array to record test events, time intervals and purposes, bind explanatory text to each event, and then use a progress bar to simulate test advancement.

  4. What to do: Make an Artemis task simulation learning tool

    • Why it’s worth doing: The mission objectives of Artemis 1, 2, and 3 are clear and suitable for a staged learning path.
    • How ​​to start: UseArtemisMissionSave the year, whether it is manned or not, goals, key mileage, and filter unmanned and manned phases by mission.

  5. What to do: Make a team inclusion checklist

    • Why it’s worth doing: The speech breaks down innovation into passion, data and diversity of thinking, and is suitable for turning into team review actions.
    • How ​​to start: Use a fixed template to generate pre-meeting check items, including speaking opportunities, user sample sources, data basis and decision records.

Comments

GitHub Issues · utterances