Learners Programming Language a Helping System for Introductory Programming Courses

Programming is the core of computer science and due to this momentousness a special care is taken in designing the curriculum of programming courses. A substantial work has been conducted on the definition of programming courses, yet the introductory programming courses are still facing high attrition, low retention and lack of motivation. This paper introduced a tiny pre-programming language called LPL (Learners Programming Language) as a ZPL (Zeroth Programming Language) to illuminate novice students about elementary concepts of introductory programming before introducing the first imperative programming course. The overall objective and design philosophy of LPL is based on a hypothesis that the soft introduction of a simple and paradigm specific textual programming can increase the motivation level of novice students and reduce the congenital complexities and hardness of the first programming course and eventually improve the retention rate and may be fruitful in reducing the dropout/failure level. LPL also generates the equivalent high level programs from user source program and eventually very fruitful in understanding the syntax of introductory programming languages. To overcome the inherent complexities of unusual and rigid syntax of introductory programming languages, the LPL provide elementary programming concepts in the form of algorithmic and plain natural language based computational statements. The initial results obtained after the introduction of LPL are very encouraging in motivating novice students and improving the retention rate.


INTRODUCTION
P rogramming skill is an expected outcome of computer science students [1]; however, it is hard to learn programming as it fundamentally entails to think and verbalize in a way that is unnatural and usually queer for the beginner. In [2], Winslow claims that approximately ten years are required to turn the beginner into an expert.
Akin to the impact of our native language on our cogitation and apprehension, the first programming language has a strong impact on our thoughts [7], and similarly the programming language chosen for the introductory programming course is an essential element in the progress of students [8].
The paradigm of the first programming course is one of a pivotal factor in its success. Among several programming paradigms, the imperative (also called procedural) paradigm is highly acknowledged for introductory courses [9][10][11][12], yet its various features are quite hard for novice students. For instance, in [13], the sequence, assignment and iteration are cited as the difficult concepts.
Whereas in [14], the control structures, pointers, arrays and recursion are classified as difficult concepts for beginners. Gobil, et. al. argued that beginners face problems in recognizing the valid selection structure for the problems [15].
Virtually there is a series of factors for high attrition in computer programming courses, but lack of previous knowledge of programming is an important reason that affects the completion of computer science degree [16][17][18]. Conversely the novice students with previous knowledge of programming have better performance [19][20], and based on this thesis, it can be inferred that basic concepts of the first programming course can become easier if novice students have prior knowledge of programming. In this paper we have introduced a LPL which is based on a thesis that induction of small and plain language before a first programming course can appreciably increase retention levels of novice students and decrease attrition rate by providing them elementary acquaintance of imperative programming.

PREVIOUS WORK
The notion of pre-programming language as a precursor of introductory programming courses is not very new; several programming systems have been formalized to support the first programming courses. McIver et al.
introduced a language called GRAIL and inducted before the first course of programming [21]. GRAIL helps the novice students in comprehending the imperative programming concepts.
In [22], a course is introduced to help novice students who have no prior programming knowledge. The course covers the elementary topics like sequence, selection structures, operators, arrays and functions.
In another landmark study [23], the effectiveness of CS0 with Scratch [24] is studied. The course encompasses the sequence, variables, arrays, selection, repetition, and basic objects. The course significantly reduced the attrition rate.
In another study [25], a course called Computational Thinking is described to help novice students and found very effective in increasing the problem solving abilities of beginners.
To trounce the difficulties of introductory programming courses the MindStorms robots based course is introduced to encourage the beginners to focus on algorithmic problems solving before introducing the Java [26].

Design Theory and Motivation
The overriding theory of LPL is to facilitate the learning of introductory programming in a way to help the novice students in comprehending first imperative programming course. Principally it is merely not developed to ease the programming -if that was the objective; the graphical tools would be ample to provide simple drag-and-drop facilities to construct the programs. Fundamentally the ZPL course and first programming course are radically different, since the former is aimed is to introduce the elementary programming concepts, whereas the later is the actual platform to explore the actual concepts to beginners and therefore LPL is primarily developed for introducing elementary programming, rather than for doing programming.

Prime Features
The The traditional symbol (=) is used for assignment, and likely to add dot-equal notation for assignment.
The complex I/O is one of the reasons that make programming language more hard and complex. The I/O mechanism in most of the programming language is extremely difficult, however, it should be simple and straightforward [38]. According to Dale, the control structures are one of the difficult topic for novice students [14], and due to this reason a special care is taken while defining the control structures. The iteration structure in LPL may take several forms; however, each of the possible forms is prefixed by the word "repeat" (or some equivalent): repeat the statements 500 times … end of loop or repeat as long as age < 50 … end of loop A very comprehensive study, reported in [39], revealed that students face difficulties in identifying the right selection structure for the given problems. The selection structure in LPL, may take the following forms, but each of the possible forms is prefixed with the word "execute" In LPL each syntactic structure (other than the expression) is started with the unique word, and this feature obviously helps the novice students in understanding, differentiating and implementing programs and their pertinent components.

