Software Development Using the Global Programming Language

Exception handling mechanisms have been introduced into programming languages in an effort to help deal with runtime irregularities. These mechanisms aim to improve code reliability by providing constructs for sectioning code into exception scopes (e.g. Java try blocks) and exception handlers (e.g. Java catch blocks). Whilst exception handling mechanisms have been the focus of much research over the past years, empirical studies have only focused on characterising exception handling code of Java and C# programs. There exists little empirical evidence on how exception handling mechanisms are used to develop software with other programming languages. Moreover, to date there exists no empirical study which has examined the structure of exception scopes across software projects. We address these shortcomings by examining the commonalities and differences of both exception scopes and handlers implemented with a wider range of languages. To this end, we analysed 50 software projects, containing code developed in C++, JavaScript, PHP, Java and C#. More than 9 million lines of code and over 20,000 exceptional code blocks were analysed. Our findings revealed significant differences in the frequency, structure and length of exception scopes and exception handlers across languages. This finding suggests that certain exception handling mechanisms are less explored by programmers using certain programming languages. However, regardless of language, exception handlers remained simplistic and in general only ever one handler was associated with each scope. Finally, our analysis confirms the existing belief that developers often pay little attention to developing exception scoping and handling behaviour.

Computer programming is now increasingly becoming a compulsory subject at the high school level. The main purpose of the introduction of programming languages at this stage is to develop logic and reasoning skills that may help students in their ordinary activities. Pakistani schools have also started introducing computer programming at the high school level. GWBasic and C are two major languages being used to teach this introductory course. This paper presents the difficulties faced by the students to learn programming languages in the high schools of Pakistan while learning in any of these two languages. To this end, the content of the course has been divided into three difficulty levels. A survey based approach has been employed to get useful data from the students who have been taught this course in either of the aforementioned languages. A detailed questionnaire has been created and is filled by the student to express the ease of learning for different concepts. The collected data enables us to perform a retrospective analysis to figure out as to which language offers a smoother and easier learning curve at a given level. The results show that GWBasic is relatively easier language for the students to learn introductory course in computer programming. The accumulated data also reveals that the students struggle to learn advanced concepts that invites for a revision of curriculum or pedagogical practices being followed to teach this course.

In translation, an equivalent communicative effect will be more difficult to attain, as the cultural distance between the receivers of the source and target text is greater. This may lead into what is termed as a problem of untranslatability. Cultural distance between the receivers of the source and the target text can cause some problems in translating. Sometimes is necessary to omit some features having a little or no textual relevance in a given source text. It means sacrificing less relevant textual details and maintaining more relevant ones to attain a maximum equivalent communicative effect. The paper discusses some issues related to the problems in translation, especially the phenomena that appear in the German translation from Indonesian and English expressions. Keywords: problem in translation, Indonesian translation, German translation

Developers often combine multiple programming languages to build large-scale applications. They choose programming languages properly for their tasks at hand instead of solving all of their problems with a single language. Foreign Functions Interface allow code written in one programming language to access features available in another programming language. Multi-language systems benefits from several advantages. However, they also introduce challenges related to the development, comprehension, and maintenance of such systems. Software quality is achieved partly by following good practices---architectural styles, design patterns, idioms---and avoiding bad practices---design anti-patterns and code smells. Yet, a review of the literature shows that there are a few works that study developers' practices among multi-language systems. The heterogeneity of components introduces code smells at the source code level. While design patterns are defined as good solutions to a recurrent problem, code smells are defined as poor design and coding choices that can negatively impact the quality of a software program despite satisfying functional requirements. In this paper, we report four patterns and five code smells related to multi-language systems. Those patterns and code smells were extracted from open-source systems, developers' documentation, and bug reports. We encoded these practices in the form of patterns and code smells in the context of Java Native Interface systems.

