Demonstrating programming language feature mining using Boa

Programming languages evolve over time, adding additional language features to simplify common tasks and make the language easier to use. For example, the Java Language Specification has four editions and is currently drafting a fifth. While the addition of language features is driven by an assumed need by the community (often with direct requests for such features), there is little empirical evidence demonstrating how these new features are adopted by developers once released. In this paper, we analyze over 31k open-source Java projects representing over 9 million Java files, which when parsed contain over 18 billion AST nodes. We analyze this corpus to find uses of new Java language features over time. Our study gives interesting insights, such as: there are millions of places features could potentially be used but weren't; developers convert existing code to use new features; and we found thousands of instances of potential resource handling bugs.

Multi-core platforms are becoming prevailing in telecom infrastructures, and many SIP(Session Initiation Protocol) enabled applications are using Java as the development language and runtime environment. It is important to understand the workload characteristics and performance issues of Java based SIP stack over multi-core platforms. In this paper, two RFC 3261 compliant Java based SIP stacks, the JAIN-SIP and a proprietary SIP stack are studied in depth. Especially we focused on the typical performance issues caused by either Java language features or the workload of SIP protocol, including scalability of SIP stack, resource contention issue and GC impact with SIP memory usage pattern. Some optimization techniques and their drawbacks are also discussed along with the performance evaluation. It turns out that due to the complex combination of SIP protocol semantics and Java language features, the performance of Java based SIP stack tends to be far from competitive on multicore platforms. Extensive optimization and certain improvements of program structure and object management policy may help, however, may, on the other hand, sacrifice some key values of the java language, e.g. easy development.

Many optimizations need precise pointer analyses to be effective. Unfortunately, some Java features, such as dynamic class loading, reflection, and native methods, make pointer analyses difficult to develop. Hence, prior pointer analyses for Java either ignore these features or are overly conservative. This paper presents the first non-trivial pointer analysis that deals with all Java language features. This paper identifies all problems in performing Andersen’s pointer analysis for the full Java language, presents solutions to those problems, and uses a full implementation of the solutions in Jikes RVM for validation and performance evaluation. The results from this work should be transferable to other analyses and to other languages.KeywordsVirtual MachinePointer AnalysisConstraint GraphCall GraphInterprocedural AnalysisThese 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 1990s saw a hugely productive interaction between database and programming language research. Ideas about type systems from programming languages played a central role in generalizing and adapting relational database systems to new data models. At the same time databases provided some of the best concrete examples of the application of concurrency theory and of the benefits of high-level optimization in functional programming languages. One of the driving ambitions behind this research was the idea that database access should be properly embedded in programming languages: one should not have to be bilingual in order to use a database from a programming language; and that goal has to some extent been realized. In the past fifteen years, new data models, both for data storage and for data exchange have appeared with depressing regularity and with each such model, the inevitable query language. Does programming language research have anything to contribute to these new languages? Should we take the time to to worry about embedding these models in conventional languages? Over the same period, some interesting new connections between databases and programming languages have emerged, notably in the areas of scientific databases, annotation and provenance. Will this provide new opportunities for cross-fertilization?

This is the 23rd Self-Assessment Procedure. 1 The purpose of this procedure is to let its readers test their knowledge of some of the more important features of significant programming languages. The features of imperative languages like Fortran, Algol 60, PL/I, Pascal, Modula-2, C, and Ada considered are data types, data structures, control structures, program units, scope of names, and parameter passing. Some of the corresponding features of functional languages like Lisp, logic programming languages like Prolog, and ohject-oriented programming languages like C++ and Smalltalk, are reviewed. Finally brief consideration is given to syntax and semantics, chiefly by reference to the Backus-Naur form, BNF. The features of programming languages affect all aspects of programming, including the ease of writing and maintaining programs, the reliahility of software, and the efficiency and portability of programs. Knowledge of programming language concepts and constructs is of importance to software developers, programmers, and designers of programming languages and compilers. The topic of this procedure should be of interest to any computer science student or practitioner who wishes to test his or her knowledge and learn more about one of the most important and broad areas in the computer field. The language used most often in the questions is Pascal, with Ada, Lisp, and Prolog also featured prominently. A glossary is included which defines some of the terms used in the procedure. The questions are either multiple-choice or short answer. Some of the multiple-choice questions allow for more than one correct answer.

