scholarly journals A method for the complete definition of programming languages

1970 ◽  
Author(s):  
Charles Thomas Wright
Author(s):  
Muhammad Shumail Naveed ◽  
Muhammad Sarim ◽  
Kamran Ahsan

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.


2021 ◽  
pp. 7-10
Author(s):  
I.E. Ditkovskaya ◽  

Analyzed is experience of distance education in the context of the coronavirus pandemic. In the context of education quality problems, attention is drawn to the inability of most students to organize their independent work and low motivation for independent mastering of the specialty. Meanwhile, under conditions of rapid development of technologies, rapidly changing economic conditions, flexible and timely planning in the context of overcoming the production crisis, specialists, who possess modern technologies in a narrow field, programming languages and the skills of working on specific equipment, are required. But, at the same time, employers are interested in well-educated and big-minded professionals, for example, crisis managers. Graduates should have broad knowledge that allows them to quickly adapt to new requirements, independently choose and master new professions in the future, receiving necessary education, navigate growing flows of information, strive for self-education and self-development, which should be based on the motivation of independent learning. The article focuses on the role of humanitarian knowledge, mastery of which is the basis for self-education and self-development. The definition of the concept of “philosophy of personal education” as a system of thinking in which the principles of philosophy of education are projected onto a personal assessment of one’s own physical, intellectual, spiritual, moral and ethical potential as a foundation for self-education and self-development is given. On the basis of philosophy of personal education, abilities, intellectual and creative potential of the individual are realized and a clear motivation for the need to master a particular specialty and self-improvement in this area is determined.


1998 ◽  
Vol 8 (1) ◽  
pp. 1-22 ◽  
Author(s):  
AMR SABRY

Functional programming languages are informally classified into pure and impure languages. The precise meaning of this distinction has been a matter of controversy. We therefore investigate a formal definition of purity. We begin by showing that some proposed definitions which rely on confluence, soundness of the beta axiom, preservation of pure observational equivalences and independence of the order of evaluation, do not withstand close scrutiny. We propose instead a definition based on parameter-passing independence. Intuitively, the definition implies that functions are pure mappings from arguments to results; the operational decision of how to pass the arguments is irrelevant. In the context of Haskell, our definition is consistent with the fact that the traditional call-by-name denotational semantics coincides with the traditional call-by-need implementation. Furthermore, our definition is compatible with the stream-based, continuation-based and monad-based integration of computational effects in Haskell. Finally, we observe that call-by-name reasoning principles are unsound in compilers for monadic Haskell.


1992 ◽  
Vol 01 (01) ◽  
pp. 93-126 ◽  
Author(s):  
ALEXANDER BORGIDA

We first explore the similarities and differences between concept definitions in description/terminological logics such as KL-ONE, Classic, Back, Loom, etc. and the types normally encountered in programming languages. The similarities lead us to consider the application of natural semantics — the mechanism most frequently used to describe type systems — to the definition of knowledge base management systems that use such description logics. The paper presents inference rules in the natural semantics style for a variety of judgments involving descriptions, such as “subsumption” and “object membership”, and provides the full definition of subsumption in the Classic KBMS as a proof system. One of our objectives is to document some advantages of this approach, including the utility of multiple complementary semantics, and especially the characterization of implementations that are computationally tractable but are incomplete relative to standard denotational semantics.


1982 ◽  
Vol 11 (2) ◽  
pp. 143-153
Author(s):  
Vincent J. Skudrna

The concepts from instructional design, theory of instruction and the systems approach were used to develop COBOL and RPG instructional modules. These modules are designed to present COBOL and RPG programming knowledge to accounting students for the audit of computerized accounting systems. The steps in the modules are definition of terminal performance objective, required content with regard to knowledge and skills, learning experiences, instructional methods and evaluation of the learning results. The modules represent a training tool that includes terminal objectives, curricular content and instructional strategies for the programming languages involved.


2019 ◽  
Author(s):  
Nick Papoulias

