Project EE/06/B/FPP-169000 

Learning Materials for Information Technology Professionals (EUCIP-Mat)

PROGRAMMING 1. Number of study hours: 50 2. Short description of the course: Module expands upon programming methods (object oriented programming, structured programming). Student gets the review of different data structures (arrays, entries, linked lists etc) and the algorithms of their processing. Students also learn to differentiate different translation methods (compiling and interpreting). Module gives also brief introduction of main program constructions (such as iteration, conditional sentence etc) and review of program testing, documenting and managing. 3. Target groups Module target groups are first of all vocational and high education students, who specialize on information technology, but it is also an interest of those who simply wish to pass the respective qualifying examination. 4. Prerequisites Passing through the module does not presuppose from student any former knowledge from the field of information technology. 5. Aim of the course - learning outcomes Student who has passed through the module: 1) Can differentiate different programming methods, such as object oriented programming, top-down engineering, structure programming; 2) Knows abstraction as the method used for solving tasks and development works; 3) Understands specific needs of legacy system needed for software development; 4) Understands the attributes of different data structures: entries, arrays and linked list; 5) Understands relations between multiple widely known algorithms and above mentioned data structures; 6) Knows basic types of programming languages (different generations, functional, procedural, object oriented); 7) Understands the roll of syntax in programming language; 8) Understands the differences between compiling and interpreting of programming language; 9) Understands most important constructions of programming languages; 10) Understands main functions of automatic testing tools; 11) Knows and is able to use testing methodologies; 12) Understands main functions of module, link and system testing; 13) Knows and is able to use basic documenting requirements for software development and distribution (f.e. decision trees); 14) Understands the conception of well structured program and the respective documentation.

6. Content : B.3 PROGRAMMING B.3.1 Software Design Methods and Techniques B.3.1.1 Main features of different program design methods

Software development is mostly teamwork nowadays and therefore this field is based on different rules and methods. Those rules and best practice is worked out foremost for making it easier for people, related to software development, to understand each other, but also for standardization of their work in order to make it understandable to everyone.

Standardization enables to ensure software quality and reduce the time and money spent on software development.

