yusuke1997/dblp-id-title huggingface dataset:
rdp - An Iterator-Based Recursive Descent Parser Generator with Tree Promotion Operators
Report on the programming language Euclid
Bidirectional Data Flow Analysis: Myth and Reality
SIGPLAN programming language curriculum workshop: Workshop report summary
Java bytecode verification for secure information flow
Using programming language concepts to teach general thinking skills
Handling the subclassing anomaly with Object Teams
Aspects of OBERON suitable for graphics applications
Procedural specifications and implementations for abstract data types
An elementary language construct for parallel programming
A prototype intelligent prettyprinter for Pascal
A Bibliography on Parallel Parsing
PS-algol: an Algol with a persistent heap
Context Senitive Formatting
EQL - The Query Language You Never Heard Of
Indeterminate (0 ÷ 0) check in APL
About the Semantic Nested Monitor Calls
An exception-based mechanism for syntactic error recovery
A Fortran preprocessor for the large program environment
Full report of the Flowchart Committee on ANS Standard X3.5-1970
A Separate Compilation Facility for Pascal
A generalized object model (abstract only)
Implementation of an optimizing compiler for VHDL
Object-Oriented Programming for Embedded Systems
COST: Common Object Support Toolkit (C++ Toolbox)
A model for procedures passed as parameters
An Object-Oriented Programming Language for Developing Distributed Software
The versatility of PROLOG
Stickiness and liveness
The case against Ada as an APSE command language
Cylinders: a relational data structure
TSO-speakeasy newsletter #5
A comparative feature-analysis of microcomputer prolog implementations
States merging in LR parser
Infix to prefix conversion as a PST reduction
Analysis of the limitations of multiple client handling in a Java server environment
An extension to the cyclomatic measure of program complexity
SIGPLAN and the World Series
Uniform Abstract Syntax Trees
Survey of existing programming aids
An anomaly in an interpreter using GCC source-code-level register allocation
A vector programming language
The design of a language-directed editor for block-structured languages
Book Nook: Compiler Contruction by Niklaus Wirth
Nestable bracketed comments
A generalized object model
The linked class of Modula-3
SNOBOL4 as a language for bootstrapping a compiler
How Does PASCAL-XSC Compare to Other Programming Languages with Respect to the IEEE Standard?
Forms as a language facility
On the cost of mixed language programming
HAL/S/V: a verifiable subset for HAL/S
Raw pointers in application classes of C++ considered harmful
Introduction to the programming language convert
Disciplined C
Functional Programming in C++ using the FC++ Library
Comments on the proposed "revision of PL/I conversion and precision rules"
The taming of the pointer
An approach to loop programs debugging
Compiler textbook bibliographies considered harmful
Extracting grammar from programs: evolutionary approach
Ambiguity and orthogonality in Ada
A guide to natural naming
Control flow complexity and structuredness of programs
A Program Design Language for software engineering
A concurrent N ≤ 8 Queens' algorithm using modcap
ACM SIGPLAN history of programming languages conference APT language summary
The DO trace: a simple and effective method for debugging GOTO-free programs
Thoughts on large scale programming projects
Workshop on programming languages and analysis for security (PLAS 2008)
A language design for program structure
Padded string: treating string as sequence of machine words
Vector Pascal reference manual
PL/I for OS/2
Assertions in programming languages
A simple bucket-brigade advancement mechanism for generation-bases garbage collection
Addition of repeat & until as identifiers
On the Need for Predictable Floating-Point Arithmetic in the Programming Languages Fortran 90 and C/C++
Template Instantiation For C++
Attribute grammars and data-flow languages
Software complexity research: a survey
Evaluation of boolean expressions on one's complement machines
The Self-Similarity and Computer Programs
Some observations on the in- and output in high-level languages
Microsoft and Yale Conclude Agreement to License Technology for Haskell
Two approaches to implementing generic data structures in Modula-2
R3: repeatability, reproducibility and rigor
Correspondence from the members
A method for controlling parallelism in programming languages
SNOBOL bulletin no. 5
Object-Oriented Symbol Management in Syntax-Directed Compiler Systems
A Note on H. E. Tomplin's Minimum-Period COBOL Style
Program Analysis: A Toolmaker's Perspective
A syntax for character and string constants supplying user-defined character codes
Migration of enterprise JavaBeans with ProActive Interposition Objects
The Third International Conference on Parallel Computing Technologies (PaCT-95), Saint Petersburg, Russia
On expressing control and data structures in predicate logic language ALGOL M
A control form for complex iterations
Forth report: strap-on Forth
A model and an implementation of a logic programming environment
Optimal evaluation order for expressions with redundant subexpressions
An Extensible Program Representation for Object-Oriented Software
Is Forth Dead?
A Demonstration of Three Requirements Language Systems
Toward a semiotic theory of programming languages
DUIF: A Data-Oriented Flowchart Environmemnt
The switching reverse polise algorithm
The Checkers Problem: A Solution with Linear Time Complexity
Writing algorithms in ALGOL 60
Edison, a Unix and C friendly Rete based production system
Foundation of Object-Oriented Languages, 2nd Workshop Report
Orthogonal type extensions and reductions
Grammars for FFP
The Ackermann function in APL
Structured Fortran: with or without a preprocessor
Simulating the object-oriented paradigm to Nial
The flow of control notations pancode and boxcharts
SIGPLAN Professional Activities Committee Report
LISA: A Tool for Automtic Language Implementation
DDD - A Free Graphical Front-End for UNIX Debuggers
Protocols for processes: programming in the large for open systems
Implementing a graph-colouring algorithm in Parlog
Compilation of a subset of SNOBOL4
On the structure of dictionaries for compilers
Some things that computer science majors should know
A study on program level dependency of implemented algorithms on its potential operands
Development of interactive languages for scientific computing: programming language research report
Preprocessing of typed two-dimensional mathematical expressions
Pascal Implementation of a LISP Interpreter
Psychological complexity of computer programs
Some exception handling problems in language systems displaying a multi-path capability
Programming languages should NOT have comment statements
Tree-structured programs
Intelligent And Multi Agent Object Level Computing: The Preliminary Overview
Introducting Data Decomposition into VDM for Tractable Development of Programs
SIMOB: a portable toolbox for observation of SIMULA executions
Ten mini-languages in need of formal definition
Treating statement sequences as block objects
Logic and Databases: A Response
Maintaining consistency in a database with changing types
Natural laws controlling algorithm structure?
Checking spelling in source code
An algorithm for the selection of overloaded functions in ADA
How Objective Mechanisms Facilitate the Development of Large Software Systems in Three Programming Languages
Towards a Classification of Visibility Rules
Singleton types here, singleton types there, singleton types everywhere: (abstract only)
Granularity of modules in object-based concurrent systems
Reply to "Interactive PL/I"
Announcing CONCURRENT SP/k
Implementing FORTRAN77 Support in the GNU gdb Debugger
LATEX Support for Proceedings
Optimizing compilers are here (mostly)
On the use of keywords for passing procedure parameters
J + = J
International symposium of memory management (ISMM 2008)
Executing the formal definition of Ada
Notes on termination of OCCAM processes
C++ versus LISP: a case study
Functional Programming and the Two-Pass Assembler
Remarks on Remarks on Many-Sorted Equational Logic
MACE: High-level distributed objects in a flexible testbed for distributed AI research
Poly manual
POPL 2005: Combinators for Bi-Directional Tree Transformations: Linguistic Approach to the View Update Problem
The new ANSI BASIC standard
Integration of the Standard Template Library and the Microsoft Foundation Class
ETAPS '99 - Conference Report
Good design principles in a compiler university course
Polymorphic Queries Across Sets, Bags, and Lists
A Modula-2 Implementation of CSP
Protection of proprietary software
Industrial strength compiler construction with equations
Programming languages and program analysis for security: a three-year retrospective
In defense of program testing or correctness proofs considered harmful
A Repetition Construct for UNIX Version 6
PLDI 2002: Extended static checking for Java
Measuring commercial PL/I programs using Halstead's criteria
How many trivial getter methods does java have?
An example of multiple inheritance in C++: a model of the lostream library
do considered reflectively: a contribution to group programming
Environmental primitives for programming languages
Cellang 2.0: language reference manual
Optional, repeatable, and varying type parameters
The CWIC/36O system, a compiler for writing and implementing compilers
An Object Oriented Approach to Constructing Recursive Descent Parsers
ParsesraP: Using One Grammar to Specify Both Input and Output
A note on the Power Operators "loops are harmful"
Evaluating correctness criteria for transactions
Computer aids for writers
CACM research highlights annual report
Turtle walk through functional language
Detab/65 in third-generation Cobol
Where is the evidence against arrays and pointers?
Programming languages in a liberal arts education
An Evaluation of High Performance Fortran
The symbol table representation of types in the PROPHET system
On submissions and resubmissions
Review of "Symposium on some directions in high-level languages"
Bracketing programme constructs
Considerations in Developing a Formally-Based Visual Programming Language Reference Manual: A Case Study on the SLAM II Language
The use and abuse of formal proofs
The "project which failed" which succeeded
Fourth generation problems
Polymorphism and type checking in object-oriented languages
Prediction models for cyclomatic complexity
Object-oriented specification (abstract only)
Algorithms: number 77 multiple integration
Syntax diagrams for ISO Pascal standard
A Survey of Object Oriented Forths
Why teach programming languages in this day and age and how to go about it
Indexed, global objects for distributed memory parallel architectures
Design and implementation of PL/I preprocessor-based systems
PS-Algol's device-independent output statement
Error checking, tracing, and dumping in an ALGOL 68 checkout compiler
A concept for functional programming and distributed data processing in a local area network and its implementation
Isolation of machine dependencies in Euclid
The extension facilities of IMP
PL/I program efficiency
Abstraction mechanisms for database programming
Managing C++ libraries
Introduction to SQURL
The Ubik configurator: A fusion of messages, daemons, and rules
A Software Science Counting Strategy for the Full Ada Language
Efficient computation of flow-insensitive interprocedural summary information - a correction
An algorithm for user interaction
A practical adoption of partial redundancy elimination
Some applications of AMTRAN
On parametric array expressions
On high-level languages for system programming
Extensions to the object paradigm for the development of distributed applications
Complex Gaussian Integers for 'Gaussian Graphics'
Programming languages with hierarchical structure
Compiling Fibonacci-Like Recursion
Snobol bulletin no. 2
Programming languages: fundamental concepts for expanding and disciplining the mind
Free and bound generics: two techniques for abstract data types in modular C
Asynchronous communication on Occam
Detection of information leak by data flow analysis
A note on procedure timing
An improved algorithm for loop dead optimization
Templates-based portable just-in-time compiler
An analysis of programming via decision table compilers
The 'natural' set of basic control structures
WinHIPE: an IDE for functional programming based on rewriting and visualization
APL arrays and their editor
ETAPS'98 Trip Report
Ignorance of ALGOL 68 considered harmful
A Style for Structured APL
The game of life: a CLEAN programming tutorial and case study
A note on parallel parsing
Indirect Threaded Code used to emulate a virtual machine
Foreward to the candidate extension library
A Tutorial Introduction to Using IDL
DoD-I: the summing up
Paths between Imperative and Functional Programming
Information sharing
A note on some limits of the algebraic specification method
Multibox Parsers
ALGOL bulletin no. 27
A structured APL preprocessor
Efficient calculation of the scope program complexity metric
Fortran development newsletter
A theory of small program complexity
Multilingual debugging with the SWAT high-level debugger
The Effect of Parameter Passing and Other Implementation Dependent Mechanisms is Undecedable
Extending IDL to Support Concurrent Views
Efficient evaluation of Boolean expressions
Smalltalk and exploratory programming
A Review of Exploitation of And-Parallelism and Combined And/Or-Parallelism in Logic Programs
An equivalence result for temporal logic
"Structured programming" considered harmful
Specifying concurrent objects
Comments on an Example for Procedure Parameters
Coding benchmark for Utopia84
Book review: Systems Software Tools by Ted J. Biggerstafff: Prentice-Hall, 1986
An overview of C++
A Neural Net Compiler System for Hierarchical Organization
Yet another meta-language for programming language processing
Identifiers and static name abstraction
Measurement of program complexity by the pair: (Cyclomatic Number, Operator Count)
Developing a superset language of smalltalk for modeling distributed mechanical design systems
ICFP 2002: Contracts for higher-order functions
Object Oriented Method for Axiom
MLF: raising ML to the power of system F
Corrections to the paper: Scannerless NSLR(1) Parsing of Programming Languages
Polylith: An environment to support management of tool interfaces
TRANSACT 2008 paper abstracts
Fighting the disease: more comments after Dijkstra and Tompking
A survey of control structures in programming languages
On embedding Boolean as a subtype of integer
On the object-orientedness of C++
Basic Forever
A note on loop "optimization"
The role of opaque types to build abstractions
Design and Implementation of a C-based Language for Distributed Real-time Systems
An improved mixture rule for pattern matching
Jovial information bulletin no. 1
Re-engineering Needs Generic Programming Language Technology
Comments on mathematical overkill
High-level problems in teaching undergraduate programming languages
APL community meets at NASA
Interactive debugging of concurrent programs
A Variation on Knoop, Rüthing, and Steffen's Lazy Code Motion
A comparison of the structures of APL, FORTRAN, ALGOL and PL/I
Translation of nested Pascal routines to C
The F Programming Language
Scientific processing in ISO-Pascal: a proposal to get the benefits of mixed precision floating-point
Concurrency Annotations in C++
Discussion of Statement Labels; Proposal of a "Transfer/Junction" Construct as Alternative to "Goto"
A chapter in the history of DOD-1
Introduction to Oregano
Macro facilities in ADA
Program readability, closing keywords and prefix-style intermediate keywords
A paradigm for dealing with exceptions
Formal Methods: From Object-Based to Object-Oriented
Pattern matching for high level languages
A general construction for expressing repetition
The Alonzo functional programming language
The Intel Fortran-80 compiler for the 8080 and 8085 microprocessors
The JOY of forth
Curriculum 2001 Draft Found Lacking in Programming Languages
An introduction to object-based reflective concurrent computation
Everything is Fortran, in its own way
The use of decision tables in Babel
A graphical FP language
Evaluating Forth in the Windows environment
A type system for data-flow integrity on Windows Vista
MITRE's future generation computer architectures program
Where are the optimizing compilers?
Standardized Extensions to Modula-2
Formal Specification of Debuggers
From Pascal to Delphi to Object Pascal-2000
An overview of actor languages
ADA(*) vs. Modula-2: a view from the trenches
A Reconfigurable Data Flow Machine for Implementing Functional Programming Languages
Enhancement for multiple-inheritance
Bridges: a tool for increasing the reliability of references to Fortran variables
CONS should not CONS its arguments, or, a lazy alloc is a smart alloc
A poor man's realization of recursive structured Fortran
Details on a simple parallel system
Eiffel: programming for reusability and extendibility
Architecture and Design of Adaptive Object Models
APLISP: a simple list processor in APL
Deeply nested IF-THEN-ELSE's
Building Collections of LR(k) Items with Partial Expansion of Lookahead Strings
Naked objects: a technique for designing more expressive systems
Feature analysis of Turbo Prolog
The American side of the development of Algol
HARE: an optimizing portable compiler for Scheme
SIGPLAN chair's report
The reflective nitrO abstract machine
An intermediate language level optimization framework for dynamic binary translation
A Brief Essay on Capabilities
Axiomatic computational model
"D 2 R": A Dynamic Dataflow Representation for Task Scheduling
Fractal Structure of Random Programs
Introduction to extensible languages
A new notion of encapsulation
An abstract machine design for lexically scoped parallel Lisp with speculative processing
An Executable Language Definition
Sources in Software Pipelining Loops with Conditions Branches
Using Regional Conferences to Mentor Student Development: A Case Study
Type syntax in the language "C": an object lesson in syntactic innovation
Adapting a Debugger for Optimized Programs
Parallel objects on distributed constraint logic programming machines
Abstract specification of resource accessing disciplines: adequacy, starvation, priority and interrupts
Supplemental Material from HOPL II
SN-2: a data acquisition and processing system
4th Workshop for Doctoral Student in Object-Oriented Systems, Held in Conjunction with ECOOP'94 (Report)
YALE: The design of yet another language-based editor
An annotated bibliography of background material on text manipulation
Contour: a method of preparing structured flowcharts
C++ in Eight Weeks
Pointer-Induced Aliasing: A Clarification
Resource management in PORTAL
Programming language assessments using the program profiles
Scope and Pascal
The application of error-sensitive testing strategies to debugging
A calculus for java's reference objects
A universal intermediate representation for massively parallel software development
A Revised Indexed Bibliography for LR Grammars and Parsers
A different solution for improving the readability of deeply nested IF-THEN-ELSE control structure
On Formal and Informal Proofs for Program Correctness
Continuations Without Copying
Integrating destructive assignment and lazy evaluation in the multiparadigm language G-2
Run-time declaration elaboration
Designing new languages or new language manipulation systems using ML
A simple extension of Pascal for quasi-parallel processing
XL: a language structure
Steelman and the verifiability of (preliminary) ADA
GRAMOL
A modulus oriented hash function for the construction of minimal perfect tables
An alternative view of polymorphism
A uniform object model for parallel programming
A note on types and prototypes
Formal specification of program slicing
Basic concepts in object oriented programming (abstract only)
An approach to analyzing recursive programs with exception handling constructs
PL/I subsets for software writing
A Nesting Level Complexity Measure
Defining software science counting strategies
EAPLS: the European Association for Programming Languages and Systems
POPL 2003: A real-time garbage collector with low overhead and consistent utilization
CLANG - a simple teaching language
Development of a debugger for a concurrent language
Some comments on "Pitfalls in Prolog Programming"
Comparing the cost of software conversion to the cost of reprogramming
Teaching programming languages in a post-linnaean age
Java in the Computing Curricula
Observations on the EuroForth '97 Conference
Automating comments
Function inlining versus function cloning
SIGPLAN Notices Introduction to the Special Issue on the Interface Description Language IDL
On the Return Types of Virtual Functions
Modern programming: a definition
Kinds Of Language, Kinds Of Learning
Visionaries: An interview with professor Michael O'Leary
Comments on portions of the ACM SIGPLAN conference on the ADA programming language not available in the proceedings
Message Conversion and A New Type System for OO Model
Announcing the Mozart Programming System
A note on the speed of Prolog
Interactive Pascal input
Two experiments on a program complexity perception by programmers
PLAS 2008 paper abstracts
Synapse: a small and expressibe object-based real-time programming language
Efficient Execution of Programs with Static Semantics
Secondary effects
An Algebraic Specification of Pascal's File Type
Abstract data types with shared operations
About Code Layout for Lisp
Intgrl XDX does Gaussian integration
A fast algorithm for code movement optimisation
Comments on "the law of demeter" and C++
Some concerns aboul Modula-2
An IBM-PC numeric I/O interrupt
SIGPLAN Notices - Where We Are, Wher We're Going
Formal types and their application to dynamic arrays in PASCAL
Unloading Java Classes That Contain Static Fields
Implementing generic types in Modula-2
The implementation of Etude, an integrated and interactive document production system
A quick introduction to the programming language MIKE
Functional Programming and the Fragile Base Class Problem
Connector functions: another view of the GOTO ?
New developments in Pascal-SC
Displaying IDL Instances
Five Principles for the Formal Validation of Models of Software Metrics
An extension to PASCAL input-output procedures
Encapsulation in Object-Oriented Programs
Work with strings of variable length in COBOL
Adding the leads-to operator to Dijkstra's calculus
Problems with the Ada reference grammar
Exceptions in object-oriented languages
Noised or filtered programming? (about enumerated types)
A Note on "Protecting Against Uninitialized Abstract Objects In Modula-2"
Loslan implementation of the AMPL message-passing system
PASES: a programming environment for PASCAL
The translation of boolean: expressions into optimal transfer logic code for the OLIVER data base management system compiler
ALGOL bulletin no. 28
A language-based design for portable data files
A new set theory language
Random number generators are chaotic
Sparse Matric Multiplication
The International Workshop on Parallel C++ (IWPC++), Kanazawa, Ishikawa Prefecture, Japan
An independent test of the theory of software physics
An alternative to the communication primitives in ADA
The PL/I standard: an apostate's view
An intuitive translation technique
Screen-oriented highlevel debugger (SHD) for Pascal
Extended Pascal - Illustrative Features
POPL'11 program chair's report
Orca: a language for distributed programming
SARTEX a programming language for graph processing
A technique for finding storage allocation errors in C-language programs
Hardware assisted high level debugging: preliminary draft
OOPSLA 2004: Mirrors: Design Principles for Meta-level Facilities of Object-Oriented Programming Languages
A case for using procedure calls for I/O
Software patents: an example of the threat
A New Methodology of Data Dependence Analysis for Parallelizing C++
On the use of tree-like structures to symplify measures of complexity
Programming the Loral LDF 100 Dataflow Machine
XE design rationale: Clu revisited
A self interpreter for BaLinda Lisp
A Comparison of Real/time Object-Oriented Modeling Methods ROOM and OCTOPUS
Is Pascal suitable for GKS?
A new programming language: GALILEI
Expressing Opposition in the Object Model, First Step towards Negation
Java as a Better C++