What concepts are needed to train Computational Thinking – Layer 1
In this First Layer of the ontology, concepts were identified that describe the domain of Computational Thinking and the domain of Computer Programming. Examples of collected concepts are:
Concepts{
Abstraction, Algorithm, Algorithmic_Thinking, Attribution, Automaton, Bit, Block, Byte, Collaboration, Computational_Thinking, Computer,
Control_Structure, Creation, Data_Structure, Data, Decomposition, Debug, Evaluation, Error, Flowchart, Input, Instruction, Language, Logical_Reasoning,
Operation, Operator, Operating, Output, Reading, Perseverance, Pattern_Recognition, Problem, Program, Programming, Regular_Expression, Result, Sequence,
Test, Text_Lang, Tinkering, Variable, Visual_Lang, Writing, ...}
After defining the concepts, it was necessary to add the relationships that connect concepts to give meaning to the universe of discourse.
Examples of relationships add are:
Relations{
acts_on, analyze, break, can_be, can_have, detect, follows, guide, involves, is_composed_of, is_equivalent_to, is_used_in, is_executed_by,
is_materialized_by, is_written_in, manipulate, oblige, produces, requires, structure, ...}
After concepts and relations, the necessary tuples (Subject=Predicate=>Object) were defined.
Below is a display fragment of this OntoCnE component that describes three main concepts: Algorithm, Computational Thinking and Program.
Triples{
Algorithm =[
requires => Computational_Thinking;
is_materialized_by => Program;
is_composed_of => Block;
manipulate => Data_Structure;
oblige => Sequence;
can_have => Control_Structure;
produces => Result;
follows => Skeleton ];
Computational_Thinking =[
involves => Creation, Debug, Collaboration, Tinkering;
requires => Perseverance, Decomposition, Abstraction, Pattern_Recognition, Logical_Reasoning, Algorithmic_Thinking, Evaluation ];
Program =[
is_composed_of => Block;
is_guided_by => Automaton;
is_written_in => Language;
is_executed_by => Computer ]; ... }
Reading the triples makes it simpler to see how the concepts relate to each other to form an understandable and meaningful description.
From the triples above it is possible to infer facts as: an Algorithm requires Computational Thinking and is materialized by a Program.
To go into details, the triples below provides more information about some of the object concepts in the listing above that are concerned with CT.
Triples{
Decomposition =[
acts_on => Problem;
break => Problem ];
Debug =[
analyze => Program;
detect => Error;
requires => Perseverance ];
Tinkering =[ involves => Test, Evaluation ]; ...}.
Computational Thinking involves Debug, and from triples above it is possible to understand that
Debug that analyzes a Program to detect Errors, and requires Perseverance.
To learn more about CP, triples below provides more information about some of the object concepts in the triples above that are concerned with CP.
Triples{
Block =[ is_composed_of => Instruction ];
Instruction =[
involves => Operation;
can_be => Attribution, Reading, Writing ];
Language=[
has => Syntax, Semantics, Lexicon;
can_be => Text_Lang, Visual_Lang];
Automaton =[
is_equivalent_to => Regular_Expression;
guide => Program ];
Regular_Expression =[
is_used_in => Pattern_Recognition ]; ...}.
Program is composed of Block, and from above it is possible to infer that a Block is composed of Instruction that can be
Attribution, Reading, Writing; and involves Operation.
Similarly Program is guided by an Automaton that is equivalent to a Regular Expression which is used in
Pattern Recognition.
Figure below displays a fragment of Layer 1 of OntoCnE.