Federico Biancuzzi and Shane Warden's Masterminds of Programming: Conversations with the Creators of Major Programming Languages is a treasure. The book consists of interviews with the creators of, in order, C++, Python, APL, Forth, BASIC, AWK, Lua, Haskell, ML, SQL, Objective C, Java, C#, UML, Perl, PostScript, and Eiffel. Each chapter asks similar, but not identical questions, and the above-mentioned masterminds, including Larry Wall, James Gosling, Brian Kernighan, Bertrand Meyer, Robin Milner, Simon Peyton-Jones, Guido van Rossum, and Bjarne Stroustrop give a wide variety of answers. Some of the masterminds are charming, and many are contentious, even cranky; they are also, almost all, full of deep insights into the deepest problems of software engineering. This insight comes in two forms; first, programming languages are the mechanisms by which software engineering solutions are almost always produced. Second, perhaps even more importantly, creating and evolving a widely-used programming language is a heroic, Herculean, critical software engineering task. All of these masterminds have succeeded in a massive software engineering task; they are not mere ivory tower thinkers about software engineering, but have, in some cases, entire lives shaped by a single, extremely complex, software project. More on that key point below.

The design and test of error control encoding and decoding mod ules for simulating data communications systems is described. Generic application library modules for the Interactive Commu nications Systems Simulation Module (ICSSM) were developed for block and convolutional codes using the programming lan guage FORTRAN. The end user specifies a system for simulation study by linking various communications, signal processing and error control modules. In developing the encoding and decoding modules, a top-down approach resulted in a heirarchy of subroutines and function calls. This approach simplified the validation task and allowed easier upgrades and maintenance. Some of the design trade-offs for both the block code and convolutional code modules are viewed. It was found that modest use of storage can be traded for execution time. Various computations and operations can be efficiently accomplished with table look-up when using a high-level language such as FORTRAN. A simple communication system using these modules was studied. The error behavior was as expected. The key problems identified in this development were systems issues; primarily, module initialization and synchronization.

This study focuses on the problems in translation and creative interpretation by using bilingual texts. Bilingual here means English and “Hangeul,”which is Korean. As a professor majoring in English literature, I have been teaching English and literature mainly in elective courses. And I am more aware of the importance of English as a global language. The professors in the elective courses using bilingual texts should encourage students, even impromptu, to translate some parts into English, or Korean, at any time during the classes. The effect is that students will participate in active learning. That is, by using bilingual literature texts and attempting a new translation, students will be able to enlarge their humanistic imagination and creativity. I emphasize the development of bilingual texts and classes in abreast with the translation of Korean literature for its globalization and of the world literature into Korean. This is a process of learning to have a deep thought and understanding of human science through the development of literature and art which goes beyond the mere dimension of language ability.

Objectives: The primary objectives of this study revolve around understanding the intricacies of Chinese linguistics and its historical development over three thousand years. The focus is on delineating the unique system of field terms within Chinese linguistics, distinct from other global languages. The objectives include examining how this system reflects classical Chinese linguistic traditions, incorporates Western linguistic perspectives, and balances both influences. Additionally, the study aims to identify and address negative aspects within the Chinese linguistic term system, such as variability, doublet, and synonymy. Methods: To achieve the stated objectives, the study employs a comprehensive approach. It involves analyzing historical sources to trace the evolution of Chinese linguistics and its system of field terms. The methods also include an examination of contemporary challenges within the terminological lexicon, considering factors like variability and synonymy. Furthermore, the research delves into the translation issues associated with Chinese linguistic terms, particularly focusing on the work of Uzbek Chinese scholars. The methods encompass a thorough analysis of existing problems in translation and propose potential solutions. Results: The findings of the study reveal significant factors and reasons necessitating the unification of linguistic terms in Chinese language grammars. The results highlight the impact of historical traditions, Western influences, and contemporary challenges on the terminological lexicon. Additionally, the study sheds light on the state of translation of industry terms into Uzbek language, identifying problems and shortcomings in the process. The results contribute to a better understanding of the current landscape of Chinese linguistic terms and the challenges associated with their translation. Conclusion: In conclusion, the study underscores the relevance of addressing issues within the Chinese linguistic term system, particularly in the context of modern challenges such as the recent pandemic and the surge in online education. The conclusion emphasizes the significance of unifying field terms in Chinese language grammars and proposes actionable suggestions for overcoming the identified problems. Furthermore, the study concludes that the scientific exploration of this issue is crucial for contemporary Chinese studies, especially in the realms of linguistics and language education.

