yusuke1997/dblp-id-title huggingface dataset:
How do developers use dynamic features? The case of Ruby
Agent-oriented model-driven development for JADE with the JADEL programming language
Syntax Optimization for and Parsing of Patterns
An Approach to Software System Modelling and Analysis
Special issue of VMCAI'03
An Empirical Study of the Run-Time Behavior of Quicksort, Shellsort and Mergesort for Medium to Large Size Data
The Multiparadigm Language G
Model checking XSL transformations
Design and implementation of domain-specific language easytime
Safe model polymorphism for flexible modeling
Automatic assessment of Java code
Concern-oriented language development (COLD): Fostering reuse in language engineering
Reconciling method overloading and dynamically typed scripting languages
μ-DSU: A Micro-Language Based Approach to Dynamic Software Updating
A Formal Design of an Arabic Text Formatter for Microcomputers
A Usually Linear Algorithm for Register Assignment Using Edge Placement of Load and Store Instructions
Mechanical Proof Testing
Incremental Generation of LR Parsers
Dynamic reordering of alternatives for definite logic programs
Structured Flowcharts for Multiprocessing
Facilitating the development of cross-platform software via automated code synthesis from web-based programming resources
Re-scheduling invocations of services for RPC grids
A Controlling Scheme for Prolog Through Count Terms
Functional Combination
Building Efficient Incremental LL Parsers by Augmenting LL Tables and Threading Parse Trees
Using Closures for Code Generation
An Algorithm for Generating Abstract Syntax Trees
Unanticipated partial behavioral reflection: Adapting applications at runtime
A browser for incremental programming
Special issue on the programming languages track at the 30th ACM symposium on applied computing
Induced intentional software views
A Closer Look at Export and Import Statements
Fairness in shared invocation servicing
Anatomy of a Text Analysis Package
Compositional Petri net models of advanced tasking in Ada-95
A higher-order strategy for eliminating common subexpressions
Parallel Developments in Programming Languages and Operating Systems
Detection of redundant expressions: A precise, efficient, and pragmatic algorithm in SSA
A monotone framework for CCS
A New Approach to Code Motion and its Application to Hoisting
Efficient Retargetable Code Generation Using Bottom-up Tree Pattern Matching
A Critique of Occam Channel Types
Programming with partially specified aggregates in Java
Prolog Based Retargetable Code Generation
The Equational Specification of Efficient Compiler Code Generation
EQL: a Language for Numerical Computation
Approaches to interpreter composition
Concurrency and Backtracking in VPL
SAwUML - UML-based, contractual software architectures and their formal analysis using SPIN
Case studies on automated verification with slope boundaries for block diagrams
A Relational-Calculus Query Language for Historical Databases
BaLinda Lisp: Design and Implementation
Reverse Execution in a Generalized Control Regime
A change-aware per-file analysis to compile configurable systems with #ifdefs
Use-Definition Chains with Applications
Bounded memory protocols
Temporal constrained objects: Application and implementation
An analysis of metamodeling practices for MOF and OCL
A Formal Notation for Specifying Static Semantic Rules
Performance Evaluation Methodologies for Abstract Data Type Implementation Techniques
Evaluating and comparing language workbenches: Existing results and benchmarks for the future
Lazy Narrowing with Simplification
Three Simple Node List Algorithms
Interface Type Checking of Large C Applications
Program Structure as Basis for the Parallelization of Global Register Allocation
Costing stepwise refinements of parallel programs
Ann: A domain-specific language for the effective design and validation of Java annotations
Towards proving type safety of C #
Aspect composition for multiple target languages using LARA
A Relational Model for the Specification of Data Types
Recording concerns in source code using annotations
Inheritance of Theory in the Adabtpl Language
Structuring FP-Style Functional Programs
A sparse evaluation technique for detailed semantic analyses
A Parallel Implementation of the Scan Language
Combining deep and shallow embedding of domain-specific languages
Distributed Logic Objects
Language support for adaptive object-models using metaclasses
The dependence condition graph: Precise conditions for dependence between program points
A language to bridge the gap between component-based design and implementation
Declarative secure distributed information systems
Altering and Applying Predicates
Closure Generation Based on Viewing Lambda as Epsilon Plus Compile
Formal Integration: A Program Transformation Technique
A Practical Approach to Type-Sensitive Parsing
Structured Syntax Diagrams
An optimal data structure to handle dynamic environments in non-deterministic computations
A model driven architecture for the development of smart card software
Computation of Logical Effort in High Level Languages
Component-based LR parsing
Direct Microprogrammed Execution of the Intermediate Text from a High-Level Language Compiler
A Comparison of Cobol, Fortran, PL-I and Spitbol
Software composition with Linda
Procedural Operators Considered as Fundamental Programming Devices
Leveraging variability modeling to address metamodel revisions in Model-based Software Product Lines
Compiling and verifying SC-SystemJ programs for safety-critical reactive systems
Construct specific coupling measurement for C++ software
Occam - A Programming Language for Multiprocessor Systems
Implementation of CSP-S for Description of Distributed Algorithms
Empirical analysis of search based algorithms to identify change prone classes of open source software
Exception Handling in RT-CDL
Program Testing by Specification Mutation
Design pattern oriented development of model transformations
Run-Time Behavior of SASL Programs: A Performance Study
G: A Functional Language with Generic Abstract Data Types
Monaco - A domain-specific language solution for reactive process control programming with hierarchical components
DISPEL: A Run-Time Debugging Language
Toward Modular Verifiable Exception Handling
Visual Occam: Syntax and Sematics
A methodology for speeding up loop kernels by exploiting the software information and the memory architecture
Compiling Lambda-Expressions Using Continuations and Factorizations
Special issue on the 3rd and 4th ACM SIGPLAN workshops on programming based on actors, agents, and decentralized control (AGERE! 2013/2014)
A To Z: C Language Shortcomings
Data-bound variables for WS-BPEL executable processes
Orderly communication in the Ambient Calculus
A Continuation-Based Language Embedded in Scheme
Exception Handling: Expecting the Unexptected
Cyclic reference counting by typed reference fields
Distributed call-tracking for security
Design and Implementation of an Adaptable Software Environment
Model-based analysis of Java EE web security misconfigurations
Implementing Polymorphic Typing in a Logic Programming Language
Statistical model checking of Timed Rebeca models
A Proposal for Comparison of Types in Pascal and Associated Semantic Models
A Lambda-Calculus Model of Programming Languages - I. Simple Constructs
A Sketch-Based Technique for the Derivation of Self-Interpreters
Foundations of a simple and unified component-oriented language
QoS-enabled and self-adaptive connectors for Web Services composition and coordination
Special issue on the Programming languages track at the 29th ACM symposium on applied computing
Flex: Towards Flexible Real-Time Programs
Cost-driven autonomous mobility
Facet Grammars: Towards Static Semantic Analysis by Context-Free Parsing
Special issue on the Programming Languages track at the 28th ACM Symposium on Applied Computing
Revisiting actor programming in C++
SafeGPU: Contract- and library-based GPGPU for object-oriented languages
Towards the Uniform Implementation of Declarative Languages
A Survey of Parlog and Concurrent Prolog: The Integration of Logic and Parallelism
Synchronization abstraction in the BETA programming language
Implementing a Data Definition Facility Driven by Graph Grammars
Grammar Partitioning and Modular Deterministic Parsing
Safe metaclass composition using mixin-based inheritance
On Open Arrays and Variable Number of Parameters
Program transformations for information personalization
Multi-Way Streams in Scheme
STAPLE, An Experimental Structured Programming Language
Fully abstract trace semantics for protected module architectures
jLab: Integrating a scripting interpreter with Java technology for flexible and efficient scientific computation
Utility-driven solution for optimal resource allocation in computational grid
A two-phase software reliability modeling involving with software fault dependency and imperfect fault removal
Language Constructs for Real-Time Distributed Systems
A Survey on Syntactic Error Recovery and Repair
SOLMAR - A Computer Language for Utilizing Sonar Models
Active Objects as Atomic Control Structures in BaLinda K
Language- and Machine-Independent Global Optimization on Intermediate Code
A type system for static and dynamic checking of C++ pointers
Parallel Compilation: A Design and Its Application to SIMULA 67
Applying model-checking to solve queries on semistructured data
Prograph: A Preliminary Report
Abstractions for Distributed Programming
Fail-Safety Techniques and their Extensions to Concurrent Systems
Generating Optimal Contiguous Evaluations for Expression DAGs
Frame conditions in the automatic validation and verification of UML/OCL models: A symbolic formulation of modifies only statements
Object Logic Integration: A Multiparadigm Design Methodology and a Programming Language
Functional Semantics of Programs with Exceptions
Financial information description language and visualization/analysis tools
Incremental programming language development
Parallel Arithmetic Expression Evaluation on Reconfigurable Meshes
Creating Efficient Programs by Exchanging Data for Procedures
Refinement of worst-case execution time bounds by graph pruning
Elements of Style Among Machine-Generated Cobol Flowcharts
An Automatic Parallelization Framework for Multicomputers
The Denotational Semantics of a Functional Tree-Manipulation Language
Inter-language reflection: A conceptual model and its implementation
Heuristic Chaining in Directed Acyclic Graphs
Semantic Issues in the Design of Languages for Debugging
Modular interpreters with implicit context propagation
Visualising business processes
Message Oriented Programming - A Resource Based Methodology
Integrating Emerald into a System for Mixed-Language Programming
TXL: A Rapid Prototyping System for Programming Language Dialects
Iteration constructs in data-flow visual programming languages
Practical domain-specific debuggers using the Moldable Debugger framework
Associative definition of programming languages
Effective Implementation of Matrix-Vector Multiplication on Intel's AVX multicore Processor
On domain driven design using annotation-based domain specific language
Register Assignment Using Code Placement Techniques
Grammar-based model transformations: Definition, execution, and quality properties
Error Handling in a Parallel LR Substring Parser
A Portable Implementation of Unity on Von Neumann Machines
An Abstract Programming Language and Correctness Proofs
Program Derivation in Type Theory: A Partitioning Problem
Atomistic Galois insertions for flow sensitive integrity
A point based model of the Gregorian Calendar
Automatically Generating SL Parsers From LL(1) Grammars
Implementation of Language Enhancements
Why Automatic Error Correctors Fail
A framework for attaching personal assistants to existing applications
An SR Approach to Multiway Rendezvous
Overloading in the Ada Language: Is ist Too Restrictive?
Refinement of structural heuristics for model checking of concurrent programs through data mining
On goal-directed provability in classical logic
Extracting Program Structure for Packaging in a Component-Based Environment
Design of an Arabic Programming Language (ARABLAN)
Two-Level Grammar as an Implementable Metalanguage for Axiomatic Semantics
Noninterference in a predicative polymorphic calculus for access control
Interprocedural Test Path Evaluation
MDL (Methodology Definition Language): A Language for Defining and Automating Software Development Processes
Conversations of Objects
Methods for Specifying Static Semantics
The Notion of Priority in Real-Time Programming Languages
A semantic view of ALGOL 68
Optimizing the stack size of recursive functions
Object-oriented modelling and specification using SHE
Static Analysis of PostScript Code
Side-Effect Free Functions in Object-Oriented Languages
The Precise Handling of Qualitative Relationships
An object model for dynamic mixins
Constructors for Composed Objects
An Animation Description Language
Coding Ants: Optimization of GPU code using ant colony optimization
LR Techniques for Handling Syntax Errors
Introduction: Computer Languages: A Perspective
DesCaRTeS: a run-time system with SR-like functionality for programming a network of embedded systems
A Denotational Approach for Type-Checking in Object-Oriented Programming Languages
Pointers and Data Abstractions in High Level Languages - II: Correctness Proofs
A bulk-synchronous parallel process algebra
SystemJ: A GALS language for system level design
A transactional model for automatic exception handling
High Level Data Structure - the Grid
Supporting comprehensible presentation of clone candidates through two-dimensional maximisation
A DSL for modeling application-specific functionalities of business applications
Protob: An Object Oriented Methodology for Developing Discrete Event Dynamic Systems
Creating sophisticated development tools with OmniBrowser
Using the local context for the definition and implementation of visual languages
RASP - A Language with Operations on Fuzzy Set
Grammar Transformations for Optimizing Backtrack Parsers
Ontological approach for DSL development
New Mechanisms for Invocation Handling in Concurrent Programming Languages
A Methodology for Procedure Cloning
Rule-Based Coordination of Logic Programs
Linda Sub System on Transputers
Parallel resource co-allocation for the computational grid
The Green language type system
Harmony search based remodularization for object-oriented software systems
Review: Countdown Y2K; Peter de Jager, Richard Bergeon. John Wiley & Sons, Inc. ISBN: 0-471-32734-4
Discrete Loops and Worst Case Performance
A Measure of Program Complexity
Intermediate Container Removal
Optimization of Very High Level Languages - I. Value Transmission and Its Corollaries
Mechanisms for improved covariant type-checking
An Extension of SQL for Querying Graph Relations
Non-repudiation analysis using LySa with annotations
Optimization of Hierarchical Directed Graphs
A Familial Specification Language for Database Application Systems
A Proposal for a Generalized "FOR" Statement
RT-CDL: A Distributed Real-Time Design Language and Its Operational Semantics
Optimization of Very High Level Languages - II. Deducing Relationships of Inclusion and Membership
Characterization of Program Loops in Code Optimization
Lightweight and static verification of UML executable models
A text-based visual notation for the unit testing of model-driven tools
Incremental Attribute Evaluation Through Recursive Procedures
ALua: flexibility for parallel programming
A flexible framework for studying trace-based just-in-time compilation
Distributed termination of concurrent processes in Occam
The Design of Apple - A Language for Modular Programs
Isolating untrusted software extensions by custom scoping rules
Intra- and interdiagram consistency checking of behavioral multiview models
A new code generation algorithm for 2-offset producer order queue computation model
The Use of Forth Language in Process Control
Arabic Text Formatter: Comments and Implementation
MudPie: layers in the ball of mud
Software language engineering in the large: towards composing and deriving languages
Automatized integration of a contextual model into a process with data variability
Linguistic symbiosis between event loop actors and threads
Reasoning about layered message passing systems
Inference of ranking functions for proving temporal properties by abstract interpretation
Spy: A flexible code profiling framework
Synthesizing test scenarios in UML activity diagram using a bio-inspired approach
On the Role of Error Productions in Syntactic Error Correction
Performance Issues in C Language Fault-Tolerant Software
An attribute-grammar framework for specifying the accessibility in Java programs
TaKo: Providing transparent collaboration on single-user applications
Unanticipated integration of development tools using the classification model
A calculus for parallel computations over multidimensional dense arrays
Design and Implementation of 8_½: A Declarative Data-Parallel Language
DILOG - Digitaled Intelligence Logic Machine
Special issue on the Programming Languages track at the 27th ACM Symposium on Applied Computing
Review: Building Microsoft SQL Server 7 Applications with COM; By Sanjiv Purba. John Wiley & Sons, Inc. ISBN: 0-471-19233-3
Deep and Shallow Binding: the Assignment Operation
Sublist Assertions for Listless and Lazy Evaluation
First-Class Patterns for Icon
Action Semantics-Directed Prototyping
A Compiler Writing System Based on Affix Grammars
Uniform and safe metaclass composition
Elimination of Single Productions and Merging Nonterminal Symbols of LR(1) Grammars
Introduction to the special issue on semantics and costs models for high-level parallel programming
An approach for non-intrusively adding malleable fork/join parallelism into ordinary JavaBean compliant applications
Generic Procedures: An Implementation and an Undecidability Result
SIR: inter-program concurrency support for SR programs
SDAC: A model for analysis of the execution semantics of data processing framework in cloud
Parallel Programming with Logic Languages: A Survey
Co-evolving code and design with intensional views: A case study
A Unifying Model for Lookahead LR Parsing
Special issue on search-based techniques and their hybridizations in software engineering
C-Flavours: A Scheme-Based Flavour System with Coroutines and its Application to the Design of Object-Oriented Simulation Software
Experiments wiht Destructive Updates in a Lazy Functional Language
Scheduling Expression Trees with Reusable Registers on Delayed-Load Architectures
A formal semantics of nested atomic sections with thread escape
On transparent value-sensitive run-time monitoring for information flow policies
Some Proposals for Improving Pascal
Elimination of parallel copies using code motion on data dependence graphs
Zero - a blend of static typing and dynamic metaprogramming
Access Control for Private Declarations in Ada
A Grammatical Specification of Human-Computer Dialogue
Broadcasting Buffering Communication
Orthogonal parallel processing in vector Pascal
Introduction to the Special Issue on ICCL '92
ConC: A Language for Concurrent Programming
LASS: A Language for Stochastic Systems
A Probabilistic Analysis of Loop Programs
An approach to build XML-based domain specific languages solutions for client-side web applications
Automated modelling assistance by integrating heterogeneous information sources
High Level Iterators and a Method for Automatically Designing Data Structure Representation
High Level Definition of Abstract Domains in a Relational Data Base System
MMFilter : A CHR-Based Solver for Generation of Executions under Weak Memory Models
Widening and narrowing operators for abstract interpretation
Modular Verification of Ada Generics
A Text Editing Interface: Definition and Use
First-order reasoning for higher-order concurrency
Constant Folding Within an Expression by Semantic Attributes
From Babbage to Babel and Beyond: A Brief History of Programming Languages
Taking an object-centric view on dynamic information with object flow analysis
Unified selection from lists, arrays, and objects
A Constraint Language and Its Interpreter
Constraint-Driven Programming in Strongly-Typed Object-Oriented Languages
A Proposal for a Genuinely-Lazy Streams Facility for Ada
Implementing SNOBOL4 Pattern Matching in Icon
Recursive Ascent-Descent Parsing
Semantics of well-moded input-consuming logic programs
Comparison and evaluation of back-translation algorithms for static single assignment forms
Special issue on model-driven engineering of multi-agent systems in theory and practice
Classboxes: controlling visibility of class extensions
Branching-Time Logic Programming: The Language Cactus and its Applications
User-story driven development of multi-agent systems: A process fragment for agile methods
Array Representation in Symbolic Execution
Designing Programming Languages for the Analyzability of Pointer Data Structures
On the applicability of the longest-match rule in lexical analysis
A platform for the automatic generation of attribute evaluation hardware systems
Dragonfly: A multi-platform parallel toolbox for MATLAB/Octave
Multiple Views and Abstractions with an Extended-Entity-Relationship Model
Formal: A Language with a Macro-Oriented Extension Facility
Introduction by the guest editor
Context-Free Parsing on O(n) Processors
Source Statement Libraries and IBM System/370
Some Steps Towards a Better Pascal
Parallel Recognition and Parsing on Mesh Connected Computers with Multiple Broadcasting
A Layered, Operational Model of Data Control in Programming Languages
Towards a Facility for Lexically Scoped, Dynamic Mutual Recursion in Scheme
Dynamic composition of parameterised logic modules
An Intermediate Language to Define Dynamic Semantics
Reflections on Landins's J-Operator: A Partly Historical Note
CL_ARRAY: A new generic library of multidimensional containers for c++ compilers with extension for OpenCL framework
Seamless requirements
The Question Answering System on Mathematical Models (QAS): Description of the Language
DRL: A Distributed Real-Time Logic Language
Bidirectional data flow analysis for type inferencing
Black-Box Specification in Spec
A Distributed Synchronization Mechanism for Interacting Processes
Practical, pluggable types for a dynamic language
Logic programs as compact denotations
List and Execute Forms of Macros
Distributed Programming with Shared Data
Dependent vector types for data structuring in multirate Faust
Interpreters From Functions and Grammars
REDOSPLAT: A readable domain-specific language for timetabling requirements definition
Derivation and inference of higher-order strictness types
Prosper: A Language for Specification by Prototyping
Effective abstractions for verification under relaxed memory models
Data access skipping for recursive partitioning methods
Behavioural typing for safe ambients
Program equivalence in a simple language with state
Design and Implementation of a Chinese Terminal Controller
JavaLog: a framework-based integration of Java and Prolog for agent-oriented programming
An LR Parsing Technique for Extended Context-Free Grammars
Inter-Entry Selection: Non-Determinism and Explicit Control Mechanisms
Generalized Query-By-Rule: A Heterogeneous Database Query Language
Seque: A Programming Language for Manipulating Sequences
Symbolic Execution of Concurrent Systems Using Petri Nets
Constraint programming for type inference in flexible model-driven engineering
Optimal Code From Flow Graphs
Context-sensitive trace inlining for Java
On Display Optimization for Algol-Like Languages
First-Class Stores and Partial Continuations in a Programming Language and Environment
A Proposal to Merge Multiple Tuple Spaces, Object Orientation, and Logic Programming
Towards a completely extensible dynamic geometry software with metadata
Extending movilog for supporting Web services
Language Aspects of Envisager: An Object-Oriented Environment for the Specification of Real-Time Systems
Concepts and evaluation of the extended entity-relationship approach to database design in a multi-paradigm information system modeling tool
Optimizing floating point operations in Scheme
A semantic approach for automated test oracle generation
Assembling a Resolution Multiprocessor from Interface Programming and Distributed Processing Components