Software development can roughly be divided into following subordinate tasks: 1. Description and analysis of needs 2. Design of software product 3. Execution 4. Testing 5. Product release 6. Product management Description and analysis of needs Software creation begins usually with the description and analysis of needs. The more precise and correct the description and analysis of the needs are, the easier it is to accomplish all the other development phases thereafter. Main problem in this phase is different vision of the customer and software developer. We can often face the situation where customer does not know anything about programming and software design, but he does own clear vision of what he needs. Software developer in turn has no clear vision of customers’ working processes and tends to think about different software implementation possibilities and tools too early. Design of software Developer must think about different software implementation possibilities in phase of software design. Main task in this phase is to think about how to implement needed software product with as little money and time as possible. It is important to assure that the product in creation would correspond to the following requirements: • reliability • altering contingency • comprehensibility • reusability At this point the meaning of reliability is the fact that software must correspond to the needs of customer and how the software acts in situations not described by the customer. Software is considered as error-free if it satisfies the needs described by the customer. If software is functioning as expected also in situations not described by the customer, then the software product is considered as robust. Altering contingency is also very important in case of modern software solutions, because each existing software product can be a basis for some new product. Therefore it is very important to think of what is needed to do for reusing the software in creation in similar products. Altering contingency is also important if errors or non conformances to the needs are found in software product. Need of the comprehensibility comes foremost from the fact, that software execution is done as teamwork and solution must be understandable for everyone related to software product implementation, testing and management, and also later, after the execution of the software. Software design phase is also the phase, where it is necessary to decide about the division of software solution (how many subroutines and which ones). It is very important to consider the reusability requirements, while dividing software into subroutines – too huge subroutines might be too difficult to reuse and too small subroutines might cause unnecessarily high primary development costs. There are very few solutions nowadays that enable solid solutions. There are two approaches in dividing the software solution into subroutines: top-down and bottom-up. In case of top-down approach the inception task is divided into subordinate tasks, each one of which can in turn consist of subordinate tasks. Those subordinate tasks are also divided into subordinate tasks until the inception task consists of simple and clear subordinate tasks. Shortcoming of this approach is the fact, that it is useless to use it in case of huge solution, because inception task would then be divided into very many subordinate tasks and this might cause situations where one and the same problem is solved repeatedly (because multiple subordinate tasks require solving of similar problems). In addition to foregoing it is necessary that software designer starts to think quite early about concrete algorithms, which could be used for solving given problems. Bottom-up approach divides inception task into submodules, which are handled as “black boxes”. Thereafter it is necessary to describe each submodule, i.e. how should it function and between which modules the information has to be exchanged. This enables the dividing huge inception task into independent subordinate tasks, which can be developed separately It is easy to find reusable modules, that can be used for compiling a new solution from existing solutions, in case of bottom-up approach. This in turn hastens up and simplifies the implementation of new solution remarkably. Greatest problem of this solution is often the fact, that information exchange between modules and managing of data exchange is not precisely described. Often it is useful to divide inception task into submodules with the help of bottom-up approach and in turn to solve them for good with the help of top-down approach. Additional reading: Software development methods Structured programming can be seen as a subset or subdiscipline of procedural programming, one of the major programming paradigms. It is most famous for removing or reducing reliance on the GOTO statement. Several different structuring techniques or methodologies have been developed for writing structured programs. The most common are: 1. Dijkstra's structured programming, where the logic of a program is a structure composed of similar sub-structures in a limited number of ways. This reduces understanding a program to understanding each structure on its own, and in relation to that containing it, a useful separation of concerns. 2. A view derived from Dijkstra's which also advocates splitting programs into sub-sections with a single point of entry, but is strongly opposed to the concept of a single point of exit. 3. Data Structured Programming, which is based on aligning data structures with program structures. This approach applied the fundamental structures proposed by Dijkstra, but as constructs that used the high-level structure of a program to be modeled on the underlying data structures being processed. Additional reading: Edsger Dijkstra, Notes on Structured Programming, Object-oriented programming (OOP) is a programming paradigm that uses "objects" and their interactions to design applications and computer programs. Programming techniques may include features such as encapsulation, modularity, polymorphism, and inheritance. Fundamental concepts of OOP are the following: Class Defines the abstract characteristics of a thing (object), including the thing's characteristics (its attributes, fields or properties) and the thing's behaviors (the things it can do, or methods, operations or features). One might say that a class is a blueprint or factory that describes the nature of something. For example, the class Dog would consist of traits shared by all dogs, such as breed and fur color (characteristics), and the ability to bark and sit (behaviors). Classes provide modularity and structure in an object-oriented computer program. A class should typically be recognizable to a non-programmer familiar with the problem domain, meaning that the characteristics of the class should make sense in context. Also, the code for a class should be relatively self-contained (generally using encapsulation). Collectively, the properties and methods defined by a class are called members. Object A pattern (exemplar) of a class. The class of Dog defines all possible dogs by listing the characteristics and behaviours they can have; the object Lassie is one particular dog, with particular versions of the characteristics. A Dog has fur; Lassie has brown-and-white fur. Instance One can have an instance of a class or a particular object. The instance is the actual object created at runtime. In programmer jargon, the Lassie object is an instance of the Dog class. The set of values of the attributes of a particular object is called its state. The object consists of state and the behaviour that's defined in the object's class. Method An object's abilities. In language, methods are verbs. Lassie, being a Dog, has the ability to bark. So bark() is one of Lassie's methods. She may have other methods as well, for example sit() or eat() or walk() or save_timmy(). Within the program, using a method usually affects only one particular object; all Dogs can bark, but you need only one particular dog to do the barking. Message passing The process by which an object sends data to another object or asks the other object to invoke a method, is called the “Message passing” Also known to some programming languages as interfacing. E.g. the object called Breeder may tell the Lassie object to sit by passing a 'sit' message which invokes Lassie's 'sit' method. The syntax varies between languages, for example: [Lassie sit] in Objective-C. In Java code-level message passing corresponds to "method calling". Some dynamic languages use double-dispatch or multi-dispatch to find and pass messages. Inheritance ‘Subclasses’ are more specialized versions of a class, which inherit attributes and behaviors from their parent classes, and can introduce their own. For example, the class Dog might have sub-classes called Collie, Chihuahua, and GoldenRetriever. In this case, Lassie would be an instance of the Collie subclass. Suppose the Dog class defines a method called bark() and a property called furColor. Each of its sub-classes (Collie, Chihuahua, and GoldenRetriever) will inherit these members, meaning that the programmer only needs to write the code for them once. Each subclass can alter its inherited traits. For example, the Collie class might specify that the default furColor for a collie is brown-and-white. The Chihuahua subclass might specify that the bark() method produces a high pitch by default. Subclasses can also add new members. The Chihuahua subclass could add a method called tremble(). So an individual chihuahua instance would use a high-pitched bark() from the Chihuahua subclass, which in turn inherited the usual bark() from Dog. The chihuahua object would also have the tremble() method, but Lassie would not, because she is a Collie, not a Chihuahua. In fact, inheritance is an ‘is-a’ relationship: Lassie is a Collie. A Collie is a Dog. Thus, Lassie inherits the methods of both Collies and Dogs. Multiple inheritance is inheritance from more than one ancestor class, neither of these ancestors being an ancestor of the other. For example, independent classes could define Dogs and Cats, and a Chimera object could be created from these two which inherits all the (multiple) behavior of cats and dogs. This is not always supported, as it can be hard both to implement and to use well. Encapsulation Encapsulation conceals the functional details of a class from objects that send messages to it. For example, the Dog class has a bark() method. The code for the bark() method defines exactly how a bark happens (e.g., by inhale() and then exhale(), at a particular pitch and volume). Timmy, Lassie's friend, however, does not need to know exactly how she barks. Encapsulation is achieved by specifying which classes may use the members of an object. The result is that each object exposes to any class a certain interface — those members accessible to that class. The reason for encapsulation is to prevent clients of an interface from depending on those parts of the implementation that are likely to change in future, thereby allowing those changes to be made more easily, that is, without changes to clients. For example, an interface can ensure that puppies can only be added to an object of the class Dog by code in that class. Members are often specified as public, protected or private, determining whether they are available to all classes, sub-classes or only the defining class. Some languages go further: Java uses the default access modifier to restrict access also to classes in the same package, C# and VB.NET reserve some members to classes in the same assembly using keywords internal (C#) or Friend (VB.NET), and Eiffel and C++ allow one to specify which classes may access any member. Abstraction Abstraction is simplifying complex reality by modelling classes appropriate to the problem, and working at the most appropriate level of inheritance for a given aspect of the problem. For example, Lassie the Dog may be treated as a Dog much of the time, a Collie when necessary to access Collie-specific attributes or behaviors, and as an Animal (perhaps the parent class of Dog) when counting Timmy's pets. Abstraction is also achieved through Composition. For example, a class Car would be made up of an Engine, Gearbox, Steering objects, and many more components. To build the Car class, one does not need to know how the different components work internally, but only how to interface with them, i.e., send messages to them, receive messages from them, and perhaps make the different objects composing the class interact with each other. Polymorphism Polymorphism allows the programmer to treat derived class members just like their parent class' members. More precisely, Polymorphism in object-oriented programming is the ability of objects belonging to different data types to respond to method calls of methods of the same name, each one according to an appropriate type-specific behavior. One method, or an operator such as +, -, or *, can be abstractly applied in many different situations. If a Dog is commanded to speak(), this may elicit a bark(). However, if a Pig is commanded to speak(), this may elicit an oink(). They both inherit speak() from Animal, but their derived class methods override the methods of the parent class; this is Overriding Polymorphism. Overloading Polymorphism is the use of one method signature, or one operator such as ‘+’, to perform several different functions depending on the implementation. The ‘+’ operator, for example, may be used to perform integer addition, float addition, list concatenation, or string concatenation. Any two subclasses of Number, such as Integer and Double, are expected to add together properly in an OOP language. The language must therefore overload the concatenation operator, ‘+’, to work this way. This helps improve code readability. How this is implemented varies from language to language, but most OOP languages support at least some level of overloading polymorphism. Many OOP languages also support Parametric Polymorphism, where code is written without mention of any specific type and thus can be used transparently with any number of new types. Pointers are an example of a simple polymorphic routine that can be used with many different types of objects.[2] Decoupling Decoupling allows for the separation of object interactions from classes and inheritance into distinct layers of abstraction. A common use of decoupling is to polymorphically decouple the encapsulation, which is the practice of using reusable code to prevent discrete code modules from interacting with each other.

B.3.1.2 Procedures and functions

In order to simplify the structure of the program, it is reasonable to divide greater programming task into smaller subordinate tasks. Solving of subordinate tasks is delegated to smaller consistent submodules – procedures and functions. Such approach simplifies program debugging and managing. This method reduces programming works due to the reusability of submodules. Procedures and functions are different comparing to their using methods. Function is used by means of function reference, procedure is used by means of procedure sentence. Function always returns the value differentially from the procedure.

Relation between submodule and module that calls submodules is organized with the help of module parameters. They are divided into two groups by types of parameter transmition:

a) call by reference – in case of which the values of parameters stored by calling module can be altered by called module. This call is technically realized the way, that calling module passes the addresses of referable parameters to the called module. b) call by value – in case of which the actual values of the referable parameters are passed by the calling module to the called module. Values of parameters stored by calling module of stored for calling module can not be altered by called module in case of call by value.

Example If we have the procedure myproc defined with two parameters and function myfunc defined with one parameter, then it is possible to activate them as follows:

myproc (a, b); d = myfunc( e/f );

In case of first sentence the procedure myproc is accompliched, in case of second sentence the value of function myfunc is calculated and stored to the variable d.

