TL;DR
This paper investigates how prior programming experience, particularly with procedural and object-oriented paradigms, impacts learning a new visual, scenario-based programming language called Live Sequence Charts (LSC). The study reveals that experienced programmers often misinterpret or distort new concepts to fit their existing mental models, leading to less effective use of the new language and potentially erroneous programs.
What Problem Does This Paper Address?
The field of computer science education has long debated the optimal first programming language and paradigm. A core tenet of learning theory, constructivism, suggests that new knowledge is built upon existing mental frameworks (schemas). This paper specifically explores how these pre-existing schemas, formed by experience with procedural and object-oriented programming, influence the learning and adoption of a fundamentally different paradigm: scenario-based programming, as exemplified by LSC. The challenge is to understand if and how this prior experience, rather than being a pure advantage, can become a hindrance when encountering novel programming concepts and execution models.
Methods
The study employed a qualitative research methodology, focusing on in-depth interviews with nine graduate students learning LSC. This approach aligns with grounded theory, aiming to uncover emergent phenomena rather than test pre-defined hypotheses. The students were divided into two groups: Group A (CS graduates with significant procedural and OOP experience) and Group B (non-CS graduates with less programming experience). Data collection involved pre-interviews to assess experience, learning style questionnaires, analysis of student projects implemented in LSC, and semi-structured post-interviews to delve into their design decisions and understanding of LSC concepts.
Datasets
Not discussed in the paper. The study used student projects as the primary data source, which were developed by the participants themselves within the context of a university course.
Key Insights and Ideas
- The "Loss of Control" Phenomenon: Experienced programmers, accustomed to lower-level control, often perceive higher-level abstraction languages like LSC as limiting, leading to a feeling of "loss of power" and a negative attitude towards the new language.
- Forcing Familiar Patterns: Instead of fully embracing the new paradigm, experienced programmers tend to "force" familiar procedural or object-oriented patterns onto LSC. This includes mimicking functions with dedicated charts and imposing sequential execution where concurrency is natural.
- Misinterpretation of Novel Concepts: Concepts like LSC's symbolic instances, designed for flexible behavior definition, are often misinterpreted through the lens of object-oriented class/instance relationships, leading to suboptimal or incorrect usage.
- The "Not Really Programming" Sentiment: Some experienced programmers expressed that LSC felt "not really programming" because it didn't offer the low-level manipulation they associated with traditional programming.
- Attitude Matters: The study highlights how negative attitudes, stemming from perceived limitations or misunderstandings, can directly impact performance and the effective adoption of new programming concepts.
Key Results
The study identified several key phenomena:
- Perception of LSC as a Programming Language: One student (student #2) expressed dissatisfaction with LSC's perceived lack of low-level control, stating, "What you can do with LSC is very limited... You can't make computational things. You can't interact with the computer." This student also exhibited a negative attitude and less accurate programming.
- Procedural and Sequential Design Patterns: Five out of seven projects exhibited a "function pattern" where students mimicked procedural functions using dedicated LSC charts. Additionally, three students implemented a "sequentialization pattern" to force sequential execution, bypassing LSC's concurrent model. These patterns were observed in both Group A and Group B, but the underlying motivation and implications differed.
- Interpretation of Symbolic Instances: Students from Group A (experienced OOP) showed difficulties with meaningful binding expressions and the universal/existential modality of symbolic instances. For example, student #3 admitted, "The truth is that I don't really remember the difference [between universal/existential]." This contrasted with Group B students who used these features more effectively.
Limitations and Future Work
The authors acknowledge that their study is qualitative and based on a small sample size (nine students). They also note that individual characteristics, beyond programming experience, can influence learning. Future work could involve larger-scale empirical studies to quantify these effects and explore interventions to mitigate the negative impacts of prior experience. The authors also suggest that educators should explicitly address the underlying assumptions of different programming patterns and paradigms to help learners bridge the gap between familiar and novel concepts.
Summary updated