Over the past few years, Large Language Models of Code (Code LLMs) have started to have a significant impact on programming practice. Code LLMs are also emerging as building blocks for research in programming languages and software engineering. However, the quality of code produced by a Code LLM varies significantly by programming language. Code LLMs produce impressive results on high-resource programming languages that are well represented in their training data (e.g., Java, Python, or JavaScript), but struggle with low-resource languages that have limited training data available (e.g., OCaml, Racket, and several others). This paper presents an effective approach for boosting the performance of Code LLMs on low-resource languages using semi-synthetic data. Our approach, called M ulti PL-T, generates high-quality datasets for low-resource languages, which can then be used to fine-tune any pretrained Code LLM. M ulti PL-T translates training data from high-resource languages into training data for low-resource languages in the following way. 1) We use a Code LLM to synthesize unit tests for commented code from a high-resource source language, filtering out faulty tests and code with low test coverage. 2) We use a Code LLM to translate the code from the high-resource source language to a target low-resource language. This gives us a corpus of candidate training data in the target language, but many of these translations are wrong. 3) We use a lightweight compiler to compile the test cases generated in (1) from the source language to the target language, which allows us to filter our obviously wrong translations. The result is a training corpus in the target low-resource language where all items have been validated with test cases. We apply this approach to generate tens of thousands of new, validated training items for five low-resource languages: Julia, Lua, OCaml, R, and Racket, using Python as the source high-resource language. Furthermore, we use an open Code LLM (StarCoderBase) with open training data (The Stack), which allows us to decontaminate benchmarks, train models without violating licenses, and run experiments that could not otherwise be done. Using datasets generated with M ulti PL-T, we present fine-tuned versions of StarCoderBase and Code Llama for Julia, Lua, OCaml, R, and Racket that outperform other fine-tunes of these base models on the natural language to code task. We also present Racket fine-tunes for two very recent models, DeepSeek Coder and StarCoder2, to show that M ulti PL-T continues to outperform other fine-tuning approaches for low-resource languages. The M ulti PL-T approach is easy to apply to new languages, and is significantly more efficient and effective than alternatives such as training longer.

The work of Fuzz has pioneered the use of functional programming languages wheretypes allow to reason about the sensitivity of programs. Fuzz and subsequentwork (e.g., DFuzz and Duet) use technical devices like linear types, modal types, and partial evaluation. These features usually require the design of a newprogramming language from scratch - a major task on its own! While thesefeatures are part of the classical toolbox of programming languages, they areoften rather obscure for non-programming language experts. In this work, weexplore a different direction. We propose the design of a library capable ofcalculating the sensitivity of programs. The library is built on a novel use ofpolymorphism to represent (and prove) the sensitivity of functions andthe use of type constraints and type-level natural numbers. We show how ourapproach can be used to reason about the sensitivity of classical examplesworking over vectors, such as sum, map, and sort - we leave reasoning aboutmore complex programs for future work. Our library, called DSencity, isimplemented with just 360 lines of Haskell code.

Usability is an important feature for programming languages, and user evaluations can provide invaluable feedback on language design. However, user studies which compare programming languages or systems are often very expensive and typically inconclusive. In this paper, we posit that discount usability methods can be successfully applied to programming languages concepts such as language features. We give examples of useful feedback received from applying heuristic evaluation to two language features targeted at parallel programming.

Events and Sightings David Walden (bio) and Dag Spicer (bio) Fifty-Year Anniversaries in Norwegian Computing History Two fifty-year anniversaries in computing history were celebrated in Oslo in September 2017: the fifty-year anniversary of the creation of the Simula programming language, and the fifty-year anniversary of the founding of the Norsk Data computer company. Simula The Simula 67 programming language, first formally defined in 1967, was a step in a series of developments by Ole-Johan Dahl and Kristen Nygaard that began in the early 1960s.1 Dahl and Nygaard were given the 2001 IEEE John von Neumann Medal and the ACM 2001 A.M. Turing Award for their creation of Simula. A fifty-year anniversary celebration for Simula took place (in the “Simula Auditorium” in the “Ole-Johan Dahl Building”) at the University of Oslo on 27 September 2017. The celebration began with unveiling of a plaque from the IEEE History Committee’s Milestone program. The plaque reads: IEEE Milestone Object-oriented Programming, 1961–1967 Ole-Johan Dahl and Kristen Nygaard created the Simula programming languages in the 1960s at the Norwegian Computer Center, and in so doing introduced a new way of modeling and simulating complex tasks. Object-oriented programming is now dominant in systems development. It is an integral part of computer science curricula, as are languages built on object-oriented programming concepts, such as Smalltalk, C++, Java, and Python. September 2017 The nomination of this Milestone was from the IEEE Norway Section. The photo shows Section Vice-Chairman Kaveh Niayesh unveiling the plaque. The rest of the day consisted of presentations by several programming language researchers and developers: Oscar Nierstrasz (“Great Moments in the History of OOP”), Dave Thomas (“The Legacy of Simula 67”), and James Gosling (“Simula: A Personal Journey”), as well as a panel discussion chaired by Eric Jul (“Whither Programming Languages? Can We Still Celebrate Simula 50 Years from Now?”) with participation of the prior three speakers and Ole Lehrmann Madsen and Olaf Owe.2 Videos from the event are available.3 The previous afternoon, the Association of Simula Users (ASU) held a several-hour meeting at which there were six presentations and a wrap-up session. According to Boris Magnusson (ASU chairman 1982–83), the ASU has been in continuous existence since the early days of Simula 67, holding annual conferences and publishing a quarterly newsletter. However, in recent years the ASU activities “have slowly faded away, and the meeting in Oslo was intended as a last meeting and also a way to formally close down the Association.” Click for larger view View full resolution Photo 1. Photo credit: Harald Brombach/digi.no. Norsk Data On 16–17 September 2017, the fiftieth anniversary of the founding of Norsk Data was marked. In 1967 Lars Monrad-Krohn, Per Bjørge, and Rolf Skår left the Norwegian Defence Research Establishment (NDRE), where they had worked on the computer developments in “Siffergruppen” (the Digital Group), initiated and [End Page 93] led by Yngvar Lundh. They founded Norsk Data Elektronikk, where their first computer development was the Nord-1, building on work they had done in the Digital Group. Click for larger view View full resolution Photo 2. Veslemøy Østrem of Aftenposten interviewing Norsk Data founders Rolf Skår and Lars Monrad-Krohn. Photo credit: Ragnar Sturzel. The Nord-1was a minicomputer and competed well in Europe with minicomputers from the United States. With additional computers being developed over the years (arguably better hardware and software than some US competitors) and many high-profile or operation-critical installations, Norsk Data eventually became a high-flying company listed on the London as well as the NASDAQ stock exchanges, in addition to on the Norwegian exchange. With the personal computer revolution, Norsk Data went the way of almost all minicomputer manufacturers, eventually going out of business. For many of the eventual 4,500 employees of Norsk Data, their time with a company was one of the most exciting times of their professional careers, and the one-time employees of Norsk Data went on to populate a significant part of the developing Norwegian computing industry. The day of 18 September involved a five-hour...