Procedures and functions are often also called as subroutines. Program which calls subordinate program, but is not itself a subroutine, is called main program.

B.3.1.3 Abstraction as a technique for problem-solving and software design Abstraction has an important role in software development. Abstraction is considered as an approach, where all the irrelevant sides, which are irrelevant in context of solving given problem, are left aside during the analysis of some certain phenomena. Thinking of this, the abstraction in information technology is similar to abstraction in mathematics, where only those attributes of real words’ objects- phenomena are kept for defining mathematic terms (line, number, function etc), which are important for building up the respective mathematic theory. Example of this could be the number of abstract terms, which have meaning both in mathematics and programming languages. Depiction of number in computer depends on both the software and hardware, but it does not alter the meaning of the content of the term. Abstractions in programming languages can generally be divided into two groups: a) control abstraction; b) data abstraction. Control abstraction is considered as systematic use of submodules and commands of control flow (iteration, selection etc) in case of structure programming. Data abstraction is considered as adequate mirroring of real words’ data in data structures of programming language (vectors, entries etc). Control and data abstractions are compatibility in object oriented programming languages. B.3.1.4 Legacy systems

Legacy system is considered as over-aged application program or hardware device, which has been in use in past and which is also used nowadays.

Legacy systems are related with following possible problems: a) They often function on over-aged hardware and therefore it is expensive to keep them functioning; b) Absence of skills needed for system development and management in the enterprise (i.e. the engineers that have created the system have left the enterprise); c) Backward compatibility has to be taken care of in case of the implementation of new systems.