Background. Context-free grammars (CFGs) and Parsing-expression Grammars (PEGs) are the two main formalisms used by formal specifications and parsing frameworks to describe programming languages. They mainly differ in the definition of the choice operator, describing language alternatives. CFGs support the use of non-deterministic choice (i.e., unordered choice), where all alternatives are equally explored. PEGs support a deterministic choice (i.e., ordered choice), where alternatives are explored in strict succession. In practice the two formalisms, are used through concrete classes of parsing algorithms (such as Left-to-right, rightmost derivation (LR) for CFGs and Packrat parsing for PEGs), that follow the semantics of the formal operators. Problem Statement. Neither the two formalisms, nor the accompanying algorithms are sufficient for a complete description of common cases arising in language design. In order to properly handle ambiguity, recursion, precedence or associativity, parsing frameworks either introduce implementation specific directives or ask users to refactor their grammars to fit the needs of the framework/algorithm/formalism combo. This introduces significant complexity even in simple cases and results in incompatible grammar specifications. Our Proposal. We introduce Multi-Ordered Grammars (MOGs) as an alternative to the CFG and PEG formalisms. MOGs aim for a better exploration of ambiguity, ordering, recursion and associativity during language design. This is achieved by (a) allowing both deterministic and non-deterministic choices to co-exist, and (b) introducing a form of recursive and scoped ordering. The formalism is accompanied by a new parsing algorithm (Gray) that extends chart parsing (normally used for Natural Language Processing) with the proposed MOG operators. Results. We conduct two case-studies to assess the expressiveness of MOGs, compared to CFGs and PEGs. The first consists of two idealized examples from literature (an expression grammar and a simple procedural language). The second examines a real-world case (the entire Smalltalk grammar and eleven new Smalltalk extensions) probing the complexities of practical needs. We show that in comparison, MOGs are able to reduce complexity and naturally express language constructs, without resorting to implementation specific directives. Conclusion. We conclude that combining deterministic and non-deterministic choices in a single grammar specification is indeed not only possible but also beneficial. Moreover, augmented by operators for recursive and scoped ordering the resulting multi-ordered formalism presents a viable alternative to both CFGs and PEGs. Concrete implementations of MOGs can be constructed by extending chart parsing with MOG operators for recursive and scoped ordering.


2017 ◽  
Vol 7 (2) ◽  
Author(s):  
Marco Gaboardi ◽  
Chris J. Skinner

This special issue presents papers based on contributions to the first international workshop on the “Theory and Practice of Differential Privacy” (TPDP) held in London, UK, 18 April 2015, as part of the European joint conference on Theory And Practice of Software (ETAPS). Differential privacy is a mathematically rigorous definition of the privacy protection provided by a data release mechanism: it offers a strong guaranteed bound on what can be learned about a user as a result of participating in a differentially private data analysis. Researchers in differential privacy come from several areas of computer science, including algorithms, programming languages, security, databases and machine learning, as well as from several areas of statistics and data analysis. The workshop was intended to be an occasion for researchers from these different research areas to discuss the recent developments in the theory and practice of differential privacy. The program of the workshop included 10 contributed talks, 1 invited speaker and 1 joint invited speaker with the workshop “Hot Issues in Security Principles and Trust” (HotSpot 2016). Participants at the workshop were invited to submit papers to this special issue. Six papers were accepted, most of which directly reflect talks presented at the workshop


1980 ◽  
Vol 9 (126) ◽  
Author(s):  
Brian H. Mayoh

The semantics of a programming language are given by a function M from Programs to Meanings. In this paper we bring some uniformity into the definition of logical programming languages like LUCID and PROLOG by specifying M in Logic -> (Control -> Meanings). We describe how a context-free grammar can be assigned to each logical program and we identify Control with the language generated by the grammar. After this reduction there is no difference between the semantics of logical and conventional programming languages.


Sign in / Sign up

Export Citation Format

Share Document