Reflective programming is becoming popular due to the increasing set of dynamic services provided by execution environments like JVM and CLR. With custom attributes Microsoft introduced an extensible model of reflection for CLR: they can be used as additional decorations on element declarations. The same notion has been introduced in Java 1.5. The extensible model proposed in both platforms limits annotations to class members. In this paper we describe [a]C#, 1 an extension of the C# programming language, that allows programmers to annotate statements or code blocks and retrieve these annotations at run-time. We show how this extension can be reduced to the existing model. A set of operations on annotated code blocks to retrieve annotations and manipulate bytecode is introduced. Finally, we discuss how to use [a]C# to annotate programs giving hints on how to parallel a sequential method and how it can be implemented by means of the abstractions provided by the run-time of the language.

Digital nations have become dependent on computer applications. One of the most important part of literacy in today’s digital and connected word are the basics of computer applications development and usage, but also algorithmic thinking. Programmers, developers, analysts are very wanted resource in business, administration and educational organizations. Job portals contain a lot of well-paid job offers for developers, data scientists, knowledge engineers or robotic process automation developers. Still more and more specialists in these areas are needed not only by IT market but also other sectors of the economy. Therefore, schools and universities introduce many courses concerning process modeling, developing, programming and customizing applications used in management, finance, logistics or engineering. Programming seems to be quite difficult to learn, therefore several educational programming environments and the new easier languages like visual programming languages were developed, so that more people, not necessarily specialists, could create new IT tools and speed up development of the information society.The aim of the article is to present the role of visual programming languages like Scratch in encouraging university students to create algorithms and start programming. The paper presents the characteristic of Scratch visual programming language, the framework of VBA programming course with elements of Scratch. It contains also students’ opinions about learning the basics of programming with visual programming language. In the main part of the article the author presents the results of the survey that was at conducted at the beginning of 2019 on a group of Polish Master’s students (n=119) The author’s observation and students’ opinions allow to conclude that Scratch is very easy to access and to use. It makes introduction to programming more enjoyable, helps to concentrate on the problem, solution structure, and the flow of the process. Scratch platform is not an ideal tool, however it allows for faster introduction of new elements of programming languages such as variables, loops, code blocks, objects. Finally, visual programming languages thanks to its easiness and quickly visible final effect (working application) encourages students to self-development in the field of computer programming. Performed research indicates also that business students notice the benefits of knowing basics of programing, they would like to attend basic programing classes. Students acquire knowledge and skills mainly performing instructions received from the teacher (86%) and watching video tutorials. The comparative analysis showed also some differences between various groups of students. Therefore, tools like Scratch can be successfully used to develop IT courses for non-majors. Many advantages make Scratch useful in introductory programming courses prepared for business students that frequently had no prior experience in the area of IT applications development.

Code clones are widespread in software since programmers always reuse code to reduce programming effort. As programming languages are continuing to evolve and morph, code clones also widely exist across different languages for platform compatibility and adoption. Although code clones can improve development efficiency, they are prone to introducing bugs. Existing code clone detection technologies, however, mainly focused on single programming language or syntactical features of code. The syntax of different programming language are diverse because of syntax sugar, and many cloning pairs are semantic related instead of syntactic similar, such as Type 4 clones. To bridge the gap between syntax and semantic, and detect clone-related bugs more accurately, we explore an IR (Intermediate Representation) based method to represent code semantic representation information of multiple language code. We utilize graph neural network to learn code semantic representation. Through the semantic representation, we can detect more cross-language clone related bugs across multiple language.