B.3.2 Data structures and algorithms B.3.2.1 Data types and structures Variables Programming involves often the need of remembering some amount of data (intermediate results, happened events, input values, output values etc). Such values have to be kept in memory. Therefore one spot in memory is defined and used for storing data. This spot is called variable. As data, which is stored, can be very different, then the type of data, which will be stored in variable, is also named while defining variable (type of variable). Need after the variable type derives from the fact, that different data uses different amount of memory space in memory. For example, 8 bits i.e. one byte enables to remember 28=256 different states. 256 different states enable: to remember integers 0..255, integers with marks -128..127, one symbol with the help of ASCII code table etc. Number of binary system 111111112 can stand for integer 255 for example, but also -1. In order to understand how should this value be used, we must know the type of data. Well known variable types are: truth-value, integer without mark, integer with mark, real number (with decimal point), character, text etc. As different data uses memory space differently then different variable types also use different size in the memory. Truth-value uses least memory (two states – correct/false) – 1 bit and integer (2-8 bytes), real number variables demand already more memory and text demands at least 1 byte for one symbol. Variable types can be divided: mathematical variable types (integers, real numbers etc) and symbolical variable types (characters, texts, etc), values types (variables, which have concrete size and place) and pointer types. Additional reading: Arrays Array is the set of variables of the same type, which have the same name and which can be differentiated in between by index. Arrays simplify the process of data of the same type remarkably. Simplifying derives from the fact that it is easy to alter variable during the program execution and therefore it is easier to turn to the needed variable. Arrays can be one-dimensional (sequence, row), two-dimensional (table, matrix), three-dimensional (cubic) etc. Example (C#) int[] mass = new int[10]; mass[0]=1; mass[1]=1; for (int i = 2; i <= 9; i++) mass[i] = mass[i - 1] + mass[i - 2]; for (int i = 0; i <= 9; i++) Console.WriteLine(mass[i]); Mass

1 1 2 3 5 8 13 21 34

55 This is an example where one-dimensional array mass is created, which has ten members. Two of which are valued with “1” and following are filled with the sum of previous two members. Thereafter all the values are typed to the console window in a row (beginning from 0 member and ending with 9th member). Records (structures) Records are used for keeping different type of data that forms together into some sort of related set. For example, record “human” forms from following data: name (text), family name (text), gender (truth-value, 0- woman, 1 - man), weight (real number). Such data forms an integral whole for describing one person, but is of very different type if stands alone. Example (C#)

       struct person {
            public string name;
            public string family name;
            public bool gender;
            public float weight;

Such record can be used for creating new variable user and give the user a name, family name, gender and weight:

       person user; = "Jaan"; name = "Mets";
       user.gender = 1;
       user.weight = 80.0;

Linked lists and trees Lists are often used for data storing nowadays. Linked lists and arrays are similar since they both store collections of data. Linked lists have their own strengths and weaknesses, but they happen to be strong where arrays are weak. The array's features all follow from its strategy of allocating the memory for all its elements in one block of memory. In contrast, a linked list allocates space for each element separately in its own block of memory called a "linked list element" or "node". The list gets is overall structure by using pointers to connect all its nodes together like the links in a chain. Each node contains two fields: a "data" field to store whatever element type the list holds for its client, and a "next" field which is a pointer used to link one node to the next node. End of linked list is marked as 0-member.

Linked list, where each member refers to the following, is called one-way list. Linked list, where each member refers both to the following and previous member, is called two-way list. Linked lis, where the first and last member is absent and each member refers to the following member, is called circular list. Length of linked list is the number of its members. First member is the head and all the others are tail. Stack is a linked list, where the finally added member is read out first ( LIFO – Last In First Out). Queue is a linked list, where first member is read out first ( FIFO – First In First Out). Additional reading: Tree is the data structure, where data is located in shape of tree and it consists of nodes and edges, which connect nodes (references). Nodes that are connected to the top node with the edge are called children and top node is called a parent in that case. The first top node is called a root. Node that has no children is called a leaf.

Moving from the node to the parent and iteratively further we reach the root. All the ancestors are nodes that are situated between the node and root. Tree height is the longest from the leaf to the root. In case of sorted tree, the definition is given to the root and nodes connected directly to the root are called first level nodes (roots’ children). Nodes connected directly to the first level nodes are second level nodes etc. The order of children from left to the right is important. Additional reading: Binary tree is a tree, where each parent can have none, one or two children and the order of the children is important.

B.3.2.2 Typical search and sort algorithms using the different data structures Binary search tree is a binary tree, which is ordered. Smaller quantity is always on the left side and greater quantity is always on the right side of the node.

Searching from such tree the searchable value is always compared with the root. If searchable value is equal to root value, then the value exists. If searchable value is not equal to root value, then further comparison is needed respectively in between nodes on left side and nodes on right side until the leaf is found. If searchable value is equal to the value of some node, then the element exists. If there is no equal value, then the element does not exist. Such searching type is many times faster than looking through the linked list or array. Additional reading: B-tree is a searching tree, where the number of children in each node is between (t-1) and (2t-1), where “t” is an arbitrary constant. Additional reading: B*-tree is B-tree, where fulfilment of nodes is kept around 2/3, by filling two child nodes by reallocating the keys and dividing them into three nodes. B.3.3 Programming languages

B.3.3.1 Main types of programming languages

A computer requires programs to function. Every program is written in certain programming language. A programming language is an artificial language that can be used to control the behaviour of a machine, particularly a computer. Programming languages differ from natural languages in that natural languages are only used for interaction between people, while programming languages also allow humans to communicate instructions to machines. Programming languages differ from most other forms of human expression in that they require a greater degree of precision and completeness. When using a natural language to communicate with other people, human authors and speakers can be ambiguous and make small errors, and still expect their intent to be understood. However figuratively speaking, computers "do exactly what they are told to do", and cannot "understand" what code the programmer intended to write. The combination of the language definition, the program, and the program's inputs must fully specify the external behaviour that occurs when the program is executed. Computer programs can be categorized by the programming language paradigm used to produce them. A programming paradigm is a fundamental style of programming. Two of the main paradigms are imperative and declarative.

Imperative programming

Imperative programming is a programming paradigm that describes computation as statements that change a program state. In much the same way as the imperative mood in natural languages expresses commands to take action, imperative programs are a sequence of commands for the computer to perform. Procedural programming is a common method of executing imperative programming, and the terms are often used as synonyms.

Procedural programming can refer to a programming paradigm based upon the concept of the procedure call. Procedures, also known as routines, subroutines, methods, or functions simply contain a series of computational steps to be carried out. Any given procedure might be called at any point during a program's execution, including by other procedures or itself. Procedural programming is often a better choice than simple sequential or unstructured programming in many situations which involve moderate complexity or which require significant ease of maintainability.

Possible benefits of procedural programming:: • The ability to re-use the same code at different places in the program without copying it. • An easier way to keep track of program flow than a collection of "GOTO" statements (which can turn a large, complicated program into spaghetti code). • The ability to be strongly modular or structured.

List of some popular procedural programming languages: • Ada • ALGOL • BASIC • C • COBOL • Fortran • Pascal • Perl • PHP • Python • VBScript

Object-oriented programming

Object-oriented programming (OOP) is an imperative programming paradigm that uses "objects" and their interactions to design applications and computer programs. Programming techniques may include features such as encapsulation, modularity, polymorphism, and inheritance. It was not commonly used in mainstream software application development until the early 1990s. Many modern programming languages now support OOP.

Object-oriented programming may be seen as a collection of cooperating objects, as opposed to a traditional view in which a program may be seen as a group of tasks to compute ("subroutines"). In OOP, each object is capable of receiving messages, processing data, and sending messages to other objects. Each object can be viewed as an independent little machine with a distinct role or responsibility. The actions or "operators" on the objects are closely associated with the object. For example, in object oriented programming, the data structures tend to carry their own operators around with them (or at least "inherit" them from a similar object or "class"). The traditional approach tends to view and consider data and behaviour separately.

A non-comprehensive list of some languages with object-oriented features:

• Java • C++ • C# • Python • PHP • SmallTalk • Ruby

Declarative programming

A program is "declarative" if it describes what something is like, rather than how to create it. For example, HTML web pages are declarative because they describe what the page should contain, but not how to actually display the page on a computer screen. This is a different approach from imperative programming languages, which require the programmer to specify an algorithm to be run. Declarative programming languages can be declarative in a variety of ways. Logic programming languages, such as Prolog, are declarative in that the programmer states relationships and asks a question about those relationships — without defining how to compute the answer. Functional programming languages, such as Haskell, are declarative in that functions relate their output to their input — without defining a strict order to evaluate any operations. Data-oriented programming languages and query languages are declarative in that queries are not given in terms of how to find data but instead give criteria for the desired data (SQL and regular expressions are examples).

B.3.3. The syntax programming languages The syntax of a programming language is the set of rules that a sequence of characters in a source code file must follow to be considered as a syntactically conforming program in that language. Syntax defines the structure of a language. In a natural language, the structure of words and sentences is defined by the syntax. In a programming language, the ways of composing directives, declarations and other programming constructs are defined by the syntax. B.3.3.3 Compilation and interpretation

Before the computer is able to execute a program written in high language, it is necessary to translate it into a language understandable for the computer i.e. machine code.

Such process is called translation and translator of translation program. Translators divide into two classes: compilators and interpretators. In case of compiling, the program in machine code (called compilator) translates the program written in some sort of a programming language into machine code. Thereafter the program in machine code is executed. Examples of compiled languages are such as C, Fortran, Pascal.

In case of interpretation, the program in machine code (called interpretator) reads the program file into internal memory and starts to execute it from there row by row. Example of interpretators can be old BASIC-language.

Interpretation of the program is 10-200 times slower than execution of compiled code. Debugging (removing of faults from the program) of interpreted program in turn easier than in case of compiled program.

Basically, programs can be executed both by interpreting or compiling, no matter which language is used for writing it. . B.3.4 Elementary constructs Each program written in a procedural program consists usually of the statements. Those can be grouped: • Declarations • Arithmetic and logic operations • Control commands • Input-Output (I/O) commands

A declaration specifies a variable's dimensions, identifier, type, and other aspects. It is used to announce the existence of a variable or function; this is important in many languages (such as C and Pascal), which require variables to be declared before use. A declaration is often used in order to be able to access functions or variables defined in different source files, or in a library. Here are some examples of declarations in EPL (EUCIP Programming Language): int example1; float example3; char example5; In this example we declare three variables – character type of variable example5, integer type of variable example and real number type of variable example3. In a similar way one can declare arrays:

int example6[100]; float example7[5]; char example8[10];

Arithmetic and logic operations are used for changing the state of program or values of data objects.

Control commands define the rules of execution (execution of different program parts, omissions, recurrent execution etc). Input-output commands enable the program to communicate with input-output devices or other programs.

B.3.4.1 Input/output instructions

Input/output, or I/O, refers to the communication between an information processing system (such as a computer), and the outside world – possibly a human, or another information processing system. Inputs are the signals or data received by the system, and outputs are the signals or data sent from it. The term can also be used as part of an action; to "perform I/O" is to perform an input or output operation. I/O devices are used by a person (or other system) to communicate with a computer. For instance, keyboards and mice are considered input devices of a computer, while monitors and printers are considered output devices of a computer. Devices for communication between computers, such as modems and network cards, typically serve for both input and output. Higher-level operating system and programming facilities employ separate, more abstract I/O concepts. For example, most operating systems provide application programs with the concept of files. The C and C++ programming languages, and operating systems in the Unix family, traditionally abstract files and devices as streams, which can be read or written, or sometimes both. The C standard library provides functions for manipulating streams for input and output. EPL language has only two statements (functions) which are used as input-output commands: printf() and readf().

Function printf() is usable as follows: printf(„Some text”, variable1[,variable2...])

Paragraph of text “Some text” is written to output as text and to the values of variable 1 and variable 2 as the values of the variables in case of the example above.

Output is called as standard output in case of given example (stdout – standard output). This information flow is directed to the display in case of most programming languages, but most programs have also the possibility to redirect this information flow also to file, printer, other program etc.

Function readf() is usable as follows:


In case of present example the values from input flow are read to the variable 1, variable 2 etc. Input is called as standard input in case of given example (stdin – standart input). Usually, this information flow consists of the values inserted from the keyboard, but often it is also possible to connect this flow also with some file, some other program etc.

B.3.4.2 Control statements Control commands specify the rules of program execution (execution, skipping and repeated execution of different program parts). Basically there are three types of control commands: • Unconditional jump • Conditional sentences • Repeats Unconditional jumps enable to “jump” around in code and change the queue of written code. Use of such control commands makes it much more difficult to understand the code and therefore this construction is often avoided. Multiple languages do not allow the use of unconditional jumps (inc EPL) nowadays. In case of conditional control commands the comparison operators are used for realizing the conditions:: == equality, result is true, if comparable values are equal != disparity, result is true, if comparable values are not equal > greater than, result is true, if the value on the left side of the operator is greater than the value on the right side of the operator < lesser than, result is true, if the value on the left side of the operator is lesser than the value on the right side of the operator >= greater or equal, result is true, if the value on the left side of the operator is greater than the value on the right side of the operator and also if respective values are equal <= lesser than, result is true, if the value on the left side of the operator is lesser than the value on the right side of the operator and also if respective values are disparit Conditions can be combined in between by using the following logic operations: && yes, condition is true, if both conditions are true || or, condition is true, if one of the conditions is true

For example, following condition:


could be written: (a>b) || (a=b) Wellknown control command is for sure “if”. “If” sentence enables to execute different conditions depending on the result of the condition: if(condition)

               code, which is filled, if the result of the condition is true 


              code, which is filled, if the result of the condition is false

else-clause can also be absent.

Example of if-command:

if(counter>0) printf(“Counter is positive number”);

If variable named “counter” is greater than zero, the text “Counter is positive number” will output.

Another example of if-command:

if(counter>0) printf(“Counter is positive number”); else printf(“Counter is non-positive number”);

If variable named “counter” is greater than zero, the text “Counter is positive number” will output., otherwise the text “Counter is non-positive number” will appear.

Complicated versions of if-commands are case ja switch. Those control commands enable more differentiations according to the conditions, but as EPL language does not include those commands, then those commands are also not handled here.

Repeats enable to execute some part of the code repeatedly according to the given conditions. Repeats are divided as follows: pre-controlled repeats and after-controlled repeats; repeats with static length and repeats variable length.

while-repeat is a pre-controlled repeat. It means that the condition needed for continuing the repeat is controlled before its execution.


code, which is executed, if the condition is true 

For example: int a=0; int b=0; while(a<10) {



Repeat is executed until “a” is lesser than 10, whereby the value of variable “a” is added to the value of variable “b” during each execution of the repeat, so b=1+2+3+4+5+6+7+8+9+10=55.

do-while-repeat is a after-controlled repeat. Repeat, this means that the condition needed for going on with the repeat is controlled after its execution.


 code, which is executed until the condition is true


For example: int a=0; int b=0; do {


} while(a<10)

Repeat is executed until “a” is lesser than ten, whereby the value of variable “a” is added to the value of variable “b” during each execution of the repeat, so b=1+2+3+4+5+6+7+8+9+10=55.

Now you might have got the impression, that there is no difference if to use the repeat with pre-control or after-control. Actually there is a difference – code inside the after-controlled repeat is executed at least once, might happen that pre-controlled repeat is not executed even once.

For example: int a=10; int b=0; while(a<10) {



Result is that a=10 and b=0, because the action inside the repeat was not executed. Condition was false from the beginning and it was controlled before the execution.

int a=10; int b=0; do {


} while(a<10)

Result is that a=11 and b=11, because the action was executed once and after that the condition was controlled.

for-repeat is pre-controlled and with static length.

for(variable, condition, rules of changing variables)

code, which is executed, if the condition is true

for-repeat differs from the repeats described above foremost by the fact that altering the value of the variable related to the condition of continuing repeat is described inside the repeat.

For example: int b; for(int a=0; i<10; i++)


Result is similar to “do” repeat. Value “a” of the variable is equalized to 0 in the beginning. Thereafter the condition of the repeat execution is controlled. If this is true, then the value of variable “a” is added to variable “b” and thereafter the value of variable “a” is altered according to the given rules (in given example a+++, i.e. the value of “a” is increased by one). Then the condition of continuing is controlled and if this is true, then the action inside the repeat is repeated etc. Result is that a=10 and b=0+1+2+3+4+5+6+7+8+9=45. B.3.4.3 Arithmetic and logical operations There are five arithmetic operations which we need mostly: Addition: mark „+” is used and it sums two values, f.e. c=a+b sums the value of “a” and “b” and makes the value of “c” equal to the result of the operation (c=3+2, therefore c=5). Subtraction: mark „-” is used and it substracts second value from the first, f.e. c=a-b subsrtacts the value of variable “b” from the value of variable “a” and makes the value of “c” equal to the result of the operation (c=3-2, therefore c=1). Multiplication: mark „*” is used and it multiplies two values, f.e. c=a*b multiplies the value of variables “a” and “b” and makes the value of variable “c” equal to the result of the operation (c=3*2, therefore c=6). Division: mark „/” is used and it divides one value with the other, f.e. c=a/b divides the value of variable “a” with the value of variable “b” and makes the value of variable “c” equal to the result of the operation (c=3/2, therefore c=1,5 or c=1, depends on language). End of division: mark „%” is used and it divides one value with the other, f.e. c=a%b divides value of variable “a” with the value of variable “b” and makes the value of variable “c” equal to the end of the division. (c=5%3 therefore c=2). EPL language does not have truth-value type of variable. Therefore all the logic operations are in control commands. Languages, which do have thruth-value type of variables, enable the use of logic operations, f.e. c= a && b, c=true if “a” and “b” are equal and c=false if “a” and “b” are not equal. Logic operations are handled more closely together with control commands. Queue of the operations is different in some of the programming languages and similar in the others: some languages start with multiplication and division operations and end with addition and subtraction operations. Operations are executed starting from the left to the right. Queue of the operations can be specified with braces (operations inside the braces are executed first). For example: c=a+a*b is different from c=(a+a)*b. Different programming languages enable the use of different arithmetic operators: For example: c += a adds the value of variable “a” to the value of variable “c” (i.e. c = a + c), a++ is the iteration of the variable i.e. increasing the value by one (i.e. a=a+1) etc.

B.3.5 Testing

B.3.5.1 Basic concepts of testing and debugging

Need of testing in software development derives foremost from the fact, that people make mistakes. So, main task of testing phase is to ensure that created software solution is free of faults. Testing has to ensure reliability of software and products’ conformity to the description of needs. First it’s controlled, that the code of the program is correspondent to the specification of the language. This control is executed by the compilator. Passing through this control without any faults and alerts does not ensure that the program is tree of faults. If program does not give an expected result in case of given input data due to the mistakes in program logics and not due to the mistakes deriving from syntax, then such situation is called a failure. In case of black box testing only the external attributes of the software are explored and no attention is given to the internal processes. In case of white box testing only the structure and logics of the program are tested, without the control of inputs and outputs. In case of testing the relations, the cooperation between different modules is tested. This is very important in case if the program consists of modules, which are developed separately.

Testing tools are controlled by using mutant testing: in such case new faults are added to the program in order to explore the effectivity of test procedures and scripts. Debugger is a tool for finding faults in program and finding faults in code with the help of this tool is called debugging. B.3.5.2 Different types of testing Role of the compilator is mostly to control the correspondence of written program code to the specification of the language. This controlled by using the tools of static analysis mostly and testing takes place without starting the program. As the correctness and security of software has become more and more important, then the producers have significantly enhanced the testing tools of the development tools (debuggers, tools of static analysis). Testing tool have turned to be more thorough. Testing tools of the development tools used nowadays enable to analyse the code of program very thoroughly (they also enable to discover possible exploits etc), but still the use of those tools does not assure the complete correctness. For ensuring the correctness it is necessary to use different tools of dynamic testing. As dynamic testing presupposes, that different input data is inserted to the programme, then testing robots are often used for such testing. Testing robots are the programs that insert different input data to the program and thereafter control the correspondence of the program to the expected result. For testing the correctness of the program in different situations, the testing robots are often written, which are overloading the program with the huge amount of input data. Purpose of such testing is to control the behaviour of the program in case of great overload and this kind of testing is calls stress testing. B.3.5.3 Static and dynamic test methodologies Static analysis is the technique of testing, if programs are not started and only the inception code is explorer. Dynamic analysis is used in case of there is a need to explore programs’ behaviour in different situations and output correspondence to the expected result is analysed. Prepared input values are usually used in case of dynamic analysis, because in such case the expected output is known.

B.3.6 Documentation

B.3.6.1 Documents for software development and delivery Software documentation or source code documentation is written text that accompanies computer software. It either explains how it operates or how to use it, and may mean different things to people in different roles. Types of documentation include: • Architecture/Design - Overview of software. Includes relations to an environment and construction principles to be used in design of software components. • Technical - Documentation of code, algorithms, interfaces, and APIs. • End User - Manuals for the end-user, system administrators and support staff. • Marketing - Product briefs and promotional collateral. Documenting software is often a laborious process. The main tools of code documentation are briefly described below. Structured English is the marriage of English language with the syntax of structured programming. Thus structured English aims at getting the benefits of both the programming logic and natural language. Program logic helps to attain precision while natural language helps in getting the convenience of spoken languages. Unlike decision tables and decision trees which show only branching logic, structured English contains complete step by step statements. Structured English consists of the following elements: 1. Operation statements written as English phrases executed from the top down 2. Conditional blocks indicated by keywords such as IF, THEN, and ELSE 3. Repetition blocks indicated by keywords such as DO, WHILE, and UNTIL Use the following guidelines when writing Structured English: 1. Statements should be clear and unambiguous 2. Use one line per logical element 3. All logic should be expressed in operational, conditional, and repetition blocks 4. Logical blocks should be indented to show relationship 5. Keywords should be capitalized Example of pseudo-code, written in structured english: IF (salary is LE 1000) Set income tax to zero ELSE Set income tax to 22% ENDIF

Decision Tree is a diagram used to describe decision alternatives and chance events. Tree has a root node and each new node includes some decisions. Depending on the decision, it is possible to go until the leaves, where are the solutions (outputs).

As an example, a simple decision making tree for problem „go skying”  is drawn below. 

A comment is a programming language construct used to embed information in the source code of a computer program. In most cases, when the source code is processed by a compiler or interpreter, comments are ignored. Comments have a wide range of potential uses: from augmenting program code with basic descriptions, to generating external documentation. Comments are also used for integration with source code management systems and other kinds of external programming tools. The flexibility provided by comments often allows for a wide degree of variability and potentially non-useful information inside source code. To address this, many technical commentators and software analysts subscribe to any of several "philosophies" and guidelines regarding the proper use of comments. Some programming tools read structured information in comments and automatically generate documentation. Keeping documentation within source code comments is considered as one way to simplify the documentation process, as well as increase the chances that the documentation will be kept up to date with changes in the code.[16]Examples of documentation generators include the javadoc program, designed to be used with the Java programming language, Ddoc for the D programming language and doxygen, to be used with C++, C, Java, IDL and PHPDoc for PHP. C# and Visual Basic implement a similar feature called "XML Comments" which are read by IntelliSense from the compiled .NET assembly. A flowchart is a schematic representation of an algorithm or a process. As an example, a flowchart for computing average salary of 10 employees is presented here.

The Unified/Universal Modeling Language (UML) is a standardized visual specification language for object modeling. UML is a general-purpose modeling language that includes a graphical notation used to create an abstract model of a system, referred to as a UML model B.3.6.2 Well-structured and documented code

The advantages of well-structured and documented coding include increased programmer productivity and less debugging. Well-structured code is easier to understand and change. It improves the maintainability of the code by making the code conform to coding standards, language proficiency, safety and portability, and raises the quality of documentation. Also, the information exchange between the members of the project team is easier to organize, if the. program documentation is precise, systematic and readable.

The benefits of effective documentation for software engineers:

• learning a software system • testing a software system • working with a new software system • solving problems when other developers are unable to answer questions • looking for big-picture information about a software system • maintaining a software system • answering questions about a system for management or customers • looking for in-depth information about a software system

B.3.6.3 Unified modelling language (UML)

UML was meant to be a unifying language enabling IT professionals to model computer applications. One reason UML has become a standard modeling language is that it is programming-language independent. Also, the UML notation set is a language and not a methodology. Since UML is not a methodology, it does not require any formal work products. Yet it does provide several types of diagrams that, when used within a given methodology, increase the ease of understanding an application under development. By placing standard UML diagrams in one’s methodology's work products, programmer makes it easier for UML-proficient people to join his project and quickly become productive. The most useful, standard UML diagrams are: use case diagram, class diagram, sequence diagram, statechart diagram, activity diagram, component diagram, and deployment diagram.

Use-case diagram Figure: Use case diagram

A use case illustrates a unit of functionality provided by the system. The main purpose of the use-case diagram is to help development teams visualize the functional requirements of a system, including the relationship of "actors" (human beings who will interact with the system) to essential processes, as well as the relationships among different use cases. Use-case diagrams generally show groups of use cases -- either all use cases for the complete system, or a breakout of a particular group of use cases with related functionality (e.g., all security administration-related use cases). To show a use case on a use-case diagram, you draw an oval in the middle of the diagram and put the name of the use case in the center of, or below, the oval. To draw an actor (indicating a system user) on a use-case diagram, you draw a stick person to the left or right of your diagram. Use simple lines to depict relationships between actors and use cases

Class diagram

The class diagram shows how the different entities (people, things, and data) relate to each other; in other words, it shows the static structures of the system. A class diagram can be used to display logical classes, which are typically the kinds of things the business people in an organization talk about - rock bands, CDs, radio play; or loans, home mortgages, car loans, and interest rates. Class diagrams can also be used to show implementation classes, which are the things that programmers typically deal with. An implementation class diagram will probably show some of the same classes as the logical classes diagram.

Class diagram example of association between two classes

Sequence diagram

Sequence diagrams show a detailed flow for a specific use case or even just part of a specific use case. They are almost self explanatory; they show the calls between the different objects in their sequence and can show, at a detailed level, different calls to different objects. A sequence diagram has two dimensions: The vertical dimension shows the sequence of messages/calls in the time order that they occur; the horizontal dimension shows the object instances to which the messages are sent.

Statechart diagram

The statechart diagram models the different states that a class can be in and how that class transitions from state to state. It can be argued that every class has a state, but that every class shouldn't have a statechart diagram. Only classes with "interesting" states - that is, classes with three or more potential states during system activity - should be modelled. Activity diagram

Activity diagrams show the procedural flow of control between two or more class objects while processing an activity. Activity diagrams can be used to model higher-level business process at the business unit level, or to model low-level internal class actions. In my experience, activity diagrams are best used to model higher-level processes, such as how the company is currently doing business, or how it would like to do business. This is because activity diagrams are "less technical" in appearance, compared to sequence diagrams, and business-minded people tend to understand them more quickly.

Component diagram

A component diagram provides a physical view of the system. Its purpose is to show the dependencies that the software has on the other software components (e.g., software libraries) in the system. The diagram can be shown at a very high level, with just the large-grain components, or it can be shown at the component package level.

Deployment diagram

The deployment diagram shows how a system will be physically deployed in the hardware environment. Its purpose is to show where the different components of the system will physically run and how they will communicate with each other. Since the diagram models the physical runtime, a system's production staff will make considerable use of this diagram.

B.3.7 Maintenance B.3.7.1 Documenting changes in software Nowadays there is a need after maintenance of the software solution after the completion and installation of the software. Such need is conditioned from the fact that often it is not possible to foresee all the different situations that might come up during testing: code might consist of multiple solutions and functions; other solutions, related with the software, might change; legal acts that need to be followed by the software solution can hang etc. IEEE standard 1219 defines software maintenance as follows: „The modification of a software product after delivery to correct faults, to improve performance or other attributes, or to adapt the product to a modified environment.” This international standard describes the 6 software maintenance processes as: 1. The implementation process contains software preparation and transition activities, such as the conception and creation of the maintenance plan, the preparation for handling problems identified during development, and the follow-up on product configuration management. 2. The problem and modification analysis process, which is executed once the application has become the responsibility of the maintenance group. The maintenance programmer must analyze each request, confirm it (by reproducing the situation) and check its validity, investigate it and propose a solution, document the request and the solution proposal, and, finally, obtain all the required authorizations to apply the modifications. 3. The process considering the implementation of the modification itself. 4. The process acceptance of the modification, by checking it with the individual who submitted the request in order to make sure the modification provided a solution. 5. The migration process (platform migration, for example) is exceptional, and is not part of daily maintenance tasks. If the software must be ported to another platform without any change in functionality, this process will be used and a maintenance project team is likely to be assigned to this task. 6. Finally, the last maintenance process, also an event which does not occur on a daily basis, is the retirement of a piece of software. There are a number of processes, activities and practices that are unique to maintainers, for example: • Transition: a controlled and coordinated sequence of activities during which a system is transferred progressively from the developer to the maintainer; • Service Level Agreements (SLAs) and specialized (domain-specific) maintenance contracts negotiated by maintainers; • Modification Request and Problem Report Help Desk: a problem-handling process used by maintainers to prioritize, documents and route the requests they receive; • Modification Request acceptance/rejection: modification request work over a certain size/effort/complexity may be rejected by maintainers and rerouted to a developer.

B.3.7.2 Methods to attain quality in program maintenance Software maintenance is dividable into four categories: • Adaptive: changes in software are related to changes in environment; • Additional: changes in software are related to the changes due to new business needs; • Corrective: correction of occurred faults; • Preventive: preventing of the problems that might come up in the future. Software maintenance is mostly either adaptive or additional. Analysis of changes has to come before making the changes. Analysis has to originate from the following criteria: • Modification type – will the change modify essential faults or add new functionality. • Modification coverage – how huge is the change, how much resources are needed for making changes. • Modification criticalness – how big is the influence of changes on software stability and will the changes increase security risks, if there is any influence at all . Originating from the capacity and essence of changes, the changes can be divided as follows: • Version: greater and more thorough change. Structure of the software has been changed due to the changes in functions. • Release: change has added new functionalities. • Patch: small change that solves some problems or corrects the fault. All changes in software attributes and functionalities have to be documented for sure. Making the changes might cause new faults and therefore it is very important to know the essence and history of changes. Software maintenance involves a great amount of changes and therefor the changes have to be managed. There are multiple tools and environments created for managing the changes. B.3.8 Programming examples

Following examples on programming are based on EPL language. The EPL language is based on C language, being its simplified version.

The program that everyone writes just to check they understand the very basics of what is going on in a new language is probably the program, saying a simple message to the output device. main( ) {

      printf( “Congratulations! It works!” );

} The first line is the standard start for all C (and EPL) programs - main(). After this comes the program's only instruction enclosed in curly brackets {}. The curly brackets mark the start and end of the list of instructions that make up the program - in this case just one instruction. Notice the semicolon marking the end of the instruction. Ther ending every EPL instruction with a semicolon is a good practice - it will save you a lot of trouble! Also notice that the semicolon marks the end of an instruction - it isn't a separator as is the custom in other languages.

The next example demonstrates the use of variables

main( ) { int n, nsquare; n = 5; nsquare = n * n; printf (“n = “, n); printf (“nsquare = “, nsquare); n = 7; nsquare = n * n; printf (“n = “, n); printf (“nsquare = “, nsquare); }

The new aspects in previous example are: • the declaration of two integer variables – n and nsquare in the second line; • the assigning the constant values to the variable n in the third and seventh line; • The computing squared value of n and assigning the result tu the variable nsquare in the fourth and eighth lines; • Printing the textual message and the current value of the variable in lines 5 – 6 and 9 – 10. Note, that the textual constants are enclosed in double quotes but the names of variables not.

The following example introduces the use of readf-function and conditional statement.

main( ) { int n; printf( “Please insert the smallest positive integer: “ ); readf(n); if( n < 1 ) printf( “The number must be positive!” );

	else {

if (n > 1) printf(“Inserted number is not the *smallest* positive integer!”); else printf(“You are right, thank you!”); } }

In the example above, the initialisation of the variable n is carried out using the readf-function in line 4. Note, that before using it, the prompt for user is output via printf-function in the previous line. The following conditional statements check the correctness of the input. The first of them (beginning at line 5) checks, is the input really positive. If not, the appropriate message at line 6 is output. In the case of positive input number the second conditional statement (beginning at line 8) checks, is n greater than one or not and outputs the adequate message. Note that the second if statement is the part of the first one and for the clarity of code is enclosed into curly brackets. Another potentially dangerous mistake can be made by placing the semicolon after the condition in if-statement: if( n < 1 ) ; printf( “The number must be positive!” ); Semicolon in the first line ends the if-statement (with empty statement) and the message in the second line will output anyway, independently of the value of n.

The next example demonstrates the use of the for-cycle. The goal of the program is to write out the squares of 5 first positive integers.

main( ) { int n, nsquare; for( n=1; n<=5; n=n+1) { nsquare = n * n; printf(“n, nsquare = “, n, nsqare); } }

The for cycle makes n to start with the value 1, increments it by 1 after each iteration until it is less than or equal to 5. The body of the cycle (enclosed in curely brackets) is carried out five times- for different values of n. Notice, that more than one variable can be the arguments of the printf-function.

As in the previous example, the potential mistakes can be made in this code. Placing the semicolon after the header of the for-cycle turns the cycle into empty one and only the values 6 and its square will be output:

for( n=1; n<=5; n=n+1); { nsquare = n * n; printf(“n, nsquare = “, n, nsqare); }

Another possible error is missing the pair of curely brackets:

for( n=1; n<=5; n=n+1) nsquare = n * n; printf(“n, nsquare = “, n, nsqare); Only the assignment statement (nsquare = n * n) is carried out repetitively. The output will be n, nsquare = 6 25.

The next example asks the user to input the salaries of 4 persons, store the input values in an array and finds the average salary

main( ) { int i; float sal[4]; float sum, average; for( i=0; i<4; i=i+1) { printf(i); printf(“Please input the salary”); readf(sal[i]); } for( i=0, sum=0; i<4; i=i+1) { sum = sum + sal[i] } Average = sum / 4; printf(“Average salary is “, average ); }

In the example above, the array sal consisting 4 real numbers is formed to save the values of salaries of 4 person. The for-cycle in lines 5 – 9 lets the user to input the values of salaries. Notice, that the indexes of the array begin with 0, therefore the initial value of the counter i is also set to 0 in the 5th line. The second for-cycle finds the sum of the salaries. At the beginning of the cycle two variables (i and sum) are initialized by 0. On every iteration, the value of sum is increased by next salary in the queue, stored in the array sal. The last steps in the program are calculating the average by dividing the sum by 4 and outputting the result.

The example below demonstrates the working with strings or arrays of characters. The task of the program is to count the number of spaces in the string.

main( ) { int n, account; char sentence[]=”How are you?”;

   char space = ‘ ‘;

for( n=0, account=0; n<13; n=n+1) { if (sentence[n]=space) { account=account+1; } } printf(sentence); printf(“Number of spaces is “, account); }

In the third row of this example stands the constant of string type. There are 13 symbols visible in the string, but actually the last symbol of the string is string terminating symbol (0-character). The string is autoinitialized. In the 10th row the string is print out as a single object.

The goal of the program in last example is to find the minimal value of the integer array.

main( ) { int minvalue, n; int numbers[] = {3, -2, 100, 100, 0, -4, -20, 15}; minvalue=numbers[0]; for( n=1; n<8; n=n+1) { minvalue=min(minvalue, numbers[n]); } printf(“Minimal value is: ”, minvalue); } int min( a, b ) int a, b; { int minimal; if (a < b) minimal = a; else minimal = b; return minimal; }

Again, the array is autoinitialized in third row. In the fourth row the minvalue is initialized with the first element of the array and in the following cycle it is compared with succeeding elements of the array. In case the current minvalue is greater than current element of an array, the minvalue is replaced by new value. The comparing of two values and finding the minimal of them is the task of the function min(). It has two integer arguments (a and b) and it returns also the integer value. 7. Links to additional materials: 1. Association for the Advancement of Artificial Intelligence, 2. Free Encyclopedia, 3. Nick Parlante, Linked List Basics, in the Stanford CS Education Library.

8. Test questions

Question 1 Software creation process in case of top-down method is started with: a) analyzing the details of programming task and its generalization. b) dividing the whole task into subordinary tasks.

Question 2 Use of procedures and functions is helpful for: a) Enchasing programme readability. b) Structuring long program. c) Enchasing engineers’ working efficiency.

