Academic Essay · Working Paper

This article explores how human language supports abstraction, sequencing, and rule interpretation in the development of computational thinking. It argues that language is not external to programming education, but central to how learners begin to understand systems, logic, and structure.

Focus

The discussion connects language-based reasoning with beginner problem solving, symbolic understanding, and the foundations of formal instruction.

Human Language and Computational Thinking

Abstraction, Reasoning and Meaning Making in Early Programming Education

This working paper examines the relationship between human language and computational thinking in early programming education. It argues that computational thinking should not be understood only as a technical preparation for coding, but as a cognitive and linguistic process through which learners learn to interpret problems, identify patterns, construct abstractions, reason about conditions and express processes in a formal way. Human language plays a central role in this development because learners encounter problems first as words, explanations, examples and classroom instructions before they transform them into algorithmic structures. The paper proposes that early programming education can benefit from a stronger awareness of how language supports abstraction, reasoning, sequencing and problem representation. From an applied linguistic and computational thinking perspective, the movement from ordinary language to formal reasoning is one of the central educational bridges in learning to code.

1. Introduction

Computational thinking is often described through skills such as decomposition, abstraction, pattern recognition, sequencing and algorithmic reasoning. These elements are essential, but they are sometimes presented as if they existed independently from language. In real learning situations, however, students rarely begin with abstract computational structures. They begin with human language. They read a task, listen to an explanation, ask questions, describe what they understand and try to formulate what should happen. Before computational thinking becomes visible in code, it is usually prepared through language.

This is especially important in early programming education. Beginners do not immediately think in variables, loops and functions. They first try to understand what the problem means. They ask what is given, what should be changed, what should be repeated, what should be checked and what result is expected. These questions are linguistic and cognitive before they become technical. The learner moves from meaning to structure, from structure to logic and from logic to code.

This working paper approaches computational thinking as a process of meaning making. It does not reduce programming to language learning, nor does it claim that natural language and programming languages are the same. Rather, it argues that human language provides the first cognitive space in which computational thinking begins to take shape. Through language, learners interpret problems, build mental models and prepare the transition toward formal reasoning.

2. Human Language as the First Layer of Problem Understanding

In beginner programming, the first difficulty is often not syntax. It is understanding the problem. A task such as “write a program that checks whether a number is even” may appear simple to an experienced programmer, but for a beginner it already contains several hidden relations. The learner must understand input, condition, divisibility, comparison and output. These meanings are carried by language before they are expressed in code.

Human language allows learners to approach complexity gradually. A student can first explain the task in ordinary words: I need to take a number and check if it can be divided by two without a remainder. This sentence is not yet code, but it already contains the logic of the solution. It identifies the object, the operation, the condition and the expected interpretation. The learner is already thinking computationally, but still within natural language.

This shows why classroom language matters. The way a task is formulated can support or block computational understanding. Words such as “repeat”, “compare”, “check”, “store”, “return”, “sort” and “filter” do not merely decorate a programming exercise. They guide the learner toward possible computational actions. They function as semantic signals. A learner who understands these words procedurally can more easily connect language with code.

3. From Meaning to Abstraction

Abstraction is one of the core elements of computational thinking, but abstraction does not begin in emptiness. Learners abstract from something. They begin with a concrete situation, example, sentence, object or problem and gradually identify what can be generalized. Human language supports this process because it allows learners to name relevant features and ignore irrelevant details.

For example, when students solve a problem about calculating the total price of several products, they first encounter a concrete situation. Through language, they can identify what matters: product price, quantity, discount, tax, final total. These words help separate the meaningful structure from the story around it. The learner slowly moves from a concrete narrative toward a more general computational model.

This movement is central to early programming education. A beginner may first understand one example, but the educational goal is to help the learner recognize the structure that can be reused in other situations. A calculation problem, a counting task or a filtering task becomes more than one exercise. It becomes a pattern. Language supports this transition because it allows the learner to describe the common relation behind different examples.

4. Reasoning Through Language

Reasoning in programming often begins as verbal reasoning. Learners talk themselves through a problem, either aloud or internally. They may say: first I need the input, then I need to check the condition, then I need to print the result. This verbal sequence is not a distraction from programming. It is part of the cognitive preparation for programming.

Human language helps learners hold several parts of a problem together. It allows them to organize steps, mark cause and consequence, compare alternatives and anticipate results. In early programming, this is especially important because the learner is still developing control over formal structures. Language gives them a temporary support system. It helps them manage meaning before they can fully manage syntax.

This is why explanation should not be treated as separate from programming. When students explain their solution, they reveal how they understand the problem. When they cannot explain it, the code often becomes mechanical or unstable. A student may copy an if statement without understanding the condition it expresses. They may write a loop without understanding what changes during repetition. Verbal reasoning helps expose these gaps and gives the teacher a way to respond before the learner becomes lost inside syntax.

5. Sequencing and the Grammar of Action

Programming requires sequence. A program does not execute intention in a general way; it follows ordered instructions. Human language also contains sequencing, but it often hides it through implication. In ordinary communication, people understand that some actions happen before others because context fills the gap. In code, however, the order must be explicit.

This creates a major challenge for beginners. They may understand the general goal of a task but fail to order the necessary steps. For example, they may try to print a result before calculating it, use a variable before assigning a value or place a condition after the action it was supposed to control. These are not only technical errors. They are sequencing errors, and they show that the learner has not yet stabilized the grammar of action.