Rowe : I am going to talk a little about data abstraction from a programming language viewpoint. I suspect that what I will say in some places will be every bit as controversial amongst programming language folks, as what Dennis said was amongst database folks. Historically, programming languages evolve continually, from very low-level representations or descriptions of computations to higher-level descriptions. The idea is to express computations in a way that makes them easier to write, faster to debug, and make them survive change. All these marvelous buzzwords!

Why do some programming languages fail and others succeed? What does the answer tell us about programming language design, implementation, and principles? To help answer these and other questions, we argue for examining the sociological groundings of programming language theory: socio-PLT.Researchers in the social sciences have studied adoption in many contexts. We show how their findings are applicable to programming language design. For example, many programming language features provide benefits that programmers cannot directly or immediately observe and therefore may not find compelling. From clean water to safe sex, the health community has repeatedly identified and surmounted similar observability barriers. We use such results from outside of programming language theory to frame a research agenda that should help us understand the social foundations of languages. Finally, we examine implications of our approach, such as for the design space of language features and the assessment of scientific research into programming languages.

The history of programming languages shows a continuous search for new composition mechanisms to find better ways for structuring increasingly complex software systems into modules that can be developed and reused independently. Composition mechanisms can address various forms of interactions, e.g., inheritance, delegation, aggregation, design patterns, contracts, explicit protocols, or domain-specific compositions. However, most languages adopt a fixed set of composition mechanisms, usually with explicit notation and predefined semantics. In case a language does not provide any mechanisms with the desired compositional behavior, programmers may need to write workarounds or introduce the new composition mechanism through macros, libraries, frameworks or language extensions. The FREECO workshop series intends to stimulate research in programming languages and software development by exploring the notion that languages should not offer a limited set of fixed composition mechanisms, but allow for flexibility, a wide variety of compositions, domain-specific and tailored compositions, or programmable compositions of various program artifacts. You can find more information about the FREECO workshop series at the workshop website located at: http://trese.ewi.utwente.nl/workshops/FREECO. These proceedings contain a selection of papers that were submitted for the [email protected]!2011 workshop that was held as part of the SPLASH/ONWARD conference in Portland, OR, October 23-27, 2011. The workshop was a fruitful and constructive day, which resulted in new insights, new inspiration, as well as a poster with the workshop results, which was presented at the plenary poster event the next day.

This paper discusses a long-distance virtual teaching platform based on VRML-JAVA language which is realistic and interactive information construction and scene guided by situational learning theories in views of insufficiency in modern long-distance network teaching. Based on characteristics of VRML and JAVA language, we introduce the structure and function of this platform to realize the platform key technologies including building the virtual scene construction, the substitute person, the community sensation and so on, which makes beneficial exploration in distance education.

Modular language implementation in Rascal – experience report

Programming complexity (the amount of difficulty in constructing a program) may depend upon certain programming factors (choices of programming language features). Using program changes as a programming complexity measure, previous research has identified five potential programming factors. This paper suggests that subjects tend to use the same levels of these factors in two different programming languages supporting the conjecture that these factors are elements of individual programming style. It also describes five potential programming factors, and although each has intuitive appeal, only average procedure length was related to programming complexity.