Language Design
The LPL is developed by using the universal notions of the theory of automata and formal language. At definition level, the LPL is divided into three sections: lexical specification, structural specification and semantic specification.
During the definition of lexical specification, the lexical units (keywords, literals, identifiers, operators and punctuators) are defined. The universally accepted mathematical system called the regular expression [40] is used for definition of lexical specification. The defined lexical specification for the LPL is highly straightforward and amenable.
Consider the regular expression for the 'identifier' LPL: '! letter (letter | digit) * With the above regular expression, it is possible to create any valid identifier in LPL.
As an illustration, consider the regular expression for integer constant in LPL: The above regular expression can only define the integer constant; however, its extended form can define the floating value constant: The regular expressions for the other lexical units like keywords and operators are highly straightforward and defined by concatenating the relevant symbols in a specific order.
After the specification of lexical units the structural specification of LPL is defined by using the context free grammar [41]. The generated tokens are passed to syntax analyzer which is the second phase of the translator. In LPL's syntax analyzer the recursive descent parsing is used [44]. In recursive descent parser, a separate method (procedure) is developed for every nonterminal of context free grammar. To

PRELIMINARY ANALYSIS OF LPL
The LPL is an experimental language designed on a hypothesis that the induction of a small, simple and paradigm specific textual preprogramming language can help the students in comprehending first imperative programming course and resultantly increases the retention level and may also reduce the failure/dropout rates. In order to verify our theory a small study is conducted. During study 96 students of the undergraduate computer science program are randomly selected and categorized in three groups (A, B, C). As a part of our study the Python is selected as a ZPL for group A, whereas the LPL is selected for group B, however, no preprogramming is selected for group C.
For CS0 there are many popular languages. Fig. 4 illustrates the popular languages choice used in CS0.
According to the statistics given in Fig. 4, the Alice is the most popular language for CS0, whereas the Python and VB are the second popular languages in CS0. However, due to several genuine reasons the Alice is not selected for comparing the effectiveness of LPL. The Alice is used for teaching the object oriented programming [45][46], whereas the LPL is developed for introductory imperative programming courses.
During our study the same number of lectures was designated for the both groups (A and B) for introducing their respective ZPLs. After the induction of ZPL the introductory programming course (CS1) with the C language is offered to all the three groups.
After the completion of course, the students from every group were interviewed and asked "whether they are willing to take another programming course in the next semester". The feedback received from the students is shown in Fig. 5.
The retention rate of the students in group A is quite higher from the students in group C but lower than the students in group B. The students from group A were asked about the reason of their less retention in the next programming course. Most of the students respond that the language used in CS0 was very attractive, but they faced problems when switching to the actual programming language of CS1, however, one student A plaint the shortage of time and the massiveness of language used in CS0. The retention level of the students in group B who studied the LPL as a ZPL is quite higher The students from all the groups are also being internally evaluated with pen and paper exam. The summary is shown in Fig. 6. Alice is one of a powerful language and generally used for teaching object oriented programming. In [47] [51]. It is generally used in the K-12 system. Scratch is usually used for teaching object oriented programming where the LPL is developed for imperative paradigm. Like other visual languages, it is free from the distraction of syntax, and unlike the textual languages, the use Scratch provides no explicit experience of program debugging. The procedure and recursion, which are the essential elements of imperative programming are missing in Scratch and the support for data structures is also weak [52].
Visual languages simplify the programming by providing the drag-and-drop facilities and prevent the syntax errors, but the students never confronted with program coding and never gain any practical experience of coding and debugging. In fact the visual languages are useful and simple yet several studies indicate that graphical languages are only useful for certain purposes [53]. In [54], it is argued that constructs based on control flow are linear (with some exceptions), and therefore, easily symbolized with textual language, and the visual languages are more suitable for representing the constructs which are based on data flow. The graphical representation was better than textual pseudo code when the operation entails finding flow of control, but not for identifying the high level associations [55], and as far as the program comprehension is concerned the graphical representations are not superior to textual representation and sometimes seriously worse [56].

CONCLUSION
LPL is a ZPL that helps the novice students in comprehending the introductory programming course. LPL comprises of simple and understandable statements and generates the equivalent C and C++ source program from the user source programs. LPL is initially applied to a small group of students and found very positive in increasing the retention level and reducing the failure rate. As a next step we are excogitating to apply LPL to a large group of students with the aim of quantifying its successfulness and efficacy in increasing the motivation level, retention rate and decreasing the attrition rate.