The idea of a grammar of action is useful here. Human language has grammatical structure, but programming requires procedural structure. Learners must learn not only what something means, but when it should happen. They must understand the order of input, processing, condition checking, repetition and output. Early programming education can support this by asking learners to describe the order of actions before writing code.

6. Pattern Recognition Across Language and Code

Pattern recognition connects human language and computational thinking in a powerful way. In language learning, learners notice repeated forms, sentence structures, collocations and meaning relations. In programming, they notice repeated operations, control structures, data patterns and problem types. In both cases, learning depends on seeing what repeats and what changes.

A student who recognizes that several tasks ask them to “check whether” something is true begins to see a pattern of conditional reasoning. A student who sees that “count how many” often requires a counter and a loop begins to connect lexical meaning with program structure. A student who notices that “for each item” points toward iteration is already building a bridge between language and computation.

Pattern recognition also supports transfer. Learners do not become stronger because they memorize one solution. They become stronger when they recognize that the structure of one solution can be adapted to another problem. Language helps this process when teachers and learners name the pattern clearly. Instead of treating every exercise as new, they can ask: What kind of problem is this? What have we seen before? Which structure returns here in a different form?

7. Human Language, Pseudocode and Cognitive Scaffolding

Pseudocode is one of the strongest bridges between human language and computational thinking. It allows learners to express logic without immediately carrying the full burden of programming syntax. In this intermediate space, learners can organize meaning, sequence actions and test reasoning before translating the solution into Python or another programming language.

This staged movement is educationally important because beginners often face cognitive overload. They must understand the problem, remember syntax, plan the logic, manage indentation, interpret error messages and check output. When all of these demands appear at the same time, learning can become blocked. Pseudocode reduces this pressure by allowing the learner to focus first on structure.

From a learning perspective, pseudocode works as scaffolding. It supports the learner temporarily while they build more independent control over formal reasoning. The learner can write: get the number, check if the remainder is zero, print even, otherwise print odd. This is not yet Python, but it is already computational thinking. The learner has moved from meaning into ordered logic.

8. Early Programming Education as Cognitive Translation

Early programming education can be understood as a process of cognitive translation. The learner translates a human problem into a formal process. This translation does not happen in one step. It passes through several layers: natural language, internal reasoning, structured description, pseudocode, code, execution and reflection.

Each layer changes the form of the problem. Natural language carries meaning. Internal reasoning organizes intention. Structured description separates parts. Pseudocode orders action. Programming language formalizes the structure. Execution tests whether the formal structure behaves as expected. Reflection allows the learner to compare meaning and result.

This model helps explain why programming errors are often educationally valuable. An error shows where the translation broke down. Did the learner misunderstand the language of the task? Did they identify the wrong condition? Did they order the steps incorrectly? Did they choose the wrong formal structure? Error analysis can therefore reveal not only what failed, but where the learner’s understanding needs support.

9. Research Direction

This working paper proposes a research direction that connects human language, computational thinking and early programming education. Possible research questions include:

✓ How does human language support the development of computational thinking in beginner programming education?

✓ How do learners use natural language to understand, explain and structure programming problems?

✓ How do abstraction, sequencing and reasoning emerge through classroom language and task interpretation?

✓ How can pseudocode support the movement from human language to formal programming structures?

✓ How can learner explanations reveal developing mental models of computational processes?

A possible methodology could include classroom observation, analysis of learner explanations, pseudocode tasks, beginner code analysis and think aloud protocols. Such an approach would make it possible to examine how learners move between language, reasoning and formal representation during the early stages of programming education.

10. Educational Implications

If human language plays a central role in computational thinking, then programming education should create more space for explanation, reformulation and structured verbal reasoning. Learners should be encouraged to describe problems before coding, identify action words, explain conditions, name variables meaningfully and compare expected output with actual output.

This does not make programming less technical. It makes technical learning more accessible and cognitively grounded. A student who can explain the logic of a task is better prepared to express that logic in code. A student who can name the relation between input, process and output can more easily understand functions. A student who can describe what repeats can more easily understand loops.

For teachers, this means that the language around programming matters. Questions such as “What is the task asking?”, “What should happen first?”, “What changes?”, “What stays the same?”, “What condition controls the action?” and “What result do you expect?” are not simple support questions. They are tools for developing computational thinking.

11. Synthesis and Outlook

Human language is not outside computational thinking. It is one of the first spaces in which computational thinking becomes possible for beginners. Learners use language to interpret tasks, identify relations, build abstractions, reason through steps and prepare formal structures. Programming education should therefore recognize language as a cognitive resource, not merely as a way of giving instructions.

From my perspective as a linguist and educator, this is where early programming education becomes especially meaningful. Code can be taught as syntax, but it can also be taught as structured thought. When learners move from human language into formal representation, they are not only learning a programming language. They are learning to make reasoning more explicit, to transform vague understanding into precise structure and to see how meaning can become executable.

This paper argues that computational thinking should be studied not only through code outcomes, but through the linguistic and cognitive processes that precede code. The learner’s explanation, hesitation, pseudocode, variable naming and debugging language all reveal how understanding develops. For this reason, the relationship between human language and computational thinking offers a rich research field for applied linguistics, programming education and computational learning research.