yusuke1997/dblp-id-title huggingface dataset:
Modula-3 language definition
A case for while-until
SIMULA as a tool for extensible program products
Principled design of logical fisheye views of functional expressions
Should Program Editors not Abandon Text Oriented Commands?
CRL/Pascal: A Pascal-oriented Cross Reference Language And Its Applications
Welcome ever smiles / And farewell goes out sighing
Java and Distributed Object Models: An Analysis
Teaching the fatal disease: (or) introductory computer programming using PL/I
On realism in programming examples
A programming environment for ubiquitous computing environment
A technique for automatically porting dialects of pascal to each other
Bounce-and-skip: a technique for directing the flow of control in programs
Descartes: A programming-language approach to interactive display interfaces
Multilevel files for software development
Book Review: Performance and Evaluation of Lisp Systems by Richard P. Gabriel (MIT Press, 1985)
Data oriented program design
An unstructured view of structured programming
The Newton language
A bibliography on partial evaluation
Further comments on the premature loop exit problem
Block statements and synonyms for PASCAL
Reflection facilities and realistic programming
An experimental debugger in a limited programming environment
Parallel programming techniques for compilers
Data flow analysis of recursive procedures
Toward Integration of the Imperative and Logic Programming Paradigms: Horn-Clause Programming in the Pascal Environment
Programming the Premature Loop Exit: From Functional to Navigational
Macro facilities in the Ada environment
Some remarks on abstract data types
High level input/output in Modula-2
How bad can it get??: by a large number of master's candidates
A note on iterative Hanoi
Revised 3 report on the algorithmic language scheme
OPG: an optimizing parser generator
Garment: A Mechanism for Abstraction and Encapsulation of Languages
Language extensions to SNOBOL4
A Framework for Programming Denotational Semantics in C++
E-path_PRE: partial redundancy elimination made easy
Snobol bulletin no. 1
On Beyond OOP
Joyce: an object-oriented decision tree builder
Another defence of enumerated types
ACM SIGPLAN history of programming languages conference SIMULA language summary
Forth & small systems report: potential unrealized: the MicroMED advisor
Recursive Pattern Matching on concrete data types
Using common off-the-shelf tools to implement dynamic aspects
The role of debugging within software engineering environments
Formulating Update Messages
Practically complete decision tables: a range approach
The Advanced Interactive Debugging System (AIDS)
Programming environments: report on an international workshop at Dagstuhl Castle
Report on the CHI'91 Workshop on Languages for Developing User Interfaces
ACM SIGPLAN history of programming languages conference GPSS language summary
An extension proposal for Pascal: simplifying assignments like "a : = a + 1;" by a "pronoun character"
Prolog in "C"
Minimizing memory requirement of real-time systems with concurrent garbage collector
Extended pascal - illustrative features
Software Complexity - An Alternative View
Early Storage Reclamation in a Tracing Garbage Collector
Alex - A simple and efficient scanner generator
A tabular approach to program optimization
A note on dynamic arrays in PASCAL
A note on deadlock-free proofs of network of processes
How to write a C++ language extension proposal for ANSI-X3J16/ISO-WG21
Is Circularity for Attribute Grammars Exponential-Time Complete?
Rethinking pedagogy for teaching PL with more than PL concepts in mind
Practical experiences with automatic repair of syntactical errors or syntactical error repair in the DAS compiler
Regular attribute grammars and finite state machines
What is a flowchart loop and about structured programming
AUTO STAR - a software development system
AL: a structured assembly language
Implications of Automated Restructuring of COBOL
An extension to Pascal read and write procedures
The CAMIL programming language
Optimization using LR(k) techniques
Problems with automatic restructurers
OCCAM
Transferability of high level languages
PROMIS: A Software Metrics Tool Generator
Four Dimensions of programming-language independence
Working in the garden system (abstract only)
NEMO - A nicely modified YACC
Application of a remote code generator
An overview of C++ (abstract only)
Experiences in Building c++ Front End
Use concurrent programming models to motivate teaching of programming languages
A Comparative Survey of Concurrent Programming Languages
Permanent and transient data structures and associated optimization techniques
On dynamically-scoped crosscutting mechanisms
Towards a theory of packages
GRASE: a graphical syntax-directed editor for structured programming
Some aspects of decision table conversion techniques
A discipline for the programming of interactive I/O in Pascal
Jump Tables and State Machines
Programming Languages: Past, Present, and Future
A compatible "structured" extension to Fortran
Differences between ANS and ISO standards for Pascal: ambiguities clarified
An Integrated Prolog Programming Environment
A simple mechanism that supports the prism language
Comment on a Comment by Shibin Hu
PCCTS reference manual: version 1.00
TACO - Prototyping High-Level Object-Oriented Programming Constructs by Means of Template Based Programming Techniques
An annotated bibliography of interactive program steering
On the modification of the formal grammar at parse time
JANUS: An interactive system for document composition
An Ada-based Object-Oriented Modeling Language
Improving publication quality by reducing bias with double-blind reviewing and author response
Experience with the use of the case statement within a M.O.L
ACM SIGPLAN history of programming languages conference PL/I language summary
An observation on the C library procedure random()
SIGPLAN's Professional Activities Committee
A browsing interface for S-expressions
A synchronization mechanism for typed objects in a distributed system
Coupling FORTH and GKS in monitoring processes
Global variable considered harmful
Notes on what language maturity means, and how to measure it
Structured documentation
Invariant properties of algorithms
Who needs languages, and why do they need them? or no matter how high the level, it's still programming
FLIC - a functional language intermediate code
Data and storage structures for interactive graphics
Tracing offensive values from exceptions
How (not) to code a finite state machine
Computer assisted manipulation of algebraic process specifications
A brief survey of papers on scheduling for pipelined processors
Concurrent meld
Modula-2 and the monitor concept
The memory usage of a LISP system: the Belady life-time function
Timing results of various compilers using an optimization quality benchmark
Coroutines in FORTRAN
"Out of Their Minds" by Dennis Shasha and Cathy Lezere
A precompiler for modular, transportable Pascal
Iteration and Abstract Data Types
An APL symbol set for Model 35 Teletypes
Implementing domain-specific languages as the foundation of an honors intro CS course
Some improvements of ISO-Pascal
An abstract software specification technique based on structural recursion
Is nested control structure more complex?
Some ramifications of the EXIT statement in loop control
An Algorithmic Language for Database Operations
A Modula-2 implementation of a real-time process abstraction
Data matching, data alignment, and structure mapping in PL/I
ALGOL bulletin no. 26
A technique for creating small fast compiler frontends
Specifying program structure through sequence relationships
A multi-task system for robot programming
FORTRAN programming standards
An overview of the programming language Smalltalk-72
PIC - a language for typesetting graphics
Generalized Regular Expressions - A Programming Exercise in Haskell
Messages in typed languages
Toward integrating imperative and logic programming paradigms: WYSIWYG approach to PROLOG programming
SIGPLAN most influential paper awards
An overview of SL5
The design of very fast portable compilers
Generalized data structures in Madcap VI
Counterview in favour of strict type compatibility
Function to accelerate and/or induce sequence convergence
Object oriented languages and actors: which language for a distributed approach?
Revised 5 Report on the Algorithmic Language Scheme
Minimal perfect hash functions for reserved word lists
Smart proxies for Jini services
Inline expansion of SETL procedures
The programming language MINO and its formal definition
Debugging methodology: session summary
APL language summary
Keep it Clean: A Unique Approach to Functional Programming
Ordering control data in structured COBOL
Propagation of Constants and Assertions
ACM SIGPLAN vice-chair's report
An object-oriented programming language for distributed systems: Heraklit
Seven sorts of programs
Semantic correctness of structural editing
A new technique for data monitoring
Portable software in modular Pascal
Generics in Java and C++: a comparative model
Frame programming language
If 'ELSE' then 'CASE'
On the development of data structures
Closures for statically-typed object-oriented languages
Flowcharting by stepwise refinement
Simplifying ADA by removing limitations
Text-Oriented Structure Commands for Structure Editors
Specification and implementation of resilient, atomic data types
Report of a Workshop on Future Directions in Programming Languages and Compilers
Lexing and parsing Modula-2
Generalized inheritance
On the power of conditional specifications
Resetting displays
Cantor: an actor programming system for scientific computing
Editing IDL Data Structures
News of past events
A Note Introducing Syntax Through Semantic Routines
Z 0 - a tiny experimental language
Minimum Reference Count Updating with Deferred and Anchored Pointers for Functional Data Structures
Pancode and Boxcharts: Structured Programming Revisited
The heart of object-oriented concurrent programming
Some questions about "on the elimination of pointer variables and dynamic allocation in higher level languages"
Parameter validation for software reliability
An algebraic model of subtype in object-oriented languages (abstract only)
The implementation of file structures in some high level languages
Value reuse optimization: reuse of evaluated math library function calls through compiler generated cache
Essential language el(alpha) - a reduced expression set language for system programming
A pedagogic expert system shell in Prolog
Objects for distributed systems
A standard for a graph representation for functional programs
Non-Linear Type Extensions
A proposed modification to the absolute coordinates of Logo
A common-LISP implementation of an extended Prolog system
Type equivalence in strongly typed languages: one more look
The design and implementation of a flexible retrieval language for a Prolog database system
Pedagogical Patterns - Success in Teaching Object Technology, A Workshop from OOPSLA '96
On the Application of a Popular Notation to Semantics
Parallel Multiplication: A Case Study in Parallel Programming
Philadelphia Dreaming
Bottom-up Tree Rewriting Tool MBURG
An experiment in partial evaluation: the generation of a compiler generator
A Report on the 'Java in the Computing Curriculum Conference' held at South Bank University, London, on 4th February 1997
Dhrystone benchmark: rationale for version 2 and measurement rules
Specifying the structure of large, layered, object-oriented programs (abstract only)
VisiCola, a model and a language for visibility control in programming languages
Modified structured decision table and its complexity
A technique to obtain effective locality of computation in FORTRAN IV
Workshop Report: Third Workshop on the Mathematical Foundations of Programming Language Semantics, 1987, New Orleans
Construction of an ELL(1) syntax analyser for Ada with the compiler-generator LILA
Are applicative languages inefficient?
An overview of the ISO/VDM-SL standard
Multiparadigm research: a new direction of language design
Foundational issues in concurrent computing
Comments on parameter passing techniques in programming languages
Comment on dpANS X3.160-198x, extended Pascal concerning the initial value clause
A standard syntactic metalanguage
PIDL / Pascal: A Pascal-oriented Program Interface Description Language And Its Applications
Another proposal for variable size arrays in PASCAL
The Mesa programming environment
A programming solution to certain problems with loops in Prolog
Using a high level language as a cross assembler
Granule-oriented programming
Going APE.FORTH to mars
Structure charts a structured alternative to flowcharts
On understanding type declarations in C
Efficient global register allocation for minimizing energy consumption
The proposed standard for Basic
Another view of coroutines
Module Types, Module Variables, and Their Use as a Universal Encapsulation Mechanism
A comment on "Control flow complexity and structuredness of programs" by Srinivasan and Gopalakrishna
Euclid and PASCAL
ConstraintLisp: an object-oriented constraint programming language
A simple, machine independent tool for obtaining rough measures of PASCAL programs
An object-oriented LL(1) parser generator
Experimental Comparison of Some Parsing Methods
ACM SIGPLAN history of programming languages conference SNOBOL language summary
Fips: A Functional-Imperative Language for Explorative Programming
Conceptual modeling and programming languages
A brief description of JOVIAL
Implementation Strategies for DIANA Attributes
Automatic indention versus program formatting
Abstracting linked data structures using incremental records
Points Recurring - The History of a Railway Problem
PEARL: an interactive system for the preparation and validation of structured programs
Approaches to change in an object-oriented database (abstract only)
OVIDE: A Tool for Data Acquisition and Validation
Strong typing and physical units
A useful application of formal procedure parameters
Containment Defines a Class of Recursive Data Structures
Injecting programming language concepts throughout the curriculum: an inclusive strategy
Conservative Pretty Printing
Software Portability Annotated Bibliography
The Ultimate RISC: A Zero-Instruction Computer
SIGPLAN Response to the Ironman Draft of the Computing Curricula 2001
Some suggestions for the use of tables in compilers
A proposal for a Fortran loop construct
Adding regular expressions to Pascal
Recursive structures for standard ML
Mind.Forth: Thoughts on Artificail Intelligence and Forth
The design of OWL a language for walking
Harmony as an object-oriented operating system
Hacking your mouse: errata for March 2007
Confinement of a class of harmful effects of the goto statement
Messages vs. remote procedures is a false dichotomy
On deriving a relation between circuits and input/output by analyzing an equivalent program
A Note on Metrics of Pascal Program
Cool: A Portable Project for Teaching Compiler Construction
A Bibliography of Programming Style
The generalized hypergeometric function
Modular programming in C: an approach and an example
S-SNOBOL: structured SNOBOL4
The role of procedural parameters in high order languages
Floating Point Performance of Common Lisp
Using a PC to increase your odds of winning the lottery
On-the-fly model checking from interval logic specifications
The Growing Machine, a Pre-Forth Language Implementation
The formal specification and prototype implementation of a simple editor
IF-THEN-ELSE considered harmful
Compiler writing system
Dynamically scoped functions as the essence of AOP
ISO/IEC 10514-1, the Standard for Molula-2: Changes, Clarifications and Additions
ICFP 2004: Scrap More Boilerplate: Reflection, Zips, and Generalised Casts
AspectC2C: a symmetric aspect extension to the C language
We need more than one: why students need a sophisticated understanding of programming languages
The blit debugger: preliminary draft
Type hierarchies and Semantic Data Models
Realization of multimethods in single dispatch object oriented languages
Tasking troubles and tips
Procedure semantics and language definition
A subset FORTRAN compiler for a modified Harvard architecture
The Pascal exception handling proposal
Indus: an object oriented language for Ubiquitous computing
Command level software tools
COMFY - A Comfortable Set of Control Primitives for Machine Language Programming
SUIF: An Infrastructure for Research on Parallelizing and Optimizing Compilers
Fair Transition System Specification: An Integrated Approach
The towers of Hanoi: yet another nonrecursive solution
Functional programming in a parallel environment: the implementation of FP in MDC
Post-compilation optimization for multiple gains with pattern matching
Register type bits: a proposal for efficient instruction repertoire extension
EVA: an explicit vector language
OOPSLA 2002: Reconsidering custom memory allocation
Quartus forth for the palm pilot
Threading Lisp
Parsing by numbers and asparagus
Tasking and parameters: a problem area in Ada
Tired by Forth?: you should be!
Definition of the DISC concurrent language
Beyond Prolog: Software Specification by Grammar
Design of high level language oriented processors
Application of Measurement Theory to Software Metrics - Comments on the Bollmann-Zuse Approach
Letter from the Newly Elected Chair
Porting the mcc PowerPC C/C++ Compiler into an Interactive Development Environment
The Simplest Functional Programming Language
A redisplay algorithm
Panel of language authors
Workshop on object-oriented programming ECOOP 1987, Paris, June 18, 1987
Classes: an abstract data type facility for the C language
Inverting back the inversion of control or, continuations versus page-centric programming
What is a Procedure Call?
On the semantics of control statements
On nondeterministic control structures
Understanding Class Evolution Through Atomic Changes
Experimental Trac language primitive to allow user control of the scan algorithm
Graph Attribution with Multiple Attribute Grammars
A note on the MODULO operation
"Some concerns about Modula-2" considered unwarranted
Exception handling in parallel computations
Alex - A Simple and Efficient Scanner Generator
Design of a language for high-level data structures
Better C: An Object-Oriented C Language with Automatic Memory Manager Suitable for Interactive Applications
SEIS++: A Pattern Language for Seismic Tools Construction and Integration
An integration of logic and object-oriented programming
Transformational programming: the derivation of a Prolog interpretation algorithm
Further notes on the modulo operator
Multithreading in C++
Suggested revisions and additions to the syntax and control mechanisms of SNOBOL4
Inner Classes: Closures for the Masses
Umbriel - Another Minimal Programming Language
Chatin's Graph Coloring Algorithm as a Method for Assigning Positions to Diana Attributes
Requirements for a safe PL/1 implementation
IF-THEN-ELSE, again
A comment on "operator identification in ADA" by Ganzinger and Ripken
A method of linking PL/I to SNOBOL4
A generative nested-sequential basis for general-purpose programming languages
A New Resource for C++ Programmers and an Invitation for Participation
Meeting on melpomenes: a story used to introduce the theory of data types
On the application of Rothon diagrams to data abstraction
An algol-based language for defining collateral execution of procedures in general and hybrid programming in particular
Los Angeles SIGSPACE/SIGSOFT/SIGPLAN December meeting
Embedding built-in tests in hot spots of an object-oriented framework
Monitoring Remote Sensing Devices in C++
English for Decision Tables Considered Harmful
An Intelligent Backtracking Schema in A Logic Programming Environment
Supporting a flourishing language culture
The Security Problem of Nested Classes
Extending PowerEpsilon with Algebraic Rewriting
A generalization of Neta Amit's statement of the general problem of deeply nested IF-THEN-ELSEs
MUMS: a machine independent programming language consisting of 360 assembler macro calls
POPL 2014 program chair's report
Compilation reuse and hybrid compilation: an experiment
Ranking the Complexity of NIAM Conceptual Schemas by Alpha Metric
Implementing a real computational-environment jump in order to develop a runtime-adaptable reflective platform
Provably-Secure Programming Languages for Remote Evaluation
BUILD: a primitive approach to the design of computer languages and their translators
A concept by concept description of the AMTRAN language
A topological analysis of the complexity of computer programs with less than three binary branches
A rooster of XPL implementations
High-level languages for operating systems development: a historical overview
Breadth-first search in the Eight Queens Problem
Compiler generation for attribute grammars
Executive Commitee News: SIGPLAN Conferences
Some common misconceptions about Lucid
On the need for fewer restrictions in changing compile-time environments
In defense of simplicity of comment syntax
Plasma-II: an actor approach to concurrent programming
Concurrent programming in Orient84/K: an object-oriented knowledge representation language
CST: C State Transformers
Parallelism, control and synchronization expression in a single assignment language
Preliminary ideas of a conceptual programming language
A software debugging glossary
Pointers to local variables
Structured formatting of Pascal programs
Remarks about terminal I/O in APL/360
1999 SIGPLAN Awards
An overview of the Oregon programming languages summer school
An extension of programming languages for clerical computation in science and engineering with special reference to PASCAL
Improving the control structure of SNOBOL4
Influences on the design of exception handling: ACM SIGSOFT project on the impact of software engineering research on programming language design
A knowledge-based problem-specific program generator
Implementing an Access and Object Oriented Paradigm in a Language That Supports Neither
On data structures in associative memories
Alternatives to extensible languages
Loop-dead optimization
Letter from the LCTES Steering Committee
A formal semantic definition of DEVIL
Forth & small systems report
Generic data structures in UCSD pascal
The scope of imported identifiers in Modula-2
FORTRAN: a viable option for the introductory computer science course
Positional versus keyword parameter communication in programming languages
Tactics, an integrated system for structured programming
A programming language framework for designing user interfaces
Multilevel EXIT and CYCLE aren't so bad
Systematic identation in PL/I: minimizing the reduction in horizontal space
On prolog and the occur check problem
Minimizing GC work by analysis of live objects
Confessions of a used program salesman - The loves in My Life
Spreadsheets: A Research Agenda
A response to "some concerns about Modula-2"
A reply to "A note on metrics of Pascal programs"
A Comparison of Three Strategies for Computing Letter Oriented, Minimal Perfect Hashing Functions
Rosette: An object-oriented concurrent systems architecture
Syntax extension and the IMP72 programming language
Developments in Pascal-FC
The semantics of CAT
Application of the goal invariant to the structuring of programs
SIGPLAN treasurer's report
A generalized approach to document markup
Programming tools: statement counts and procedure timings
On the design of monitors with priority conditions
Does anybody out there want to write HALF of a compiler?
A generalization of APL array-oriented concept
Approximations for the Halstead software science software error rate and project effort estimators
Ten years of Forth in ACM Sigplan Notices: part 2
Abstract data types in Euclid
Errors and fixes in the APL/360 Program Product
APL\1130 missing primitives
Orient84/K (abstract only): an object oriented concurrent programming language for knowledge systems
PEN: A hierarchical document editor
Non-technical issues in acceptance of SILs
A potpourri of notational pet peeves (and their resolution in modcap)
LINUS: an experiment in language preprocessing
The Case against Pascal as Teaching Tool
Psychological complexity of computer programs: an experimental methodology
Generative programming for C#
Extensions to PASCAL for separate compilation
A peek at Acore, an actor core language