Competency Structure Model for Programming (COMM_P)
Barkmin, Mike
The learning of programming can take manifold starting points, e.g. via friends or family, a school course, a compulsory requirement in vocational education (e.g. industrial robotics) or even in an academic setting (e.g. formalization and execution of mathematical algorithms in numerical mathematics). Within these approaches, context-specific programming languages are used, which might support different paradigms. In this paper, a proposal for a language and paradigm overarching competency structure model is developed from theoretical considerations. By analyzing different programming languages, textbooks and papers three content dimensions are derived.
Principles and the application of high-Level paradigms build the first dimension.
The second dimension elements represents paradigm and language independent concepts of program components, data types, basic data structures and algorithmic paradigms.
The last content dimension language is defined by syntax, semantics, standard library and the build/compile and run process of programming languages.
Network
List
- cognitive_processes
- interpreting
- producing
- elements
- program_components: Program components are the main building block of every program. They are used to determine the overall form of a program.
- expressions: An expression computes another value, based on the interpretation of a combination of variables, subprograms and operators. In most languages the evaluation order of an expression can be controlled by parenthesis. Expressions are used to control the flow of a program.
- coroutines: Generalized subroutines for non-preemptive multitasking. They allow to pause and resume the exGeneralized subroutines for non-preemptive multitasking. They allow to pause and resume the execution.
- subroutines: They are identified by name and exchange information with the rest of the program using parameters and return values. Depending on the high-level paradigm they can also be called functions, procedures or methods
- operators: An operator acts on one or more operands. These operands can be infix (4 + 4), prefix (+ 4 4) or postfix (4 4 +).
- arithmetic: e.g.: +, -, *, %, ...
- logical: e.g.: !, ||, not, &&, ?? ...
- relational: e.g.: >, <, <=, ...
- ternary: e.g.: _ ? _ : _
- bitwise: e.g.: >>, <<, |, &
- pointer: &hi, *hi
- other: new
- variables: They are named slots in memory where a value is stored.
- statements: They can be divided into two groups. Assignment statements and the statements to control the flow of a program.
- assignment: An assignment statement provides the mechanism by which the user can dynamically change the bindings of values to variables
- control: Select statements (e.g. if, switch) provide the means of choosing between two or more executing paths, iterative statements are causing a statement or collection to be executed zero, one, or more time or unconditional branch statements, which are transferring the execution control to a specified location in the program.
- iterative
- for
- while
- select
- if
- switch
- unconditional_branch
- call
- return
- break
- scope: The scope of a variable or subprogram is the range of statements in which the variable or subprogram is visible.
- data_types
- scalars: A data type which only consists of a single value. Common representatives: Boolean, Byte, Character, Integer, Float, Pointer, Null, Undefined, Void
- boolean
- character
- integer
- float
- pointer
- null_pointer
- void
- compounds: A data type which is composed of a set of types. Common representatives: Pair, Array, Associative Array, String, Record, Enum, Union
- array
- string
- record
- enum
- data_structures
- list
- linked_list
- binary_search_tree
- algorithmic_paradigms: Algorithmic paradigms are a generic way to design an algorithm. On the highest abstraction level an algorithm can be designed by using the iterative or recursive paradigm. There are also more specific algorithmic paradigms like divide and conquer, backtracking, greedy algorithm and so forth. The knowledge about these algorithmic paradigms helps design algorithms regardless of the high-level paradigm and the concrete languages.
- iteration
- recursion
- high_level_paradigm
- default
- imperative
- object_oriented
- application
- principles
- structure
- abstraction: Creating classes to simplify aspects of reality using distinctions inherent to the problem
- class: A description of the organization and actions shared by one or more similar objects
- encapsulation: Designing classes and objects to restrict access to the data and behavior by defining a limited set of messages that an object can receive
- inheritance: The data and behavior of one class is included in or used as the basis for another class
- object: An individual, identifiable item, either real or abstract, which contains data about itself and the descriptions of its manipulations of the data
- behavior
- message_passing: An object sends data to another object or asks another object to invoke a method
- method: A way to access, set, or manipulate an object’s information
- polymorphism: Different classes may respond to the same message and each class implements it appropriately
- functional
- principles
- first_class_functions: Functions are first-class citizens that may be manipulated as data.
- referential_transparency: A function call can be replaced by its return value. It makes the order and count of execution irrelevant.
- immutability: If a value is assigned to some variable, it cannot be reassigned.
- closure: Pairing a function with its environment.
- recursion: It is a situation when a function calls itself.
- lazy_evaluation: A value of an expression is not calculated in the moment of declaration. Instead, the calculation is delayed until needed.
- currying: Is a technique of transforming a function of multiple arguments into evaluating a sequence of functions, each taking one argument.
- pattern_matching: It provides the means to inspect and decompose nested data structure in a single statement.
- polymorphism: The operands of a function can be of more than one single type.
- procedural
- logical
- principles
- language
- default
- syntax
- semantic
- java
- syntax
- semantic
- standard_library
- python
- scratch
- c
- syntax
- semantic
- standard_library
- c++
- smalltalk
- lisp
- semantic
- standard_library
- pascal
- syntax
- semantic
- prolog
- syntax
- semantic
- javascript
- pseudocode: The guide can be found here: http://tiny.cc/codeguide
- syntax
- semantic
- standard_library