In the evolving landscape of software development, the nMorph framework introduces a potential advancement in multi-programming language development. This framework is designed to allow developers to code in a single language that can be transpiled into multiple target languages, aiming to maintain single design integrity while offering the potential for customization, technological adaptability, and platform independence. Architecturally, nMorph focus on the back-end, incorporating a layered design that includes components such as ORM & Database Connectors and a dedicated security layer. Central to this construct is the Haxe transpiler, which is designed to transform between languages such as Java, C#, and PHP. The framework also considered the support for connecting databases such as the Oracle, SQL Server, MySQL and PostgreSQL. Also the preparation for running in IIS, Apache, Tomcat, Glassfish and others. A controlled empirical experiment was conducted in which novice programmers used the nMorph framework in comparison with traditional programming languages in a simple banking-like transactional exercise. Results showed that participants took an average of 15.19% longer when using nMorph compared with commonly used programming languages. Despite that, with nMorph they obtained a multi-language and multi-platform software. Some other factors were analyzed about the influence of individual developer proficiency on outcomes, suggesting areas where the nMorph could be refined. This study underscores the relationship between perceived task difficulty, language proficiency, and software development phases. This study was primarily lab-based. There is potential value in further exploring real-world applications and broadening the scope of the framework to assess its broader relevance and efficacy.

This paper was inspired by [FBW 94]. An arbitrary upper bound on the size of some program for the target function suffices for the learning of some program for this function. In [FBW 94] it was discovered that if “learning” is understood as “identification in the limit,” then in some programming languages it is possible to learn a program of size not exceeding the bound, while in some other programming languages this is not possible.We have studied three other learning types, namely, “finite identification,” “co-learning” and “confidence-learning.” These three types are very different. Co-learning with the considered additional information in the form “an arbitrary upper bound for the size of the minimal program” allows the learning of the class of all recursive functions. “Finite identification” does not allow this. “Confidence-learning” is strong enough to learn the class of all recursive functions even without the additional information. However, the results of our paper show exactly the opposite rating for the capabilities of learning programs not exceeding the size given by the bound.For finite identification it is still possible to identify small programs with additional information in some programming languages but not in all of them. For co-learning it is not possible in any programming language. These results contrast to the result in [FKS 94] showing that an arbitrary class of recursive functions is co-learnable if and only if it is identifiable in the limit. Finally, for confidence-learning it is in general not possible to identify small programs with additional information.KeywordsProgramming LanguageTarget FunctionRecursive FunctionInductive InferenceIdentification TypeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The self-directed learning industry is gathering more and more pace nowadays. One of the most common ways in this learning model is YouTube tutorials, which provide worldwide easy access to knowledge. This paper investigates tutorial trends utilising their publicly available YouTube data. The research is limited to tutorials for 11 programming languages, but can be replicated to any other field of interest. This obtained data is analysed for different categories such as tutorials spreading through years, video statistics, localisation, language facts, and tags distribution for each programming language. Aiming to understand the changing path and trends in a certain programming language over time, we introduce two new metrics for this objective - increase ratio and weighted average for each programming language. It is found that the programming language Java is the most popular over the years, followed by PHP and Python. At the end of the popularity list are Perl, Swift and Objective-C. On the other side, the most contemporary programming language is Swift, followed by Python. The most outdated is Perl, followed by Objective C and C++.

This paper argues that the mass-count distinction does not represent a fundamental division between the world's languages. We demonstrate that such a distinction, as commonly defined within the linguistic literature, often conflates two facts: the semantic fact, found in all languages, that some words have atomic denotations and some do not, and the morphosyntactic fact, found in languages with contrasting singular-plural morphology, that some nouns have both singular and plural forms while others have only one such form. By comparing English with Mandarin Chinese, we discuss whether this morphosyntactic distinction might correlate with the presence or absence of a rich classifier system (as well as other types of quantification). This potential correlation has greatly influenced how linguists have investigated nominal systems across languages and it has even led some to hypothesize that morphosyntactic subcategories might determine the ways in which a grammar can “count” and “quantify.” We outline some important exceptions to this proposed correlation in languages such as Ch’ol, Mi’gmaq and Western Armenian. The paper concludes by arguing not only that there is no such correlation, but that linguists should rethink how they investigate nominal systems, focusing more on lexical variation (even within a single language) than on parametric variations across languages.