Vincent Falbo · RIT Scholar Works (Rochester Institute of Technology) · 2008
In an effort to provide better computer programming instruction to more students at an introductory level, pedagogical methods could be improved using a paradigm of instruction based on the same strategies used to teach students spoken languages. Although many different methodologies of instruction have been explored in the past, this document identifies relationships between spoken languages and computer languages that encourage the exploration of the best practices of teaching English Language Arts so that they could be applied to computer programming instruction. Those with backgrounds in mathematics and science initially completed programming tasks. Much literature about the problem solving aspects of programming is available; however, the researcher of this document found it difficult to obtain literature about the opportunities for growth provided by the humanities. This research is an attempt to foster the programming skills of students based on language skills. Given the similarities between spoken languages and object-oriented programming languages that have emerged, there is much encouragement that there may be possibilities for a new instructional paradigm. Following is an analysis of how computer languages are taught and how English is taught, as well as a description of fundamental learning theories. Example demonstrations in a high-level programming language and example problem sets that could be used in an introductory programming course are included that use the best practices employed in English classes, the best practices of computer programming instruction, and the generally accepted learning principles defined by educational theorists.
Cited by 0
Falbo, Vincent · RIT Scholar Works (Rochester Institute of Technology) · 2008
In an effort to provide better computer programming instruction to more students at an introductory level, pedagogical methods could be improved using a paradigm of instruction based on the same strategies used to teach students spoken languages. Although many different methodologies of instruction have been explored in the past, this document identifies relationships between spoken languages and computer languages that encourage the exploration of the best practices of teaching English Language Arts so that they could be applied to computer programming instruction. Those with backgrounds in mathematics and science initially completed programming tasks. Much literature about the problem solving aspects of programming is available; however, the researcher of this document found it difficult to obtain literature about the opportunities for growth provided by the humanities. This research is an attempt to foster the programming skills of students based on language skills. Given the similarities between spoken languages and object-oriented programming languages that have emerged, there is much encouragement that there may be possibilities for a new instructional paradigm. Following is an analysis of how computer languages are taught and how English is taught, as well as a description of fundamental learning theories. Example demonstrations in a high-level programming language and example problem sets that could be used in an introductory programming course are included that use the best practices employed in English classes, the best practices of computer programming instruction, and the generally accepted learning principles defined by educational theorists.
Cited by 0Open access
Lennart Beringer, Randall L. Brukardt, Thomas Plum et al. · 2012
Whether programming in a high-level modeling language providing automatic code generation, in a formally-verifiable language, in a language with advanced static analysis tools, or directly in a normal third-generation programming language, we ultimately depend on a compiler to generate the actual machine code that is executed by the target machine. This panel will discuss the issue of how we build trust in our compilers, using a commercial test suite, a standardized test suite, or a formal verification process.
Cited by 0
Han Jipeng, Lichen Zhihang · arXiv (Cornell University) · 2022
Since the advent of LISP, the fifth generation programming language has developed for decades. However, compared with the fourth generation programming language, the fifth generation programming language has not been widely used because of its obscure semantics, rigorous representation of problems, and limited inference ability. For this reason, COOL (Constraint and Object Ordered Language), a fifth generation programming language proposed in this paper, overcomes the problems of intuitive semantics, rigorous restrictions on handling problem conditions, and improves the inference ability of previous fifth generation programming languages. Specific improvements are as follows: First, COOL supports process-oriented and object-oriented for easy application in production projects; Second, COOL supports expression as function declaration and function return, which improves language affinity for mathematical formulas, and supports embedding function parameters into function name strings to make function naming closer to natural languages. Make mathematical problems easier to describe; Third, COOL introduces a weighting mechanism and accelerates the inference process through cumulative weighting. Fourth, COOL introduces the concepts of forward and reverse functions in programming so that computers can infer and execute problems with logical sequential constraints. Fifth, the computer can deduce the reverse solution process by using the forward solution process through the back-tracking algorithm and the dynamic programming algorithm, so that the computer can deduce the problem with time-sequential constraints. Sixth, the pre-execution step is introduced to separate the inference and function query process of the program from the execution process, so as to improve the execution speed of the program.
Cited by 2Open access
Audrey A. Hook, Bill R. Brykczynski, Catherine W. McDonald et al. · 1995
Abstract : This study reports on a programming language survey commissioned by the Assistant Secretary of Defense for C3I to determine how many programming languages are being used in the DoD today as compared to 20 years ago when the DoD began development of the Ada language. The sample population for this survey consisted of weapons systems taken from the 1994 Presidential Budget requests for RDT&E programs exceeding $15 million and Procurement budgets exceeding $25 million. The current DoD list of major Automated Information Systems was used as the survey sample for non-weapons systems. The survey found that over 80% of the applications in the sample were written in third generation languages. Moreover, it identified 37 third generation languages in contrast to an estimate of at least 450 general purpose languages and dialects in 1974. In weapons systems modernization, Ada is the most commonly used language.
Cited by 5
Philip J. Hatcher, Michael J. Quinn, Anthony J. Lapadula et al. · 2005
Dataparallel C is a SIMD extensiotii to the standard C programming language, It is derived from the original C* language developed by Thinking Machine,r Corporation, We have completed a third-generation Dataparalle1 C compiler, which produces SPMD-style C code suitable for execution on Intel and nCUBE multicomputers. In this paper we discuss the characteristics and strengths of data-parallel programming languages, summarize the syntax and semantics of Dataparallel C', and document the perjbrmance of six benchmark programs executing on the nCUBE 3200 multicomputer. Our work demonstrates that SIMD programs can achieve reasonable speedup when compiled and executed on multicomputers.
Cited by 9
Mahmoud Husseini Orabi, Ahmed Husseini Orabi, Timothy C. Lethbridge · 2019
We extend Umple, a model-oriented programming language, to incorporate text emission from templates as an integral feature. Umple as a template language (Umple-TL) is the term we use to describe the template sublanguage of Umple. Using Umple-TL, developers can benefit from synergies among UML modelling, templating and programming in several target languages (Java, C++), all in one textual language – Umple. Umple itself is written in Umple; using Umple-TL, we eliminated Umple's dependency on third-party libraries for text emission. We also support any other application developed in JET to be converted to use Umple-TL and attain benefits such as smaller and faster executables, target-language independence and IDE independence. The word ‘template’ in this paper refers to patterns for the generation of output, and not to generic types, another common use of the term.
Cited by 3Open access
Kemal Ebcioglu, et al. · 2004
The challenges faced by current and future-generation largescale systems include: 1) Frequency wall: inability to follow past frequency scaling trends, 2) Memory wall: inability to support a coherent uniform-memory access model with reasonable performance, and 3) Scalability wall: inability to utilize all levels of available parallelism in the system. These challenges manifest themselves as both performance and productivity issues in the use of large-scale systems. X10 is an experimental modern object-oriented programming language being developed to help address the second and third of these three challenges. It is intended for highperformance, high-productivity programming of large-scale computer systems with non-uniformities in data access and coherence, as well as multiple heterogeneous levels of parallelism. This paper provides a summary of the X10 language and programming model, and discusses its applicability to future processor architectures and runtime systems.
Cited by 0
Alan Clements · 1987
From the Publisher:
The Third Edition of MICROPROCESSOR SYSTEMS DESIGN covers the design of systems that use Motorola's 68000 family of microprocessors (including the latest generation of 68000 chips), and addresses both hardware and software considerations. Professor Clements' emphasis is practical, providing the necessary detail to enable students to design actual, working systems. The author covers hardware and programming comprehensively in an accessible writing style. A new chapter on the C programming language and its relationship to assembly language will appeal to instructors whose courses emphasize software aspects of systems design. A bound-in CD-ROM contains a 68000 cross-assembler and simulator, a C cross-compiler, fragments of the 68000 assembly code from the book, the 68000 and 68020 instruction sets, and documentation.
Cited by 17
Matuszczak, Witold · Jagiellonian University Repository (Jagiellonian University)
History of programming languages begins in the mid-twentieth century, when the creation of the first tube and the development of computers von Neumann architecture. At the time of the creation of transistors, microcontrollers and mikroproceserów, the development of computers took off. Along with at once more computing power and at lower cost once the creation of a computer, followed the development of programming languages. In the 50s, the first procedural programming languages (eg Fortran), 10 years later, the first structural languages. Decade, however, was enough to have developed new languages, now called third-generation languages such as C + +, Delphi. In recent years, major development languages, as well as their specialization, the resulting language interpreted by the so-called virtual machines, languages for querying databases or languages of the definition of the user interface.The main aim of this work is to learn practical knowledge of problems associated with the process of compilation and definition of the language by creating a compiler that converts a program written in object-in low-level language code. Both the high-level language and low-level will be created for this work. The compiler and all the analyzers were written by the author in Object Pascal (Delphi).The work consists of six chapters and a book reading.Work begins admission, as the first chapter. It contains the goals and sub-objectives posed this work.The second chapter is devoted to the field problem and the elements of the theory of formal languages and automata. It contains information and definitions related to programming languages, grammars, compilation and interpretation.The third chapter contains a detailed description of the language concerned with the division of the offered opportunities, identifiers, literals and grammar.The fourth chapter describes the process of compilation and code generation. This chapter contains sections devoted to the analysis of lexical, structural, and semantic. Grammar used is described, and a dedicated component for the structural analysis of specially written for the created object-oriented language. Also describes the semantic shares executed at compile, process model validation and code generation for each instruction and command.The fifth chapter is devoted to the target language. Includes a list of possible instructions, description of registers and memory addressing modes.Work has been summarized in chapter six. This chapter contains observations, concluding remarks and plans for the development of compiler and language under consideration.
Cited by 0
Frank M. Rijnders, H.J.W. Spoelder, E. P. M. Corten et al. · ACM SIGSMALL/PC Notes · 1992
We report on a visual programming environment designed to make and execute programs using already existing procedures written in some third generation language. The utilization of a client/server model combined with the dataflow principle makes this visual programming environment capable of networkwide operations. This feature can be used to elegantly incorporate dedicated hardware like data-acquisition devices and/or number crunchers into one visual program. The combination of these features offers interesting possibilities in the field of e.g. parallel processing and data-acquisition combined with number crunching thus making this tool very apt for the physics community.
Cited by 0
Jones, Neil D. · arXiv (Cornell University) · 2013
This research is about operational- and complexity-oriented aspects of classical foundations of computability theory. The approach is to re-examine some classical theorems and constructions, but with new criteria for success that are natural from a programming language perspective. Three cornerstones of computability theory are the S-m-ntheorem; Turing's "universal machine"; and Kleene's second recursion theorem. In today's programming language parlance these are respectively partial evaluation, self-interpretation, and reflection. In retrospect it is fascinating that Kleene's 1938 proof is constructive; and in essence builds a self-reproducing program. Computability theory originated in the 1930s, long before the invention of computers and programs. Its emphasis was on delimiting the boundaries of computability. Some milestones include 1936 (Turing), 1938 (Kleene), 1967 (isomorphism of programming languages), 1985 (partial evaluation), 1989 (theory implementation), 1993 (efficient self-interpretation) and 2006 (term register machines). The "Swiss pocket knife" of the title is a programming language that allows efficient computer implementation of all three computability cornerstones, emphasising the third: Kleene's second recursion theorem. We describe experiments with a tree-based computational model aiming for both fast program generation and fast execution of the generated programs.
Cited by 0Open access
Jeff Allen, H. S. Porter, T. Ray Nanney et al. · 1990
We describe our rationale for developing a new introductory computer science course at Furman University and summarize our experience with it. The pilot offerings were made possible in part by an grant from the National Science Foundation that provided important facilities for the laboratory components of the course. While the course does not abandon the traditional programming content found in CS 1, the course does attempt to place programming in the context of a larger framework of computer science stressing virtual machine and object oriented paradigms. It introduces problem solving at several levels of abstraction-including fourth generation, third-generation, and real-time operating system virtual machine language levels. It serves both as an entry level course to the computer science major and a rigorous service course for students in other (primarily scientific) disciplines.
Cited by 3Open access
Zhen Guo, Adriana Meza Soria, Wei Sun et al. · arXiv (Cornell University) · 2024
We introduce API Pack, a massive multi-programming language dataset containing over one million instruction-API calls for improving the API call generation capabilities of large language models. Our evaluation highlights three key findings: First, fine-tuning on API Pack enables open-source models to outperform GPT-3.5 and GPT-4 in generating code for entirely new API calls. We show this by fine-tuning CodeLlama-13B on 20,000 Python instances from API Pack. Second, fine-tuning on a large dataset in one language, combined with smaller datasets from others, improves API generation accuracy across multiple languages. Third, we confirm the benefits of larger datasets for API generalization, as increasing fine-tuning data to one million instances enhances generalization to new APIs. To support further research, we open-source the API Pack dataset, trained model, and code at https://github.com/zguo0525/API-Pack.
Cited by 1Open access
Jiahao Gai, Hao Chen, Zhican Wang et al. · 2025
Recent advances in code generation have illuminated the potential of employing large language models (LLMs) for general-purpose programming languages such as Python and C++, opening new opportunities for automating software development and enhancing programmer productivity. The potential of LLMs in software programming has sparked significant interest in exploring automated hardware generation and automation. Although preliminary endeavors have been made to adopt LLMs in generating hardware description languages (HDLs) such as Verilog and SystemVerilog, several challenges persist in this direction. First, the volume of available HDL training data is substantially smaller compared to that for software programming languages. Second, the pre-trained LLMs, mainly tailored for software code, tend to produce HDL designs that are more error-prone. Third, the generation of HDL requires a significantly higher number of tokens compared to software programming, leading to inefficiencies in cost and energy consumption. To tackle these challenges, this paper explores leveraging LLMs to generate High-Level Synthesis (HLS)-based hardware design. Although code generation for domain-specific programming languages is not new in the literature, we aim to provide experimental results, insights, benchmarks, and evaluation infrastructure to investigate the suitability of HLS over low-level HDLs for LLM-assisted hardware design generation. To achieve this, we first finetune pretrained models for HLS-based hardware generation, using a collected dataset with text prompts and corresponding reference HLS designs. An LLM-assisted framework is then proposed to automate end-to-end hardware code generation, which also investigates the impact of chain-of-thought and feedback loops promoting techniques on HLS- design generation. Comprehensive experiments demonstrate the effectiveness of our methods.
Cited by 4Open access
George Wilkie · Medical Entomology and Zoology · 1993
Introduction - how to use this book, technology transfer, level of genuine interest, current problems in software development, the advantages of an object-oriented technique, the disadvantages of an object-oriented approach concepts - introduction, objects, classes, inheritance, message passing, polymorphism, reuse, potential benefits, summary the OO software engineering life cycle - the traditional life cycle, object-oriented techniques in the software life cycle, conclusions analysis and design - why should I consider OO analysis and design?, OO analysis, OO design, a reference model for analysis and design, summary of some OO analysis and design methods, experiences with OO analysis and design, choosing an OO analysis and design method, summary and conclusions object-oriented programming languages - object-oriented language foreword, using a procedural language in an object-oriented way, C++, objective-C, Eiffel, Smalltalk, other notable OOPLs, general object-oriented programming issues, choosing an OO programming language, summary and conclusions developing information systems using OO techniques - a brief history of database management systems, limitations of relational technology, third generation database, management systems, object-oriented applications and relational technology, summary and conclusions migrating to an OO regime - technology transfer - introducing new technology - foreword, experiences introducing OO techniques, a nine-point plan for introducing object orientation, choosing an OO analysis and design method, choosing an OO programming language, choosing an OO database management system, summary and conclusions user case studies - the applied logic group - a case study using Eiffel, Winter Partners Ltd - a case-study using Smalltalk, British Airways plc - a case study using C++, Praxis Systems plc - a case study using objective-C, British Aerospace plc - a case study using Ontos, Satellites International Ltd - a case study in analysis and design summary, conclusions and future trends - the software development life cycle, analysis and design, programming, database management systems, overall, future trends appendices - structured analysis - introduction, entity relationship diagrams, data flow diagram, state transition diagram OOSD notation software development maturity - background, the SPMM model, the five process maturity levels OO groups - the object management group, the object interest group the OO database system manifesto third-generation database manifesto some commercial OODBMSs - GemStone, Ontos, O[2], ObjectStore, Versant, Objectivity.
Cited by 34
Alaa Nazar Abd Algaffar · Baghdad Science Journal · 2011
Java is a high-level , third generation programming language were introduced Javaoptics Open Source Physics (OSP) as a new simulation for design one of the most important interference optical coating called antireflection coating. It is recent developments in deign thin-film coatings. (OSP) shows multiple beam interferences from a parallel dielectric thin film and the evolution of reflection factors. It is simple to use and efficiently also can serve educational purposes. The obtained results have been compared with needle method
Cited by 1Open access
Baghdad Science Journal · Baghdad Science Journal · 2011
Java is a high-level , third generation programming language were introduced Javaoptics Open Source Physics (OSP) as a new simulation for design one of the most important interference optical coating called antireflection coating. It is recent developments in deign thin-film coatings. (OSP) shows multiple beam interferences from a parallel dielectric thin film and the evolution of reflection factors. It is simple to use and efficiently also can serve educational purposes. The obtained results have been compared with needle method
Cited by 1Open access
Alexander Reinefeld, Volker Schnecke · 1994
Although PVM was developed to use a network of heterogeneous UNIX computers as a single large parallel computer, it has become an interface for portable programming even on MPP's. We present PVM performance results for a massively parallel transputer system with up to 512 processors. In comparison to an implementation of the same application in the native transputer operating system Parix, we realized about 30% performance loss for the PVM application. This is mainly caused by restrictions in the process model and the less efficient communication of PVM in comparison to Parix. 1 Introduction Analogous to the shift from assembler language programming to the third-generation languages in the early years of computer science, we are currently witnessing a paradigm change towards the use of portable programming models in parallel high-performance computing. Like before, the high-level programming environment is paid for by a lower system performance. But how much does portability cost in p...
Cited by 0
Vadim Zaytsev · University of Twente Research Information · 2020
Many techniques in software language engineering get their first validation by being prototyped to work on one particular language such as Java, Scala, Scheme, or ML, or a subset of such a language. Claims of their generalisability, as well as discussion on potential threats to their external validity, are often based on authors' ad hoc understanding of the world outside their usual comfort zone. To facilitate and simplify such discussions by providing a solid measurable ground, we propose a language called BabyCobol, which was specifically designed to contain features that turn processing legacy programming languages such as COBOL, FORTRAN, PL/I, REXX, CLIST, and 4GLs (fourth generation languages), into such a challenge. The language is minimal by design so that it can help to quickly find weaknesses in frameworks making them inapplicable to dealing with legacy software. However, applying new techniques of software language engineering and reverse engineering to such a small language will not be too tedious and overwhelming. BabyCobol was designed in collaboration with industrial compiler developers by systematically traversing features of several second, third and fourth generation languages to identify the core culprits in making development of compiler for legacy languages difficult.
Cited by 1Open access