Question 3 Data transmission from called procedure/function to the calling module is possible with a) address parameter. b) value parameter.

c) both address and value parameter. 

Question 4 Array is: a) A huge and massive set of scalar variables. b) A set of variables with the same type and name, which are differentiated in between by the indexes. c) Index of a variable.

Question 5 Record in programming language is: a) A whole set of variables with simpler structure. b) A row in data table. c) A set of structured data.

Question 6 Binary search tree in programming is used for: a) Realization search algorithm. b) Demonstration of tree shaped data structure. c) Conversion of binary numbers.

Question 7 Following programming languages form a part of procedural programming languages: a) Java b) C c) Fortran

Question 8 Which one works faster: a) Complied program? b) Interpreted program? c) Difference is not remarkable.

Question 9 Control commands are used for: a) Specifying the working order of programming commands. b) Skipping the parts of program. c) Repeating the parts of program.

Question 10 Purpose of debugging is: a) To remove faults from the program. b) To make the program more steady in functioning. c) To interface the program with other programs.

Question 11 Well structured documentation has to enable: a) Detailed review of program code. b) Studying possibilities for joined people. c) Information exchange between the people related with the product.

Answers (correct and false)

Question 1 a) False b) Correct Question 2 a) Correct b) Correct c) Correct Question 3 a) Correct b) False c) False Question 4 a) False b) Correct c) False Question 5 d) Correct e) False f) Correct Question 6 a) Correct b) False c) False Question 7 a) False b) Correct c) Correct Question 8 a) Correct b) False c) False Question 9 a) Correct b) Correct c) Correct Question 10 a) Correct b) Correct c) False Question 11 a) False b) Correct c) Correct

1. Feedback for answering Question 1 a) False, Top-down method starts from general and moves towards details b) Correct! Question 2 d) Correct! e) Correct! f) Correct! Question 3 a) Correct! b) False! Information can be sent back only with the help of address parameters. c) False! Information can be sent back only with the help of address parameters. Question 4 a) False! Array is the set of variables with the same type and name, which can be differentiated by the indexes. b) Correct! c) False! Array is the set of variables with the same type and name, which can be differentiated by the indexes. Question 5 a) Correct! b) False. Rows of data tables are called as entries in context of databases, not in programming languages. c) Correct! Question 6 a) Correct! b) False. Binary tree is used for the realization of search algorithm. c) False. Binary tree is used for the realization of search algorithm. Question 7 a) False. Java is object oriented language b) Correct! c) Correct! Question 8 a) Correct! b) False! Compiled program works faster. c) False! Compiled program works faster. Question 9 a) Correct! b) Correct! c) Correct! Question 10 a) Correct! b) Correct! c) False! Purpose of debugging is to remove the faults from the program. Question 11 d) False! Program code does not have to be presented in documentation. a) Correct! b) Correct!