Classes 6-7 · Year two • Lobuche SummitAnalytical & representational

Own the logic in text.

By Class 7, text programming is a primary medium rather than a special event. Students design algorithms, use functions with parameters and returns, work with structured data, build simulations, test deliberately and inspect code they did not write.

“I can solve and explain more complex systems.”

Who owns whatThe problem and component structure are supplied; the learner increasingly owns algorithms, text implementation, data handling, testing and explanation.

“I can read and modify structured text with support.”

“I can design algorithms and implement most core logic in text, then test, debug and explain the system.”

What changes this year

Blank functions and small blank programs stop being intimidating.
Lists and dictionaries become normal representations of many pieces of information.
Functions become genuine abstraction: inputs through parameters, outputs through returns.
Algorithms are explicit objects of thought, not just code that happened to work.
Unfamiliar and AI-generated code becomes normal material to analyze, test and repair.
Data quality includes missing, duplicate and inconsistent values.
Simulation becomes a major way to reason about changing systems and assumptions.
Features, labels, model errors and training-data quality become more explicit.

Text is normal. Syntax is still not the curriculum.

Try the thinking

A minute of Lobuche Summit thinking.

An illustrative interaction, not a lesson from the curriculum — but the reasoning is the reasoning.

The code runs. The logic is still wrong.

Interactive example

A working program is not the same as a correct program. Find the case that exposes the bug.

The requirement

Orders of Rs 1,000 or more receive free delivery.

def free_delivery(total):
    if total > 1000:
        return True
    return False

Which test case exposes the bug?

Each case passes or fails silently. Pick the one whose expected result the code cannot produce.

Order total	Expected	Choose
Rs 850	false
Rs 1,000	true
Rs 1,250	true

What they produce

Structured Python programs
Algorithm descriptions / pseudocode
Simulation models and generated data
Data cleaning records and visualizations
Model feature/label experiments
Unfamiliar-code modifications
Intentional test suites/tables
Technical explanations

What you should be able to see

Text code the learner can trace and explain
A function design with meaningful parameters/returns
A deliberately chosen boundary/invalid test
A debugging record
A data cleaning decision
A simulation claim and its limitation
A model error the learner can explain

Support matters. A heavily guided success is not reported as independent mastery.

Twelve Projects. One climb.

A Band is not a pile of unrelated activities. Each standard Band contains 12 Projects arranged so that capability is established, combined, transferred and increasingly owned.

P1–P4Establish / Acquire
P5–P8Combine / Extend
P9–P12Transfer / Own

Illustrative synthesis example

A changing-system simulation with data and learned-model investigation

Design archetype: Simulation / data / model synthesis

Current Band design establishes the synthesis pattern; public Project naming should come from approved curriculum data.

Where Lobuche Summit lands on each capability

These are Band end-states, not lesson titles. Follow any of them across all eight years in the Capability Telescope.

Algorithms & problem solving: Describe algorithms independently of code, implement linear search and simple sorting/ranking, and compare alternatives.
Programming & representation: Text becomes a primary medium; trace functions, return values and collections and modify unfamiliar programs deliberately.
Debugging: Reproduce, isolate functions, inspect state, test minimal inputs and verify the fix against prior cases.
Testing & reliability: Choose ordinary, boundary and invalid inputs designed to reveal mistakes.
Data & evidence: Clean missing, duplicate or inconsistent values and use visualizations to answer evidence questions.
AI & machine learning: Use features/labels, investigate training-data quality and bias, and demystify fluent natural-language output as pattern-based rather than automatically true.
Systems & architecture: Coordinate functions, data, simulation state and simple network/request-response ideas.
Technical judgment: Explain when a hand-written rule is better than a learned model and critique unreliable AI output.
Security, privacy & human-centered computing: Use stronger privacy/security reasoning and refine systems through observed user feedback.
Explanation, transfer & technical defense: Explain functions, return values, simulation state, model features/labels, data cleaning and technical decisions.

Open the Capability Telescope

What becomes possible next

What Ama Dablam Basecamp adds

Class 8 turns fluency into applied building. The architecture is still supplied, but the learner owns serious implementation across algorithms, real data, APIs and simple machine learning.

Enter Ama Dablam Basecamp

What prepared them: Lobuche Basecamp See the whole climb

The whole climb