Pascal is a 'natural' [for microprocessor software programs

In this paper, we identify a set of factors that may be used to forecast software productivity and software development time. Software productivity was measured in function points per person hours, and software development time was measured in number of elapsed days. Using field data on over 130 field software projects from various industries, we empirically test the impact of team size, integrated computer aided software engineering (ICASE) tools, software development type, software development platform, and programming language type on the software development productivity and development time. Our results indicate that team size, software development type, software development platform, and programming language type significantly impact software development productivity. However, only team size significantly impacts software development time. Our results indicate that effective management of software development teams, and using different management strategies for different software development type environments may improve software development productivity.

The Fortran (FORmula TRANslating) computer language was the result of a project begun by John Backus at IBM in 1954. The goal of this project was to provide a way for programmers to express mathematical formulas through a formalism that computers could translate into machine instructions. Initially there was a great deal of skepticism about the efficacy of such a scheme. “How,’’ the scientists asked, “would anyone be able to tolerate the inefficiencies that would result from compiled code?’’ But, as it turned out, the first compilers were surprisingly good, and programmers were able, for the first time, to express mathematics in a high-level computer language. Fortran has evolved continually over the years in response to the needs of users, particularly in the areas of mathematical expressivity, program maintainability, hardware control (such as I/O), and, of course, code optimizations. In the meantime, other languages such as C and C11 have been designed to better meet the nonmathematical aspects of software design, such as graphical interfaces and complex logical layouts. These languages have caught on and have gradually begun to erode the scientific/engineering Fortran code base. By the 1980s, pronouncements of the “death of Fortran” prompted language designers to propose extensions to Fortran that would incorporate the best features of other high-level languages and, in addition, provide new levels of mathematical expressivity popular on supercomputers such as the CYBER 205 and the CRAY systems. This language became standardized as Fortran 90 (ISO/IEC 1539: 1991; ANSI X3.1981992). At the present time, Fortran 95, which includes many of the parallelization features of High Performance Fortran discussed later in this paper, is in the final stages of standardization. It is not yet clear whether the modernization of Fortran can, of itself, stem the C tide. However, I will demonstrate in this paper that modern Fortran is a viable mainstream language for parallelism. It is true that parallelism is not yet part of the scientific programming mainstream. However, it seems likely that, with the scientists’ never-ending thirst for affordable performance, parallelism will become much more common—especially

The variety and complexity of processes required to be controlled in modern manufacturing places heavy demands on PLCs. To meet these demands PLC manufacturers are producing increasingly more powerful PLCs which require more complex programming languages. These complex programming languages result in longer specialised training and familiarisation times. To overcome these problems, the PLC programming language standard IEC 1131-3 was created. The standard details the workings of languages which provide PLC users with a set of programming languages based around familiar PLC concepts, but with language constructs similar to those of current generation PC programming languages. This paper describes the work done in a TCS partnership between Elite Control Systems Ltd. and Napier University to examine the viability of using structured methods for developing PLC software. Object oriented methods have established themselves as the future of software development for high level language users. We discuss how the object modelling technique of Rumbaugh et al. (1991) [one of the principal object oriented methods used in the UK] can be adapted for the creation of PLC software, and how the resulting practices differ from traditional PLC software development. We then describe the improvements in terms of software quality, development time, development costs, and maintainability that we have observed by adopting these techniques.

Effort estimation is the process of predicting a software's likely cost and development time. Estimating software development effort is still a complex problem that receives a lot of research attention. The accuracy with which the effort necessary for software development is estimated, and it is a significant success element in software project management. The estimated effort should be roughly equal to the actual effort in a good software estimation model. Accurate estimation enables managers to allocate resources for the planning and coordination of all activities. In this paper the effort estimation for small size projects involving technical and analytical aspects of engineering intent. The estimation of time resources is done in three steps firstly Identification of seven novel traits of software (LOC, N&C, CGPA, R, CC, AC, FP). Secondly PCA was implemented to decide the significant parameters among the software features. Lastly linear regression and polynomial regression models were developed using the significant features predicted by the PCA. The result of evaluation of the two models are encouraging with the minimum RMSE of 32-204 minutes and maximum regression coefficients(r <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> ) of 0.95-0.98

Pengembangan perangkat lunak adalah tugas kompleks dan membutuhkan adaptasi untuk mengakomodasi kebutuhan pengguna. Untuk membuat konsep dan perubahan perangkat lunak, dalam pemeliharaan, sekarang telah dikembangkan lebih mudah dalam pengembangan perangkat lunak, pola model-view-controller, yang merupakan arsitektur yang dapat membantu memfasilitasi dalam pengembangan dan pemeliharaan perangkat luna. Hal ini, karena dalam arsitektur model tiga-lapis, yaitu: tampilan dan pengontrolan dalam pembangunan dilakukan secara independen, sehingga dapat memberikan dahan dalam pengembangan dan pemeliharaan. Selain itu, arsitektur ini juga dapat melihat hal-hal yang sederhana dan menarik bagi pengguna. Software sistem on-line test adalah perangkat lunak yang memerlukan interaksi dengan pengguna, dan pemeliharaan perangkat adaptif. Karena sistem ujian on-line memerlukan pengembangan perangkat lunak untuk mengakomodasi kebutuhan ini berkembang dengan cepat. Makalah ini untuk menganalisis Model-View-Controller dan mencoba pembangunan, untuk menerapkannya dalam pengembangan perangkat lunak sistem pengujian on-line.

3 - The Program Assembler and Debugger

Compilers and interpreters are systems-software programs which are used to implement high-level languages; they facilitate the running of high-level language programs on a particular computer, even though the computer can only directly execute programs written in its own, low-level, machine code. Each compiler, or interpreter, implements only one high-level language, and so a computer system will usually have several of them, so that programs in several different high-level languages can be executed.

Software cost estimation is a process of planning, risk analysis, and decision making for project management in software development. Cost of project development encompasses a software project’s effort and development time. One popular model of software cost estimation is constructive cost model (COCOMO) model, which is a mathematical model proposed by Boehm, used for estimate the software effort and development time. The objective of this paper is to improve the basic COCOMO model’s coefficients for modern programming languages like Python, R, C++, etc. Many techniques were presented in the past for effort and time estimation using machine learning. But all these techniques were trained and tested for older programming languages. In order to improve the accuracy of COCOMO for modern programming languages, six Python projects have been considered and genetic algorithm (GA) is applied in these projects to define new values for basic COCOMO coefficients and the development time is calculated for Python projects. The time estimated using GA coefficients is compared with the original COCOMO and actual time. Using mean magnitude relative error, the error from the original COCOMO time is 54.49% and error from GA time is 21.23%.

The existing tools of deductive verification allow us to successfully prove the correctness of functions written in high-level languages such as C or Java. However, this may not be enough for critical software because even fully verified code cannot guarantee the correct generation of machine code by the compiler. At the moment, developers of such systems have to accept the compiler correctness assumption, which, however, is extremely undesirable, but inevitable due to the lack of full-fledged systems of formal verification of machine code. It is also worth noting that the verification of machine code by a person directly is an extremely time-consuming task due to the high complexity and large amounts of machine code. One of the approaches to simplify the verification of machine code is automatic deductive verification reusing the formal specification of the high-level language function. The formal specification of the function consists of the specification of the pre- and postcondition, as well as loop invariants, which specify conditions that are satified at each iteration of the loop. When compiling a program into machine code, pre- and postconditions are preserved, which, however, cannot be said about loop invariants. This fact is one of the main problems of automatic verification of machine code with loops. Another important problem is that high-level function variables often have ‘projections' to both registers and memory at the machine code level, and the verification procedure requires that invariants be described for each variable, and therefore the missing invariants must be generated. This paper presents an approach to solving these problems, based on the analysis of the control flow graph, and intelligent search of the locations of variables.

RISC

Compiler design plays an important role in ensuring that the translation of the programs written in high-level language into executable code is correct. However, in todays’ safety-critical environments, security gaps, visible and hidden defects in compiler models are liability factors that needed to be addressed in the process of examining that a system meets specifications and requirements of its intended objectives. Nevertheless, defects in this model are errors in coding which bring about incorrect or unexpected results from a compiler design that does not meet the actual requirements. Hence, this paper developed a novel approach by integrating the computational power of Communicating Stream X-Machine (CSXM) to address the problem associated with compiler correctness. In addition, this paper outlines the development of a novel compiler design called X-compiler, emphasizing its important role in software development. CSXM technique was implemented in Visual Studio (2022) to develop the X-compiler. The X-compiler utilize state-of-the-art techniques to translate program source code written in high-level programming language which is the blend of C# and Python programming language into executable code. The development process includes the lexical analysis, syntax parsing, semantic analysis, and code generation ensuring the correctness of the X-compiler. The results of the compiled code were run to produce output in command Windows environment for user interactions. Also, highlights the potential for enhanced language interoperability and the development of efficient compiler that leverage the strengths of multiple programming paradigms. Overall, the study on CSXM contributed to a deeper understanding of concurrent systems, while the design and implementation of the compiler showcased the feasibility of creating a synergistic blend of C# and Python programming languages.

10 - Hardware and software development tools

This thesis presents research to build and evaluate embedding of a textual form of state machines into high-level programming languages. The work entailed adding state machine syntax and code generation to the Umple model-oriented programming technology. The added concepts include states, transitions, actions, and composite states as found in the Unified Modeling Language (UML). This approach allows software developers to take advantage of the modeling abstractions in their textual environments, without sacrificing the value added of visual modeling. Our efforts in developing state machines in Umple followed a test-driven approach to ensure high quality and usability of the technology. We have also developed a syntax-directed editor for Umple, similar to those available to other high-level programming languages. We conducted a grounded theory study of Umple users and used the findings iteratively to guide our experimental development. Finally, we conducted a controlled experiment to evaluate the effectiveness of our approach. By enhancing the code to be almost as expressive as the model, we further support model-code duality; the notion that both model and code are two faces for the same coin. Systems can be and should be equally-well specified textually and diagrammatically. Such duality will benefit both modelers and coders alike. Our work suggests that code enhanced with state machine modeling abstractions is semantically equivalent to visual state machine models. The flow of the thesis is as follows; the research hypothesis and questions are presented in “Chapter 1: Introduction”. The background is explored in “Chapter 2: Background”. “Chapter 3: Syntax and semantics of simple state machines” and “Chapter 4: Syntax and semantics of composite state machines” investigate simple and composite state machines in Umple, respectively. “Chapter 5: Implementation of composite state machines” presents the approach we adopt for the implementation of composite state machines that avoids explosion of the amount of generated code. From this point on, the thesis presents empirical work. A grounded theory study is presented in “Chapter 6: A Grounded theory study of Umple”, followed by a controlled experiment in “Chapter 7: Experimentation”. These two chapters constitute our validation and evaluation of Umple research. Related and future work is presented in “Chapter 8: Related work”.

Hydrologists need simple, yet powerful, open source framework for developing and testing mathematical models. Such framework should ensure long-term interoperability and high scalability. This can be done by implementation of the existing, already tested standards. At the moment two interesting options exist: Open Modelling Interface (OpenMI) and Object Modeling System (OMS). OpenMI was developed within the Fifth European Framework Programme for integrated watershed management, described in the Water Framework Directive. OpenMI interfaces are available for the C# and Java programming languages. OpenMI Association is now in the process of agreement with Open Geospatial Consortium (OGC), so the spatial standards existing in OpenMI 2.0 should be better implemented in the future. The OMS project is pure Java, object-oriented modeling framework coordinated by the U.S. Department of Agriculture. Big advantage of OMS compared to OpenMI is its simplicity of implementation. On the other hand, OpenMI seems to be more powerful and better suited for hydrological models. Finally, OpenMI model was selected as the base interface for the proposed open source hydrological framework. The existing hydrological libraries and models focus usually on just one GIS package (HydroFOSS – GRASS) or one operating system (HydroDesktop – Microsoft Windows). The new hydrological framework should break those limitations. To make hydrological models’ implementation as easy as possible, the framework should be based on a simple, high-level computer language. Low and mid-level languages, like Java (SEXTANTE) or C (GRASS, SAGA) were excluded, as too complicated for regular hydrologist. From popular, high-level languages, Python seems to be a good choice. Leading GIS desktop applications – GRASS and QGIS – use Python as second native language, providing well documented API. This way, a Python-based hydrological library could be easily integrated with any GIS package supporting this programming language. As the OpenMI 2.0 standard supported interfaces only for Java and C#, the Python interface for OpenMI standard, presented in this paper, is the first step done towards the open and interoperable hydrological framework. GIS-related issues of the OpenMI 2.0 standard are also outlined and discussed.

Last 14 months students and teachers faced a necessity to realize students’ self-control at the temporary or permanent absence of help from the teachers’ side at degradation of teaching quality from teachers’ side and decreasing of perception quality from the students’ side in online mode of studying process. Such self-control will help to student to check him/herself independently, will increase the self-evaluation and self-confidence and will improve the quality and depth of knowledge. Students of the different educational institutions study at least one high level programming language, automation of calculations in electronic spreadsheets. Also students of different technical specialties study mathematical application software. Some students also study even more specific software for industry automation development. Therefore it’s proposed to realize the following ways for students’ self-checking at different technical tasks solving. 1. High level programming language. 2. Electronic spreadsheets. 3. Mathematical application software. 4. Application software for industrial automation systems development. Obtained results must be compared by student and solutions must be reanalyzed independently at the results mismatch.This self-checking approach is partly realized for students of technical specialties who study academic subjects like “Information technology”, “Computer technology”, “Programming of PLCs”. Exactly the last one requires the corresponding knowledge obtained during another academic subject learning.Proposed approach allows the refreshing of earlier obtained knowledge, the obtaining of new knowledge at new application software studying, to realize self-control at performance of different technical tasks at different subfields of information technologies studying and to increase the self-evaluation and self-confidence as a result.KeywordsSelf-controlOnline educationAutomation systems and data transfer networksPLC programmingMaritime branch