yusuke1997/dblp-id-title huggingface dataset:
Language integration in the common language runtime
Some Comments on 'The Priority-Based Coloring Approach to Register Allocation'
Looking for love (in all the wrong places)
A database design for graphical models
Extensions in Pascal implementations
CHAMIL: a case study in microprogramming language design
Operation expressions in MARY
Exploratory language design
The icon programming language: an overview
Bug Analysis of Pascal Programs
Some statistics on ALGOL 68 programs
Characteristic equation of a matrix
Test Programs to Observe Parallelism
A Note on Enumerations
How to Evaluate Object-Oriented Software Development?
The Object Oriented Pre-Compiler
Solution of the Tower of Hanoi problem using a binary tree
Slicing Z specifications
Iterators Evaluate Table Queries (C++ Toolbox)
HPC is a strange land
Computational Steering Annoted Bibliography
High level language debugging with a compiler
Some short comments on the definition and the documentation of the ADA programming language
Optimization of error recovery in syntax-directed parsing algorithms
Software engineering: portability
PROPHET system
Responsive sequential processes
A new top-down parsing algorithm to accommodate ambiguity and left recursion in polynomial time
An interpretative implementation of limited entry decision tables in Algol 68
Proposed data structures for QL/Bn
Automated compiler construction based on top-down syntax analysis and attribute evaluation
ACM SIGPLAN history of programming languages conference JOSS language summary
Foundations of Object-Oriented Languages - Workshop Report
Classification in object-oriented systems
A functional shell
Functional programming is not self-modifying code
Did Turing Discover How the Leopard Got Its Spots?
A portable pseudo-code for Pascal-like languages
The Design and Implementation of a Program Development System Based on Rewriting Method
Software conversion: retargeting from a super-mini to a micro
Comments, assertions and pragmas
The role of the language standards committee
Some features of PPL, a polymorphic programming language
TM: a systematic methodology of software metrics
Benchmark test to estimate optimization quality of compilers
Real programmers don't use spreadsheets
ALGOL-N +
A real-time microprocessor debugging technique
Uninitialized Modula-2 abstract objects, revisited
A system for writing Pascal programs interactively
On the implementation of parsing tables
Lucinda - an overview
On control constructs for constructing programs
A Pragmatic Approach to C++, Eiffel and Ada 9X Programming
Preliminary ZENO language description
Attribute propagation by message passing
The 'Hamming' in Prolog
A new language for multicomputer programming
The design and implementation of quest, a very high level pedagogic programming language
A methodology for modular use of Ada
Fusing Loops With Backward Inter Loop Data Dependence
Recursion: A choice between readability and execution speed
Proofs, program correctness, and software engineering
A three-processor Lisp machine architecture based on statistical analysis of Common Lisp programs
Reasoning about arrays
Control constructs for programming languages
A Functional Approach to Type Constraints of Generic Definitions
Theoretical relationships between potential operands and basic measurable properties of algorithm structure
Formal definition of programming languages
The specification language T
Denotational semantics for program analysis
The Pascal-XT Code Generator
The Calculation of Easter
Forth's DOOM
Syntax error repair for a Java-based parser generator
A micro-manual for LISP - not the whole truth
The PRESTO system
RT-MODULA2: an embedded in MODULA2 language for writing concurrent and real time programs
On Dart-Zobel Algorithm for Testing Regular Type Inclusion
Toward the specification of a common base language
Foreword to work in progress
Shallow binding makes functional arrays fast
Developing a Tool for Memoizing Functions in C++ (C++ Toolbox)
A note on one-pass CASE statement compilation
A "Linear Logic" Quicksort
Some notes on processing limited-entry decision tables
Involving coroutines in interaction between functional and conventional language
Poor Man's Watchpoints
Comment on Poor Practice in Coding Examples
XVF: C++ introspection by extensible visitation
About Conversations for Concurrent OO Languages
SIGPLAN Web Pages and Mailing List
Efficient full LR(I) parser generation
Objects for Lexical Analysis
Decomposition of complex selection criteria
Rated and operating complexity of program - an extension to McCabe's theory of complexity measure
COLLOQUE APL: Paris, September 1971
A source of redundant identifiers in PASCAL programs
When Bad Programs Happen to Good People
The history of FORTRAN I, II, and III
A flowcharting proposal
Using BINS for inter-process communication
Programming Dynamically Reconfigurable Open systems with SALSA
Remarks on many-sorted equational logic with respect to algebraic implementations
The ensemble system: concurrent programming on a personal computer
Objects in concurrent logic programming languages
A solution to the great big substitution problem: subject modification during pattern matching in SNOBOL4
Data structure models for programming languages
Error handling using Modula-2
Basic operations of the VisiCola scope model
Compiling objects into actors (abstract only)
Towers of Hanoi revisited a nonrecursive surprise
CONS Should Not CONS Its Arguments, Part II: Cheney on the M.T.A
An intermediate level dynamic storage capability
An improvement to the 'if-then-else' and 'select' clauses, and some comments on Arun Lakhotias' an improvement over . .
Programming and writing
Parallel programming concepts in a definitional language
Fast additions on masked integers
A further note on looping in Prolog
Instruction-coated translation: an approach to restructure directly threaded interpreters with low cohesion
Position paper: practical foundations for lrogramming languages
Recursive ascent: an LR analog to recursive descent
The implementation and experiences of a structure-oriented text editor
Scarcely variabled programming and Pascal
Using Simple English Sentences to Call Procedures
Resource typing in guru: (abstract only)
Implementing Semaphores by Binary Semaphores
Universal editor unattainable
A Brief Look at Extension Programming Before and Now
A Novel Program Representation for Interprocedural Analysis
The EXEC 8 implementation of LIST PROCESSOR-N
University of Washington implementation
Measurements of program similarity in identical task environments
APL-FIOS; APL-FIDOS: multilevel total file access and special features
An object-oriented specification for compiler
Aspen language specifications
What Should Be In a Parallel Library
A production system language KDOPS
Challenge benchmarks for verification of real-time programs: (abstract only)
A new modula compiler for the LSI-11
SP-Grammars: context-free grammars for structured programming
From Recursive Ascent to Recursive Descent: Via Compiler Optimizations
Towards Situation-Oriented Programming Languages
ACM SIGPLAN history of programming languages conference COBOL 60 language summary
Notes on argument-parameter association in Fortran
Algol 68 as an extensible language
Another look at the CASE statement
Venturing Forth With a Flashlite
On extending Fortran control structures to facilitate structured programming
C++'s destructors can be destructive
On FP languages combining forms
NDC++: An Approach to Concurrent Extension of C++
IDL as a Data Description Language for a Programming Environmemnt Database
A Fortranner's lament: comments on the draft proposed ANS Fortran standard
DYSTAL 2: a general purpose extension of FORTRAN
SetLog, a tool for experimenting with new semantics
<u>do</u> considered <u>ob</u>viously <u>odd</u> in three dimensions
J - Set of Tools for Native Code Generation for the Java Virtual Machine
Using smgn for Rapid Prototyping of Small Domain-Specific Languages
Coco-2: a new compiler compiler
1998 SIGPLAN Awards
Concurrent programming vs. concurrency control: shared events or shared data
An extension to the language-based access-control mechanism of Jones and Liskov
An aspect-oriented approach to the undergraduate programming language curriculum
Overview of Relational Programming
A note on data abstractions
Eliminating unwanted loops in Prolog
Implementation of Multiple Attribute Grammar Inheritance in the Tool LISA
A Note On Type Checking Linear Functional Languages
On a finite axiomatization of the data type L
The present most recent final word about labels in MARY
A Note on the Modulo Operation in Edison
PL research and its consequences on PL curriculum
BlurFit - an Application of Functional Programming to Scientific Analysis
The 1999 ICFP Programming Contest
Learning Forth with Modular Forth
A General, Fine-Grained, Machine Independent, Object-Oriented Language
NARPL: A solution to the student compiler project problem
A Note on Before and After Metamethods
Another nonrecursive algorithm for the towers of Hanoi
FWEB: A Literate Programming System for Fortran8x
Software Metrics - An Experimental Analysis
On the generation of ALGOL 68 programs involving infinite modes
On Defusing a Small Landmine in the Type Casting of Pointers in the 'C' Language
Translating EXPRESS language model into C language model
A simple software environment based on objects and relations
Visual Specification of Blocks in Programming Languages
Comments on innovative control constructs in pancode and EPN
Object-based real-time programming
Multiparadigm Design of a Simple Relational Database
A question-answering system for automatic program synthesis
An overview on ModPascal
ACM SIGPLAN Workshop on Language, Compiler, and Tool Support for Real-Time Systems, 1994 (Summary of the Workshop)
Functional Programming, and Where You Can Put It
A compiler for APL
An integrated data base language
On the elimination of pointer variables and dynamic allocation in higher level languages
Type-safe linkage for variables and functions
The programmer as navigator: a discourse on program structure
Introduction of history to variables
A Letter Oriented Minimal Perfect Hash Function
Covariant Deep Subtyping Reconsidered
A generic sorting module in Modula-2
Towards functional programming in Prolog
Review of the DDI Jovial evaluation study
Modular reasoning about invariants over shared state with interposed data members: (abstract only)
On eliminating loops in Prolog
Comment on a note on dynamic arrays in PASCAL
Reply to: Erhard Konrad - Software Metrics, Measurement Theory, and Viewpoints - Critical Remarks on a New Approach
Io: a new programming notation
Detap/55: a decision table preprocessor for generating single-paragraph, fully-nested Cobol code
A portable high-speed PASCAL to C Translator
Editorial - Justifying Java?
Using Object-Orientation as a Common Basis for System Development Eduaction
Edicates - A Specification Of Calling Sequences
An overview of methods for dependence analysis of concurrent programs
A study of record packing methods
Maintained and constructor attributes
EXTREME Forth
Acceptive grammars
A short note on scanning signed integers
A one-pass prettyprinter
A Report on Object-Oriented Extensions to Pascal
Lookahead recall error recovery for LALR parsers
A taxonomy of datatypes
An overview of Fortran 2003
A simple measure of software complexity
PASCAL for operating software? A critical examination
"do considered od" considered odder than "do considered ob"
Process migration: effects on scientific computation
Corporate Support and SIGPLAN
A practical guide to SQL white-box testing
Making C++ Practical for Business Applications: 3 Essential Classes
Gödel numbers: a new approach to structured programming
NIL: An integrated language and system for distributed programming
Parallel Forth
Prolog Puzzles
Testing the readability and composability of computer programs: methodology
HOPL-II - Closing Panel: The History of Programming: Does our Present Past Have a Future?
Modification to the APL/1130 system: part 3
A new method of generating LL(1) lookahead sets
Yet another history mechanism for command interpretors
Four relational programs
ACM SIGPLAN history of programming languages conference ALGOL 60 language summary
A simple parallel system
Distributed debugging: session summary
Putting More Meaning in Expressions
An experimental C compiler for the Cray 2 computer
On the impossibility of content exchange through the by-name parameter transmission mechanism
Embed with Forth
Thank you, Seth
Block structure and object oriented languages
Bugfind: A Tool for Debugging Optimizing Compilers
The DrScheme Project: An Overview
Structured Editor Support for Modularity and Data Abstraction
On hobbits and the growth of APL
A comparison of PASCAL and FORTRAN as introductory programming languages
On Data Flow Guided Program Testing
The efficiency of the equation interpreter compared with the UNH Prolog interpreter
Using formal procedure parameters to represent and transmit complex data structures
Method driven model: a unified model for an object composition language
Adding Generic Function to Scheme
Intensional Equality ;=) for Continuations
Quality assessment of processor documentation
Ada syntax chart
L-Systems with Inheritance: An Object-Oriented Extension of L-Systems
Implementation issues: session summary
Some comments on ADA as a real-time programming language
SYSL: system description language
The Towers of Hanoi - a representation-free solution
Introducing a CPS Style Optimizer into an Existing Compiler
A structured model of programs suitable for analysing time/storage trade-offs
Program Adaption based on Program Transformation
Program structure definition using binary relations
Reducing Garbage in Java
What does Modular-2 need to fully support object oriented programming?
A Model for Implementing an Object-Oriented Design without Language Extensions
Parallel Bounded Quantification - Preliminary Results
A syntax-directed editor, world-builder and simulator for the language of KAREL the robot
ParCeL-1: A Parallel Programming Language Based on Autonomous and Synchronous Actors
Java RMI, RMI tunneling and Web services comparison and performance analysis
An experimental natural-language processor for generating data type specifications
EPILOG = PROLOG + Data Flow: Arguments for Combining PROLOG with a Data Driven Mechanism
Pitfalls in PROLOG programming
Improving the quality of compiler construction with object-oriented techniques
PL/I compile time extensibility
PROGEN: A Programming Environment
The IFAD VDM-SL toolbox: a practical approach to formal specifications
Interactive debug requirements
Strength Reduction of Multiplications by Integer Constants
Differences between preliminary and final ADA
How to avoid getting schlonked by Pascal
Response on Remarks on Recent Algorithms for LALR Lookahead Sets
GPL, a general purpose language
Notes on the computer program test methods symposium
Recursive definitions for iterative algorithms
On Dimishing the Vibrant Confusion In Software Metrics
Considerations in Choosing a Concurrent/Distributed Object-Oriented Programming Language
COMPAS: compatible Pascal
Language and compiler design to enhance reliability
Fair concurrency in actors (abstract only): eager evaluation producers strong convergence
The Complexity of Formal Specifications - Assessments by alpha-Metric
Estimating the execution speed of an Algol program
A walk through AWK
Fable: A programming-language solution to IC process automation problems
Adaptive automata for context-dependent languages
Syntax directed graphical interaction
The effectiveness of error seeding
The design of the REXX language
Parametrized Methods
Handling ambiguous tokens in LR-Parsers
A model for a reflective object-oriented language
Recursion vs. non-Recursion in Pascal; a rejoinder
Dominance analysis of irreducible CFGs by reduction
A graded bibliography on macro systems and extensible languages
Operating system development with ATS: work in progress: (abstract only)
How to print with style
Many cyclic block diagrams do not need parallel semantics
Soma: a compositional language for distributed systems
Covariant Specification
Paged input/output in some high level languages
Classification as a paradigm for computing (abstract only)
A note on pattern matching under Quickscan in SNOBOL4
Nested sublanguages of Algol 68 for teaching purposes
Remarks on Recent Algorithms for LALR Lookahead Sets
A monadic program slicer
Trip Report: UIST '90, The Annual Symposium on User Interface Software and Technology
Static Head Nodes in the Operations on Dynamic Structures - An useful programming technique
Enhanced Arithmetic for Fortran
Extended Pascal is no problem
An approach to automatic testing exception handling
Hypercube experiments with Joyce
Knowledge-based fault localization in debugging: preliminary draft
On a proposed measure of program structure
A Grammar Rule Notation Translator
Types in red
Compiler structure engineering with attribute grammars
Program design visualization system for object-oriented programs
On the synchronization mechanism of the ADA language
The Static Semantics File
Incremental definition and operationalization of domain-specific markup languages in ADDS
A translation machine with automated top-down parsing
Etude and the folklore of user interface design
A note on PCI: distributed processes communicating by interrupts
Remarks on A Methodoly for Implementing Highly Concurrent Data Objects
Structured programming with loop statements
Comments on ADA process communication
A simple model of distributed programs based on implementation-hiding and process autonomy
An automated refactoring tool for dataflow visual programming language
Thoughts on the 1996 Rochester FORTH Conference
An experimental LISP system for the SPERRY UNIVAC 1100 Series
Ada syntax diagrams for top-down analysis
uu for Programming Languages
Faster XML data validation in a programming language with XML datatypes
Integration mechanisms in Cedar
FORTH for microcomputers
Multitasking without compromise: a virtual machine evolution
Pascal and comms programming
Pi machines: virtual machines realizing graph structured transition P systems
Recursion versus non-recursion in Pascal: recursion can be faster
A note on the vector C language
The data flow programming language CAJOLE - an informal introduction
Flowchart techniques for structured programming
A New Sort Algorithm: Self-Indexed Sort
Column Constructor
A system for structured programming
PASCAL standardisation
Some sad remarks about string handling in C
Report on the Programming Language Haskell, A Non-strict, Purely Functional Language
APL compared with other languages according to Halstead's theory
Introduction to the special issue of the SIGPLAN Notices on the Object-Oriented Programming Workshop
Some deficiencies of C++ in teaching CS1 and CS2
Less complex elementary functions
Parsing with C++ Classes
An algebra for program fragments
An object-based parallel programming assistant
A note on the checking of interfaces between separately compiled modules
Draft proposed ANS FORTRAN BSR X3.9 X3J3/76
Formulations and benefits of the law of demeter
A comparison of the object-oriented and process paradigms
Differences between Modula-2 and Pascal
Regular right part programming languages
Experiences porting Pascal source from a micro computer to a Vax
How to Give a Good Research Talk
Dynamically-Valued Constants: An Underused Language Feature
Exception handling design issues
SIGPLAN and SIGSOFT Joint Efforts
Observations on the differences between formulas and sentences and their application to programming language design
A design for Fortran to facilitate structured programming
The A-TABLE data-type for LISP systems
Programming with Abstract Data Types
Lazy functional programming in Java
CommonObjects: object-oriented programming in Common Lisp
Process scheduling in Modula-2
Robot Control Techniques, Part Two: Forth as a Robotics Languags
Bootstrapping XPL from IBM/360 to UNIVAC 1100
Decentralised control flow - based on UNIX
"Further critical comments on PASCAL, particularly as a systems programming language"
CUL-de-SAC and dramatic EXIT for use in structured languages
The use of sets as an application programming technique
Procedural objects in Newton
Automatic predicate abstraction of C programs
Slicing Object-Oriented Java Programs
On the formal treatment of a permutation finding program
Terminable Statements and Destructive Computation
Implementing C function calls in rules for an expert system shell
Foundations and extensions of object-oriented programming (abstract only)
The Talking Toaster
Forth and the Open Terminal Architecture
A simpler iterative solution to the Towers of Hanoi problem
Spreadsheet language level: how high is it?
The use of names to indicate the scope of structured language constructs
The rewards of generating true 32-bit code
Addressing the disconnect between the good and the popular
Static analysis of programs as an aid to debugging
Modula-2 - A Solution to Pascal's Problems
Lazy evaluation of C++ static constructors
SFOR: a precompiler for the implementation of a FORTRAN-Based structured language
Making C++ Concurrent and Real-time
Portable IPC on Vanilla Unix
A Data Type Theory
Arrays and pointers considered harmful
Feature Inversion: A Practice on Language Versions Determination
Adding meta rules to OPS5 a proposed extension
Extensions and foundations of object-oriented programming
Detection of deadlocks in multiprocess systems
ASAP - A Simple Assertion Pre-processor
A supercompiler system based on the language REFAL
An extended attribute grammar for Pascal
Review of The elements of programming style by Brian W. Kernighan and P. J. Plauger. McGraw-Hill Company, 1974
Programming language concepts for software developers
The frequency of dynamic pointer references in "C" programs
Towards a Novel String Processing Language
How to best return the value of a function
Concurrent data structures and actor programming under the Matroshka model
An interactive high-level debugger for control-flow optimized programs
Knowing is better than thinking: a simple approach to inter-procedural optimization
A view of coroutines
PEPM 2006 paper abstracts
Can entity-based information systems live with exceptions? (abstract only)
The translation of programming languages through the use of a graph transformation language
Dynamic parsers and evolving grammars
Module interconnection languages and Prolog
LL and LR Translators Need k>1 Lookahead
Index to the Euclid report
P-code and compiler portability: experience with a Modula-2 optimizing compiler
Note on semantics and optimization
Linearizable concurrent objects
Comments on the suggested implementation of tasking facilities in the "rationale for the design of the ADA programming language"
A compiler building system for small-scale computers
An annotated bibliography of software matrices
On "Power Loop" Constructs in Programming Languages
Implementing Separate Compilations in Pascal
Towards a dynamic (FORTRAN) programming system
The hierarchical language system
On Hartmann's error-recovery scheme
Visual programming languages: the next generation
Toward an Object-Oriented Forth
A finite state machine for Western Swing
A comprehensive analytical model for garbage collection algorithms
Empiric: a sketch of a programming language designed to facilitate a fine grain of protection
Structured programming is reductionistic!
Programming interactively with a graphical abstract programming language
Language design for the Ironman requirement: notes and examples
Programming languages as part of core computer science
The benefits of enumerated types in Modula-2
Sticky variables and memory optimization
Description of B
An Evaluation of The Message-Passing Interface
Introduction to this issue's special section on Intriguing Technology from OOPSLA
A structured FORTRAN translator
A "card-marking" scheme for controlling intergenerational references in generation-based garbage collection on stock hardware
Proposed control structures for extended FORTRAN
Subtypes versus Cell Constancy With Subrange Constraints
Calculating Encoding and Decoding Functions for Prefix Codes
LISP bulletin
Improvements of an incremental evaluation algorithm for ordered attribute grammars
A comment on Chapin's and Denniston's "characteristics of a structured program"