yusuke1997/dblp-id-title huggingface dataset:
Design and Static Semantics of Algorithm Language L
Objects in concurrent logic programming languages (abstract only)
A Scripting Language to Help the Blind to Program Visually
JSpace: Implementation of a Linda System in Java
Translating SQL for Database Reengineering
More about multi-adic functions
Dimensional analysis in Pascal
Fortran 77 input-output seems out of touch
Using CORBA and JDBC to Produce Three Tier Systems
String-handling facilities of the LSE language
More on dynamic arrays in PASCAL
Process algebra model of Ada protected objects
Compiling functional languages for von Neumann machines
ISMM 2008 paper abstracts
Projecting Functional Models of Imperative Programs
Cluster: an informal report
The report on the standard hardware representation for ALGOL 68
KGOL: a Knowledge Grid operating language
Taking concurrency seriously (position paper)
On the use of the cyclomatic number to measure program complexity
Efficient abstractions for the implementation of structured editors
A New Iteration Mechanism for The C++ Programming Language
Proposed extensions to PL/I for real-time applications
Language issues in the specification and design of composite systems
Eliminate Memory Fragmentation through Holes in the Heap
Why the goto is harmful
An embedded language approach to teaching hardware compilation
What to Do with a Dangling Else
New books: May 1981
"Combined actions to reduce LR-parsertables": (experimental results)
Programming language issues for the 1980's: SIGPLAN '83: symposium on programming languages issues in software systems
Compilers and Interpreters Archive
A proposal for improving optimizer quality via dynamic analysis
A Geometrical Data-Parallel Language
And/Or Parallel Execution of Logic Programs: Exploiting Dependent And-Parallelism
SNOOPS: An object-oriented language enhancement supporting dynamic program reconfiguration
QUILL: a programming language for literary text analysis
A Critical Look At Some Ada Features
Typographical Extensions for Programming Languages: Breaking out of the ASCII Straitjacket
The primitive string manipulation (PRISM) language
C++ for Scientific Applications of Iterative Nature
Why teach programming languages
Implementation issues II
An Advanced Programming Language Definition and Domain Correctness of Programs
Design of a distributed implementation of ABCL/I
LogC: a language and environment for embedded rule based systems
Arithmetic shifting considered harmful
Declarative Peephole Optimization Using String Pattern Matching
A programming language for mini-computer systems
Forth in the UK
Real-time programming in PORTAL
SIGPLANet - A Modest Proposal for SIGPLAN in the 21 st Century
System validation via constraint modeling
Free theorems for functional logic programs: (abstract only)
15th July 1972: A Significant Moment for Logic Programming
Index in BNF Grammars (Short Comment)
Some practical experiences formatting Pascal programs
Defining dynamic variables and abstract data types in Pascal
Using COBOL macroprocessing for reliable parameter passing
The ICFP developer conference 2008
Concurrency specification in high level languages
On layout, identifiers and semicolons in Pascal programs
Can structured programs be efficient?
Synthesis of system state models
A Framework Design of Workflow Management System with Java RMI
Modelling of storage properties of higher level languages
Dynamic programming and industrial-strength instruction selection: code generation by tiring, but not exhaustive, search
General Syntax Analyzer (GSA)
History of Programming Languages and Software Engineering - A Web-Based Tool
SIGPLAN professional activities committee report
Program Transformation in Constructive Type Theory
Coroutines in Pascal
Impurities found in algorithm implementations
The Astro System
A bibliography on garbage collection and related topics
Pool: an unbounded array
Building abstract iterators using continuations
Ada packages and distributed systems
Review of UCC seminar on "Programming Languages Today"
AspectCOOL: An experiment in design and implementation of aspect-oriented language
The automatic measurement of the relative merits of student programs
SLD: a folk acronym?
Efficient data accessing in the programming language Bliss
A Subset Algorithm for Deterministic FSMs within Deterministic PDAs
Guidelines for writing PL/I programs
Keyword input for C
Flow trace of a structured program
On Subprograms With A Variable Number Of Parameters Of Varying Types
Semantics of Programming Languages: A Tool-Oriented Approach
A Technique for Finding Storage Allocation Errors in C-language Programs
Run-time Print Values
MANEVRO: a new approach to class based programming
Programming Languages: Towards Greater Commonality
Denotational Semantics of Programming Languages and Compiler Generation in PowerEpsilon
Bindings persistent programming languages
Elint in Lamina: application of a concurrent object language
The definition of AMTRAN
Two-dimensional grammars and structured programming languages
High-level debugging assistance via optimizing compiler technology
Opportunistic garbage collection
Fortran: a comparison of the new proposed language (1976) to the old standard (1966)
A cellular automata simulation system
An analysis of length equation using a dynamic approach
How to Build LR Parsers Which Accept Incomplete Input
Serial attitudes, parallel attitudes
A hierarchical approach to program testing
Some inconsistencies in programming language implementation
STRCMACS: an extensive set of macros to aid in structured programming in 360/370 assembly language
Evolution of loop statements
You Could Learn a Lot from a Quadratic: Newton Squares the Circle
A Systematic Generation of Initial Register-Reuse Chains for Dependence Minimization
Functions for manipulating floating-point numbers
Debugging "level": step-wise debugging
Notes from: The Aspenäs Symposium on Functional Languages and Computer Architecture
An algebraic model of sybtypes in object-oriented languages (draft)
A modest Modula wish list
A Note on Covariance and Contravariance Unification
The programming system polyp: structure and experience
Comments on Self-Indexed Sort
Some comments on structured Fortran
Languages and performance engineering: method, instrumentation, and pedagogy
Detection of version features in distributed systems
Parametric polymorphism for Java: is there any hope in sight?
The token-oriented approach to program editing
Basic concepts in object oriented programming
Language support for a semi-dataflow parallel programming environment
Errata to 1971 September issue
On readability of programs with loops
A modest proposal for curing the public field phobia
Experiences using Inmos proto-OCCAM (TM)
Data abstraction in GLISP
Design notes for TINY BASIC
Reverse Execution of Programs
Alternatives to keyword parameters
Completeness of many-sorted equational logic
The syntax definition formalism SDF - reference manual
Crosscutting invariant and an efficient checking algorithm using program slicing
The "Hamming problem" in Prolog
PL/I bulletin no. 5
Type independent modules: the preferred approach to generic ADTs in Modula-2
A simple and efficient algorithm for cycle collection
Patterns, Architecture and Software
The Search for Simplicity - Essays in Parallel Programming by Per Brinch Hansen
An experiment with the extensibility of SIMULA
Design of a language for complex systems
The lion and the unicorn met PROLOG
Comparing two definitions for the notion "data type"
USSA - universal syntax and semantics analyzer
Adverbial programming
Machine-independent C optimizer
Prettyprinting styles for various languages
Specialization, generalization and inheritance teaching objectives beyond data structures and data types
An analysis of language models for high-performance communication in local-area networks
Program slicing under UML scenario models
Structured programming in COBOL
Call for Articles and Columns - SIGPLAN Notices Wants YOU!
New feature for module protection in SIMULA
Syntax of Comments: Discussion and a Proposal
Ada vs. Modula-2: A response from the ivory tower
A prolog space benchmark suite: a new tool to compare prolog implementations
Linear expression bounding
Generic packages in C
Propoosed Knowledge Units for Programming Languages for Curriculum 2001
Computational Reflection in PowerEpsilon
How practical is POPL?
Improving the COBOL called and calling program interface with a pre-processor: call statements are harmful, but can be controlled
Agent Language NUML and Its Reduction Implementation Model Based on HOpi
Uniform handling of exceptions in a stack based language
Regular expressions in a program complexity metric
A basis for executing PASCAL programmers
Some investigations on deadlock freedom issues of a cyclically connected system using Dijkstra's weakest precondition calculus
Letter: Processing Recursive Data Types in Java
Does Scheme Enhance an Introductory Programming Course? Some Preliminary Empirical Results
Tamper-proofing basis path by using oblivious hashing on Java
Class-is-type is inadequate for object reuse
Number crunching in C
SIGAda '98: ACM/SIGAda International Conference (Report)
SPLAW: A Computable Language for Agent-oriented Programming
Testing traversable stacks
Small languages in an undergraduate PL/Compiler course
On evolution of FORTRAN
Top-down parsing in Coco-2
Forttran Information File
An overview of an organized industrial research and development activity for language and language processors
Structuring control in Fortran
Semantics of data structures
How to Achieve Modularity in Distributed Object Allocation
An implementation of on-conditions in LISP
A Report from OOPSLA
Block structure and object oriented languages (abstract only)
Variables: bindings and protection
Experience with extensible, portable Fortran extensions
Formal definition of programming language standards
Progress: a programming language for real-time systems
Nested Scopes in Pascal and Algol 68
Book review: Designing Embedded Hardware
An approach to efficient, fault tolerant programming
Semaphores outside the kernel
An alternate characterization of preorder, inorder, and postorder
A Survey of Implementations of Concurrent, Parallel and Distributed Smalltalk
Implementing data abstractions and monitors in UCSD Pascal
Some issues on the translator of Smalltalk to C++
A systems programming language for minicomputers
An Improvement Over Deeply Nested IF-THEN-ELSE Control Structures
Uniprep - Preparing a C/C++ Compiler for Unicode
Requirements for an Imperative Language to Host Logic Programming in a Seamless Way
Keywords: Scanners and Screeners
The DoD common high order programming language effort (DoD-1): what will the impacts be?
Structured Programing in Java
Communication types
Smgn - some historical remarks
Protecting against uninitialized abstract objects in Modula-2
Personal personnel programmer profile
An Overview of the Standard Template Library
Multi-sequential execution in the BETA programming language
Off-And-On Tokens
A limited-character APL symbolism
The NIL distributed systems programming language: a status report
Compact chart: a program logic notation with high describability and understandability
The HSSM macro-architecture, Virtual Machine and H languages
y+: A yacc preprocessor for certain semantic actions
Structured programming in COBOL under IBM 360/370 OS
SIGPLAN Awards
Bit processing with FORTRAN
Limits of the "algebraic" specification of abstract data types
A bibliography of parallel debuggers, 1990 edition
The OOPSLA two-phase review process
The META/REDUCE translator writing system
A short introduction to the ABC language
Understanding object-oriented programming
Using spreadsheet software to support metric's life cycle activities
A note on the ambiguity of the common statement
Types in School
Musical Equational Programs: A Functional Approach
Generalized path expressions: a high level debugging mechanism
On the great big substitution problem
Simplicity = efficiency = readability a simple infix to prefix algorithm
On generating binary decision trees with minimum nodes
More dynamic imperative languages
Optimized code generation from extended-entry decision tables
Substring Parsing for Arbitrary Context-Free Grammars
Fortran Program Specialization
Structured decision tables
Job control languages as machine orientated languages
Suggestions about a specification technique
Programming World Wide Web Pages in Scheme
APL/360 recursed!
The structure of Cedar
A Definition of an ISWIM-Like Language via Scheme
FEA: a formal English subset for Algebra/Assertions
Value receiving procedures
Position Statements on Strategic Directions for Research on Programming Languages
Debugging in a side effect free programming environment
Programming language grammar anthology
Generating the minimal model in Prolog
Internal representation of programs in GRASE
An intermediate systems language for the PDP-11
Portability: high level language implementation
Guarded attribute grammars: top down parsing and left recursive productions
An efficient and reliable object-oriented exception handling mechanism
APL and Algo168, the correspondence and the differences, especially in applications of graph-analysis
MS-DOS Prolog implementations revisited
Reasonably priced compilers an interpreters for the IBM PC and compatible computers
OPUS #16G software structure: its characteristic polynomials
Toward a better language for structured programming
Searching in discrete universes
The problem of the definition of subroutine calling conventions
Values and Objects in Programming Languages
After the goto debate
An interactive system for studying semantic models of computer programs
Simple patches to Modula-2 text IO
Hybrid compilation: a case study
On some extensions of syntactic error recovery technique based on phrase markers
FORTRAN 77 and structured design
Single global lock semantics in a weakly atomic STM
The importance of implementation models in ALGOL 68: or how to discover the concept of necessary environment
Pseudo object-oriented programming considered harmful
A note on determining the complexity of algorithms
Clarify function]
The PDP-11 as B5500 in teaching systems programming
The best simple code generation technique for WHILE, FOR, and DO loops
On the implementation of an interactive system on a small computer
The case for simplified languages
A Note On Type Checking Linaer Functional Languages
APL Quote-Quad
Are LR parsers too powerful?
A machine-oriented recognition algorithm for context-free languages
Extracting grammar from programs: brute force approach
Universal closure operator for prolog
Communicating reactive objects: message-driven parallelism
A procedure invocation syntax for enhanced readability
A semantic editor
Adapters and Binders - Overcoming Problems in the Design and Implementation of the C++-STL
The PLUS programming language
Practices of PLDI
Further comments on "a view of coroutines"
More Ambiguities and Insecurities in Modula-2
Interactive mathematics textbooks
A better way to combine efficient string length encoding and zero-termination
On the appropriate language for system programming
Newlines and Lexer States
Consummating Virtuality to Support More Polymorphism in C++
What is programming really all about?
A Simple Implementation Technique for Mixin Inheritance
Actors: the stage is set
Structured programming constructs for concurrency in program optimisation
Review of On programming: an interim report on the SETL project, intallment II: the SETL language and examples of its use by J. T. Schwartz. New York University, 1973
An Approach to Executable Specifications, Based On Formal Source-To-Source Conversion
More fuel for the goto controversy
Language tools for data access: past, present and future
A basis for software physics?
An economical method for comparing data type specifications
The doublet model: run-time model and implementation of Ada types
Generalizing APL scalar extension
Operational and mathematical semantics for recursive polyadic program schemata
Macro processing in EPS
Enhanced input/output on Pascal
An automatic decision-logic-table processor
Unfurling the PL/I standard
Languages of the Net (Historial Notes)
Reliance on correlation data for complexity metric use and validation
Dialogues: A basis for constructing programming environments
IDL: Background and Status
A paradigm for programming style research
Rationale for the design of the Ada programming language
On Choosing Identifiers
Design issues in a Rule-Based System
Unfair process scheduling in Modula-2
Storage control in MARY
Report on the 6th international symposium on programming
Roster of programming languages for 1973
On research in structured programming
Evolution of the High Level Programming Languages: A Critical Perspective
Panel on the concept of extensibility
Predicting the Performance of Parallel Machines
Indirect naming in distributed programming languages
Path feasibility, linear optimizers and the evaluate standard form
Action and transaction skeletons: : High level language constructs for database transactions
Adaptable Java Agents (AJA): a tool for programming of multi-agent systems
Back-propagation of knowledge from syntax tree to C source code
Up-down parsing with prefix grammars
Modeling the semantics of smalltalk-80 with Petri nets
Experiences from teaching functional programming at Chalmers
The Cornell Program Synthesizer: a syntax-directed programming environment
DAHLIA: a notation fabrication plan
An extensible system for abstract machines
The implementation kit with monitors
Ambiguities and Insecurities in Modula-2
Some issues and strategies in heap management and memory hierarchies
Empirical Measurements of Six Allocation-intensive C Programs
Interpreting RSets, SSets and Features by Denotational Semantics
Data flow analysis for Cobol
Empirical study of motivation in a entry level programming course
Roster of programming languages for 1976-77
Optimizing loops in programs compiled with the IBM PL/I optimizing compiler
Close Encounters of the Forth Kind
small-X - a language and interpreter for building expert systems
Internal procedure parameters in structured Fortran precompliers
Fortran information bulletin no. 1
Cognitive psychology and programming language design
Requirements/design debugging: session summary
Fixing PASCAL'S I/O
Primitive string transformations as reductions to normal form
A programmer controlled approach to data and control abstraction
A pedagogical disadvantage of repeat and while
Macro processing in high-level languages
The 3rd ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Real-Time Systems (Workshop Report)
A finite state approach to operator classification
TAO: a harmonic mean of Lisp, Prolog and Smalltalk
An algebraic specification of a Pascal compiler
Requirements for a real-time .NET framework
Pun-dora's box or how to produce enough papers to wrap up structured programming
Dependence Analysis for Recursive Java Programs
You Could Learn a Lot from a Quadratic: I. Overloading Considered Harmful
An Introduction to the Extended Pascal Language
MUCKing Around With Forth
Feedback scheduling: an event-driven paradigm
The treadmill: real-time garbage collection without motion sickness
Alternate returns
The chemistry of control structures
A note on algebraic specification of binary trees
Announcing the Release of Aquarius Prolog
MASPLAS '98 - Conference Report
Relationship between IDL and Structure Editor Generation Technology
Global register allocation for non-equivalent register sets
Towards a simpler method of operational semantics for language definition
Reply to a paper by A. N. Habermann on the programming language Pascal
A translational BNF grammar notation (TBNF)
On bugs and swarms: towards a sociobiology of programming?
M'PAL: a programming language based on natural English definitions
Errata to 1971 November 10 issue
Some Comments on Moral and Renvoise's "Global Optimization by Suppression of Partial Redundancies"
PegaSys: A system for graphical explanation of program designs
Static Header as Sentinel
Build a Tree - Save a Parse
Why a two pass front end?
Process oriented programming
Logical Objects with Constraints
A consolidation of synchronization primitives
The Hermes language in outline form
Eiffel Linda: an object-oriented Linda dialect
An Intelligent Neural Network Programming System (NNPS)
Combining object-oriented techniques with data-driven parallel execution on message passing, MIMD computers
A bibliography on syntax error handling in context free languages
Parameterisation of the environment for transportable numerical software
Codebugger - A Software Tools for Cooperative Debugging
A translator from Small Euclid to Pascal
A Formal Approach to the Teaching of Programming Language Concepts
Decision tables: a tool for documenting logical condition relationships
A Prototype of an Interface Bilder for the Common Lisp Interface Manager - CLIB
On the adequacy of finite equational methods for data type specification
Teaching Object-Oriented Design with Heuristics
Software metrics, measurement theory, and viewpoints
VisiCLANG - a visible compiler for CLANG
Tabsol decision table preprocessor
Typed functional programming
The ART of compiler construction projects
Abotec: An Autmatic Back-of-the-Envelope Calculator
"Flowblocks": a technique for structured programming
Dynamic storage routines for Fortran programs
Analysis and Detection of Computer Viruses and Worms: An Annotated Bibliography
Assessment of the Java programming language for use in high integrity systems
Static profile of COBOL programs
The IL programming language
The paradigm of open C++
Per Brinch Hansen's Concerns about High Performance Fortran
Libraries as programs preserved within compiler continuations
Data structures for computer graphics
Process to Process Communication in Prolog
'Infant Mortality' and Generational Garbage Collection
Prediction of software effort and project duration: four new formulas
The contour model of block structured processes
A Generative Approach to Universal Cross Assembler Design
Parallel module specification on SLPX
Intent: an integrated environment for distributed heterogeneous databases
Lazy Evaluation and Nondeterminism Make Backus' FP-Systems More Practical
A cellular automata simulation system: version 2.0
Project Rosetta Stone: an exhibition of languages for system implementation
Proving Assertions is Also Useful
A Pascal compiler testing facility
Representing Calendrical Algorithms and Data in Prolog and Prolog III
Programming lessons from days gone by: Cobol, stewed for students
A syntax diagram for (preliminary) Ada
A simplified operator identification scheme for Ada
Is Object-Oriented Programming Structured Programming?
Structured Data Flow Programming
A mechanism for specifying the structure of large, layered, object-oriented programs
Parallel Evolution Programming Language for Data Flow Machines
Tail-Recursive Parallel Summing of a Multi-List
A comparison of the object-oriented and process-oriented paradigms (abstract only)
An alternative to conformant-array parameters in Pascal
An Invitation to OOPSLA '98
Implementation of a Pascal compiler for the CII IRIS 80 computer
CommonObjects: an overview
Pitfalls with procedure parameters
Proposal for a Language Compatible Arithmetic Standard
Two Models For Integrating Persistence and Lazy Functional Languages
TRICK: tracking and reusing compiler's knowledge
Some compiler-compiler techniques for use in extensible languages
Matrix-based component dependence representation and its applications in software quality assurance
An automatic formatting program for PASCAL
Integrated environments
Detecting Uninitialized Modula-2 Abstract Objects
Actra-a multitasking/multiprocessing smalltalk
Program Language Semantics: The Description of Computational Structures
A new benchmark test to estimate optimization quality of compilers
Cheap concurrency in C
The universal compiling system
On a missing mode in ALGOL 68
On the line breaking problem in text formatting
Efficient Concise Deterministic Pattern-Matching Automata for Ambiguous Patterns
Passing Large Dynamic Objects out of Function Frame Boundaries: The Temporary Linked List Method
The UNIMAC lexical analyzer
A compile-time optimization framework for Ada rendezvous
The GOTO Machine
The equivalence of sequential and associate information structure models