Keleusma Research Spike: When an Apparent Design Wart Is a Semantic Boundary

A system had grown two ways of doing what looked like one thing. The obvious move was to tidy them into one. The tidying turns out to be impossible, and the reason it is impossible is the reason the two ways exist.

The argument that settles it needs no specialist knowledge and fits in a sentence. One of the two cases has two things to report and only one slot to report them in. Whichever thing the slot is given, the other is lost. The other case has only one thing to report, so the single slot is exactly enough. That is a counting argument, it is decided before any code is written, and it is not the argument an engineer reaches for by default.

The engineer’s instinct is to look at the cases and ask whether they resemble one another. They did. Every one of the nine measured occurrences had exactly the shape that invited the tidy-up, and the measurement encouraged precisely the wrong conclusion. The resemblance was real and it was irrelevant, because the defect was never in the instances. It was in the interface they would have had to share.

This article is about that distinction, which is between evidence about members of a class and evidence about the channel the class must pass through. The second dominates the first and is cheaper to check.

The article reports the measurement, the way the measurement pointed the wrong direction, and the argument that settled it. It also reports a rule this author shipped one increment earlier which turns out to be stricter than the property it enforces, excluding ten of twenty-four cases for no reason. No test found that. It surfaced while gathering data for this article.

How to read this

The general argument is in the opening, in the section called The Argument That Settled It, and in Pattern Extraction. Those three need nothing but attention. The sections between them work the argument through a real case with real numbers, and they use the vocabulary of the trade. Every term is glossed at first use, but a reader who wants the result and not the machinery can take those three and stop.

The mathematics is optional throughout. It appears because the central result is a counting argument, and counting arguments are the one place where a line of notation settles what a paragraph of prose can only assert. Wherever notation appears, the sentence before it says the same thing in words.

What this is a case study of

The setting is compiler design, and specifically the part of a compiler called the backend, which is the stage that turns a program the compiler has already understood into instructions a processor can run. The project is Keleusma, whose backend is described in the previous article in this series. No compiler background is required. The shape of the problem is a general one. A system offers one abstraction whose instances divide into two classes with genuinely different observable behaviour, and an engineer, seeing two implementations, tries to collapse them.

The question this article treats is when that instinct is right and when it is a category error. The answer offered is a test, and it is this. Count the observable events each class produces, and count the channels the proposed unification provides. If the counts differ, the unification is lossy and no amount of shape analysis on individual instances will rescue it, because the loss lives in the interface and not in the instances.

The instinct to unify is not a bad one. Two ways of doing one thing is a real cost, paid by every consumer who must learn both and by every future change that must be made twice. This article does not argue against tidiness. It argues that tidiness is a claim about the world, and like any other claim it can be checked before it is acted on, cheaply, and that the check is not the one an engineer reaches for by default.

The Setting

A coroutine is a computation that can suspend in the middle, hand a value to whoever called it, and later be resumed with a value handed back. The two-flavour split this article is about is not peculiar to Keleusma, and the language specifications record it plainly. Python began with generators that only produce values in Python Enhancement Proposal 255 , or PEP 255, and later admitted values back in at the suspension point in PEP 342, which is exactly the step that turns one observable event into two, then separated the coroutine from the generator entirely in PEP 492. Lua exposes asymmetric coroutines in which resume and yield are distinct operations and a coroutine additionally returns when its body completes, so that a caller must distinguish a yield from a return. The European Computer Manufacturers Association standard 262, or ECMA-262, which specifies JavaScript, gives its generator results an explicit done flag for the same reason, C# iterators make the distinction syntactic, and C++ separates co_yield from co_return at the level of the grammar. Every one of these designs carries a discriminator, and that is the fact this article rediscovers from the compiler side.

Keleusma has two forms.

A yield function suspends a bounded number of times and then finishes. It is a total function with interruptions. The type system guarantees it terminates.

A loop function suspends forever. It is productively divergent, which is the property that it never finishes but always makes progress, so a host, meaning whatever program is driving the coroutine from outside, can pull values from it indefinitely and each pull terminates. This is the language’s stream abstraction and it is the normal way a Keleusma program does work over time.

Both are written with the same yield keyword in the body. The difference is the declaration, and the type checker already separates them into different categories with different rules about what may call what.

Notation

The formal machinery below is worth the six symbols it costs, because the central result is a cardinality argument that prose states as an opinion and arithmetic settles in one line. A reader who prefers prose can take the following and skip to the results. A terminating coroutine emits two values per call and a return slot holds one.

Let $W$ denote the machine word type, so that $\lvert W \rvert = 2^{64}$ on the present target. Let $K$ denote the set of coroutine chunks, a chunk being one compiled unit of code, partitioned by the type checker into

where $K_\Sigma$ are the divergent stream chunks and $K_\Upsilon$ the terminating ones. Write $\lvert K_\Sigma \rvert = 24$ and $\lvert K_\Upsilon \rvert = 1$ for the present corpus.

An execution of a chunk is driven by an initial argument $a \in W$ and a sequence of resume values $\vec{r} = (r_1, r_2, \ldots)$. It produces an **observable trace**, a sequence over the alphabet ${\mathsf{Y}(v), \mathsf{F}(w)}$ in which $\mathsf{Y}$ marks a suspension carrying $v$ and $\mathsf{F}$ a completion carrying $w$. For a terminating chunk with $n$ suspensions the trace is finite and ends in a completion,

while for a divergent chunk it is infinite and contains no completion at all,

That asymmetry is the entire article. The two trace shapes differ not in length but in alphabet. One uses both letters and the other uses one.

A calling convention is an encoding $\varepsilon$ that carries a trace into what a host can observe from native calls. Write $\mathrm{chan}(\varepsilon)$ for the number of distinguishable $W$-valued channels a single native call exposes under $\varepsilon$, and $\mathrm{obs}(k)$ for the number of distinct observable values a single call of $k$ must convey.

The two conventions

The generator emits native code that a host program calls. When the generated code suspends, the value has to reach the host. Two mechanisms are available.

The callback convention declares an external function, here called kel_yield, that takes the yielded value and returns the resume value. Generated code calls it at each suspension point and carries on. The host implements it. Control passes to the host and back without the generated function returning, so the generated function’s stack frame stays live throughout, a stack frame being the scratch space a function reserves for its own working values and gives back when it returns. This is the stackful shape, of which the context-switching functions of the Portable Operating System Interface or POSIX are the oldest standardised instance, and its defining property is exactly that a frame outlives the suspension.

The return convention ends the native call at the suspension. The yielded value is the function’s return value. The host receives it as an ordinary result, does whatever it does, and calls the function again with the resume value as an argument. No frame persists between suspensions.

The return convention is strictly cheaper. It needs no external symbol, no callback indirection, and crucially no stack frame alive during host code, which matters to a project whose entire premise is statically bounded memory. A frame held across an arbitrary amount of host activity is a frame the memory analysis cannot account for.

The compiler infrastructure this backend targets already names both shapes. The coroutine intrinsics of the Low Level Virtual Machine compiler infrastructure or LLVM provide a switch-resume family, in which a coroutine handle is resumed through a function pointer and the frame persists in an explicit allocation, and a returned-continuation family, llvm.coro.id.retcon, in which the coroutine returns at each suspension and hands back a continuation to be called next. The two families correspond closely to the callback and return conventions described here. Frame liveness across a suspension is the same property that LLVM stack maps exist to describe, and the WebAssembly stack-switching proposal is the same design question posed for a portable target. None of these settle the choice, and that is worth saying, because they establish that both shapes are standard and that the trade is real, not that either is correct here.

How the backend arrived at two

The yield function was implemented first, on the callback convention, because it is the general mechanism and it was obviously correct.

The loop function was implemented later. Its bytecode, meaning the compact intermediate instructions the compiler produces before machine code, has a recognisable shape, being an opening marker, a body, a stack cleanup, and a reset instruction that rewinds execution to just after the marker and hands control to the host. The reset clears every local variable. That clearing is the key structural fact. If the body’s suspension is the last thing on every path, then no local outlives the suspension, because the reset would have cleared it anyway. Nothing needs to persist, so nothing needs a frame, so the return convention applies.

Two conventions resulted, not by design but by two increments arriving from different directions. That is exactly the situation in which an engineer reaches for a unification.

The Measurement That Pointed The Wrong Way

Before proposing anything, the corpus was measured. The instrument walks every compiled program in the project’s shipped examples and self-hosted compiler sources, classifies each coroutine chunk, and reports the distribution.

The distribution of stream chunks

The zero is worth pausing on. An earlier design in this project assumed the general case was a body with several suspension points that would need to be reordered relative to one another. No such body exists in the corpus. That design was specified in some detail before the count was taken, and the count deleted it.

The nested case looked like the hard one until it was measured per suspension instead of per chunk. All nineteen of its suspensions sit inside conditionals and not one sits inside a loop. A suspension inside a conditional is a control-flow join, where every path still suspends once and ends. A suspension inside a loop crosses a back edge and genuinely needs a frame. The word nested had been covering both, and they have entirely different costs.

The distribution of terminating coroutines

One. The entire terminating-coroutine population of the corpus is a single chunk, and that chunk has, in nine of nine cases, precisely the shape that appeared to invite the return convention, which is to suspend and then return.

This is where the measurement pointed the wrong way. A distribution of nine out of nine looks like an invitation. It reads as evidence that the shape is natural, that the callback is an accident of implementation order, and that a unification is available at the cost of a shape check. The author of this article drafted exactly that plan.

The Argument That Settled It

The plan was checked against the smallest possible instance before it was implemented, which is the only thing in this article that went right on the first attempt.

Consider a terminating coroutine that suspends once with its argument.

yield main(a: Word) -> Word { yield a }

It compiles to three instructions, which load the argument, suspend, and return. The suspension instruction pops the value to yield and pushes the value the host resumes with, so the return instruction returns the resume value.

Run it on the reference virtual machine and it produces two observable events.

1. Suspension, carrying a, the yielded value. 2. Completion, carrying r, the resume value.

A return-based lowering, meaning a translation from the intermediate form down to machine code, has one return slot. Give the slot the yielded value and the completion is gone. Give it the completion and the suspension is gone. There is no third option, and no analysis of the chunk’s shape changes this, because the deficiency is in the calling convention and not in the chunk.

The obvious objection is that the completion could arrive on a second call, and the reason it cannot is the part of the return convention that is easiest to skip over. The convention has no resumption point. The host drives the chunk by calling a plain function again, passing the resume value as the argument, so the sequence the host executes is

and $f$ carries nothing between calls. For a divergent chunk that is exactly right, because the reset instruction rewinds to the same place and clears every local, so re-entering from the top is what resumption means there. For a terminating chunk it is wrong. A second call re-runs the body from the beginning and suspends again, so it yields a second time and never reaches the completion at all.

Everything the host will ever learn about one terminating execution therefore has to arrive from the first call, which is why the budget is one slot rather than one slot per event.

The counting argument, stated once

Under the return convention a single native call exposes exactly the return register, which is one of the processor’s few named storage slots, so $\mathrm{chan}(\varepsilon_{\mathrm{ret}}) = 1$. The chunk above must convey both $v$ and $w$ from one call, so $\mathrm{obs}(k) = 2$. An encoding faithful to the trace must therefore be an injection

and no such injection exists whenever $\lvert W \rvert \ge 2$, by cardinality,

The same statement in bits is the one that generalises, and it is the elementary case of the channel-capacity argument Shannon 1948 introduced. An interface of $m$ machine words carries $64m$ bits and a trace of $k$ words needs $64k$, so a faithful encoding requires

and here $k = 2$ against $m = 1$. The shortfall is 64 bits, which is to say a whole second word.

The general statement is immediate. For any chunk $k$ and convention $\varepsilon$,

and a non-injective encoding is one in which two distinct executions become indistinguishable to the host, which is precisely what it means for a lowering to be wrong.

The deficit does not grow with the number of suspensions, which deserves a check and not an assumption. A terminating chunk with $n$ suspensions emits $n$ yielded values and one completion, so its trace carries $n+1$ words and the executions it can distinguish number $\lvert W \rvert^{\,n+1}$. The single call it is granted distinguishes $\lvert W \rvert$ of them, so the collapse factor is

which is catastrophic at every $n$ and no worse in kind at $n = 9$ than at $n = 1$. The smallest instance was therefore the right one to check, and checking a larger one would have added nothing.

The pigeonhole is doing all of the work, and it is worth noticing how little it needs. It does not inspect the body, the number of suspensions, the control flow, or the corpus. It needs the alphabet of the trace and the width of the interface, both of which are known before any code is written.

The claim is false in its strong form, and the reference work is what showed it

A return slot is not one word. The System V AMD64 application binary interface , or ABI, which is the document that fixes how functions pass arguments and return results on a given machine, returns a two-eightbyte aggregate in the register pair RAX:RDX, and AAPCS64 returns small aggregates in X0 and X1. So $\mathrm{chan}(\varepsilon_{\mathrm{ret}})$ is a property of the chosen signature rather than a constant of the machine, and the honest statement is conditional.

Under a two-word return the injection $\varepsilon : W \times W \to W \times W$ exists trivially, and the unification this article rejects becomes representable.

Two designs are being run together here and they cost very different amounts, so they are worth separating. Cramming both events into one call needs the pair $W \times W$, which is 128 bits against 64, a shortfall of a whole word. Making the convention re-entrant with a discriminator needs only

a shortfall of exactly one bit. That single bit is what forces a second register, since $\lceil 65 / 64 \rceil = 2$, and it is the whole reason the register-pair rules in the two application binary interfaces matter to this decision. The expensive-sounding option costs one bit of information and one register of encoding, a very different proposition from carrying a second word. The pigeonhole refutes the unification at the signature the backend currently emits, not for all time.

That distinction matters and it was not visible from inside the problem. It surfaces a third option , which is to widen every coroutine entry point so that it returns a discriminated pair,

so that one convention carries both trace alphabets.

That form is sufficient only for a coroutine that suspends at most once per call, and the article as published did not say so. A coroutine resumes at the point it suspended, which is the defining property of the construct. Under the callback convention that is free, because the native function never returned and its frame, program counter and locals are all still live. Under a return convention the call has ended and nothing survives. For the divergent form that costs nothing, since the reset instruction clears every local and the next iteration legitimately starts from the top. For the terminating form it is fatal, because the next call must resume mid-body and a function entered at its entry point cannot do that.

A widened return must therefore carry, beyond the value and the tag, something identifying where to resume and with what state. That is a continuation, and it is what llvm.coro.id.retcon returns alongside the yielded value. The returned-continuation family exists because returning a value at a suspension is not sufficient on its own. The general interface is a triple,

and the continuation implies an allocation for the saved frame whose lifetime spans host execution, which is the very property this option was credited with preserving.

The cost is therefore that every call of every coroutine pays a wider return and a host-side discrimination, including the 95.83 percent of the corpus, twenty-three chunks of twenty-four, that need only one letter, and that the terminating form pays a frame as well. The 95.83 percent is a count of chunks needing one letter and must not be read as the fraction for which a pair suffices, because that is a claim about the terminating form and the corpus holds one instance of it.

Whether that is cheaper than two conventions is an empirical question this article does not answer, and the shape of the comparison can be stated without measuring anything. Writing $c_{\mathrm{tag}}$ for the per-call cost of the discriminator, $c_{\mathrm{frame}}$ for the amortised cost of allocating and reclaiming the saved frame, and $c_{\mathrm{meta}}$ for the one-off cost of declaring and dispatching two conventions, the totals over $N$ calls are

where $c_{\mathrm{frame}} = 0$ only for coroutines that suspend at most once per call, so the widened return is cheaper only below

The frame term moves the crossover down, which strengthens rather than weakens the observation that follows.

A per-call term always loses to a constant eventually, and a stream abstraction exists to be called many times, so the crossover is the whole question. Neither constant is published and this article declines to invent them, which is why the recommendation below rests on the memory property and not on a cost model.

Two production language runtimes already do exactly this, which is the strongest argument available that the option is practical rather than merely representable. A Kotlin suspending function returns its ordinary result, or a distinguished COROUTINE_SUSPENDED sentinel to signal that it suspended instead. That is a discriminated return in the narrowest possible encoding, a single reserved value carved out of the result type. A Rust future’s poll returns Poll::Ready(T) or Poll::Pending, which is the same discrimination made explicit in the type rather than hidden in a sentinel. Both carry the completion and the suspension through one interface, and both pay the tag on every call.

The sentinel form has a hazard the tagged form does not, and it is worth naming because the narrow encoding is the tempting one here. Carving a reserved value out of $W$ shrinks the value space to

which is 18,446,744,073,709,551,615 usable values, a loss of $2^{-64}$ or about $5.421 \times 10^{-20}$ of the space, and any program able to produce the reserved value as a legitimate yield becomes unrepresentable. The loss is negligible in measure and total in reachability, and only the second of those matters. A sentinel is available exactly when the yielded type is a proper subset of $W$ missing at least one element, a statement about the type and not about how unlikely the value is. Kotlin can afford it because the sentinel is a reference no user value aliases. A backend whose yielded values are arbitrary machine words cannot, so for Keleusma the tagged pair is the honest form and the sentinel is unavailable.

The correction is left in the text rather than folded into the argument, because the sequence is the useful part. A counting argument was stated in a form stronger than the evidence supported, and reading the governing interface specification rather than assuming the register width is what caught it.

The nine-out-of-nine measurement was answering a different question than the one that mattered. It established that the shape is uniform. It said nothing about the arity of the interface, and the arity is what fails.

Why the divergent case is genuinely different

A loop function never completes. The reset instruction rewinds and returns control to the host, so there is no completion event at all. The count of observable events is one, the count of channels is one, and the convention fits exactly,

so the required encoding is $\varepsilon_{\mathrm{ret}} : W \to W$, for which the identity suffices. The host drives the chunk by iterating the native function, and the correspondence with the virtual machine is

with no distinguished first call, because iteration zero consumes the call argument and iteration $k$ consumes the $k$-th resume value, exactly as the virtual machine does when it writes the resume value into the entry chunk’s parameter slot.

So the two conventions are not an accident awaiting cleanup. They track the boundary between a construct that terminates and one that does not, which is a distinction the language already makes, the type checker already enforces, and the memory analysis already depends on. The backend grew two conventions because there are two things.

The general form of the test

Stated without reference to compilers, the test reads as follows.

Let a proposed unification map a class of behaviours onto an interface. Count the distinguishable > outcomes each behaviour can produce and count the distinguishable outcomes the interface can carry. > If the first exceeds the second for any member of the class, the unification is lossy, and evidence about > the distribution of members cannot rescue it.

The failure mode this catches is common, and it is collecting evidence about instances when the defect lives in the interface. Nine out of nine is a fact about instances. One slot against two events is a fact about the interface. The second dominates the first entirely, and it is cheaper to check.

A Rule Stricter Than The Property It Enforces

Gathering the distribution for this article surfaced a defect in code shipped one increment earlier, which no test had caught because no test asked.

The admissibility rule for the return convention requires that between a suspension and the reset, nothing runs except block delimiters and a single stack-cleanup instruction. The intent is to establish that the resume value is discarded, since the return convention does not supply one.

Ten of the twenty-four stream chunks fail this rule. All ten are the same program shape and their tail instruction sequence is the following.

PopN(1), Const(0), PopN(1)

The source is a body that suspends and then evaluates a trailing constant, so the constant is pushed and immediately discarded. The sequence has no observable effect and leaves the stack balanced. It is exactly as safe as the sequence the rule admits. The rule refuses it because the rule was written by enumerating the instructions the author had seen rather than by stating the property.

Write $\delta(\iota) \in \mathbb{Z}$ for the net operand-stack effect of an instruction and $\mathrm{eff}(\iota)$ for its set of side effects. For a tail segment $\pi$ following a suspension, the property that actually licenses the transformation is

the $-1$ recording that the segment consumes exactly the resume value the suspension pushed and nothing else. Both candidate tails satisfy it.

The shipped rule instead tests membership in a fixed instruction set $A = {\mathtt{PopN(1)}} \cup D$, with $D$ the block delimiters. Let $P$ denote the set of tail segments satisfying the property and $R$ the set the rule admits. The rule is sound but not complete,

and the containment is what makes the defect a coverage loss rather than a correctness loss. The property is effect-free and stack-neutral. The rule is drawn from a list of two instructions. Those coincide on the corpus the rule was written against and diverge on the next ten cases, the standard failure of a whitelist standing in for a predicate.

A sound but incomplete rule is the normal condition of static analysis and this instance is not the normal reason for it. The framework of Cousot and Cousot 1977 exists because an exact answer is often uncomputable, so an analysis deliberately accepts imprecision in exchange for soundness. The imprecision here was not forced. The property is decidable on straight-line bytecode by summing two integers, so nothing about the problem required an approximation, and the rule is an approximation that nobody chose. That is a worse position than the classical one and an easier one to fix.

The cost is measurable and is not correctness. Nothing is mislowered, because the rule refuses rather than admits. The cost is coverage. Writing $R$ for what the rule admits and $P$ for what the property licenses,

so 41.67 percent of the corpus is refused the cheap convention for no reason, and ten stream chunks that could use it currently do not. The fix is a small generalisation and it is not attempted here, because this article’s subject is the convention question and a coverage improvement inside it would be a second claim wearing the first one’s clothes.

It is reported because it was found by writing rather than by testing, the second time in this series that assembling a table for publication has surfaced something a green test suite did not.

Method

The instrument compiles every .kel source in the project’s example directories, the self-hosted compiler stage sources, and the standalone compiler subproject, discarding any that fail to compile. For each resulting module it walks every chunk and classifies it.

Suspension nesting is computed with a depth counter over the block-opening instruction set, which was checked against the full block-structured instruction list and not assumed. A missed opener would report a nested suspension as a top-level one and admit a chunk the transformation is wrong for.

The tail-position walk follows jumps rather than scanning the instruction stream linearly. This is necessary, not fastidious. The instructions textually between a deeply nested suspension and the reset include the bodies of sibling branches, which are on different paths and never execute after that suspension. A linear scan answers a question nobody asked.

Suspension nesting is summarised by the enclosing block stack. Writing $B(y)$ for the stack of open blocks at suspension $y$, the distinction that matters is

a suspension that is a control-flow join rather than one crossing a back edge. For the nested chunk the measurement is $\mathrm{join}(y)$ for all $19$ of its suspensions, at depths $\lvert B(y) \rvert$ ranging over $2$ to $11$.

Equivalence between the two lowerings is checked by a differential oracle against the reference virtual machine, comparing whole sequences of yielded values rather than final results. Writing $\mathcal{Y}(\cdot)$ for the projection of a trace onto its suspension letters, the assertion is

for a caller-supplied bound $n$, over a finite sample of $\vec{r}$. A stream never produces a final result, so a comparison of final results would be vacuous for exactly the class under study, and the truncation at $n$ is not a weakness of the test but a consequence of the trace being infinite.

The sample is finite and the claim is universally quantified over $\vec{r}$, so the oracle refutes and does not prove. The resume values in each case are chosen to differ from one another and from the argument, and in the nested case to drive different branches on successive iterations, because a $\vec{r}$ that takes one path every time exercises one return site and licenses nothing about the join.

How the literature survey was assembled

The 35 hand-selected research references were chosen because a step of the argument depends on them, and each was read. The 1,944 harvested references were not chosen that way and were not read individually. Stating that plainly is the point of this subsection, because a list of four thousand citations otherwise implies a reading it does not represent.

The harvest issued keyword queries against Crossref and the NASA technical report server across thirteen topic clusters, being coroutines, continuations, effect handlers, calling conventions, code generation, verified compilation, compiler testing, resource analysis, static analysis, concurrency runtimes, bytecode virtual machines, types and semantics, and a general systems cluster. Each returned record was kept only if its title carried a subject anchor, meaning a term specific to computing and not one shared with every discipline. That test discarded 5,313 of the 7,334 retrieved records. Records already cited by hand were discarded again at assembly so that no work appears twice under two anchors.

The count that survives is smaller again. The arithmetic is worth stating and not leaving to be noticed. Of the records the filter admitted, 85 were duplicates holding the same title and year under two identifiers, 2 carried a doubled word in the title where a registry had concatenated a title with a book title, 1 was untitled or undated, and 4 duplicated a hand-selected entry. 1,945 therefore reach the reference list. One was removed by a later audit as an identifier that does not resolve, leaving 1,944.

The anchor filter is the step most likely to be wrong, and it was wrong twice before it was right.

The first version was inherited from an article on a different subject and tested for the presence of that subject’s vocabulary, so it rejected 2,174 compiler-science titles for containing no aircraft. That failure is loud once looked at and silent otherwise, because a filter that rejects everything reports a small corpus rather than an error.

The second version was written for this subject and overcorrected into uselessness. It admitted generic stems, being analysis, implementation, generation, evaluation, system, model, performance and interface, each of which occurs in every discipline that publishes. It admitted 4,305 records, and a sample of them contained rabies control, seismic depth imaging, breeding soundness examination in veterinary medicine, supercontinuum generation in photonics, transport appraisal and fibre art. A survey listing those has surveyed nothing. The larger count was the symptom rather than the reassurance.

The version used here requires a term that is computing-specific on its own, so an ambiguous term contributes nothing however many of them a title carries. It admits 2,021 records of the 7,334 retrieved. The corpus is less than half the size of the one the permissive filter produced. That reduction is the result rather than a cost of it.

What the harvested list therefore supports is a claim about coverage, being that the survey did not select for agreement with its conclusion, since the queries were fixed before the records were seen. What it does not support is any claim about the content of an individual harvested record beyond its title, authors, year and venue as the registry holds them.

Threats to Validity

The corpus is one project’s own sources. It over-represents text processing, because the self-hosted compiler is a text processor. A terminating-coroutine population of one is not evidence about the language. It is evidence about this corpus at this date. A user may write many, in shapes not seen here.

The conclusion does not depend on the corpus. This is the important asymmetry and it is why the argument is stated the way it is. The event-counting argument is about the calling convention and holds for a population of one or one million. The measurement is reported because it is what pointed the wrong way, not because the conclusion rests on it.

The classification was written by the party proposing the unification. The instrument that produced the nine-out-of-nine figure and the plan that figure encouraged share an author. The mitigation offered is that the figure is accurate and was not the thing that failed. The reasoning built on it failed, which is the weaker position for the author and the stronger one for the reader.

No claim is made about performance. The return convention is argued to be cheaper on structural grounds, meaning no external symbol, no indirection, and no frame across the suspension. None of that has been measured. The machine-code frame sizes that would settle it are emitted only into a section of the Executable and Linkable Format, or ELF, which this development host does not produce, so the measurement is deferred and not done.

Pattern Extraction

The pattern is available wherever an interface is proposed to cover a class of behaviours.

Two implementations of one abstraction may be tracking a real boundary. Before unifying, ask what distinguishes the two implementations, and check whether the source domain distinguishes it too. Here the type system already had two categories, enforced by a rule about which may call which, and the memory analysis already depended on the distinction. The backend was not being untidy. It was reflecting something upstream. The tidying instinct treats a difference as noise, and the check is whether anything else in the system treats it as signal.

Evidence about instances cannot repair a defect in an interface. This is the sharper half, and the reason is a quantifier. Admissibility of a unification is a universal claim over the class,

whose negation is existential,

A single witness refutes $\Phi$, and no quantity of confirming instances establishes it. The nine-out-of-nine figure has the form of a frequency $\hat{p} = 9/9 = 1$ over observed shapes, and a frequency estimates a proportion. It does not bound a maximum, and $\Phi$ is a statement about a maximum,

The measurement is weak even taken on its own terms, and it is worth putting a number on how weak. Reading nine successes from nine trials as a sampling exercise, the exact one-sided lower confidence bound of Clopper and Pearson 1934 on the underlying proportion at confidence $1 - \alpha$ is

so the observation is consistent with 28.31 percent of cases failing, and at 99 percent confidence the bound falls to 0.5995. A run of twenty-four would give 0.8827 and still leave 11.73 percent unexcluded, and licensing a claim of 0.99 at the same confidence would need

consecutive successes. Nine is not a large number and the arithmetic says so. The case of no observed failures is the one Hanley and Lippman-Hand 1983 treat under the heading of whether nothing going wrong means everything is all right, where they give the same bound in its approximate form as a rule of three. Their subject is clinical and the arithmetic is indifferent to that. That is a separate and much weaker objection than the one this section rests on, because the counting argument does not need the sample to be small. It would refute the unification from a sample of a million.

A uniformity measurement over instances is genuinely useful for deciding what to build first, which is the subject of the previous article in this series, because that question really is about proportions. It is useless here. The two questions feel adjacent, and one of them is answerable by counting slots.

A whitelist standing in for a predicate coincides with it on the sample it was drawn from. The tail-position rule is a small instance of a large pattern. Whenever a condition is written by enumerating the cases the author has seen, it will pass every case the author has seen. The discipline is to state the property and then check that the enumeration matches it, in that order, because the reverse order produces a rule that looks correct and is merely well-sampled.

Assembling a table for an audience is a distinct verification activity. Twice now in this series, a figure gathered for publication has exposed something that a passing test suite did not. The mechanism is not mysterious. A test asks a question its author thought to ask. A table forces a row for every case, including the ones nobody thought about, and an empty or surprising cell is a question the author did not have the imagination to ask directly.

The Decision This Informs

The spike was commissioned to inform a choice, and it narrows rather than makes it.

One option is ruled out on evidence. A single return-based convention for both forms at a one-word return type is lossy for the terminating form, and no shape analysis rescues it.

Three options remain and all are genuinely open.

One convention with a widened return. Every coroutine entry point returns a discriminated pair, which the System V AMD64 and AAPCS64 register-pair rules make free of memory traffic on the two targets that matter. One convention for the host and one discriminator to check. The frame property is preserved only for coroutines that suspend at most once per call, and is surrendered otherwise, because resuming mid-body needs a continuation that outlives the call. This option exists only because the ABI documents were read, and it was absent from the draft that preceded the reference pass. It has not been costed.

Two conventions, declared per entry point. The artefact states which convention each exported function uses, and the host dispatches accordingly. Costs a consumer-visible distinction and a metadata field. Preserves the cheap path for the twenty-three of twenty-four chunks that can use it.

One callback convention everywhere. Uniform for the host. Costs every stream chunk an external call and, more seriously, gives up the property that no frame is live during host execution, which is the property the bounded-memory analysis wants. That is not a small concession in a project whose value proposition is definitive worst-case memory.

The memory difference is the one that can be stated exactly. Let $L(\varepsilon)$ denote the set of native frames live while host code executes between suspensions. Then

because the return convention has ended the call by the time the host runs and the callback convention has not. The worst-case native stack bound therefore differs by

a quantity that is bounded and computable but charged for the whole duration of host activity, which the analysis does not bound. Under the return convention that term is identically zero.

The host-interaction counts also differ. Writing $s$ for suspensions per iteration, the native call counts per iteration are

against a virtual-machine baseline of two host round-trips per iteration, since the reset instruction returns control separately from the suspension. Every stream chunk in the corpus has $s = 1$.

A fourth option this spike did not evaluate, and which is recorded so it is not mistaken for absent, is to make the delegating chunk’s callee terminate. The one delegating stream chunk calls a terminating coroutine, and if that call were restructured so the suspension belonged to the stream chunk instead of the callee, the whole corpus would fit one convention. This is a change to the source program and not the backend, it is outside the backend’s authority, and whether it is reasonable is a language question this article is not equipped to answer.

Delegation is a specified problem elsewhere and the specification is instructive. PEP 380 defines yield from so that a subgenerator’s yields pass through to the outermost caller while its return value becomes the value of the delegating expression. That is precisely the two-channel discipline this article arrives at, imposed at the language level rather than at the interface level. The delegating construct must distinguish the callee’s suspensions from the callee’s completion, because they go to different places. The Keleusma delegating chunk has the same structure and currently resolves it by routing suspensions through the callback while discarding the completion, which works only because the completion is unused in this program.

The recommendation is two conventions declared per entry point, on the grounds that the memory property is the project’s reason for existing and one chunk in twenty-four is a poor reason to give it up. This is a recommendation and not a conclusion, and the option to restructure the source has not been costed.

The Contemporary Literature

The question this article treats sits at the intersection of four literatures that rarely cite one another, being coroutine implementation, continuation-passing transformation, application binary interface design, and worst-case resource analysis. The first three have answered the representation question repeatedly and the fourth is the reason the answer matters here. What follows surveys each and marks where the present problem is and is not covered.

Coroutines were classified before they were implemented well

The construct is old. Conway 1963 introduced coroutines to structure a separable compiler, and the motivating example was a compiler passing tokens between phases, close to the present use. The taxonomy that still governs discussion is de Moura and Ierusalimschy 2009, which separates coroutines along three axes, symmetric or asymmetric, first-class or constrained, and stackful or stackless. Keleusma’s two forms are both asymmetric and constrained, and the article’s question is precisely whether the backend must be stackful.

That taxonomy already contains the article’s finding in a different vocabulary. An asymmetric coroutine returns to its resumer, and the resumer must distinguish a suspension from a completion, which Marlin 1980 treats as a defining obligation of the mechanism rather than an implementation detail. The literature has never regarded the discriminator as optional, and it took a backend author rediscovering it from cardinality to notice.

Where the literature does not reach the present question is this. It treats coroutines as a language feature to be provided, not as an interface exposed across a foreign function boundary to a host in another language. The distinction matters because a language runtime can afford a uniform representation with a tag, while a statically bounded artefact linked into a C or Ada program is charged for every byte of that representation by an analysis that must be sound.

The contemporary work on the construct, harvested rather than recalled and listed in full below, is where the classification stopped being the interesting part and the implementation started being it.

• Grolaux and others, 2026, Async/await is an Effective Paradigm for Event Management of User Interfaces
• Castañeda and Rodríguez, 2026, Asynchronous Wait-Free Runtime Verification and Enforcement of Linearizability
• Han and others, 2026, Design and Implementation of Boss AI for 2D Action Games Using Finite State Machines and Coroutine Chaining
• Frąszczak and Frąszczak, 2026, PhishingWebCollector Async python library for automated phishing feed collection
• Magesty and Montandon, 2026, PromiseAwait A Dataset of JavaScript Migrations from Promises to Async/Await
• Williams and Elliott, 2025, Libfork Portable Continuation-Stealing With Stackless Coroutines
• Reitz and Posner, 2025, Stackless vs. Stackful Coroutines A Comparative Study for RDMA-based Asynchronous Many-Task AMT Runtimes
• Posner and others, 2025, Toward Dynamic Resource Management An Asynchronous Many-Task AMT Runtime System leveraging Dynamic Processes with PSets DPP
• Shcherbakov and Shcherbakova, 2024, Comparative analysis of coroutine functionality in modern programming languages
• Zhao and others, 2024, COPS A Coroutine-Based Priority Scheduling Framework Perceived by the Operating System
• Li and others, 2024, GastCoCo Graph Storage and Coroutine-Based Prefetch Co-Design for Dynamic Graph Processing
• Friese and others, 2024, Lamellar A Rust-based Asynchronous Tasking and PGAS Runtime for High Performance Computing
• Mykola, 2024, USING ASYNCHRONOUS PROGRAMMING IN PYTHON TO IMPROVE APPLICATION PERFORMANCE
• Castañeda and Rodríguez, 2023, Asynchronous Wait-Free Runtime Verification and Enforcement of Linearizability
• Mane Ritesh Pratap and Alpona Das, 2023, Designing a Random Password Generator Using Python Programming Language
• Gore and others, 2023, Sentence Generator for English Language using Formal Semantics
• Daiß and others, 2023, Stellar Mergers with HPX-Kokkos and SYCL Methods of using an Asynchronous Many-Task Runtime System with SYCL
• Weber and others, 2022, A closer look at process-based simulation with stackless coroutines
• Suetterlein and others, 2022, Extending an asynchronous runtime system for high throughput applications A case study
• Wang and Huang, 2022, SGPM A coroutine framework for transaction processing
• Wang and huang, 2022, Sgpm A Coroutine Scheduling Model for Wound-Wait Concurrency Control
• Holmen and others, 2021, A Heterogeneous MPI+PPL Task Scheduling Approach for Asynchronous Many-Task Runtime Systems
• Diehl and others, 2021, Performance Measurements Within Asynchronous Task-Based Runtime Systems A Double White Dwarf Merger as an Application
• Zhou and others, 2020, Design and Implementation of Coroutine Scheduling System on SW26010
• PIETERS and SCHRIJVERS, 2020, Faster coroutine pipelines A reconstruction
• Weber and Fischer, 2020, Process-Based Simulation with Stackless Coroutines
• Ataei and Manohar, 2019, AMC An Asynchronous Memory Compiler
• Wagle and others, 2019, Runtime Adaptive Task Inlining on Asynchronous Multitasking Runtime Systems
• Wang, 2019, Web Crawler Scheduler Based on Coroutine
• Corrodi and others, 2018, A semantics comparison workbench for a concurrent, asynchronous, distributed programming language
• Peterson and others, 2017, Addressing Global Data Dependencies in Heterogeneous Asynchronous Runtime Systems on GPUs
• Yoo and Kim, 2017, Coroutine based Algorithms for reducing Memory overhead in Virtual Reality
• Spivey, 2017, Faster coroutine pipelines
• DeBuhr and others, 2017, Scalable Hierarchical Multipole Methods Using an Asynchronous Many-Tasking Runtime System
• Baskaran and others, 2016, Automatic Code Generation and Data Management for an Asynchronous Task-Based Runtime
• Толстікова and others, 2016, Efficiency asynchronous application programming language Python
• Wibowo and others, 2015, Unit test code generator for lua programming language

Continuation-passing style answers the representation question, expensively

The general transformation is known and exact. Reynolds 1972 established continuation passing as a definitional technique, Strachey and Wadsworth 1974 gave it its semantics, and Appel 1991 made it a compiler architecture. Under continuation passing every suspension becomes a call to a continuation and the representation question dissolves, because there are no returns to collide with.

It dissolves the question by paying for it everywhere. The transformation is global, it changes the calling convention of every function and not of coroutines alone, and the resulting closures are heap allocated unless a later analysis recovers the stack discipline. Danvy and Nielsen 2001 show defunctionalisation recovering first-order code from the higher-order form, the step that makes continuation passing implementable without a garbage collector, and it is the step a bounded-memory project would have to trust.

Delimited control is the sharper tool. Danvy and Filinski 1990 introduced shift and reset, Felleisen 1988 the prompt-based formulation, and Dybvig et al. 2007 a monadic framework with an implementation strategy. Flatt et al. 2007 report adding delimited and composable control to a production system, the closest thing in the literature to a cost report. A delimited continuation is exactly a coroutine frame, and the delimiter is exactly the boundary this article’s reset instruction draws.

The continuation literature harvested for this survey is listed below. It is the thinnest of the modern clusters, at 15 records from 2015 onward against 38 earlier ones, and the imbalance is itself informative. The representation question was answered in the 1970s and 1990s and the modern work has moved to the handler formulation surveyed further down.

• Todoran and Ciobanu, 2025, Metric Continuation-Passing Semantics for Multiparty Interactions
• Pyzik, 2023, Call-By-Name Is Just Call-By-Value with Delimited Control
• VANDENBROUCKE and SCHRIJVERS, 2023, Disjunctive Delimited Control
• Ikemori and others, 2023, Typed Equivalence of Labeled Effect Handlers and Labeled Delimited Control Operators
• Schuster and others, 2022, A typed continuation-passing translation for lexical effect handlers
• Ishio and Asai, 2022, Type System for Four Delimited Control Operators
• Gibbons, 2021, Continuation-Passing Style, Defunctionalization, Accumulations, and Associativity
• Avanzini and others, 2021, On continuation-passing transformations and expected cost analysis
• Komolov and others, 2020, An empirical study of multi-threading paradigms Reactive programming vs continuation-passing style
• Todoran, 2020, Metric Semantics for Concurrent Languages Designed in Continuation-Passing Style
• FORSTER and others, 2019, On the expressive power of user-defined effects Effect handlers, monadic reflection, delimited control
• Abdallah, 2018, PRISM revisited Declarative implementation of a probabilistic programming language using multi-prompt delimited control
• Todoran and Papaspyrou, 2017, Concurrency Semantics in Continuation-Passing Style
• Schöpp, 2017, Defunctionalisation as modular closure conversion
• Biernacki and others, 2015, A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations

The stackless transformation is what production compilers actually ship

The state-machine transformation, in which a coroutine becomes a function over an explicit state record, is the dominant implementation strategy and it is well documented. Syme et al. 2011 describe the F# asynchronous model, Bierman et al. 2012 formalise the C# async transformation, and Elizarov et al. 2021 give the design rationale for Kotlin coroutines including the suspension sentinel discussed above. Prokopec and Liu 2018 extend the treatment to coroutines with snapshots and give a cost model.

Every one of these reports the same discriminator problem and solves it the same way, by returning a tagged or sentinel value. That convergence is the strongest available evidence for the widened-return option this article identifies, and it was invisible from inside the backend.

It is also evidence for the correction recorded in the Epistemic State, and reading it carefully would have prevented the error. Not one of these systems returns a bare tagged value. Each pairs the tag with a state object that survives the call, being the state machine in C# and F# and the continuation in Kotlin, because a coroutine that suspends more than once must resume mid-body. The literature converged on the triple, and this article originally read it as converging on the pair.

The alternative is stackful, which the operating-systems literature has costed thoroughly. von Behren et al. 2003 argue for threads with dynamically sized stacks against event-driven code, and the stack-growth machinery they describe is what a stackful coroutine needs. For a project whose memory bound must be static, that machinery is not available.

The code-generation literature this article’s backend sits inside is the largest of the survey’s topical clusters, at 201 contemporary records, exceeded only by the general systems cluster listed at the end. It is here because the stackless transformation is a code-generation decision before it is a language-design one.

• Pan and others, 2026, A Backend-Agnostic Compiler for Approximate Query Processing with Probabilistic Tensor Algebra
• Zhong and others, 2026, A Multi-Modal Retrieval-Augmented Framework for Compiler Backend Generation with LLMs
• Tirichine and others, 2026, A Reinforcement Learning Environment for Automatic Code Optimization in the MLIR Compiler
• Maldonado and Carrasco-Sáez, 2026, A Reusable J48-Targeting Python Backend for Scikit-Learn Workflows Differential Validation Against WEKA J48
• Zhong and others, 2026, BePilot An AI Programming Assistant for Compiler Backend Development
• Horvat and others, 2026, Comparative Evaluation of Gemini and DeepSeek for LLM-Generated Code Quality and Architectural Robustness in Backend Software Engineering
• Reddy and others, 2026, Compiler-Assisted Instruction Fusion
• Kwon and others, 2026, Compiler-Runtime Co-operative Chain of Verification for LLM-Based Code Optimization
• Biradar and others, 2026, Design and Development of an AI-Powered Code Generation System with Persistent Memory and Multi-Agent Architecture
• Wu and others, 2026, Designing quantum chemistry algorithms with just-in-time compilation
• Alladi and others, 2026, Enabling Automatic Compiler-Driven Vectorization of Transformers
• Burgholzer and others, 2026, Focus Session Paper The MQT Compiler Collection A Blueprint for a Future-Proof Quantum-Classical Compilation Framework
• Zhang and others, 2026, GeoIR-Compiler A Geospatial Intermediate Representation and Compilation Framework for Chinese Urban Spatial Question Answering
• Luo and others, 2026, GeoJSON agents a multi-agent LLM architecture for geospatial analysis-function calling vs. code generation
• Zhang and others, 2026, LEGO-compiler enhancing neural compilation through translation composability
• Fang and others, 2026, LLM-VeriOpt Verification-Guided Reinforcement Learning for LLM-Based Compiler Optimization
• M, 2026, No-Code Backend Orchestrator with Drag and Drop Architecture and AI-Assisted Contextual Code Generation
• Krogstie and others, 2026, PIP Making Andersen’s Points-to Analysis Sound and Practical for Incomplete C Programs
• Dickerson and others, 2026, Practical Python FPGA Acceleration with Fast Just-In-Time Compilation and Configuration
• Zhao and others, 2026, QuaMap A Multi-Backend Benchmark Dataset for Quantum Circuit Mapping and Learning-Based Compiler Evaluation
• Lancellotti and others, 2026, Quantum Oracle Synthesis from HDL Designs via Multi Level Intermediate Representation
• Baradaran and others, 2026, Reusing Legacy Code in Wasm Key Challenges of Compilation and Code Semantics Preservation
• de Ferrière and others, 2026, SecSwift, a Compiler-Based Framework for Software Countermeasures in Cybersecurity
• Rinard, 2026, Testing, Credible Compilation, and Verification in the Axon Verified Compiler in Lean and Claude Code
• Qian and others, 2026, Thinking Fast and Correct Automated Rewriting of Numerical Code through Compiler Augmentation
• Ko and Heo, 2026, TinyGen Portable and Compact Code Generation for Tiny Machine Learning
• Cheng and Wu, 2026, Toward Unified Chinese Multi-Dialectal Speech Recognition via Pinyin Intermediate Representation
• Zhong and others, 2026, Towards Fully Automated Compiler Backend Generation with Multi-Agent Systems How Far Are We?
• Schwarz and others, 2026, TPDE A Fast Adaptable Compiler Back-End Framework
• Yi and others, 2026, Understanding and Finding JIT Compiler Performance Bugs
• Li and others, 2026, Unleashing Triton on CPUs Compilation and Runtime Co-Optimization for Scalable Vector Architectures
• Kang and others, 2026, WAMI Compilation to WebAssembly through MLIR without Losing Abstraction
• Maia and others, 2026, Why Just-In-Time Compilation Matters Evaluating Runtime and Energy Efficiency
• Zhu and Xie, 2025, A Domain-Specific Compiler for Embedded DSP Development Based on Component Code Generation Architecture and Correctness
• Lopoukhine and others, 2025, A Multi-level Compiler Backend for Accelerated Micro-kernels Targeting RISC-V ISA Extensions
• Sun and others, 2025, Archs A WebAssembly Runtime for Cross-host Heterogeneous Computing in Serverless
• Sun and others, 2025, Automating Target Description Processing for Efficient Compiler Backend Development
• Lee and others, 2025, Bit-Level Semantics Scalable RAG Retrieval with Neurosymbolic Hyperdimensional Computing
• Tamura and others, 2025, Bringing Together Cross-ISA Checkpoint/Restoration and AOT Compilation of WebAssembly Programs
• Meier and others, 2025, CertiCoq-Wasm A Verified WebAssembly Backend for CertiCoq
• Bryant and others, 2025, Certified Knowledge Compilation with Application to Formally Verified Model Counting
• Hammer and others, 2025, Compiler-Like Code Generation for fUML Reducing Overhead in Executable UML
• Kocourek and others, 2025, Copy-and-Patch Just-in-Time Compiler for R
• Ali and others, 2025, Does Coding Style Really Survive Compilation? Stylometry of Executable Code Revisited
• Kaynaroglu and others, 2025, EUTROPY A Python-based software optimized with Just-In-Time compilation for simulating eutrophication dynamics in aquatic systems
• Ding and others, 2025, HFF-JIT A Hybrid Fuzzing Framework for JIT Compiler Vulnerability Detection in JavaScript
• Lin and others, 2025, Intermediate Representation-Based Approach for Code Refactoring and Quality Evaluation
• Rong and others, 2025, IRFuzzer Specialized Fuzzing for LLVM Backend Code Generation
• Souha and others, 2025, Modeling and Automated Code Generation of the Backend of Tourism Applications
• Ravedutti Lucio Machado and others, 2025, P4IRS An intermediate representation and compiler for parallel and performance-portable particle simulations
• Ramdani and others, 2025, Pengembangan Backend Aplikasi Geoproperty dengan Golang di PT. Nerdvana Solusi Teknologi
• Georgakoudis and others, 2025, Proteus Portable Runtime Optimization of GPU Kernel Execution with Just-in-Time Compilation
• Cieszewski, 2025, PyHLS Intermediate Representation for Versatile High-Level Synthesis
• Pavlovskiy and Platov, 2025, RESEARCH ON CODE GENERATION OF C/C++ COMPILER FOR HIGH-PERFORMANCE COMPUTING IN MICROPROCESSOR SYSTEMS
• Fruehwirth, 2025, Runtime Repeated Recursion Unfolding in CHR A Just-In-Time Online Program Optimization Strategy That Can Achieve Super-Linear Speedup
• Patel and others, 2025, SySTeC A Symmetric Sparse Tensor Compiler
• Gaißert and others, 2025, Tracing Just-in-Time Compilation for Effects and Handlers
• Berger and others, 2025, Translation Validation for LLVM’s AArch64 Backend
• Shaikhha and others, 2024, A Tensor Algebra Compiler for Sparse Differentiation
• Choi and others, 2024, Accelerating Sensor Software Performance on Edge Devices Through Just-in-Time Compilation
• Robin and Khan, 2024, An open-source P416 compiler backend for reconfigurable match-action table switches Making networking innovation accessible
• Osborne and others, 2024, Awkward Just-In-Time JIT Compilation A Developer’s Experience
• Raju Cherukuri, 2024, Building Scalable Web Applications Best Practices for Backend Architecture
• Zhong and others, 2024, ComBack A Versatile Dataset for Enhancing Compiler Backend Development Efficiency
• Engelke and Schwarz, 2024, Compile-Time Analysis of Compiler Frameworks for Query Compilation
• Geeson and Smith, 2024, Compiler Testing with Relaxed Memory Models
• Han and others, 2024, Enabling Fine-Grained Incremental Builds by Making Compiler Stateful
• Jesus and Weiland, 2024, Evaluating and optimising compiler code generation for NVIDIA Grace
• Drescher and Engelke, 2024, Fast Template-Based Code Generation for MLIR
• Mukherjee and others, 2024, HLS-IRT Hardware Trojan Insertion through Modification of Intermediate Representation During High-Level Synthesis
• Nejjar and others, 2024, LLMs for science Usage for code generation and data analysis
• Jung, 2024, Miri Practical Undefined Behavior Detection for Rust Keynote
• GREEN and WOOD, 2024, REASONING ABOUT THE ACOUSTIC REALISATION OF SEMIVOWELS USING AN INTERMEDIATE REPRESENTATION - THE ‘SPEECH SKETCH’
• Duhamel and Pillement, 2024, Runtime Task Scheduling for FPGA-Based Embedded Systems Using Just-in-Time Bitstream Prefetching
• Pham and Odersky, 2024, Stack-Copying Delimited Continuations for Scala Native
• Ramesh and others, 2024, ThriveJIT Dynamic Just-In-Time Compilation for Efficient Execution of Arithmetic Expressions
• Kwon and others, 2024, Translation Validation for JIT Compiler in the V8 JavaScript Engine
• Bauckholt and Holz, 2024, WebAssembly as a Fuzzing Compilation Target Registered Report
• Titzer, 2024, Whose Baseline Compiler is it Anyway?
• Телегин, 2023, AHEAD-OF-TIME and JUST-IN-TIME technologies
• Bhamidipati and Vemuri, 2023, ASPIRE An Intermediate Representation for Abstract Security Policies
• Lim and Debray, 2023, Automatically Localizing Dynamic Code Generation Bugs in JIT Compiler Back-End
• Blazy, 2023, CompCert A Journey through the Landscape of Mechanized Semantics for Verified Compilation Keynote
• Prinz, 2023, Compilation of Distributed Programs to Services Using Multiple Programming Languages
• Abdelmaksoud and others, 2023, DEL Dynamic Symbolic Execution-based Lifter for Enhanced Low-Level Intermediate Representation
• Shahrokhi and others, 2023, Efficient Query Processing in Python Using Compilation
• Barrière and others, 2023, Formally Verified Native Code Generation in an Effectful JIT Turning the CompCert Backend into a Formally Verified JIT Compiler
• Groß and others, 2023, FUZZILLI Fuzzing for JavaScript JIT Compiler Vulnerabilities
• 2023, Green Supply Chain Management and Competitive Advantage Evidence of Just-in-time Management on Firm Performance SMEs in Indonesia
• Pichler and others, 2023, Hybrid Execution Combining Ahead-of-Time and Just-in-Time Compilation
• Gourdin, 2023, Lazy Code Transformations in a Formally Verified Compiler
• Thangamani and others, 2023, Lifting Code Generation of Cardiac Physiology Simulation to Novel Compiler Technology
• Gu, 2023, LLM-Based Code Generation Method for Golang Compiler Testing
• He and others, 2023, Profile Guided Optimization Transfer-Learning for OpenCL/SYCL Kernel Compilation and Runtime
• Nedoria, 2023, Programming Language for Teaching Compilation and Transformation Technologies
• Wu, 2023, PyTorch 2.0 The Journey to Bringing Compiler Technologies to the Core of PyTorch Keynote
• Pečimúth, 2023, Remote Just-in-Time Compilation for Dynamic Languages
• Moron and Wallentowitz, 2023, Support for Just-in-Time Compilation of WebAssembly for Embedded Systems
• Lopes, 2023, Torchy A Tracing JIT Compiler for PyTorch
• Rivera and others, 2022, A Compiler for Sound Floating-Point Computations using Affine Arithmetic
• Huang and others, 2022, A High-Performance Bidirectional Compiler for Conversion Between SystemC and Verilog
• Stepanov and Itsykson, 2022, Backend Bug Finder a platform for effective compiler fuzzing
• Schmale and others, 2022, Backend compiler phases for trapped-ion quantum computers
• Jain and others, 2022, Coarse Grained FPGA Overlay for Rapid Just-In-Time Accelerator Compilation
• Akanbi and others, 2022, Code Generation Techniques in Compiler Design Conceptual and Structural Review
• Nguyen and McCaskey, 2022, Extending Python for Quantum-classical Computing via Quantum Just-in-time Compilation
• Polito and others, 2022, Interpreter-guided differential JIT compiler unit testing
• Hartley and others, 2022, Just-In-Time Compilation on ARM-A Closer Look at Call-Site Code Consistency
• Katel and others, 2022, MLIR-based code generation for GPU tensor cores
• Serrano, 2022, On JavaScript Ahead-of-Time Compilation Performance Keynote
• Ji and Wang, 2022, Optimizing Aggregate Computation of Graph Neural Networks with on-GPU Interpreter-Style Programming
• Efthymiou and others, 2022, Quantum simulation with just-in-time compilation
• 2022, Supplemental Material for A Just-in-Time Adaptive Intervention to Enhance Physical Activity in the SMARTFAMILY2.0 Trial
• Izawa and others, 2022, Threaded Code Generation with a Meta-Tracing JIT Compiler
• Li and others, 2022, Unleashing the power of compiler intermediate representation to enhance neural program embeddings
• Mzid and others, 2022, Use of Compiler Intermediate Representation for Reverse Engineering A Case Study for GCC Compiler and UML Activity Diagram
• Ortiz, 2022, Using WebAssembly to Teach Code Generation in a Compiler Design Course
• Rand, 2022, Writing and verifying a Quantum optimizing compiler keynote
• Quiring and others, 2021, 3CPS The Design of an Environment-Focussed Intermediate Representation
• Rivera and others, 2021, An Interval Compiler for Sound Floating-Point Computations
• Papadimitriou and others, 2021, Automatically exploiting the memory hierarchy of GPUs through just-in-time compilation
• Jamieson and Brown, 2021, Compact native code generation for dynamic languages on micro-core architectures
• Xu and Kjolstad, 2021, Copy-and-patch compilation a fast compilation algorithm for high-level languages and bytecode
• Barrière and others, 2021, Formally verified speculation and deoptimization in a JIT compiler
• Demmler and others, 2021, Improved Circuit Compilation for Hybrid MPC via Compiler Intermediate Representation
• Song and Wang, 2021, Monadic Programming Featured Teaching Innovation of Compilation Experiments
• Serrano, 2021, Of JavaScript AOT compilation performance
• Liu and others, 2021, Relaxed Peephole Optimization A Novel Compiler Optimization for Quantum Circuits
• Koehler and Steuwer, 2021, Towards a Domain-Extensible Compiler Optimizing an Image Processing Pipeline on Mobile CPUs
• Chhak and others, 2021, Towards formally verified compilation of tag-based policy enforcement
• Sambasivam and others, 2021, Writing P4 compiler backend for packet processing engines
• Loveless and others, 2020, A performance-optimizing compiler for cyber-physical digital microfluidic biochips
• Saieva and Kaiser, 2020, Binary Quilting to Generate Patched Executables without Compilation
• Felker, 2020, Design of Cyanobyte An Intermediate Representation to Standardize Digital Peripheral Datasheets for Automatic Code Generation
• Blazy, 2020, From Verified Compilation to Secure Compilation a Semantic Approach
• Paul and others, 2020, Improving execution efficiency of just-in-time compilation based query processing on GPUs
• Brennan and others, 2020, JIT Leaks Inducing Timing Side Channels through Just-In-Time Compilation
• Schuiki and others, 2020, LLHD a multi-level intermediate representation for hardware description languages
• Dakkak and others, 2020, The design and implementation of the wolfram language compiler
• Scheidl, 2020, Valent-Blocks Scalable High-Performance Compilation of WebAssembly Bytecode For Embedded Systems
• Liu and others, 2019, Accelerating sequential consistency for Java with speculative compilation
• Finkel and others, 2019, ClangJIT Enhancing C++ with Just-in-Time Compilation
• Hariri and others, 2019, Comparing Mutation Testing at the Levels of Source Code and Compiler Intermediate Representation
• Namakonov and Podkopaev, 2019, Compilation of OCaml memory model into Power
• Enrici and others, 2019, Efficient Data-Flow Analysis of UML/SysML Diagrams for Optimized Model Compilation of Hardware-software Systems
• Nappa and others, 2019, Fast Parallel Equivalence Relations in a Datalog Compiler
• HATABA and others, 2019, Generation of Efficient Obfuscated Code through Just-in-Time Compilation
• Müssig, 2019, Just enough, just in time, just for me
• Schkufza and others, 2019, Just-In-Time Compilation for Verilog
• Bourke and others, 2019, Mechanized semantics and verified compilation for a dataflow synchronous language with reset
• Castro-Lopez and Vega-Lopez, 2019, Multi-target Compiler for the Deployment of Machine Learning Models
• Tine and others, 2019, POSTER Tango An Optimizing Compiler for Just-In-Time RTL Simulation
• Zhang and others, 2019, SNC A Cloud Service Platform for Symbolic-Numeric Computation Using Just-In-Time Compilation
• KIAM TAN and others, 2019, The verified CakeML compiler backend
• Baghdadi and others, 2019, Tiramisu A Polyhedral Compiler for Expressing Fast and Portable Code
• Turcotte and Vitek, 2019, Towards a Type System for R
• Tinnerholm and others, 2019, Towards introducing just-in-time compilation in a Modelica compiler
• Curtis and others, 2018, A compiler for cyber-physical digital microfluidic biochips
• Vandercammen and others, 2018, A flexible framework for studying trace-based just-in-time compilation
• Leopoldseder and others, 2018, Dominance-based duplication simulation DBDS code duplication to enable compiler optimizations
• Caamaño and Guelton, 2018, Easy Jit compiler assisted library to enable just-in-time compilation in C++ codes
• Ottoni, 2018, HHVM JIT a profile-guided, region-based compiler for PHP and Hack
• Brock and others, 2018, PAYJIT space-optimal JIT compilation and its practical implementation
• Caliskan and others, 2018, When Coding Style Survives Compilation De-anonymizing Programmers from Executable Binaries
• Pape and others, 2017, Adaptive just-in-time value class optimization for lowering memory consumption and improving execution time performance
• Su and others, 2017, Automatic generation of fast BLAS3-GEMM A portable compiler approach
• Mainland, 2017, Better living through operational semantics an optimizing compiler for radio protocols
• Reis and others, 2017, Compiler Techniques for Efficient MATLAB to OpenCL Code Generation
• Basu and others, 2017, Compiler-based code generation and autotuning for geometric multigrid on GPU-accelerated supercomputers
• Rohr and Lindenstruth, 2017, Fast Failure Erasure Encoding Using Just in Time Compilation for CPUs, GPUs, and FPGAs
• Welch and others, 2017, Formalization IDEs Integrated with a Verifying Compiler
• HAMID and ITO, 2017, Image Segmentation to Design Semi-optimized Curve for B-code Generation
• Fumero and others, 2017, Just-In-Time GPU Compilation for Interpreted Languages with Partial Evaluation
• Sharygin and Buchatskiy, 2017, Survey of Just-in-Time Query Compilation Methods
• Fox and others, 2017, Verified compilation of CakeML to multiple machine-code targets
• Zhang and others, 2017, Weak Memory Models Balancing Definitional Simplicity and Implementation Flexibility
• Spampinato and Püschel, 2016, A basic linear algebra compiler for structured matrices
• Tan and others, 2016, A new verified compiler backend for CakeML
• Dissegna and others, 2016, An Abstract Interpretation-Based Model of Tracing Just-in-Time Compilation
• Bulej and others, 2016, Beneath the bytecode
• Martinsen and others, 2016, Combining thread-level speculation and just-in-time compilation in Google’s V8 JavaScript engine
• Kwon and Bae, 2016, Development of a Code Generation Support System in Integrated Development Environment of an Educational Compiler
• Suhendra and Bachtiar, 2016, MIGRATION CODE PADA BACKEND CRIMEZONE DARI PHP KE SCALA
• Li and others, 2016, Modular SDN Compiler Design with Intermediate Representation
• Béra and others, 2016, Practical Validation of Bytecode to Bytecode JIT Compiler Dynamic Deoptimization
• Moss and others, 2016, The ARES High-Level Intermediate Representation
• Alexander and Black, 2016, The performance of object encodings in JavaScript
• Plangger and Krall, 2016, Vectorization in PyPy’s Tracing Just-In-Time Compiler
• Xu and Gregg, 2015, An Efficient Vectorization Approach to Nested Thread-level Parallelism for CUDA GPUs
• Oh and others, 2015, Bytecode-to-C Ahead-of-Time Compilation for Android Dalvik Virtual Machine
• Refaie and Thyabat, 2015, Effect of just-in-time selling strategy on firms’ performance in Jordan
• Lee and others, 2015, Flow-sensitive runtime estimation an enhanced hot spot detection heuristics for embedded Java just-in-time compilers
• Melrose and others, 2015, Just in Time
• Khaldi and others, 2015, LLVM parallel intermediate representation
• Hollingshaus and Daddario, 2015, Performance Philosophy Arrived Just in Time?
• Heck and Zaidman, 2015, Quality criteria for just-in-time requirements just enough, just-in-time?
• Khorasani and others, 2015, Scalable SIMD-Efficient Graph Processing on GPUs
• Heumann and others, 2015, Scalable Task Scheduling and Synchronization Using Hierarchical Effects
• Meybodi, 2015, The links between just-in-time practices and alignment of benchmarking performance measures
• Santhi and others, 2015, The Simian concept Parallel Discrete Event Simulation with interpreted languages and just-in-time compilation

Effect handlers are the modern generalisation, and they carry the same obligation

Algebraic effects subsume coroutines. Plotkin and Pretnar 2009 give the handler formulation, Leijen 2017b a type-directed compilation, Hillerström and Lindley 2016 a row-typed treatment, and Sivaramakrishnan et al. 2021 a production retrofit onto OCaml with performance figures.

The relevance here is narrow and worth stating precisely. An effect handler’s return clause and its operation clauses are syntactically distinct, which is the same discriminator appearing a third time, now in the type system rather than the calling convention. A language that adopted handlers would not face this article’s question, because the distinction would already be in the source. Keleusma does not adopt them, and the V0.4 architecture does not propose to.

• Segura, 2026, Algebraic effects for bounded prompt pipelines Lawvere theories, handlers, and outcome traces
• Gillard and others, 2026, Dynamic Wind for OCaml Effect Handlers with Escaping Continuation Support
• Trifanov and Schrijvers, 2026, Staging Effect Handlers for Modular Search
• Gao and Parreaux, 2025, A Lightweight Type-and-Effect System for Invalidation Safety Tracking Permanent and Temporary Invalidation with Constraint-Based Subtype Inference
• van Rooij and Krebbers, 2025, Affect An Affine Type and Effect System
• Asai and Fujii, 2025, Defining Algebraic Effects and Handlers via Trails and Metacontinuations
• Voigt and others, 2025, Dynamic Wind for Effect Handlers
• Ma, 2025, Lexical Effect Handlers Fast by Design, Correct by Proof
• Jaafar and Jaber, 2025, Operational Game Semantics for Generative Algebraic Effects and Handlers
• Ma and others, 2025, Zero-Overhead Lexical Effect Handlers
• Yoshioka and others, 2024, Abstracting Effect Systems for Algebraic Effect Handlers
• Mückenschnabel, 2024, Algebraic Effect Handlers with Bidirectional Type-Checking
• SANADA, 2024, Algebraic effects and handlers for arrows
• Tsuyama and others, 2024, An Intrinsically Typed Compiler for Algebraic Effect Handlers
• Kawamata and others, 2024, Answer Refinement Modification Refinement Type System for Algebraic Effects and Handlers
• HILLERSTRÖM and others, 2024, Asymptotic speedup via effect handlers
• Ma and others, 2024, Lexical Effect Handlers, Directly
• Xie and others, 2024, Parallel Algebraic Effect Handlers
• Isoda and others, 2024, Type-Safe Code Generation with Algebraic Effects and Handlers
• Sanada, 2023, Category-Graded Algebraic Theories and Effect Handlers
• Nguyen and others, 2023, Effect Handlers for Programmable Inference
• Müller and others, 2023, From Capabilities to Regions Enabling Efficient Compilation of Lexical Effect Handlers
• New and others, 2023, Gradual Typing for Effect Handlers
• Sekiyama and Unno, 2023, Temporal Verification with Answer-Effect Modification Dependent Temporal Type-and-Effect System with Delimited Continuations
• Cong and Asai, 2023, Towards a Reflection for Effect Handlers
• Xie and others, 2022, First-class names for effect handlers
• Ghica and others, 2022, High-level effect handlers in C++
• Hamana, 2022, Modular Termination for Second-Order Computation Rules and Application to Algebraic Effect Handlers
• de Vilhena and Pottier, 2021, A separation logic for effect handlers
• Zyuzin and Nanevski, 2021, Contextual modal types for algebraic effects and handlers
• Karachalias and others, 2021, Efficient compilation of algebraic effect handlers
• Xie and Leijen, 2021, Generalized evidence passing for effect handlers efficient compilation of effect handlers to C
• Noguchi and others, 2021, Implementing Algebraic Effects and Handlers in Non-functional Programming Languages
• Punchihewa and Wu, 2021, Safe mutation with algebraic effects
• Liu and others, 2020, A type-and-effect system for object initialization
• Schuster and others, 2020, Compiling effect handlers in capability-passing style
• Xie and Leijen, 2020, Effect handlers in Haskell, evidently
• HILLERSTRÖM and others, 2020, Effect handlers via generalised continuations
• Xie and others, 2020, Effect handlers, evidently
• Brachthäuser and others, 2020, Effects as capabilities effect handlers and lightweight effect polymorphism
• BRACHTHÄUSER and others, 2020, Effekt Capability-passing style for type- and effect-safe, extensible effect handlers in Scala
• Zhang and Myers, 2019, Abstraction-safe effect handlers via tunneling
• Brachthäuser and others, 2018, Effect handlers for the masses
• Leijen, 2018, First class dynamic effect handlers or, polymorphic heaps with dynamic effect handlers
• Biernacki and others, 2017, Handle with care relational interpretation of algebraic effects and handlers
• KAMMAR and PRETNAR, 2017, No value restriction is needed for algebraic effects and handlers
• Leijen, 2017, Structured asynchrony with algebraic effects
• SALEH and SCHRIJVERS, 2016, Efficient algebraic effect handlers for Prolog
• Pretnar, 2015, An Introduction to Algebraic Effects and Handlers. Invited tutorial paper
• Bauer and Pretnar, 2015, Programming with algebraic effects and handlers

Verified compilation constrains what the backend may do

The project’s stance is that the backend refuses what it cannot lower rather than approximating it, and that stance has a literature. Leroy 2009a reports CompCert and its formally verified back end in Leroy 2009b, and Kumar et al. 2014 report CakeML, a verified implementation of ML with a verified compiler. Necula 1997 formalises proof-carrying code, in which the artefact carries its own evidence, and Sewell et al. 2013 report translation validation for a verified operating-system kernel, which is the technique a project unable to verify its compiler can still use.

None of these treats the calling convention as a proof obligation, and that is the gap the present project sits in. CompCert’s correctness theorem is about observable behaviour of whole programs under a fixed calling convention, and it does not tell you which convention to choose when a source construct emits two observable event kinds. The theorem shape assumed here, that a lowering is correct when yielded sequences agree, is a coinductive statement over infinite traces of the kind Leroy and Grall 2009 formalise for big-step semantics of diverging programs. That paper is the right formal setting for the divergent case and this article does not use it as such, which is a real weakness rather than an omission of politeness.

• Lasnier and others, 2026, Brack A Verified Compiler for Scheme via CakeML
• Lion and Broman, 2026, Making Time Observable Compiler Correctness for Real-Time C Programs
• Nezamabadi and others, 2026, Verified VCG and Verified Compiler for Dafny
• Barbosa and others, 2025, Formally Verified Correctness Bounds for Lattice-Based Cryptography
• Kwon and others, 2025, Optimization-Directed Compiler Fuzzing for Continuous Translation Validation
• Girault, 2025, Toward a Formally Verified Compiler for a Synchronous, Functional, Data-Flow Programming Language
• Melquiond and Moreau, 2024, A Safe Low-Level Language for Computer Algebra and Its Formally Verified Compiler
• Liu and others, 2024, A Verified Compiler for a Functional Tensor Language
• Debnath and others, 2024, ARMOR A Formally Verified Implementation of X.509 Certificate Chain Validation
• Wang and Xie, 2024, Enhancing Translation Validation of Compiler Transformations with Large Language Models
• Monniaux, 2024, Memory Simulations, Security and Optimization in a Verified Compiler
• Chavanon and others, 2024, PfComp A Verified Compiler for Packet Filtering Leveraging Binary Decision Diagrams
• Kanabar and others, 2023, PureCake A Verified Compiler for a Lazy Functional Language
• Derakhshan and others, 2023, Towards End-to-End Verified TEEs via Verified Interface Conformance and Certified Compilers
• Panigrahi and Karfa, 2023, Translation Validation of Information Leakage of Compiler Optimizations
• Nyangaresi and Ma, 2022, A Formally Verified Message Validation Protocol for Intelligent IoT E-Health Systems
• Abdulaziz and Koller, 2022, Formal Semantics and Formally Verified Validation for Temporal Planning
• Han and others, 2021, Parallelizing Compiler Translation Validation Using Happens-Before and Task-Set
• Mittal and others, 2021, Towards an Approach for Translation Validation of Thread-level Parallelizing Transformations using Colored Petri Nets
• Roessle and others, 2019, Formally verified big step semantics out of x86-64 binaries
• Tahat and others, 2019, Scalable Translation Validation of Unverified Legacy OS Code
• Patterson and Ahmed, 2019, The next 700 compiler correctness theorems functional pearl
• Banerjee and Karfa, 2018, Compiler-agnostic Translation Validation
• Lochbihler, 2018, Mechanising a Type-Safe Model of Multithreaded Java with a Verified Compiler
• Bourke and others, 2017, A formally verified compiler for Lustre
• Avigad and others, 2017, A Formally Verified Proof of the Central Limit Theorem
• Fonseca and others, 2017, An Empirical Study on the Correctness of Formally Verified Distributed Systems
• Barthe and others, 2017, Verified Translation Validation of Static Analyses
• Tan and others, 2015, A verified type system for CakeML
• Ngo and others, 2015, Modular translation validation of a full-sized synchronous compiler using off-the-shelf verification tools
• Neis and others, 2015, Pilsner a compositionally verified compiler for a higher-order imperative language
• Chlipala, 2015, Session details Session 4A Compiler Correctness
• Yang and others, 2015, Towards a verified compiler prototype for the synchronous language SIGNAL

Worst-case resource analysis is why the convention matters at all

If native code did not have to carry a bound, the callback convention would simply win on generality. Wilhelm et al. 2008 survey the worst-case execution-time problem and the tools that address it, and it remains the standard reference for what a sound timing analysis requires. For the memory side, Regehr et al. 2005 eliminate stack overflow by abstract interpretation of machine code, exactly the analysis a native Keleusma artefact must support and exactly what a frame held across arbitrary host execution defeats.

This is the literature that makes the choice non-obvious, and it is the one the coroutine implementation literature does not cite. A runtime that may allocate is free to choose the general mechanism. A bounded artefact is not, and the trade appears only when both literatures are read together.

• Charmanas and others, 2026, A topic-oriented trend analysis framework for Stack Exchange questions Case study on ChatGPT related queries on Stack Overflow
• O Kim and Lee, 2026, Amortised neural acoustic tomography domain-specific encoder design and topology-dependent Eikonal analysis
• Seidler and others, 2026, Wasm-WCET Worst-Case Execution-Time Analysis of WebAssembly Modules on Updatable Resource-Constrained Embedded Devices
• Zolduoarrati and others, 2025, A cross-continental analysis of how regional cues shape top stack overflow contributors
• Kaestner and others, 2025, Determining Worst-Case Execution Time Bounds for Multi-Core Processors
• Lehmann and others, 2025, Hardware/Software Co-Analysis for Worst Case Execution Time Bounds
• Djalali and others, 2025, The Evolution of Software Usability in Developer Communities An Empirical Study on Stack Overflow
• Wambua, 2025, Topics, Trends, and Sentiments in Software Testing An Analysis of Developers’ Engagement on Stack Overflow
• Merazga and others, 2025, Worst-Case Execution Time Analysis of a Real-Time System based on Arduino in CAN Network
• Hu and others, 2024, An Abstract Interpretation-Based Framework for WCET Analysis of Parallel Programs
• Thomas and others, 2024, Analyzing Data Flow and Control Flow of Multicore Software A Solution for Efficient Worst-Case Execution Time Analysis
• Arnström and others, 2024, Exact Worst-Case Execution-Time Analysis for Implicit Model Predictive Control
• Veit and Böcskei, 2024, IFRS 9 Classification Aspects Measurement of Sustainability-Linked Loans at Amortised Cost or Fair Value
• Bertholon and others, 2024, Interactive Source-to-Source Optimizations Validated using Static Resource Analysis
• Mizikovskiy, 2024, Methodology of management cost accounting and calculation of the cost of not amortised organizational and technological equipment for the production of industrial enterprise products
• Albert and others, 2024, Synthesis of Sound and Precise Storage Cost Bounds via Unsound Resource Analysis and Max-SMT
• Kumar and others, 2024, Utilizing Machine Learning Techniques for Worst-Case Execution Time Estimation on GPU Architectures
• Ghadesi and others, 2024, What causes exceptions in machine learning applications? Mining machine learning-related stack traces on Stack Overflow
• Samiei and others, 2024, Worst-Case Execution Time Analysis of Real-Time Robotic Algorithms Using Reinforcement Learning
• Paraman and Murthy, 2023, Analysis of benchmark program results of worst case execution time for multithreaded programs
• Mondal and others, 2023, Investigating Technology Usage Span by Analyzing Users’ QandA Traces in Stack Overflow
• Swillus and Zaidman, 2023, Sentiment overflow in the testing stack Analyzing software testing posts on Stack Overflow
• Rodriguez Ferrandez and others, 2023, Worst Case Execution Time and Power Estimation of Multicore and GPU Software A Pedestrian Detection Use Case
• ISLAM and others, 2022, An Exploration of npm Package Co-Usage Examples from Stack Overflow A Case Study
• WanXin and others, 2022, CUDA Acceleration of Worst-Case Execution Time Analysis Based On Model Checking
• Battle and others, 2022, Exploring D3 Implementation Challenges on Stack Overflow
• Sheth and Damevski, 2022, Grouping related stack overflow comments for software developer recommendation
• Mahajan and Prasad, 2022, Providing Real-time Assistance for Repairing Runtime Exceptions using Stack Overflow Posts
• Velazquez-Rodriguez and others, 2022, Uncovering Library Features from API Usage on Stack Overflow
• Susca and others, 2022, Worst-Case Execution Time Estimation for Numerical Controllers
• Friers and others, 2021, Amortised Encoding for Large High-Resolution Displays
• van der Hoeven and Lecerf, 2021, Amortized Bivariate Multi-point Evaluation
• Kumar, 2021, Deep Neural Network Approach to Estimate Early Worst-Case Execution Time
• Denzler and others, 2021, Experiences from Adjusting Industrial Software for Worst-Case Execution Time Analysis
• Zhao and others, 2021, Hot question prediction in Stack Overflow
• Costa and others, 2021, Use of Measurements in Worst-Case Execution Time Estimation for Real-Time Systems
• Búr and others, 2021, Worst-case Execution Time Calculation for Query-based Monitors by Witness Generation
• Zhang and others, 2020, A Dynamic Instruction Cache Locking Approach for Minimizing Worst Case Execution Time of a Single Task
• Emerson, 2020, Autoencoding Pixies Amortised Variational Inference with Graph Convolutions for Functional Distributional Semantics
• Moser and Schneckenreither, 2020, Automated amortised resource analysis for term rewrite systems
• Muts and Falk, 2020, Compiler-based WCET prediction performing function specialization
• Nadi and Treude, 2020, Essential Sentences for Navigating Stack Overflow Answers
• Uddin and others, 2020, Mining API usage scenarios from stack overflow
• Fusi and others, 2020, On the Use of Probabilistic Worst-Case Execution Time Estimation for Parallel Applications in High Performance Systems
• Azzahra and others, 2020, PRE STACK DEPTH MIGRATION UNTUK KOREKSI EFEK PULL UP DENGAN MENGGUNAKAN METODE HORIZON BASED DEPTH TOMOGRAPHY PADA LAPANGAN ‘A1 DAN A2’
• Mahajan and others, 2020, Recommending stack overflow posts for fixing runtime exceptions using failure scenario matching
• Arcaro and others, 2020, Reliability Test based on a Binomial Experiment for Probabilistic Worst-Case Execution Times
• Meng and others, 2020, Survey on Estimation and Optimization of Worst-case Execution Time with Energy Consumption Constraint
• Ventovaara and others, 2020, Worst-case Execution Time Estimation of Legacy Vehicular Embedded Functions An Industrial Case Study
• Falk and Lokuciejewski, 2019, Correction to A compiler framework for the reduction of worst-case execution times
• Zuepke and Kaiser, 2019, Deterministic Futexes Addressing WCET and Bounded Interference Concerns
• Yildiz and others, 2019, Software UART A Use Case for VSCPU Worst-Case Execution Time Analyzer
• Baltes and others, 2019, SOTorrent Studying the Origin, Evolution, and Usage of Stack Overflow Code Snippets
• Kim and others, 2019, WCET-Aware Stack Frame Management of Embedded Systems Using Scratchpad Memories
• Zhang and Deng, 2018, A Depth Variant Seismic Wavelets Extraction Method for Inversion of Post-Stack Depth Domain Seismic Data
• Reinhardt and others, 2018, Augmenting stack overflow with API usage patterns mined from GitHub
• Szydełko, 2018, BONDS BALANCE SHEET VALUATION IN AMORTISED COST CHOSEN ASPECTS
• Wu and Zhang, 2018, Cache-Aware SPM Allocation to Reduce Worst-Case Execution Time for Hybrid SPM-Caches
• Huangfu and Zhang, 2018, Estimating the Worst-Case Execution Time of the Shared Data Cache in Integrated CPU-GPU Architectures
• Carminati and others, 2018, On the use of static branch prediction to reduce the worst-case execution time of real-time applications
• Becker and Chakraborty, 2018, Optimizing Worst-Case Execution Times Using Mainstream Compilers
• Venkanna and others, 2018, PSO based optimization of worst-case execution time for ASIP application
• Becker and others, 2018, Scalable and precise estimation and debugging of the worst-case execution time for analysis-friendly processors a comeback of model checking
• Venkanna and Rao, 2018, Static Worst-Case Execution Time Optimization using DPSO for ASIP Architecture
• Baltes and Diehl, 2018, Usage and attribution of Stack Overflow code snippets in GitHub projects
• Jha and others, 2018, Worst Case Execution Time Estimation for Control Code of Automation Systems
• Aquino and others, 2018, Worst-Case Execution Time Testing via Evolutionary Symbolic Execution
• Fedasyuk and others, 2017, Architecture of a tool for automated testing the worst-case execution time of real-time embedded systems’ firmware
• Tabassam and Obermaisser, 2017, Class-based query-optimization for minimizing worst-case execution times of diagnostic queries in embedded real-time systems
• Carminati and others, 2017, Combining loop unrolling strategies and code predication to reduce the worst-case execution time of real-time software
• Hausladen and others, 2017, Integration of Static Worst-Case Execution Time and Stack Usage Analysis for Embedded Systems Software in a Cloud-Based Development Environment
• Abella and others, 2017, Measurement-Based Worst-Case Execution Time Estimation Using the Coefficient of Variation
• Jimenez Gil and others, 2017, Open Challenges for Probabilistic Measurement-Based Worst-Case Execution Time
• Knoop and others, 2017, Replacing conjectures by positive knowledge Inferring proven precise worst-case execution time bounds using symbolic execution
• Zou and others, 2017, Towards comprehending the non-functional requirements through Developers’ eyes An exploration of Stack Overflow using topic analysis
• Mizobuchi and Takayama, 2017, Two improvements to detect duplicates in Stack Overflow
• Puffitsch, 2016, Efficient Worst-Case Execution Time Analysis of Dynamic Branch Prediction
• Mondal and others, 2016, Embedded Emotion-based Classification of Stack Overflow Questions Towards the Question Quality Prediction
• Seo and Kim, 2016, Measuring Method of Worst-case Execution Time by Analyzing Relation between Source Code and Executable Code
• Seo and Kim, 2016, Operator-data type pair based execution environments independent worst-case execution time measuring method
• Soleimani and Balarostaghi, 2016, Seismic image enhancement in post stack depth migration by finite offset CDS stack method
• Mguidich and others, 2016, Time-Accurate ASM as a Refinement Scheme for Worst-Case Execution Time Estimation in Hard Real-Time Systems
• 2016, WORST CASE EXECUTION TIME CALCULATION OF PARALLEL EMBEDDED REAL-TIME SOFTWARE
• Al-Bataineh and others, 2015, Accelerating worst case execution time analysis of timed automata models with cyclic behaviour
• Mushtaq and others, 2015, Calculation of worst-case execution time for multicore processors using deterministic execution
• Yu and Cohen, 2015, Guided Test Generation for Finding Worst-Case Stack Usage in Embedded Systems
• 2015, Incorporating Near-Surface Velocity Anomalies in Pre-Stack Depth Migration Models
• Wang and others, 2015, WCET-Aware Energy-Efficient Data Allocation on Scratchpad Memory for Real-Time Embedded Systems

Compiler testing supplies the oracle and warns about its limits

The differential method used here is standard. Yang et al. 2011 report Csmith and the compiler defects it found, Le et al. 2014 introduce equivalence modulo inputs, and Chen et al. 2020c survey compiler testing as a field.

The warning these carry is directly applicable. A differential oracle refutes and does not prove, and its power is bounded by the inputs supplied. This article’s equivalence assertion is checked over a finite sample of resume sequences chosen by hand, the weakest form of the technique. Equivalence modulo inputs is the natural strengthening and it has not been applied.

• Klimis, 2026, Compilomorphic Fuzzing Turning a Compiler Against Itself
• Boda and others, 2026, CPerfSmith A Randomized C Program Generator for Performance-Oriented Compiler Testing
• Oh and Kim, 2026, Detecting Compiler-Introduced Security Bugs via IR Mutation and Coverage-Guided Fuzzing
• Shirai and others, 2026, Does Programming Language Matter? An Empirical Study of Fuzzing Bug Detection
• Liu and others, 2026, Learning Compiler Fuzzing Mutators from Historical Bugs
• Zhang and others, 2026, LLM-Powered Silent Bug Fuzzing in Deep Learning Libraries via Versatile and Controlled Bug Transfer
• Berlakovich and others, 2026, LOOL Low-Overhead, Optimization-Log-Guided Compiler Fuzzing
• Berlakovich and others, 2026, LOOL Low-Overhead, Optimization-Log-Guided Compiler Fuzzing - RCR Report
• Ren and others, 2026, SpiceFuzz LLM-Based Fuzzing for Spice Circuit Simulator Tools Bug Detection
• Zhang and others, 2026, Transformation-Recipe-Based FPGA Synthesis Compiler Testing
• Zeng and others, 2026, TypeNFuzz Dynamic Type-aware Object Dependence Graph-Guided Fuzzing for JavaScript Library Bug Discovery
• Ranjan and others, 2025, ClosureX Compiler Support for Correct Persistent Fuzzing
• Ali and others, 2025, CrossGuard Runtime-Adaptive LLM Fuzzing for Cross-Contract Vulnerabilities Detection
• Ye and others, 2025, BazzAFL Moving Fuzzing Campaigns Towards Bugs via Grouping Bug-Oriented Seeds
• Liu and others, 2025, BoostPolyGlot A Structured IR Generation-Based Fuzz Testing Framework for GCC Compiler Frontend
• Kim and others, 2025, Chimera Fuzzing P4 Network Infrastructure for Multi-Plane Bug Detection and Vulnerability Discovery
• Gao and others, 2025, Clozemaster Fuzzing Rust Compiler by Harnessing Llms for Infilling Masked Real Programs
• Boonriong and others, 2025, Compiler Fuzzing in Continuous Integration A Case Study on Dafny
• Tang and others, 2025, CTDip a diversity-guided test program synthesis approach for boosting compiler bug detection
• Zhu and others, 2025, Emerging Compiler Testing Based on Test Case Reuse
• Grabowski, 2025, Encoding Triangular Norms on Bounded Trellises with Mizar Proof Assistant
• Feng and others, 2025, Finding Compiler Bugs through Cross-Language Code Generator and Differential Testing
• Boo and Lee, 2025, Finding Device Driver Bugs With Fuzzing PCIe Configuration Input
• Gruner and others, 2025, Finding Information Leaks with Information Flow Fuzzing
• Gruner and others, 2025, Finding Information Leaks with Information Flow Fuzzing-RCR Report
• Qian and others, 2025, FreeWavm Enhanced WebAssembly Runtime Fuzzing Guided by Parse Tree Mutation and Snapshot
• Kim and others, 2025, Fuzzing Acceleration for Memory Safety Bug Discovery with Slicer
• Talaat and others, 2025, GrammLLM Grammar-Guided LLM Test Generation for Compiler Validation
• Ni and Li, 2025, Interleaving Large Language Models for Compiler Testing
• Xie and others, 2025, Kitten A Simple Yet Effective Baseline for Evaluating LLM-Based Compiler Testing Techniques
• Hyatt and Dewey, 2025, Mutation-Based Fuzzing of the Swift Compiler with Incomplete Type Information
• Ricardo and others, 2025, On the Practicality of LLM-Based Compiler Fuzzing
• Wang and others, 2025, Research on Compiler Fuzzing Based on Syntax-semantics Dual-Dimensional Classification
• Kokkonis and others, 2025, ROSA Finding Backdoors with Fuzzing
• Li and others, 2025, Solsmith Solidity Random Program Generator for Compiler Testing
• Hu and others, 2025, SSFuzz Synthesizing and scheduling bug-triggering code segments for history-driven compiler testing
• Zhao and others, 2025, Thread-sensitive fuzzing for concurrency bug detection
• Hazott and others, 2025, Using virtual prototypes and metamorphic testing to verify the hardware/software-stack of embedded graphics libraries
• Wu and others, 2025, WBSan WebAssembly Bug Detection for Sanitization and Binary-Only Fuzzing
• Zhou and others, 2024, C-CORE Clustering by Code Representation to Prioritize Test Cases in Compiler Testing
• Tian and others, 2024, Differential testing solidity compiler through deep contract manipulation and mutation
• Feitosa and Ribeiro, 2024, Differential Testing using Random Well-Typed Haskell Programs
• Georgescu and others, 2024, Evolutionary Generative Fuzzing for Differential Testing of the Kotlin Compiler
• Suo and others, 2024, Fuzzing MLIR Compiler Infrastructure via Operation Dependency Analysis
• Fan and others, 2024, History-driven Compiler Fuzzing via Assembling and Scheduling Bug-triggering Code Segments
• Munley and others, 2024, LLM4VV Developing LLM-driven testsuite for compiler validation
• Schwarcz and others, 2024, LOOL Low-Overhead, Optimization-Log-Guided Compiler Fuzzing Registered Report
• Han and others, 2024, Range Specification Bug Detection in Flight Control System Through Fuzzing
• Wang and Jung, 2024, Rustlantis Randomized Differential Testing of the Rust Compiler
• Li and others, 2024, Simulink Compiler Testing via Configuration Diversification With Reinforcement Learning
• Yang and others, 2024, WhiteFox White-Box Compiler Fuzzing Empowered by Large Language Models
• Ye and others, 2023, A Generative and Mutational Approach for Synthesizing Bug-Exposing Test Cases to Guide Compiler Fuzzing
• Wu and others, 2023, Boosting Compiler Testing via Eliminating Test Programs with Long-Execution-Time
• Lin and others, 2023, DeepDiffer Find Deep Learning Compiler Bugs via Priority-guided Differential Fuzzing
• Tu and others, 2023, Detecting C++ Compiler Front-End Bugs via Grammar Mutation and Differential Testing
• Utting and others, 2023, Differential Testing of a Verification Framework for Compiler Optimizations Case Study
• Li and Su, 2023, Finding Unstable Code via Compiler-Driven Differential Testing
• Donaldson and others, 2023, Industrial Deployment of Compiler Fuzzing Techniques for Two GPU Shading Languages
• Wang and others, 2023, MLIRSmith Random Program Generation for Fuzzing MLIR Compiler Infrastructure
• Zhong and others, 2023, Neural Network Guided Evolutionary Fuzzing for Finding Traffic Violations of Autonomous Vehicles
• Kim and Hong, 2023, Poster BugOss A Regression Bug Benchmark for Empirical Study of Regression Fuzzing Techniques
• Sharma and others, 2023, RustSmith Random Differential Compiler Testing for Rust
• Ito and others, 2023, Schfuzz Detecting Concurrency Bugs with Feedback-Guided Fuzzing
• Qu and others, 2023, Scope-based Compiler Differential Testing
• Li and others, 2022, ALPHAPROG Reinforcement Generation of Valid Programs for Compiler Fuzzing
• Godboley and others, 2022, AV-AFL A Vulnerability Detection Fuzzing Approach by Proving Non-reachable Vulnerabilities using Sound Static Analyser
• Chen and Suo, 2022, Boosting Compiler Testing via Compiler Optimization Exploration
• Aljaafari and others, 2022, Combining BMC and Fuzzing Techniques for Finding Software Vulnerabilities in Concurrent Programs
• Liu and others, 2022, Coverage-guided tensor compiler fuzzing with joint IR-pass mutation
• Zhong, 2022, Enriching Compiler Testing with Real Program from Bug Report
• Groce and others, 2022, Making no-fuss compiler fuzzing effective
• Tu and others, 2022, Remgen Remanufacturing a Random Program Generator for Compiler Testing
• Wang and others, 2022, Unleashing Coveraged-Based Fuzzing Through Comprehensive, Efficient, and Faithful Exploitable-Bug Exposing
• Kasampalis and others, 2021, Language-parametric compiler validation with application to LLVM
• Hazimeh and others, 2021, Magma A Ground-Truth Fuzzing Benchmark
• Stepanov and others, 2021, Type-Centric Kotlin Compiler Fuzzing Preserving Test Program Correctness by Preserving Types
• Xu and others, 2020, DSmith Compiler Fuzzing through Generative Deep Learning Model with Attention
• Chen and others, 2020, Enhanced compiler bug isolation via memoized search
• Kim and others, 2020, Finding Bugs in File Systems with an Extensible Fuzzing Framework
• Marcozzi and others, 2019, Compiler fuzzing how much does it matter?
• Tang and others, 2019, Compiler testing a systematic literature analysis
• Koroglu and Wotawa, 2019, Fully Automated Compiler Testing of a Reasoning Engine via Mutated Grammar Fuzzing
• Li, 2019, Haskell Compiler Testing Automation Based on Equivalence-Modulo-Inputs Method
• Jeong and others, 2019, Razzer Finding Kernel Race Bugs through Fuzzing
• Zaytsev, 2018, An industrial case study in compiler testing tool demo
• Holmes and Groce, 2018, Causal Distance-Metric-Based Assistance for Debugging after Compiler Fuzzing
• Cummins and others, 2018, Compiler fuzzing through deep learning
• Barany, 2018, Finding missed compiler optimizations by differential testing
• Chen, 2018, Learning to accelerate compiler testing
• Kargén and Shahmehri, 2018, Speeding Up Bug Finding using Focused Fuzzing
• Jay and Miller, 2018, Structured random differential testing of instruction decoders
• Julián-Iranzo and Rubio-Manzano, 2017, A sound and complete semantics for a similarity-based logic programming language
• Lidman and Svenningsson, 2017, Bridging Static and Dynamic Program Analysis using Fuzzy Logic
• Wang and others, 2017, Faster mutation analysis via equivalence modulo states
• Zhang and others, 2017, Skeletal program enumeration for rigorous compiler testing
• ISHIURA, 2016, Compiler Fuzzing
• Alatawi and others, 2016, Generating source inputs for metamorphic testing using dynamic symbolic execution
• Lidbury and others, 2015, Many-core compiler fuzzing

The calling convention itself has a literature, and it is mostly about stability

The article treats a calling convention as a design choice, which is the compiler author’s view of it. The larger literature treats it as an interface contract whose principal property is that it must not change, because every separately compiled artefact already linked against it would break. That is the sense in which adding a discriminator to the return convention is expensive, and it is a cost the cardinality argument does not see. The cardinality argument says a wider convention is available. The interface literature says a wider convention is a different convention, and that the cost of adopting it falls on everything already compiled.

Keleusma is pre-1.0 and has no external artefacts to break, so the article is right that the cost is not yet being paid. It will be, and the decision made now is the one that will be expensive to revisit.

• Zapanov, 2025, Foreign Function Interface for Managed Runtime Systems with Lightweight Threading
• Nagata and others, 2024, Evaluation of Interoperability of CNN Models between MATLAB and Python Environments Using ONNX Runtime Model
• Chichereau and others, 2024, Fully Integrated Quantum Method for Classical Register Allocation in LLVM
• Terci, 2023, A Learning-Based Coloring Algorithm for Register Allocation Problem
• Panigrahi and Karfa, 2023, An Investigation into the Security of Register Allocation with Spilling and Splitting
• Petrosino and others, 2023, Cross-Paradigm Interoperability Between Jadescript and Java
• Hammond and others, 2023, MPI Application Binary Interface Standardization
• Xiao and others, 2023, Read-Write Dependency Aware Register Allocation
• Fried and others, 2023, Register Allocation for Compressed ISAs in LLVM
• VenkataKeerthy and others, 2023, RL4ReAl Reinforcement Learning for Register Allocation
• Tant and others, 2023, Software Compilation Using FPGA Hardware Register Allocation
• De Paula and Ierusalimschy, 2022, A Foreign Function Interface for Pallene
• Chen and others, 2022, Register allocation compilation technique for ASIP in 5G micro base stations
• Hu and others, 2022, Research on global register allocation for code containing array-unit dual-usage register names
• Wu and others, 2021, Effective Register Allocation for Configurable VLIW Crypto-Processor
• Das and others, 2020, Deep Learning-based Approximate Graph-Coloring Algorithm for Register Allocation
• Doronin, 2019, PROBLEM RESEARCH AND DEVELOPMENT OF A TOOL FOR CHECKING APPLICATION BINARY INTERFACE COMPATIBILITY OF VIRTUAL METHOD TABLES
• Yallop and others, 2018, A modular foreign function interface
• Rath and others, 2018, Interoperability-Guided Testing of QUIC Implementations using Symbolic Execution
• Eisl and others, 2018, Parallel trace register allocation
• Bee and bernardo, 2018, Predicting Fork Visibility Performance on Programming Language Interoperability in Open Source Projects
• Caldwell and Chiba, 2017, Reducing calling convention overhead in object-oriented programming on embedded ARM thumb-2 platforms
• Carlotto and others, 2016, Interoperability of Annotation Schemes Using the Pepper Framework to Display AWA Documents in the ANNIS Interface
• Lozano and others, 2016, Register allocation and instruction scheduling in Unison
• Domagała and others, 2016, Register allocation and promotion through combined instruction scheduling and loop unrolling
• Burroughs, 2016, Register allocation and spilling using the expected distance heuristic
• Eisl and others, 2016, Trace-based Register Allocation in a JIT Compiler
• Sukha, 2015, A Compiler-Runtime Application Binary Interface for Pipe-While Loops
• Inoue and Kaneko, 2015, Bitwidth-aware register allocation and binding for clock period minimization
• Krause, 2015, Bytewise Register Allocation
• Ditu, 2015, Model-Based Function Call Code Generation and Stack Management in Retargetable Compilers Application Binary Interface Modeling of Stack Layout and Function Call Sequence
• Eisl, 2015, Trace register allocation
• You and Chen, 2015, Vector-aware register allocation for GPU shader processors

Static analysis supplies the vocabulary for a rule stricter than its property

The rule this article examines admits 14 of 24 chunks while the property it enforces holds for all 24, which is a soundness-preserving imprecision. The literature that names this condition, measures it and reduces it is large and the article uses only one paper from it.

The article’s position within this literature is unusual and worth being explicit about. The classical justification for an over-strict rule is that the exact property is uncomputable, so an approximation is forced. This article’s property is decidable on straight-line bytecode by summing two integers, so the imprecision is not forced and the rule is simply cruder than it needs to be. That is a better position to be in than the classical one and it is a different problem.

• Iyenghar and others, 2026, Incremental Static Analysis for Detecting and Refactoring Data Clumps in TypeScript
• Bardonek and Zachariasova, 2026, Leveraging design static analysis for vertical reuse Analytical interpretation and scalability behavior
• Negrini, 2026, Whole-value analysis by abstract interpretation
• Dimovski, 2025, Imperative Program Synthesis by Abstract Static Analysis and SMT Mutations
• Azmi, 2025, LLM-Aware Static Analysis Adapting Program Analysis to Mixed Human/AI Codebases at Scale
• Berg and others, 2025, Manim-DFA Visualising Data Flow Analysis and Abstract Interpretation Algorithms with Automated Video Generation
• Urban and others, 2025, Static analysis by abstract interpretation against data leakage in machine learning
• Simonnet and others, 2024, A Dependent Nominal Physical Type System for Static Analysis of Memory in Low Level Code
• Baek and Lee, 2024, CaLLi OCaml library for static analysis of LLVM bitcode
• Guan and Treude, 2024, Enhancing Source Code Representations for Deep Learning with Static Analysis
• Sharma and Sharma, 2024, Parameterized Static Analysis for Weak Memory Models
• Liu and others, 2024, Research on Higher-Order Operator Transformation Algorithms for Syntax Transformation-Based Model Checking
• Taft, 2024, Sound and precise static analysis using a generalization of static single assignment and value numbering
• Schnakenbeck and others, 2023, A Control Flow based Static Analysis of GRAFCET using Abstract Interpretation
• Coward and others, 2023, Combining E-Graphs with Abstract Interpretation
• Wei and others, 2023, Compiling Parallel Symbolic Execution with Continuations
• Barai and others, 2023, LLVM Static Analysis for Program Characterization and Memory Reuse Profile Estimation
• JANA, 2023, Sensitive Information Leakage Analysis of Database Code by Abstract Interpretation
• Haas and others, 2023, Static Analysis of Memory Models for SMT Encodings
• Bau and others, 2022, Abstract interpretation of Michelson smart-contracts
• Lu and others, 2022, Gradual Soundness Lessons from Static Python
• Yang and others, 2022, Simulink Model Static Analysis Results based on Abstract Interpretation
• Bartsch and others, 2021, Compositional Fault Propagation Analysis in Embedded Systems using Abstract Interpretation
• Shimchik and others, 2021, Improving Accuracy and Completeness of Source Code Static Taint Analysis
• Dimovski, 2021, Lifted termination analysis by abstract interpretation and its applications
• Punnoose, 2020, Ensuring completeness of formal verification with Gap Free Verification
• Wang and others, 2020, RSDS Getting System Call Whitelist for Container Through Dynamic and Static Analysis
• van Tonder and Le Goues, 2020, Tailoring programs for static analysis via program transformation
• Yamane and others, 2020, Verification Method of Safety Properties of Embedded Assembly Program by Combining SMT-Based Bounded Model Checking and Reduction of Interrupt Handler Executions
• Bhushan and Yadav, 2020, Verification of Virtual Machine Architecture in a Hypervisor through Model Checking
• Sato and others, 2019, Combining higher-order model checking with refinement type inference
• Meyer and Wolff, 2019, Decoupling lock-free data structures from memory reclamation for static analysis
• Blaß and Philippsen, 2019, GPU-accelerated fixpoint algorithms for faster compiler analyses
• Loring and others, 2019, Sound regular expression semantics for dynamic symbolic execution of JavaScript
• Dong, 2018, A sound abstract memory model for static analysis of C programs
• Keidel and others, 2018, Compositional soundness proofs of abstract interpreters
• Gerasimov, 2018, Directed Dynamic Symbolic Execution for Static Analysis Warnings Confirmation
• Roşu, 2018, Finite-trace linear temporal logic coinductive completeness
• Sherman, 2018, Redesigning Soot’s data-flow analysis framework for abstract interpretation
• Alkhalid and Labiche, 2018, Towards GUI Functional Verification using Abstract Interpretation
• Liang and others, 2017, Improving the precision of static analysis Symbolic execution based on GCC abstract syntax tree
• Kobayashi and others, 2017, On the relationship between higher-order recursion schemes and higher-order fixpoint logic
• Orlov, 2017, Program Source Code Static Analysis for Memory Access Error Detection Using Backwards Execution
• Kusano and Wang, 2017, Thread-modular static analysis for relaxed memory models
• Miné, 2017, Tutorial on Static Inference of Numeric Invariants by Abstract Interpretation
• Suwa and others, 2017, Verification of code generators via higher-order model checking
• Haase, 2016, Abstract Interpretation of Java Bytecode for Immutability Analysis
• Ouadjaout and others, 2016, Static analysis by abstract interpretation of functional properties of device drivers in TinyOS
• Simon and Kowalewski, 2016, Static analysis of Sequential Function Charts using abstract interpretation
• Bodin and others, 2015, Certified Abstract Interpretation with Pretty-Big-Step Semantics
• Zhang and Koutsoukos, 2015, Improving the Precision of Abstract Interpretation Based Cache Persistence Analysis
• Cousot, 2015, On Various Abstract Understandings of Abstract Interpretation
• Dong, 2015, RSTVL A Sound Abstract Memory Model for Program Static Analysis
• Montenegro and others, 2015, Space consumption analysis by abstract interpretation Reductivity properties
• Bertrane and others, 2015, Static Analysis and Verification of Aerospace Software by Abstract Interpretation
• Cousot, 2015, Verification by abstract interpretation, soundness and abstract induction

The bytecode layer is where the property is actually decidable

The backend consumes a verified bytecode, and the whole argument about stack effects lives at that level and not at the source or the machine level. The virtual-machine literature is therefore where the article’s decidability claim has to be checked, and it is also the differential oracle’s other side, since the oracle compares the virtual machine against the native code.

• Parashar and others, 2026, A Comparative Architectural and Performance Analysis of WebAssembly and JavaScript for Computationally Intensive Web Applications
• Corrias and others, 2026, An Analysis of Modern Web Security Vulnerabilities Inside WebAssembly Applications
• Israel and others, 2026, Exploring WebAssembly as a Runtime Platform for Safety-Critical Edge Systems
• I.Saetchnikov and others, 2026, Microresonator clusters for spectral analysis with machine-learning interpreter
• Hu and others, 2026, QJWasm A lightweight runtime system for efficient WebAssembly execution in resource-constrained environments
• Wu and others, 2026, Reconfigurable Computing Challenge FPGA-Based WebAssembly Stack Co-Processor
• Choi and Jeon, 2026, Stack-based static WebAssembly binary slicing and mutation for generating valid sub-binaries
• Parra, 2026, SurtGIS A high-performance raster geospatial analysis library in Rust with WebAssembly and Python support
• Blaak and Van Cutsem, 2026, Towards Least-Privilege WebAssembly Applications Transparent Interposition for WebAssembly Components
• Müller and others, 2026, WasmWeaver A Framework for Runtime-Aware WebAssembly Program Generation with Reinforcement Learning
• Massey and Olivier, 2026, WASP Stack protection for WebAssembly
• Ţălu, 2025, A Comparative Study of WebAssembly Runtimes Performance Metrics, Integration Challenges, Application Domains, and Security Features
• Stepanov and Klym, 2025, A QUANTITATIVE ANALYSIS OF WEBASSEMBLY INTEGRATION ARCHITECTURAL PATTERNS, TOOLING, AND PERFORMANCE EVALUATION
• Moskalenko, 2025, Application of WebAssembly for High-Performance Client-Side Media Content Analysis
• Watt, 2025, Concurrency in WebAssembly
• Subramanyan, 2025, CWAMR REIMAGINING A CAPABILITYBASED WEBASSEMBLY RUNTIME VIA CHERI-BASED COMPARTMENTALIZATION
• Lu and others, 2025, Detecting WebAssembly Runtime Bugs With Grammar-Guided Program Mutation
• Jiang and others, 2025, Distinguishability-Guided Test Program Generation for WebAssembly Runtime Performance Testing
• SanthiKumar and others, 2025, Enhancing Machine Learning Performance with AI-Based Virtual Machine Load Balancing
• Schlägl and Groβe, 2025, Fast Interpreter-Based Instruction Set Simulation for Virtual Prototypes
• Lei and others, 2025, Furina A Light-weight WebAssembly Runtime for ICS
• Kang and others, 2025, HybridServe Adaptive WebAssembly-Container Runtime Selection for Edge Serverless Computing
• Mallawarachchi and Jayaweera, 2025, Implementation of Wyltl An Imperative Language with a Dual Interpreter Compiler Architecture
• Marcelino and others, 2025, Lumos Performance Characterization of WebAssembly as a Serverless Runtime in the Edge-Cloud Continuum
• Kakati and Brorsson, 2025, Performance and Usability Implications of Multiplatform and WebAssembly Containers
• MIDZIC and NOVAK, 2025, Performance Comparison of WebAssembly and Phaser in Procedural Maze Generation
• Kim and others, 2025, Pre-trained Models for Bytecode Instructions
• Soluian and Lіushenko, 2025, Research of WebAssembly usage for high-performance code development in web applications
• Mao and others, 2025, Research on a Lightweight Full-Stack Edge Execution Optimization Framework Based on Serverless and WebAssembly
• Matsubara and others, 2025, Seamless Self-Healing in WebAssembly Container Orchestration with Runtime-Neutral Checkpointing
• Nakata and Matsubara, 2025, Self-Hosted WebAssembly Runtime for Runtime-Neutral Checkpoint/Restore in Edge-Cloud Continuum
• Satya Teja Muddada, 2025, Serverless 2.0 Unlocking Performance and Portability with WebAssembly
• Bhoyar and others, 2025, Sign Language Interpreter using Long Short-Term Memory LSTM
• Parwez and others, 2025, Signease Machine Learning Based Sign Language Interpreter
• Dico and Tata Sutabri, 2025, Virtual Desktop Infrastructure Sebagai Pendukung Perkuliahan Dengan Algoritma Virtual Machine
• Liu and others, 2025, WebAssembly for Container Runtime Are We There Yet?
• Karpovich and Gosudarev, 2025, WebAssembly performance in the Node.js environment
• Titzer, 2025, WebAssembly How Low Can a Bytecode Go?
• Krishnamoorthy, 2025, WEBASSEMBLY REVOLUTIONIZING WEB PERFORMANCE AND EXPANDING FRONTIERS OF BROWSER-BASED APPLICATIONS
• Heinrich and others, 2024, A Categorical Data Approach for Anomaly Detection in WebAssembly Applications
• Ménétrey and others, 2024, A Comprehensive Trusted Runtime for WebAssembly With Intel SGX
• Massidda and others, 2024, Bringing Binary Exploitation at Port 80 Understanding C Vulnerabilities in WebAssembly
• A and others, 2024, Design of Mechatronics Based Virtual Telepresence for Robotic System Using Raspberry Python Interpreter
• Silva and others, 2024, Efficient Data Exchange between WebAssembly Modules
• Bunkenburg and Wu, 2024, Making a Curry Interpreter using Effects and Handlers
• Michaud and others, 2024, Robust Stack Smashing Protection for WebAssembly
• Harnes and Morrison, 2024, SoK Analysis Techniques for WebAssembly
• Zhao and others, 2024, Wapplique Testing WebAssembly Runtime via Execution Context-Aware Bytecode Mutation
• Nikhil Sripathi Rao, 2024, WebAssembly Revolutionizing Web User Interface Development through Performance and Cross-Language Integration
• Wang and others, 2023, A Comprehensive Study of WebAssembly Runtime Bugs
• Verma and others, 2023, Array Bytecode Support in MicroJIT
• Rosà and others, 2023, Automated Runtime Transition between Virtual and Platform Threads in the Java Virtual Machine
• Park and others, 2023, Bespoke Virtual Machine Orchestrator An Approach for Constructing and Reconfiguring Bespoke Virtual Machine in Private Cloud Environment
• Zhang and others, 2023, Characterizing and Detecting WebAssembly Runtime Bugs
• Lowther and others, 2023, CHERI Performance Enhancement for a Bytecode Interpreter
• Pockstaller and others, 2023, Comparing the Energy Consumption of WebAssembly and JavaScript in Mobile Browsers
• Marcelino and Nastic, 2023, CWASI A WebAssembly Runtime Shim for Inter-function Communication in the Serverless Edge-Cloud Continuum
• He and others, 2023, Neural-FEBI Accurate function identification in Ethereum Virtual Machine bytecode
• Vepuri and Jiang, 2023, Performance Analysis of Virtual Machine Monitoring System
• Chung Seo and Kim, 2023, Portable and Efficient Implementation of CRYSTALS-Kyber Based on WebAssembly
• Rokotyanskaya and Abramov, 2023, Studying WebAssembly and comparison of its performance with JavaScript
• Johnson and others, 2023, WaVe a verifiably secure WebAssembly sandboxing runtime
• Romano and Wang, 2023, When Function Inlining Meets WebAssembly Counterintuitive Impacts on Runtime Performance
• Kovačević and others, 2022, Automatic compiler/interpreter generation from programs for Domain-Specific Languages Code bloat problem and performance improvement
• Othman and El Ghoul, 2022, BuHamad - The first Qatari virtual interpreter for Qatari Sign Language
• Kyriakou and Tselikas, 2022, Complementing JavaScript in High-Performance Node.js and Web Applications with Rust and WebAssembly
• Sahkhar and others, 2022, Efficient Cloudlet Allocation to Virtual Machine to Impact Cloud System Performance
• Lehmann and Pradel, 2022, Finding the Dwarf Recovering Precise Types from WebAssembly Binaries
• Anderton, 2022, Investigating Sign Language Interpreter Rendering and Guiding Methods in Virtual Reality 360-Degree Content
• Sai and others, 2022, Machine learning-based malware detection using stacking of opcodes and bytecode sequences
• Jodogne, 2022, Rendering Medical Images using WebAssembly
• Stiévenart and others, 2022, Static stack-preserving intra-procedural slicing of webassembly binaries
• Chmiel and Spinolo, 2022, Testing the impact of remote interpreting settings on interpreter experience and performance
• Thorpe and others, 2022, Verification of Cyber Emulation Experiments Through Virtual Machine and Host Metrics
• Menetrey and others, 2022, WaTZ A Trusted WebAssembly Runtime Environment with Remote Attestation for TrustZone
• De Macedo and others, 2022, WebAssembly versus JavaScript Energy and Runtime Performance
• Thorpe and others, 2022, WiP Verification of Cyber Emulation Experiments Through Virtual Machine and Host Metrics
• Zhang and Yin, 2021, A Virtual Machine Placement Strategy Based on Virtual Machine Selection and Integration
• Wang, 2021, Can “micro VM” become the next generation computing platform? Performance comparison between light weight Virtual Machine, container, and traditional Virtual Machine
• M and Murugesh, 2021, Comparative Study of Binary Classification Algorithms to Analyze the Students Performance on Virtual Machine
• Penev and Dimitrov, 2021, Design of a Virtual Machine for Training Compilers
• Hara and others, 2021, Machine-learning Approach using Solidity Bytecode for Smart-contract Honeypot Detection in the Ethereum
• De Macedo and others, 2021, On the Runtime and Energy Performance of WebAssembly Is WebAssembly superior to JavaScript yet?
• Menetrey and others, 2021, Twine An Embedded Trusted Runtime for WebAssembly
• -, 2021, WebAssembly for High-Performance Web Applications A Study on Execution Speed and Efficiency
• Ke and Chen, 2020, Instruction Verification of Ethereum Virtual Machine by Formal Method
• Bockisch and others, 2020, Java Bytecode Verification with OCL Why, How and Whenc
• E., 2020, Modified Support Vector Machine based Efficient Virtual Machine Consolidation Procedure for Cloud Data Centers
• Wahyudi and Miswanto, 2020, VIRTUAL MACHINE FORENSIC ANALYSIS and RECOVERY VMFAR SEBAGAI FRAMEWORK UNTUK ANALISIS BUKTI DIGITAL PADA VIRTUAL MACHINE
• Pinckney and others, 2020, Wasm/k delimited continuations for WebAssembly
• V and others, 2019, A WEIGHTED ENSEMBLE OF AUTOMATIC ALGORITHMS FOR VIRTUAL MACHINE PERFORMANCE PREDICTION IN CLOUD
• Choi and Hong, 2019, Design and implementation of virtual machine control and streaming scheme using Linux kernel-based virtual machine hypercall for virtual mobile infrastructure
• Zheng and Xia, 2019, Exploring mixed integer programming reformulations for virtual machine placement with disk anti-colocation constraints
• Cabrera Arteaga and others, 2019, Scalable comparison of JavaScript V8 bytecode traces
• Salim and others, 2019, Towards a WebAssembly standalone runtime on GraalVM
• Moliavko and others, 2019, uJVM Lightweight Java Virtual Machine for embedded systems
• Achour and others, 2018, A Constraint-Based Verification Approach for Java Bytecode Programs
• Park and others, 2018, A formal verification tool for Ethereum VM bytecode
• Liu and Li, 2018, A novel virtual machine scheduling policy based on performance prediction model
• Sohrabi and others, 2018, A Novel Virtual Machine Selection Policy for Virtual Machine Consolidation
• Kim and Lee, 2018, A Study on the Code Generator for a Virtual Machine Code based JavaScript Compiler
• Melo Alves and others, 2018, An Interference-Aware Virtual Machine Placement Strategy for High Performance Computing Applications in Clouds
• Achour and Benattou, 2018, Constraint Based Testing and Verification of Java Bytecode Programs
• Jamil, 2018, Design of a Real-Time Interpreter for Arabic Sign Language
• Attrapadung and others, 2018, Efficient Two-level Homomorphic Encryption in Prime-order Bilinear Groups and A Fast Implementation in WebAssembly
• Kuang and others, 2018, Enhance virtual-machine-based code obfuscation security through dynamic bytecode scheduling
• Yang, 2018, Formal Process Virtual Machine for Smart Contracts Verification
• Hale and others, 2018, Interpreter performance in police interviews. Differences between trained interpreters and untrained bilinguals
• Dobravec, 2018, JAVA BYTECODE INSTRUCTION USAGE COUNTING WITH ALGATOR
• V. Samuel Blessed Nayagam and Shajin Nargunam, 2018, Secure Data Verification and Virtual Machine Monitoring
• Madsen and others, 2018, Tail call elimination and data representation for functional languages on the Java virtual machine
• Sianipar and others, 2018, Virtual Machine Integrity Verification in Crowd-Resourcing Virtual Laboratory
• Kim and Lee, 2017, A Study on the Light-Weight Virtual Machine Code for IoT Virtual Machine
• Haas and others, 2017, Bringing the web up to speed with WebAssembly
• Son and others, 2017, Design and Implementation of the RSIL to LLVM IR Translator for Verification of the Intermediate Code on IoT Virtual Machine
• Lee and others, 2017, Design and implementation of the secure compiler and virtual machine for developing secure IoT services
• Lee, 2017, Exploring a relationship between students’ interpreting self-efficacy and performance triangulating data on interpreter performance assessment
• Sheinidashtegol and Galloway, 2017, Performance Impact of DDoS Attacks on Three Virtual Machine Hypervisors
• 2017, The Utilization of Cloud Computing as Virtual Machine
• 2017, Virtual Machine Consolidation using Load Balancing algorithm in Cloud Data Center
• Son and Lee, 2016, A Study on the Interpreter for the Light-Weighted Virtual Machine on IoT Environments
• 2016, Analytics of Application Resource Utilization within the Virtual Machine
• Han, 2016, Building the validity foundation for interpreter certification performance testing
• 2016, Comparative Study of Virtual Machine Migration Techniques and Challenges in Post Copy Live Virtual Machine Migration
• Cheng and others, 2016, Formalised EMFTVM bytecode language for sound verification of model transformations
• Tokumoto and others, 2016, MuVM Higher Order Mutation Analysis Virtual Machine for C
• 2016, Network-Aware Virtual Machine Placement in the Cloud
• CLERC, 2016, OCaml-Java The Java Virtual Machine as the target of an OCaml compiler
• Zhou and Mu, 2016, Representative Virtual Machine Templates An optimized virtual machine templates management mechanism for an Cloud system based on K-medoids Clustering
• O’Loughlin and Gillam, 2015, Addressing Issues of Cloud Resilience, Security and Performance through Simple Detection of Co-locating Sibling Virtual Machine Instances
• Nanthaamornphong and others, 2015, Bytecode-based class dependency extraction tool Bytecode-CDET
• Upadhyaya and Rajan, 2015, Effectively mapping linguistic abstractions for message-passing concurrency to threads on the Java virtual machine
• Gunadi, 2015, Formal Certification of Non-interferent Android Bytecode DEX Bytecode
• Salapura and Harper, 2015, High Performance Virtual Machine Recovery in the Cloud
• Pan and others, 2015, Nonvolatile main memory aware garbage collection in high-level language virtual machine
• Galloway and others, 2015, Performance Metrics of Virtual Machine Live Migration
• Ruan and Chen, 2015, Performance-to-Power Ratio Aware Virtual Machine VM Allocation in Energy-Efficient Clouds
• Salapura and Harper, 2015, Remote Restart for a High Performance Virtual Machine Recovery in a Cloud
• 2015, The Deasibility and Properties of Dividing Virtual Machine Resources using the Virtual Machine Cluster as the Unit in Cloud Computing
• Hui Zhao and others, 2015, Virtual machine placement based on the VM performance models in cloud

Types and semantics decide whether the question arises at all

The observation the article contributes is that two source forms have different trace alphabets, which is a statement about the source language’s type system before it is a statement about the backend. A language whose types separate a stream from a terminating coroutine can select the convention per form. A language whose types do not cannot, and must widen the convention globally or pay for a general mechanism. The type system is therefore the mechanism by which the choice becomes available, and the literature on what type systems can express about control effects is where the boundary of that availability is drawn.

• Arendsee, 2026, morloc a workflow language for multi-lingual programming under a common type system
• DOWNEN and ARIOLA, 2025, A contextual formalization of structural coinduction
• Baramashetru and others, 2025, A Type System for Data Privacy Compliance in Active Object Languages
• Correnson and Finkbeiner, 2025, Coinductive Proofs for Temporal Hyperliveness
• Kolesar and others, 2025, Coinductive Proofs of Regular Expression Equivalence in Zero Knowledge
• Di Lavore and others, 2025, Coinductive Streams in Monoidal Categories
• Kidney and Wu, 2025, Formalising Graph Algorithms with Coinduction
• Lee and others, 2025, React-tRace A Semantics for Understanding React Hooks An Operational Semantics and a Visualizer for Clarifying React Hooks
• Hyvernat, 2025, The Size-Change Principle for Mixed Inductive and Coinductive types
• Hyvernat, 2025, Totality for Mixed Inductive and Coinductive Types
• Dinikeev, 2025, Type system for a statically typed concatenative programming language with first class function support
• Smith and Zhang, 2024, A Pure Demand Operational Semantics with Applications to Program Analysis
• Chawla and others, 2024, COMPARATIVE STUDY OF PROPOFOL AUTO-COINDUCTION VERSUS KETAMINE PROPOFOL COINDUCTION USING PRIMING PRINCIPLE BY BISPECTRAL INDEX ANALYSIS FOR DAY CARE SURGERY
• Grabmayer, 2023, A Coinductive Reformulation of Milner’s Proof System for Regular Expressions Modulo Bisimilarity
• Francalanza and Tabone, 2023, ElixirST A session-based type system for Elixir modules
• Castagna and others, 2023, The Design Principles of the Elixir Type System
• Milano and others, 2022, A flexible type system for fearless concurrency
• Mastorou and others, 2022, Coinduction inductively mechanizing coinductive proofs in Liquid Haskell
• Sangiorgi, 2022, From enhanced coinduction towards enhanced induction
• Lambert and others, 2022, Leveraging Compiler-Based Translation to Evaluate a Diversity of Exascale Platforms
• Kanatov and Zouev, 2022, Unified type system for the modern general-purpose programing language
• Mihelic and others, 2021, A denotational semantics of a concatenative/compositional programming language
• De and others, 2021, Canonical proof-objects for coinductive programming infinets with infinitely many cuts
• Kuperberg and others, 2021, Coinductive Algorithms for Büchi Automata
• Kupke and Rot, 2021, Expressive Logics for Coinductive Predicates
• Dagnino, 2021, Foundations of regular coinduction
• Farkas and others, 2021, Improving productivity in large scale testing at the compiler level by changing the intermediate language from C++ to Java
• Sato, 2021, Proof Assistant and Type Theory
• 2020, A Fibrational Method of Indexed Coinductive Data Types
• Cassola and others, 2020, A Gradual Type System for Elixir
• Czajka, 2020, A new coinductive confluence proof for infinitary lambda calculus
• Zakowski and others, 2020, An equational theory for weak bisimulation via generalized parameterized coinduction
• Czajka, 2020, An operational interpretation of coinductive types
• Dagnino, 2020, Coaxioms flexible coinductive definitions by inference systems
• Zúñiga and Bel-Enguix, 2020, Coinductive Natural Semantics for Compiler Verification in Coq
• Abe, 2019, A type system for data independence of loop iterations in a directive-based PGAS language
• Inoue and Igarashi, 2019, A type system for first-class layers with inheritance, subtyping, and swapping
• Biernacki and others, 2019, Bisimulations for Delimited-Control Operators
• Hirschowitz, 2019, Familial monads and structural operational semantics
• Yesua and others, 2019, Keamanan Penggunaan Propofol Auto-Coinduction Dibandingkan Dengan Midazolam Coinduction Berdasarkan Perubahan Hemodinamik Pada Induksi Anestesi Pasien Yang Dilakukan General Anestesi
• Nishizaki, 2019, ML Polymorphism of Linear Lambda Calculus with First-class Continuations
• Pelsmaeker and others, 2019, Towards language-parametric semantic editor services based on declarative type system specifications
• Bosse, 2018, A Unified System Modelling and Programming Language based on JavaScript and a Semantic Type System
• Gupta and Lewis, 2018, Neural Compositional Denotational Semantics for Question Answering
• Lucanu, 2018, Proving Reachability Properties by Coinduction Extended Abstract
• Sokhatskyi and Maslianko, 2018, The systems engineering of consistent pure language with effect type system for certified applications and higher languages
• Komendantskaya and Li, 2018, Towards Coinductive Theory Exploration in Horn Clause Logic Position Paper
• Goncharov and others, 2018, Unguarded Recursion on Coinductive Resumptions
• Liu and others, 2017, Analyzing divergence in bisimulation semantics
• Aristizábal and others, 2017, Environmental Bisimulations for Delimited-Control Operators with Dynamic Prompt Generation
• Harlin and others, 2017, Impact of Using a Static-Type System in Computer Programming
• Aparanji and others, 2017, INDUCTION OF PROPOFOL WITH COINDUCTION OF PROPOFOL, MIDAZOLAM VERSUS PROPOFOL AUTO COINDUCTION- A COMPARATIVE STUDY
• Nishizaki, 2017, Linear lambda calculus with non-linear first-class continuations
• Nishizaki, 2017, Type Inference of Linear Lambda Calculus with First-Class Continuations
• Berger and Spreen, 2016, A coinductive approach to computing with compact sets
• Swierstra and others, 2016, A Lazy Language Needs a Lazy Type System
• Sculthorpe and others, 2016, A Modular Structural Operational Semantics for Delimited Continuations
• Pous, 2016, Coinduction All the Way Up
• KOZEN and SILVA, 2016, Practical coinduction
• Pattinson and Schröder, 2016, Program Equivalence is Coinductive
• Rot and others, 2016, Proving language inclusion and equivalence by coinduction
• Bruza, 2016, Syntax and operational semantics of a probabilistic programming language with scopes
• Ciaffaglione, 2016, Towards Turing computability via coinduction
• Basold and Geuvers, 2016, Type Theory based on Dependent Inductive and Coinductive Types
• Nakata and Uustalu, 2015, A Hoare logic for the coinductive trace-based big-step semantics of While
• Gan and Li, 2015, Coinduction functor in representation stability theory
• Pous, 2015, Coinductive techniques, from automata to coalgebra
• Bonchi and Pous, 2015, Hacking nondeterminism with induction and coinduction
• Schmidt-Schauß and Sabel, 2015, Improvements in a functional core language with call-by-need operational semantics

Concurrency runtimes are where the general mechanism is affordable

The callback convention holds a frame across arbitrary host execution, which is what a runtime with a scheduler does routinely and what a statically bounded artefact cannot do. The contrast is the article’s central trade seen from the other side, so the runtime literature is listed here as the case where the general answer is correct.

• Sharma and Reddy, 2025, Analysis of FreeRTOS and Contiki Scheduler Performance with Scalable Task Loads on a Uniform Platform
• Sharma, 2025, Green Threads Human Connection with Nature in Richard Powers’ The Overstory
• Zhang and others, 2025, Refactoring for Java-Structured Concurrency
• Altassan and Ahmad, 2024, Green threads of change Unravelling the gendered and experienced moderators in the sustainable symphony of green HR practices and environmental responsibility
• Sadanand Giri and others, 2024, Green threads of progress Natural fibers reshaping wastewater cleanup strategies, a review
• Kim and Park, 2023, A Multi-core Based Real-time Scheduler Supporting Periodic and Sporadic Threads and Processes
• Serafin and others, 2023, Pipestitch An energy-minimal dataflow architecture with lightweight threads
• Jagnik, 2023, Structured Concurrency in Java
• Ciesko and Roussel, 2023, User-Level Threading for HPC Applications
• Zou and others, 2022, Buddy Stacks Protecting Return Addresses with Efficient Thread-Local Storage and Runtime Re-Randomization
• Ueno and Ohori, 2022, Concurrent and parallel garbage collection for lightweight threads on multicore processors
• Shiina and others, 2021, Lightweight preemptive user-level threads
• Karsten and Barghi, 2020, User-level Threading
• Carvalho and others, 2019, A dataflow runtime environment and static scheduler for edge, fog and in-situ computing
• Iwasaki and others, 2018, Lessons Learned from Analyzing Dynamic Promotion for User-Level Threading
• Kalebe and others, 2017, A library for scheduling lightweight threads in Internet of Things microcontrollers
• Huynh and Taura, 2017, Delay Spotter A Tool for Spotting Scheduler-Caused Delays in Task Parallel Runtime Systems

The historical layer

The clusters above are drawn from work published in 2015 or later, which is the survey’s contemporary window. The older records the harvest returned are listed here in one place instead of distributed through the sections above, because for most of these clusters the pre-2015 work is the foundation the contemporary work cites rather than a competing account. There are 679 of them.

• Liu and others, 2011, Coroutine-Based Synthesis of Efficient Embedded Software From SystemC Models
• Kristensen and others, 1987, Coroutine Sequencing in BETA
• Kearns and Lou Soffa, 1983, The implementation of retention in a coroutine environment
• Bird, 1982, An implementation of a code generator specification language for table driven code generators
• Samet, 1980, A Coroutine Approach to Parsing
• Moody and Richards, 1980, A coroutine mechanism for BCPL
• Pauli and Soffa, 1980, Coroutine behaviour and implementation
• Donegan and others, 1979, A code generator generator language
• Pritchard, 1976, A proof rule for multiple coroutine systems
• Hanson, 1976, A simple variant of the boundary-tag algorithm for the allocation of coroutine environments

• Wang and Dahl, 1971, Coroutine sequencing in a block structured environment

• DOWNEN and ARIOLA, 2014, Delimited control and computational effects
• Ilik, 2014, Proofs in continuation-passing style
• Ilik, 2013, Continuation-passing style models complete for intuitionistic logic
• Ilik, 2013, Type Directed Partial Evaluation for Level-1 Shift and Reset
• Kiselyov, 2012, Delimited control in OCaml, abstractly and concretely
• Ilik, 2012, Delimited control operators prove Double-negation Shift
• Thielecke, 2012, Functional semantics of parsing actions, and left recursion elimination as continuation passing
• Kerneis and Chroboczek, 2011, Continuation-Passing C, compiling threads to events through continuations
• Yu and Haque, 2011, Decentralised web-services orchestration with continuation-passing messaging
• TARAU, 2011, The BinProlog experience Architecture and implementation choices for continuation passing Prolog and first-class logic engines
• Kameyama and Tanaka, 2010, Equational axiomatization of call-by-name delimited control
• Garcia and others, 2010, Lazy Evaluation and Delimited Control
• Santo and others, 2009, Continuation-Passing Style and Strong Normalisation for Intuitionistic Sequent Calculi
• Masuko and Asai, 2009, Direct implementation of shift and reset in the MinCaml compiler
• Garcia and others, 2009, Lazy evaluation and delimited control
• Guerrini and Masini, 2009, Proofs, tests and continuation passing style
• Yu, 2009, Scalable Services Orchestration with Continuation-Passing Messaging
• Shan, 2007, A static simulation of dynamic delimited control
• Yu and Yang, 2007, Continuation-passing enactment of distributed recoverable workflows
• Biernacki and others, 2006, A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations
• BIERNACKI and DANVY, 2006, THEORETICAL PEARL A simple proof of a folklore theorem about delimited control
• Biernacki and others, 2005, A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations
• Biernacki and others, 2005, A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations Preliminary Version
• Biernacki and Danvy, 2005, A Simple Proof of a Folklore Theorem about Delimited Control
• Asai, 2004, Offline partial evaluation for shift and reset
• Thielecke, 2003, From control effects to typed continuation passing
• Berdine and others, 2002, Linear Continuation-Passing
• Asai, 2002, Online partial evaluation for shift and reset
• Kelsey, 1995, A correspondence between continuation passing style and static single assignment form
• Hatcliff and Danvy, 1994, A generic account of continuation-passing styles
• Okasaki and others, 1994, Call-by-need and continuation-passing style
• De Bosschere and Tarau, 1994, High performance continuation passing style Prolog-to-C mapping
• Sabry and Felleisen, 1994, Is continuation-passing useful for data flow analysis?
• Sabry and Felleisen, 1993, Reasoning about programs in continuation-passing style
• Lawall and Danvy, 1993, Separating stages in the continuation-passing style transformation
• Appel and Shao, 1992, Callee-save registers in continuation-passing style
• Sabry and Felleisen, 1992, Reasoning about programs in continuation-passing style

• Appel and Jim, 1989, Continuation-passing, closure-passing style

• Lindley, 2014, Algebraic effects and effect handlers for idioms and arrows
• Bauer and Pretnar, 2014, An Effect System for Algebraic Effects and Handlers
• Wu and others, 2014, Effect handlers in scope
• Pretnar, 2014, Inferring Algebraic Effects
• Plotkin and Pretnar, 2013, Handling Algebraic Effects
• Ahman and Staton, 2013, Normalization by Evaluation and Algebraic Effects
• Brady, 2013, Programming and reasoning with algebraic effects and dependent types
• Johann and others, 2010, A Generic Operational Metatheory for Algebraic Effects
• Plotkin and Pretnar, 2008, A Logic for Algebraic Effects
• Hyland and others, 2007, Combining algebraic effects with continuations

• Power, 2006, The Universal Algebra of Computational Effects Lawvere Theories and Monads

• Wang and others, 2014, Register allocation for hybrid register architecture in nonvolatile processors
• Zhang and others, 2013, Register Allocation by Incremental Graph Colouring for Clustered VLIW Processors
• Tavares and others, 2011, Decoupled graph-coloring register allocation with hierarchical aliasing
• Colombet and others, 2011, Graph-coloring and treescan register allocation using repairing
• Lintzmayer and others, 2011, Register Allocation with Graph Coloring by Ant Colony Optimization
• Subha, 2010, A register allocation algorithm
• Tang and others, 2010, Balanced Bipartite Graph Based Register Allocation for Network Processors in Mobile and Wireless Networks
• Odaira and others, 2010, Coloring-based coalescing for graph coloring register allocation
• Subha, 2009, A Modified Linear Scan Register Allocation Algorithm
• Wang and others, 2009, Reducing Code Size by Graph Coloring Register Allocation and Assignment Algorithm for Mixed-Width ISA Processor
• Baev, 2009, Techniques for Region-Based Register Allocation
• Rong, 2009, Tree register allocation
• 2009, Tutorial on SSA-Based Register Allocation
• Falk, 2009, WCET-aware register allocation based on graph coloring
• Hong and Ramanujam, 2008, Address Register Allocation in Digital Signal Processors
• Mahajan and Ali, 2008, Hybrid evolutionary algorithm for graph coloring register allocation
• Guo and others, 2007, A Phase-Coupled Compiler Backend for a New VLIW Processor Architecture Using Two-step Register Allocation
• Wu and Li, 2007, Extending Traditional Graph-Coloring Register Allocation Exploiting Meta-heuristics for Embedded Systems
• Gao and Shi, 2005, An improved approach of register allocation via graph coloring
• Chase, 2005, Session details Register allocation
• Smith and others, 2004, A generalized algorithm for graph-coloring register allocation
• Chaitin, 2004, Register allocation and spilling via graph coloring
• Wall, 2004, Register windows vs. register allocation
• Boyapati, 2004, Session details Register allocation
• Park and others, 2001, Register Allocation for Banked Register File
• KIM and others, 2000, REGISTER ALLOCATION IN HYPER-BLOCK FOR EPIC PROCESSORS
• de Werra and others, 1999, On a graph-theoretical model for cyclic register allocation
• Zhou, 1996, Parameter passing and control stack management in Prolog implementation revisited
• Elof Frank, 1995, Constrained Register Allocation in Bus Architectures
• Jui-Ming Chang, 1995, Register Allocation and Binding for Low Power
• Eichenberger and Davidson, 1995, Register allocation for predicated code
• Briggs and others, 1994, Improvements to graph coloring register allocation
• Norris and Pollock, 1994, Register allocation over the program dependence graph
• Callahan and Koblenz, 1991, Register allocation via hierarchical graph coloring
• Nickerson, 1990, Graph coloring register allocation for processors with multi-register operands
• Wall, 1988, Register windows vs. register allocation
• Wall, 1986, Global register allocation at link time
• Larus and Hilfinger, 1986, Register allocation in the SPUR Lisp compiler
• Chaitin, 1982, Register allocation and spilling via graph coloring

• Sites, 1979, Machine-independent register allocation

• Kolek and others, 2013, Adding microMIPS backend to the LLVM compiler infrastructure
• MolinaFraticelli, 2012, Auto Code Generation for Simulink-Based Attitude Determination Control System
• Sanmorino, 2012, Development of computer assisted instruction CAI for compiler model The simulation of stack on code generation
• Inoue and others, 2011, A trace-based Java JIT compiler retrofitted from a method-based compiler
• Yi, 2011, Automated programmable control and parameterization of compiler optimizations
• Pałka and others, 2011, Testing an optimising compiler by generating random lambda terms
• Frenkel and others, 2011, Towards a Modular and Accessible Modelica Compiler Backend
• Myreen, 2010, Verified just-in-time compiler on x86
• Cordes and others, 2009, A Fast and Precise Static Loop Analysis Based on Abstract Interpretation, Program Slicing and Polytope Models
• Chen Zhao and others, 2009, Automated test program generation for an industrial optimizing compiler
• Böhme and others, 2009, HOL-Boogie-An Interactive Prover-Backend for the Verifying C Compiler
• Ly and others, 2009, Reduced Model for a PEMFC Stack Automated Code Generation and Verification
• Wagstaff and others, 2008, Automatic Code Generation for Instrument Flight Software
• Leroy, 2006, Formal certification of a compiler back-end or
• Surakka and others, 2005, Towards compiler backend optimization for low energy consumption at instruction level
• Klein and Strecker, 2004, Verified bytecode verification and type-certifying compilation
• Suganuma and others, 2003, A region-based compilation technique for a Java just-in-time compiler
• Yoshikawa and others, 2003, Random program generator for Java JIT compiler test system
• Mann, 2003, The Compiler Design Handbook Optimisation and Machine Code Generation
• Necula, 2000, Translation validation for an optimizing compiler
• ten Hagen and others, 1996, Codesign of a parallel architecture and an optimizing compiler backend SIN rete processing as a case study
• Bhasker, 1988, Implementation of an optimizing compiler for VHDL
• Fraser and Wendt, 1986, Integrating code generation and optimization
• Ching, 1986, Program analysis and code generation in an APL/370 compiler
• Powell, 1984, A portable optimizing compiler for Modula-2
• Karr, 1984, Code generation by coagulation
• Carter, 1982, Further analysis of code generation for a single register machine
• Hura, 1982, Optimization of assembly code generation in a compiler
• Cattell and others, 1979, Code generation in a machine-independent compiler
• Rudmik and Lee, 1979, Compiler design for efficient code generation and program optimization
• Couch and Hamm, 1977, Semantic Structures for Efficient Code Generation on a Stack Machine

• Painter, 1970, Effectiveness of an optimizing compiler for arithmetic expressions

• Larus, 2011, Session details Compiler correctness
• Chlipala, 2010, A verified compiler for an impure functional language
• Avigad and others, 2007, A formally verified proof of the prime number theorem
• Schneider and others, 2006, A Verified Compiler for Synchronous Programs with Local Declarations
• Brady and Hammond, 2006, A verified staged interpreter is a verified compiler
• Berghofer and Strecker, 2004, Extracting a formally verified, fully executable compiler from a proof assistant
• Rushby, 2002, Formally Verified Hardware Encapsulation Mechanism for Security, Integrity, and Safety

• Mohnen, 1997, A COMPILER CORRECTNESS PROOF FOR THE STATIC LINK TECHNIQUE BY MEANS OF EVOLVING ALGEBRAS

• Naik, 2013, Session details Compiler validation
• Tao and others, 2010, An Automatic Testing Approach for Compiler Based on Metamorphic Testing Technique
• Zaks and Pnueli, 2008, Program analysis for compiler validation
• Nair and Sarasamma, 2006, Formal Semantics of Ciset Relational Operators
• Kossatchev and Posypkin, 2005, Survey of compiler testing methods
• Jefferson and others, 1994, Ada Compiler Validation Summary Report Certificate Number 940902S1.11376. UNISYS Corporation IntegrAda for Windows NT, Version 1.0. Intel Deskside Server for Intel Pentium 60 MHz = . Intel Deskside Server with Intel Pentium 60 MHz
• Jefferson and others, 1994, Ada Compiler Validation Summary Report Certificate Number 940902S1.11377 UNISYS Corporation. IntegrAda for Windows NT, Version 1.0. Intel Deskside Server with Intel 80486DX266 = Intel Deskside Server with Intel 80486DX266
• VISTA RESEARCH CORP TUCSON AZ, 1994, Ada Compiler Validation Summary Report Certificate Number 940223W1. 11338 Green Hills Software, Inc. Green Hills Optimizing Ada Compiler, 1.8.7 SPARCstation 10 under SunOS, Release 4.1.3
• VISTA RESEARCH CORP TUCSON AZ, 1994, Ada Compiler Validation Summary Report Certificate Number 940305W1. 11335 TLD Systems, Ltd. TLD Comanche VAX/1960 Ada Compiler System, Version 4.1.1 VAX Cluster under VMS 5.5 = Tronix JIAWG Execution Vehicle i960MX under TLD Real Time Executive, Version 4.1.1
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1992, Ada Compiler Validation Procedures, Version 3.1
• Lehman, 1992, Ada Compiler Validation Support Fiscal Year 1991
• Hook and Lehman, 1992, Ada Compiler Validation Support Fiscal Year 1992
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1991, Ada Compiler Validation Summary Report Certificate Number 910612W1. 11168 Telesoft, IBM Ada/370, Version 1.2.0 without Optimization IBM 3080, V / SP HPO Rel 5.0 Unopt Host and Target
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1990, Ada Compiler Validation Procedures. Version 2.1
• Wilson, 1989, Ada Compiler Validation Capability ACVC Version 1.11 Field-Test Release . ANSI
• Wilson, 1989, Ada Compiler Validation Capability ACVC Version 1.11 Field-Test Release . ANSI, BACKUP, TAR
• Wilson, 1989, Ada Compiler Validation Capability ACVC Version 1.11 Field-Test Release . BACKUP
• Wilson, 1989, Ada Compiler Validation Capability ACVC Version 1.11 Field-Test Release . TAR
• Hook and Heilbrunner, 1989, Ada Compiler Validation Procedures
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1989, Ada Compiler Validation Procedures Version 2.0
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1989, Ada Compiler Validation Summary Report. CONVEX Computer Corporation, CONVEX Ada, Version 1.1 C210, Host and Target 890508W1.10077
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1989, Ada Compiler Validation Summary Report. Meridian Software Systems, Inc., AdaVantage, Version 3.0, IBM PS/2 Model 80 with Floating Point Co-Processor Host and Target 890405W1.10049
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1989, Ada Compiler Validation Summary Report. Verdix Corporation, VAda-110-2323, Version 5.5, Sequent Balance 8000 Host and Target , 890216W1.10029
• NATIONAL BUREAU OF STANDARDS GAITHERSBURG MD, 1989, Ada Compiler Validation Summary Report Certificate Number 880624S1. 09132, Control Data Corporation CYBER 180 Ada Compiler, Version 1.1 HOST and TARGET COMPUTER CYBER 180-930-31
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1989, Ada Compiler Validation Summary Report Certificate Number 890329I1. 10076 SYSTEAM KG, SYSTEAM Ada Compiler VAX/VMS x MC68020/05-9 Version 1.81
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1988, Ada Trade Name Compiler Validation Summary Report. Certificate Number 880620W1.09092, Encore Computer Corporation, Encore Verdix Ada Development System, Version 5.5, Encore Multimax 320
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1988, Ada Tradename Compiler Validation Summary Report Certificate Number 880201W1.09019 Verdix Corporation VAda-010-2323, Version 5.5 Sequent Balance 8000
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1988, Ada Tradename Compiler Validation Summary Report Certificate Number 880429W1.09053 Telesoft, Inc. TeleGen2 Ada Compiler for VAX/VMS to 1750A, Version 3.22 MicroVAX 2 to MIL-STD-1750A ECSPO RAID Simulator
• ADA JOINT PROGRAM OFFICE ARLINGTON VA, 1988, Ada Tradename Compiler Validation Summary Report Certificate Number 880815W1.09143 Rational VAX-VMS, Version 2.0.45 Rational R1000 Series 200 Model 20 and VAX-11/750 Host and Target
• NATIONAL BUREAU OF STANDARDS GAITHERSBURG MD, 1988, Ada Compiler Validation Summary Report Certificate Number 880708S1. 09151, SoftTech, Inc., Ada 86, Version 3.21 VAX 11/780-11/785 Host and Intel IAPX 80386R Target
• NATIONAL BUREAU OF STANDARDS GAITHERSBURG MD, 1988, Ada Compiler Validation Summary Report Certificate Number 880719S1. 09154, Naval Underwater Systems Command, ADAUYK43 ALS/N Ada/L , Version 1.0, VAX 11/785 Host and AN/UYK-43 Target
• NATIONAL BUREAU OF STANDARDS GAITHERSBURG MD, 1988, Ada Compiler Validation Summary Report Compiler Name ADE/32 Revision 3.00. Certificate Number 880527S1.09113. Host MV/20000 under AOS/VS, Revision 7.56. Target ROLM HAWK/32 under AOS/VS, Revision 7.56
• Hook, 1987, Export Control of the Ada Trade Name Compiler Validation Capability ACVC
• Dixon, 1982, A Pascal compiler testing facility
• Samet, 1977, A normal form for compiler testing
• Baird and Johnson, 1977, COBOL Compiler Validation System, 1974. Version 3.0
• Samet, 1976, Compiler testing via symbolic interpretation
• INFORMATION MANAGEMENT INC SAN FRANCISCO CA, 1970, USER’S MANUAL COBOL COMPILER VALIDATION SYSTEM

• ELECTRONIC SYSTEMS DIV HANSCOM AFB MA, 1970, USER’S MANUAL JOVIAL COMPILER VALIDATION SYSTEM

• Squire and Funkhouser, 2014, “A Bit of Code” How the Stack Overflow Community Creates Quality Postings
• Kong and others, 2014, An Overview of Worst-Case Execution Time Estimation for Embedded Programs
• Henry and others, 2014, How to compute worst-case execution time by optimization modulo theory and a clever encoding of program semantics
• Debenham and Westlake, 2014, Pre-stack depth migration for improved imaging under seafloor canyons 2D case study of Browse Basin, AustraliaFN1
• Bao and others, 2014, PWCET Power-Aware Worst Case Execution Time Analysis
• Brandner and Jordan, 2014, Refinement of worst-case execution time bounds by graph pruning
• Hardy and Puaut, 2014, Static probabilistic worst case execution time estimation for architectures with faulty instruction caches
• Kong and Chen, 2013, A Worst-Case Execution Time Analysis Approach Based on AOE Networks
• - and others, 2013, Bounding the Worst-Case Execution Time for the Fixed-Priority Preemptive Systems Based on the Preemption Points
• Freier and Jian-Jia Chen, 2013, Prioritization for real-time embedded systems on dual-core platforms by exploiting the typical- and worst-case execution times
• Wu and Zhang, 2013, Reducing worst-case execution time of hybrid SPM-caches
• Kleinsorge and others, 2013, Simple analysis of partial worst-case execution paths on general control flow graphs
• Hardy and Puaut, 2013, Static probabilistic worst case execution time estimation for architectures with faulty instruction caches
• Allamanis and Sutton, 2013, Why, when, and what Analyzing Stack Overflow questions by topic, type, and code
• Wu and Zhang, 2012, A Model Checking Based Approach to Bounding Worst-Case Execution Time for Multicore Processors
• Kong and Jiang, 2012, A Worst-case execution time analysis approach based on independent paths for ARM programs
• Whiteside and others, 2012, Directional Imaging Stack DIS for Shot Based Pre-stack Depth Migrations
• Harmon and others, 2012, Fast, Interactive Worst-Case Execution Time Analysis With Back-Annotation
• Lo and Suh, 2012, Worst-case execution time analysis for parallel run-time monitoring
• Hepp and Schoeberl, 2012, Worst-Case Execution Time Based Optimization of Real-Time Java Programs
• Zhang and others, 2011, A Case Study of Pre-stack Depth Migration Application over a Salt Dome Area
• Lu and others, 2011, A new way about using statistical analysis of worst-case execution times
• Lu and others, 2011, A trace-based statistical worst-case execution time analysis of component-based real-time embedded systems
• Zolda and others, 2011, Context-Sensitive Measurement-Based Worst-Case Execution Time Estimation
• Marref, 2011, Fully-automatic derivation of exact program-flow constraints for a tighter worst-case execution-time analysis
• Louise, 2011, Improving Branch Prediction Related WCET Abstract Interpretation
• Ermedahl and Puschner, 2011, Preface to the special issue on worst-case execution-time analysis
• Wheeler and others, 2011, Video subset selection for measurement based Worst Case Execution Time analysis
• Huber and others, 2011, Worst-case execution time analysis-driven object cache design
• Falk and Lokuciejewski, 2010, A compiler framework for the reduction of worst-case execution times
• Bartlett and others, 2010, Accurate Determination of Loop Iterations for Worst-Case Execution Time Analysis
• Kirner and others, 2010, Beyond loop bounds comparing annotation languages for worst-case execution time analysis
• Ding and Zhang, 2010, Loop-Based Instruction Prefetching to Reduce the Worst-Case Execution Time
• Wang and others, 2010, Stack Bound Inference for Abstract Java Bytecode
• Lv and others, 2010, Static worst-case execution time analysis of the μC/OS-II real-time kernel
• Schoeberl and others, 2010, Worst-case execution time analysis for a Java processor
• Zhang and Yan, 2009, Accurately Estimating Worst-Case Execution Time for Multi-core Processors with Shared Direct-Mapped Instruction Caches
• Ermedahl and others, 2009, Deriving the Worst-Case Execution Time Input Values
• Berten and others, 2009, Managing Imprecise Worst Case Execution Times on DVFS Platforms
• Kirner and others, 2009, Precise Worst-Case Execution Time Analysis for Processors with Timing Anomalies
• Mitra and Givargis, 2009, Session details Microfluidics, worst-case execution time, and cache optimization
• Hanzich and others, 2009, Subsalt Imaging through Pre-Stack Depth Migration - A Case Study from the North Red Sea
• Williams and Roger, 2009, Test generation strategies to measure worst-case execution time
• Tan, 2009, The worst-case execution time tool challenge 2006
• LEE and others, 2009, Visualization and Formalization of User Constraints for Tight Estimation of Worst-Case Execution Time
• Harmon and others, 2008, A Modular Worst-case Execution Time Analysis Tool for Java Processors
• Yan and Zhang, 2008, Analyzing the worst-case execution time for instruction caches with prefetching
• Nayvelt and Bear, 2008, Case study Anisotropic Pre-Stack Depth Migration on the Louisiana Shelf
• Bate and Kazakov, 2008, New Directions in Worst-Case Execution Time analysis
• Kirner and Puschner, 2008, Obstacles in Worst-Case Execution Time Analysis
• Hunt and others, 2008, Using global data flow analysis on bytecode to aid worst case execution time analysis for real-time Java programs
• Ferdinand and Heckmann, 2008, Worst-Case Execution Time - A Tool Provider’s Perspective
• Mohan, 2008, Worst-case execution time analysis of security policies for deeply embedded real-time systems
• Harmon and Klefstad, 2007, A Survey of Worst-Case Execution Time Analysis for Real-Time Java
• Ji and others, 2007, Automated Worst-Case Execution Time Analysis Based on Program Modes
• Aissa and others, 2007, Bringing Worst Case Execution Time Awareness to an Open Smart Card OS
• Nemer and others, 2007, Improving the Worst-Case Execution Time Accuracy by Inter-Task Instruction Cache Analysis
• Harmon and Klefstad, 2007, Interactive Back-annotation of Worst-case Execution Time Analysis for Java Microprocessors
• Kirner and Schoeberl, 2007, Modeling the Function Cache for Worst-Case Execution Time Analysis
• Kaestner, 2007, Safe worst-case execution time analysis by abstract interpretation of executable code
• Harmon and Klefstad, 2007, Toward a Unified Standard for Worst-Case Execution Time Annotations in Real-Time Java
• Auchterlonie and others, 2007, Velocity Model Building for Pre-Stack Depth Migration - An Onshore Libya Case Study
• Choi and Han, 2006, Optimal register reassignment for register stack overflow minimization
• Gustafsson, 2006, The Worst Case Execution Time Tool Challenge 2006
• Plasterie and Chagalov, 2006, Wave Equation versus Kirchhoff pre-stack depth migration algorithms ? An Australian case study
• Jong-In Lee and others, 2005, A Hybrid Framework of Worst-Case Execution Time Analysis for Real-Time Embedded System Software
• Egreteau and Thierry, 2005, Attenuating the Effects of Pre-Stack Depth Migration for AVA Analysis
• Ritchie and others, 2005, Challenges and opportunities in pre-stack depth imaging of legacy seismic data an overthrust belt case study
• Park and others, 2005, Implementation of Worst Case Execution Time Analysis Tool For Embedded Software based on XScale Processor
• Askim and others, 2004, 4D Seismic Analysis Using Pre Stack Depth Migration
• Schuele and Schneider, 2004, Abstraction of assembler programs for symbolic worst case execution time analysis
• Corti and Gross, 2004, Approximation of the worst-case execution time using structural analysis
• Tadepalli and others, 2003, 3D pre-stack depth imaging and well ties A case history of depth imaging in Gulf of Mexico
• Reshef and Roth, 2003, Anisotropy Corrections after Pre-Stack Depth Migration
• Ermedahl and others, 2003, Clustered calculation of worst-case execution times
• L. Freitas da Luz and C. Ribeiro Cruz, 2003, The CRS stack as a tool for pre-stack depth migration
• Engblom and others, 2003, Worst-case execution-time analysis for embedded real-time systems
• 2002, 3D Pre-Stack Depth Migration V0 Analysis and Monte Carlo Automatic Velocity Picking in Depth
• Blieberger, 2002, Data-Flow Frameworks for Worst-Case Execution Time Analysis
• Morford, 2001, Analysis Of The Effects Of Varying The Anti - Alias Filter In Kirchoff Pre- Stack Depth Migration
• Lemaistre and others, 2001, Automatic and Continuous Image Gather Analysis after Pre-Stack Depth Migration
• Hanitzsch and others, 2001, Pre-Stack Depth Migration for Time-to-Depth Conversion - the Ultimate Tool?
• Petkovski and Bradey, 2001, The success of pre-stack depth migration over the Anama structure in the Papuan Foreland Basin, PNG a case history
• Morford, 2000, A case study Using 3d pre-stack depth migration to image sub-salt sediments and fault zones in Marbella, Mexico
• Bernat and Burns, 2000, An Approach to Symbolic Worst-Case Execution Time Analysis
• Stappert and Altenbernd, 2000, Complete worst-case execution time analysis of straight-line hard real-time programs
• Allen and others, 2000, Subsalt Imaging using 3D Pre-Stack Depth Migration in the UK Southern North Sea - a Case History
• Sen and others, 2000, Velocity analysis using pre-stack depth migration and 3D tomogrphy A case study over steeply dipping salt
• Colin and Puaut, 2000, Worst Case Execution Time Analysis for a Processor with Branch Prediction
• Morford, 1999, A Case Study Using 3D Pre-Stack Depth Migration To Improve The Sub-Salt Image In Marbella, Mexico, Gulf Of Mexico
• Oates and others, 1998, The Application of Pre-Stack Depth Migration using Topographic Analysis to Aid in the
• Puschner, 1998, Worst-case execution-time analysis at low cost
• Puschner, 1997, Worst-Case Execution Time Analysis at Low Cost
• Shih and Chen, 1996, Iterative Pre-Stack Depth Migration With Velocity Analysis
• Boding, 1996, Pre-stack depth migration in three dimensions with the imaging wave machine
• Levy, 1996, Should caches be split or shared? Analysis using the superposition of bursty stack depth processes
• Roberts, 1995, 3D Post Stack Depth Migration in the UK Southern North Sea - a Case Study
• Nilsen and Rygg, 1995, Worst-case execution time analysis on modern processors
• Wenes and others, 1994, A Practical implementation of a 3D pre-stack depth migration algorithm
• Jyh-Charn Liu and Hung-Ju Lee, 1994, Deterministic upperbounds of the worst-case execution times of cached programs
• C. Robinson and others, 1994, Prospect definition by pre-stack depth migration of a grid of seismic lines - A case history
• P. Jeannot and Berranger, 1994, Ray-mapped focusing - A migration velocity analysis for Kirchoff pre-stack depth imaging
• P. Jeannot, 1994, Robust Kirchhoff pre-stack depth imaging with semi-gridded rays
• Hinkley and others, 1994, Velocity Model Building for 3D Pre-Stack Depth Migration - a Case Study
• Landa and Sorin, 1993, Fast pre-stack depth migration by CRP stacking
• R. Granli, 1993, Imaging salt with pre-stack depth migration
• Zhang and others, 1993, Pipelined processors and worst case execution times
• Cabrera and others, 1992, 3-D Pre-Stack Depth Migration Implementation and Case History
• J. Berkhout, 1992, True amplitude aspects of pre-stack depth migration
• G. Western and Ball, 1991, 3D Pre-stack depth migration in the Gulf of Sueza. A case history

• Tarjan, 1985, Amortized Computational Complexity

• Cousot and Cousot, 2014, A galois connection calculus for abstract interpretation
• Gao and others, 2014, A Method of Binary Code Variable Interval Analysis Based on Abstract Interpretation
• Ravanbakhsh and Sankaranarayanan, 2014, Infinite horizon safety controller synthesis through disjunctive polyhedral abstract interpretation
• Chudnov and others, 2014, Information Flow Monitoring as Abstract Interpretation for Relational Logic
• Kowalewski and others, 2013, Model checking and abstract interpretation as building blocks of advanced program analysis techniques
• Genaim and Zanardini, 2013, Reachability-based acyclicity analysis by Abstract Interpretation
• Ranzato, 2013, Session details Abstract interpretation
• Anderson and Loginov, 2013, Static analysis of machine code for supply-chain risk management
• Cousot and Cousot, 2012, An abstract interpretation framework for termination
• Chaumette and others, 2011, Automated extraction of polymorphic virus signatures using abstract interpretation
• Cousot and Cousot, 2011, Grammar semantics, analysis and parsing by abstract interpretation
• Hua and others, 2010, Model-Based Intrusion Detection by Abstract Interpretation
• Bertrane and others, 2010, Static Analysis and Verification of Aerospace Software by Abstract Interpretation
• Blanc and Kadobayashi, 2010, Towards revealing JavaScript program intents using abstract interpretation
• De Francesco and others, 2010, Using abstract interpretation to add type checking for interfaces in Java bytecode verification
• Giacobazzi, 2008, Abstract Interpretation in Code Security
• Bernardeschi and others, 2008, Decomposing bytecode verification by abstract interpretation
• Anier, 2008, Motion recognition with abstract interpretation and HMM
• LI, 2008, Program Verification Techniques Based on the Abstract Interpretation Theory
• Di Pierro and others, 2008, Relational Analysis and Precision via Probabilistic Abstract Interpretation
• Musumbu, 2008, Static Checking by Means of Abstract Interpretation
• Cortesi, 2008, Widening Operators for Abstract Interpretation
• Seo and others, 2007, Goal-directed weakening of abstract interpretation results
• Feret and others, 2007, Reachability Analysis of Biological Signalling Pathways by Abstract Interpretation
• 2007, The Role of Abstract Interpretation in Formal Methods
• Henriksen and Gallagher, 2006, Abstract Interpretation of PIC Programs through Logic Programming
• Christodorescu and Jha, 2006, Static Analysis of Executables to Detect Malicious Patterns
• Dalla Preda and Giacobazzi, 2005, Control code obfuscation by abstract interpretation
• Bayley and Shiel, 2005, JVM Bytecode Verification Without Dataflow Analysis
• Leuschel, 2004, A framework for the integration of partial evaluation and abstract interpretation of logic programs
• Basin and others, 2003, Bytecode Verification by Model Checking
• Cousot and Cousot, 2002, Systematic design of program transformation frameworks by abstract interpretation
• Cousot and Cousot, 2001, A Case Study in Abstract Interpretation Based Program Transformation
• Schmidt, 2000, Abstract interpretation and program modelling
• Baggett, 2000, An Abstract Interpretation of the Wavelet Dimension Function Using Group Representations
• Qian, 2000, Standard fixpoint iteration for Java bytecode verification
• Cousot and Cousot, 2000, Temporal abstract interpretation
• Huch, 1999, Verification of Erlang programs using abstract interpretation and model checking
• Dams and others, 1997, Abstract interpretation of reactive systems
• Cortesi and others, 1997, Complementation in abstract interpretation
• Debray, 1995, Abstract interpretation and low-level code optimization
• Cousot and Cousot, 1995, Formal language, grammar and set-constraint-based program analysis by abstract interpretation
• Deutsch, 1995, Semantic models and abstract interpretation techniques for inductive data structures and pointers
• Monsuez, 1995, Using abstract interpretation to define a strictness type inference system
• Marriott and others, 1994, Denotational abstract interpretation of logic programs
• Le Charlier and Van Hentenryck, 1994, Experimental evaluation of a generic abstract interpretation algorithm for PROLOG
• Mycroft, 1993, Completeness and predicate-based abstract interpretation
• Coppo and Ferrari, 1993, Type inference, abstract interpretation and strictness analysis
• Muller and Zhou, 1992, Abstract interpretation in weak powerdomains
• Palsberg and Schwartzbach, 1992, Binding Time Analysis Abstract Interpretation vs. Type Inference
• Janssens and Bruynooghe, 1992, Deriving descriptions of possible values of program variables by means of abstract interpretation
• Cortesi and Filé, 1991, Abstract interpretation of logic programs
• McNerney, 1991, Verifying the correctness of compiler transformations on basic blocks using abstract interpretation
• Burn, 1990, A relationship between abstract interpretation and projection analysis
• Nielson, 1988, Strictness analysis and denotational abstract interpretation

• Nielson, 1987, Strictness analysis and denotational abstract interpretation

• Hu and Zhao, 2014, Analysis on Process Code schedule of Android Dalvik Virtual Machine
• Mamdouh and others, 2014, On-demand distributed on-card bytecode verification
• Jiang and Li, 2014, Using Contour Marking Bytecode Verification Algorithm on the Java Card
• You and Lu, 2012, A markup language for java bytecode
• Kim and others, 2012, Generating Verification Conditions from BIRS Code using Basic Paths for Java Bytecode Verification
• Santone, 2011, Clone detection through process algebras and Java bytecode
• Male and others, 2011, Formalisation and implementation of an algorithm for bytecode verification of @NonNull types
• Haikun Liu and others, 2011, Live Virtual Machine Migration via Asynchronous Replication and State Synchronization
• DONG and others, 2011, Logic System for Bytecode Program Modular Certification
• Moret and others, 2011, Polymorphic bytecode instrumentation
• Bauml and Brada, 2011, Reconstruction of Type Information from Java Bytecode for Component Compatibility
• Chen and others, 2010, Implementation of Bytecode-based Software Watermarking for Java Programs
• 2010, JSIMIL - A Java Bytecode Clone Detector
• Rudolph and Thiemann, 2010, Mnemonics type-safe bytecode generation at run time
• DeVries and others, 2009, ActionScript bytecode verification with co-logic programming
• DeVries and others, 2009, ActionScript bytecode verification with co-logic programming abstract only
• Chi and others, 2009, An Improved Bytecode Verification Algorithm on Java Card
• Chen and others, 2009, Bytecode Generation for XQuery Compiler
• Gal and others, 2008, Java bytecode verification via static single assignment form
• Bavera and Bonelli, 2008, Type-based information flow analysis for bytecode languages with variable object field policies
• Shi and others, 2008, Virtual machine showdown
• Liu, 2007, Bytecode Verification for Enhanced JVM Access Control
• Huynh and Roychoudhury, 2007, Memory model sensitive bytecode verification
• Huang and others, 2006, Adaptiveness in well-typed Java bytecode verification
• Burdy and Pavlova, 2006, Java bytecode specification and verification
• Bernardeschi and others, 2006, Using Control Dependencies for Space-Aware Bytecode Verification
• Gal and others, 2005, Integrated Java Bytecode Verification
• Kot and Kozen, 2005, Kleene Algebra and Bytecode Verification
• Klohs and Kastens, 2005, Memory Requirements of Java Bytecode Verification on Limited Devices
• Hansen and Siveroni, 2005, Towards Verification of Well-Formed Transactions in Java Card Bytecode
• Klein, 2005, Verified Java Bytecode Verification Verified Java Bytecode Verification
• Bernardeschi and others, 2004, Checking secure information flow in Java bytecode by code transformation and standard bytecode verification
• Peng and others, 2004, Code sharing among states for stack-caching interpreter
• Barbuti and Cataudella, 2004, Java bytecode verification on Java cards
• Siveroni, 2004, Operational semantics of the Java Card Virtual Machine
• Coglio, 2004, Simple verification technique for complex Java bytecode subroutines
• Freund and Mitchell, 2003, A Type System for the Java Bytecode Language and Verifier
• Coglio, 2003, Improving the official specification of Java bytecode verification
• Nipkow, 2003, Java Bytecode Verification
• Avvenuti and others, 2003, Java bytecode verification for secure information flow
• Leroy, 2003, Java Bytecode Verification Algorithms and Formalizations
• Rose, 2003, Lightweight Bytecode Verification
• Leroy, 2002, Bytecode verification on Java smart cards
• Barbuti and others, 2002, Fixing the Java bytecode verifier by a suitable type domain
• Knoblock and Rehof, 2001, Type elaboration and subtype completion for Java bytecode
• Klein and Nipkow, 2001, Verified lightweight bytecode verification
• Knoblock and Rehof, 2000, Type elaboration and subtype completion for Java bytecode
• O’Callahan, 1999, A simple, comprehensive type system for Java bytecode subroutines
• Stata and Abadi, 1999, A type system for Java bytecode subroutines
• Freund and Mitchell, 1999, A type system for object initialization in the Java bytecode language
• Goldberg, 1998, A specification of Java loading and bytecode verification
• Stata and Abadi, 1998, A type system for Java bytecode subroutines
• Freund and Mitchell, 1998, A type system for object initialization in the Java bytecode language
• Freund and Mitchell, 1998, A Type System for Object Initialization In the Java Bytecode Language summary
• Shih, 1998, An operational semantic approach to continuation style interpreter of logic programs

• Hoskins, 1988, The design and implementation of a Karel compiler and interpreter

• Gundersen and others, 2013, Atomic Lambda Calculus A Typed Lambda-Calculus with Explicit Sharing
• Liu and others, 2013, Linking Algebraic Semantics and Operational Semantics for Web Services Using Maude
• Zhu and others, 2012, Linking operational semantics and algebraic semantics for a probabilistic timed shared-variable language
• Wang and Zhu, 2011, Animating the Approach of Deriving Operational Semantics from Algebraic Semantics for Web Services
• Colvin and Hayes, 2011, Structural operational semantics through context-dependent behaviour
• Zhu and others, 2009, Animating the Link Between Operational Semantics and Algebraic Semantics for a Probabilistic Timed Shared-Variable Language
• Vu, 2008, Denotational semantics for thread algebra
• Zhu and others, 2008, From algebraic semantics to denotational semantics for Verilog
• Yang and Duan, 2008, Operational semantics of Framed Tempura
• Zhu and others, 2007, Algebraic Approach to Operational Semantics and Observation-Oriented Semantics for a Timed Shared-Variable Language with Probability
• Edalat and Pattinson, 2007, Denotational semantics of hybrid automata
• Verdejo and Martí-Oliet, 2006, Executable structural operational semantics in Maude
• 2004, A structural approach to operational semantics
• Popeea and Chin, 2004, A type system for resource protocol verification and its correctness proof
• Aceto and Fokkink, 2004, Guesteditors’introduction Specialissueon Structural Operational Semantics
• Mosses, 2004, Modular structural operational semantics
• PLOTKIN, 2004, The origins of structural operational semantics
• Zhu, 2001, Denotational semantics of programming languages and compiler generation in PowerEpsilon
• Puchol and others, 1998, An Operational Semantics and Compiler for Real-Time Specifications1
• Royer, 1986, Transformations of denotational semantics in semantics directed compiler generation
• Mazaher and Berry, 1985, Deriving a compiler from an operational semantics written in VDL
• Clinger, 1984, The scheme 311 compiler an exercise in denotational semantics
• Raskovsky, 1982, Denotational semantics as a specification of code generators
• Bodwin and others, 1982, Experience with an experimental compiler generator based on denotational semantics

• Jones, 1980, Compiler Generation from Denotational Semantics

• Zhu and others, 2009, Locality-Based Normal Form Approach to Linking Algebraic Semantics and Operational Semantics for an Event-Driven System-Level Language

• Shukla and others, 2014, A Formal Approach to the Provably Correct Synthesis of Mission Critical Embedded Software for Multi Core Embedded Platforms
• Son and others, 2014, A Reversing Technique for Symbol Table Verification on Compiler Constructions
• Wang and Yang, 2014, Applied Technology in Front-End Implementation of Tiger Compiler Using Hacs Language
• Pathiran and Prakash, 2014, Design and implementation of a model-based PI-like control scheme in a reset configuration for stable single-loop systems
• Matsikoudis and Stergiou, 2014, First Draft of the act Programming Language
• Xu and Zhang, 2014, Formal verification of software safety criteria using Event-B
• Poonguzhali and Vinodha, 2014, IMPLEMENTATION OF ANTI-RESET WINDUP SCHEME IN PI CONTROLLER FOR SPHERICAL TANK PROCESS
• Balu and Saraswathi, 2014, Implementation of SAAS Compiler in Intranet
• Krebs and Schmitz, 2014, Jaccie A Java-based compiler-compiler for generating, visualizing and debugging compiler components
• Odegard and others, 2014, Model-Based GN and C Simulation and Flight Software Development for Orion Missions beyond LEO
• Radonić and others, 2014, One solution of loop invariant code motion compiler optimisation
• Keaton and Seacord, 2014, Performance of Compiler-Assisted Memory Safety Checking
• Abdulsalam and others, 2014, Program energy efficiency The impact of language, compiler and implementation choices
• Radooevii and Magdalenii, 2014, Python Implementation of Source Code Generator Based on Dynamic Frames
• Hussain and others, 2014, RUGRAT Evaluating program analysis and testing tools and compilers with large generated random benchmark applications
• Tardieu, 2014, Session details Compiler optimizations
• Boldo and others, 2013, A Formally-Verified C Compiler Supporting Floating-Point Arithmetic
• Kistel and Vandenhouten, 2013, A metamodel-based ASN.1 editor and compiler for the implementation of communication protocols
• Saraf and Dashora, 2013, An Optimal Code Heuristic Approach for Compiler Optimization using Graph Coloring Technique
• Gorringe and Jain, 2013, Architectural considerations for implementation of the ATML standards in an open systems architecture runtime environment OSA-RTS using a graphical environment
• Dong, 2013, Design and Implementation of Compiler Subsystem for Object Oriented Publish/Subscribe Systems
• Schwaab and Siek, 2013, Modular type-safety proofs in Agda
• Barash and Shchur, 2013, RNGSSELIB Program library for random number generation. More generators, parallel streams of random numbers and Fortran compatibility
• Chatterjee, 2013, Runtime Systems for Extreme Scale Platforms
• Dejtrakulwong and others, 2013, Sensitivity analysis and cascaded interpretation scheme for subtle seismic signatures in thin shaly-sand reservoirs
• Bond, 2013, Session details Garbage collection, runtime, and cache management
• 2012, A Compositional Scheme and Framework for Safety Critical Systems Verification
• Nair, 2012, A Formal Semantics for Ciset and Ciset Relation Operators
• Pike and others, 2012, Experience Report A Do-It-Yourself High-Assurance Compiler
• Grechanik, 2012, Random benchmark application generation for evaluating program analysis and testing tools
• Aung and others, 2011, Compiler-assisted technique for rapid performance estimation of FPGA-based processors
• Schliephake and others, 2011, Design and Implementation of a Runtime System for Parallel Numerical Simulations on Large-Scale Clusters
• Agathos and others, 2011, Design and Implementation of OpenMP Tasks in the OMPi Compiler
• Bansal and Singh, 2011, Dual Stack Implementation of Mobile IPv6 Software Architecture
• Magdalenić and others, 2011, Implementation Model of Source Code Generator
• Zaitsev and Guliaiev, 2011, Stack E6 and Its Implementation within Linux Kernel
• Larkins and Jones, 2011, Targeting FPGA-based processors for an implementation-driven compiler construction course
• Snavely, 2011, Test and Evaluation of Architecture-Aware Compiler Environment
• Jiang and others, 2010, A Debugging Approach for Java Runtime Exceptions Based on Program Slicing and Stack Traces
• Eachempati and others, 2010, An open-source compiler and runtime implementation for Coarray Fortran
• Manjunath, 2010, Colored Steganography Implementation Scheme of Images using Transform Technique
• Chalin, 2010, Engineering a Sound Assertion Semantics for the Verifying Compiler
• Rosenblum and others, 2010, Extracting compiler provenance from program binaries
• Orlic, 2010, Implementation by capture with executable UML
• Jiang and Yan, 2010, Implementation of Static Web-Pages Generator Using JavaScript
• Desai, 2009, A Novel Technique for Orchestration of Compiler Optimization Functions Using Branch and Bound Strategy
• Rodríguez and others, 2009, CPPC a compiler-assisted tool for portable checkpointing of message-passing applications
• Canedo and others, 2009, Design and implementation of a queue compiler
• Denney and Fischer, 2009, Generating Code Review Documentation for Auto-Generated Mission-Critical Software
• Hiroyuki, 2009, Idiom Recognition and Program Scheme Recognition Based Program Transformations for Performance Tuning–Beyond Compiler Optimizations
• Oiwa, 2009, Implementation of the memory-safe full ANSI-C compiler
• Pasareanu and others, 2009, Model Based Analysis and Test Generation for Flight Software
• Seshia and Rakhlin, 2009, Quantitative Analysis of Embedded Software Using Game-Theoretic Learning
• Reb and others, 2008, A JML Compiler Based on AspectJ
• Bushnell and others, 2008, Automatic Testcase Generation for Flight Software
• YU, 2008, Design and implementation of NC code compiler based on ANTLR
• Leinenbach and Petrova, 2008, Pervasive Compiler Verification From Verified Programs to Verified Systems
• Zanardini, 2008, The Semantics of Abstract Program Slicing
• Lucchi and Mazzara, 2007, A pi-calculus based semantics for WS-BPEL
• Chalin, 2007, A Sound Assertion Semantics for the Dependable Systems Evolution Verifying Compiler
• Bohnet and Dollner, 2007, CGA Call Graph Analyzer - Locating and Understanding Functionality within the Gnu Compiler Collection’s Million Lines of Code
• Chen and others, 2007, Design of a Certifying Compiler Supporting Proof of Program Safety
• TOKUMORI and others, 2007, Development of Metadata Generation Support System Using Compiler Compiler
• de Niz, 2007, Diagrams and Languages for Model-Based Software Engineering of Embedded Systems UML and AADL
• Dubach and others, 2007, Fast compiler optimisation evaluation using code-feature based performance prediction
• Costagliola and others, 2007, Visual language implementation through standard compiler-compiler techniques
• Heimbigner, 2006, A Tamper-Resistant Programming Language System
• Butterfield and Woodcock, 2006, A “Hardware Compiler” Semantics for Handel-C
• Azeemi, 2006, Compiler Directed Battery-Aware Implementation of Mobile Applications
• Bicarregui and others, 2006, The verified software repository a step towards the verifying compiler
• Sadat, 2005, A Compiler Driven Simulation Technique for the Analysis of Digital Logic Circuit
• Guyer and Lin, 2005, Broadway A Compiler for Exploiting the Domain-Specific Semantics of Software Libraries
• 2005, Fifth IEEE International Workshop on Source Code Analysis and Manipulation
• Denney and Fischer, 2005, Formal Safety Certification of Aerospace Software
• Xia and DiVito, 2005, Software Certification for Temporal Properties With Affordable Tool Qualification
• Shin and others, 2004, AIRES Automatic Integration of Reusable Embedded Software, Methodologies, Toolkit, and Experiments
• 2004, Fourth IEEE International Workshop on Source Code Analysis and Manipulation
• Amarasinghe, 2004, Session details Compiler and simulator construction
• Necula and Lee, 2004, The design and implementation of a certifying compiler
• Pla, 2004, Weapon System Software Technology Support WSSTS . Delivery Order 0008 Real-Time Java for Embedded Systems RTJES
• Dold and others, 2003, A Completely Verified Realistic Bootstrap Compiler
• 2003, ART An Implementation on the Active_object RunTime Systems Applicable for the Embedded Systems
• 2003, Proceedings Third IEEE International Workshop on Source Code Analysis and Manipulation
• Uh, 2003, Session details Compiler optimizations
• Hsu and Kremer, 2003, The design, implementation, and evaluation of a compiler algorithm for CPU energy reduction
• League, 2002, A Type-Preserving Compiler Infrastructure
• Goos, 2002, Compiler Verification and Compiler Architecture
• 2002, Proceedings Second IEEE International Workshop on Source Code Analysis and Manipulation
• Orlitsky, 2002, Scalar versus vector quantization worst case analysis
• Kandemir, 2001, A compiler technique for improving whole-program locality
• Zendra and Colnet, 2001, Coping with aliasing in the GNU Eiffel Compiler implementation
• Kennedy and Syme, 2001, Design and implementation of generics for the .NET Common language runtime
• MacMillen, 2001, Nimble Compiler Environment for Agile Hardware. Volume 1
• Calzarossa and others, 2001, Performance issues of an HPF-like compiler
• Auguston and others, 2001, Visual Meta-Programming Language
• Lin and Padua, 2000, Compiler analysis of irregular memory accesses
• Havelund and others, 2000, Formal Analysis of the Remote Agent Before and After Flight
• Orr and Henderson, 2000, Space Shuttle Software Development and Certification
• Frigo, 1999, A fast Fourier transform compiler
• van Deursen, 1999, Modern Compiler Implementation in Java
• Nielsen, 1998, Compiler Support for Message Passing Systems
• 1998, Compiler technology Tools, translators and language implementation
• Stöhr and O’Boyle, 1998, First Fast Sink A compiler algorithm for barrier placement optimisation
• 1998, Modern compiler implementation in Java Revised and expanded edition
• Haspert and Beauregard, 1998, The Commercialization of a Rapid Prototyping Development Tool for Real-Time Embedded Software Intensive, Process, and Resource Management Systems
• Necula and Lee, 1998, The design and implementation of a certifying compiler
• Nielsen, 1997, Compiler Support for Message Passing Systems
• Stoonkisto and Subhlok, 1997, Coordinating Foreign Modules with a Parallelizing Compiler
• Kelly, 1997, Formal Methods Specification and Analysis Guidebook for the Verification of Software and Computer Systems Volume II A Practitioner’s Companion
• 1997, Modern compiler implementation in C Basic techniques
• 1997, Modern compiler implementation in Java Basic techniques
• 1997, Modern compiler implementation in ML Basic techniques
• Cousot, 1997, Program analysis
• Pratt, 1997, Second Calculus of Binary Relations as a Concurrent Programming Language
• Badler, 1996, A Task Networking and Visual Programming Language for Jack
• Ferrante and Allard, 1996, Introducing a CPS style optimizer into an existing compiler
• Cousot, 1996, Program analysis
• Evansi and Sulaiman, 1996, Solving optimisation problems using neucomp-a neural network compiler
• Porcher, 1995, Benchmarking the POMPC compiler on the Connection Machine CM-2
• 1995, Formal Methods Specification and Analysis Guidebook for the Verification of Software and Computer Systems A Practitioner’s Companion - Volume 2
• 1995, Formal Methods Specification and Verification Guidebook for Software and Computer Systems Planning and Technology Insertion - Volume 1
• Graham, 1995, Information Technology. Programming Language. The SQL Ada Module Description Language SAMeDL
• Davenport, 1995, Object-Oriented Visual Programming Language. Phase 1
• Ertl, 1995, Stack caching for interpreters
• Oliva and others, 1995, The VLISP verified PreScheme compiler
• Brodersen, 1994, Anatomy of a Silicon Compiler
• Chi, 1994, Compiler Optimization Technique for Data Cache Prefetching Using a Small CAM Array
• Atapattu, 1994, Design of a Parallel Object Oriented Programming Language
• Surati, 1993, A Parallelizing Compiler Based on Partial Evaluation
• Rogers, 1993, Ada Embedded Computer Software Support AECSS
• Plishka and Ifarraguerri, 1993, Evaluation of Alsys 037 Ada Compiler
• Butler and Johnson, 1993, Formal Methods for Life-Critical Software
• Bailin and others, 1993, Model-based reasoning for system and software engineering The Knowledge From Pictures KFP environment
• Gaál, 1993, Parallel compiler generation
• Herring and others, 1993, Research in Presistent Simulation Development of the Persistent ModSim Object-Oriented Programming Language
• Consel and Cheng Khoo, 1993, Semantics-directed generation of a prolog compiler
• Ching and Katz, 1993, The testing of an APL compiler
• Mary-Anne K Posenau, 1993, Unstructured Grid Generation Techniques and Software
• Hoang and Rabaey, 1992, A compiler for multiprocessor DSP implementation
• Harper and Pfenning, 1992, A Module System for a Programming Language Based on the LF Logical Framework
• Russinoff, 1992, A verified prolog compiler for the Warren Abstract Machine
• Ooashi and others, 1992, ASL program written in abstract sequential machine style and its compiler
• Palsberg, 1992, Provably Correct Compiler Generation
• Gifford and others, 1992, Report on the FX-91 Programming Language
• Schmitz, 1992, The visual compiler-compiler SIC abstract
• Leavitt and Terrell, 1991, Ada Compiler Evaluation Capability
• Leavitt and Terrell, 1991, ADA Compiler Evaluation Capability User’s Guide, Release 2.0
• Leavitt and Terrell, 1991, Ada Compiler Evaluation Capability. Release 2.0
• Hird, 1991, Formal specification and verification of Ada software
• Lane and Poorman, 1991, Preserving software investment using new fortran compiler technology
• Shivers, 1991, The semantics of Scheme control-flow analysis
• Ramkumar and Kale, 1990, A Chare kernel implementation of a parallel Prolog compiler
• Wilson, 1990, Ada/Ed Compiler, Version 1.10 UNIX
• Wilson, 1990, Ada/Ed Compiler, Version 1.10 VAX
• Gupta, 1990, An Incremental Type Inference System for the Programming Language Id
• Heuring and others, 1990, Automatic Compiler Construction
• Liangliang and Yungui, 1990, Clause representations in a compiler-based prolog database
• Giorgi and Le Métayer, 1990, Continuation-based parallel implementation of functional programming languages
• Sharp, 1990, Pythia A Parallel Compiler for Delirium
• Rosing and others, 1990, The DINO Parallel Programming Language
• Woronow, 1989, Correction for a “FORTRAN program for generation of multivariate normally distributed random variables”
• Harrison, 1989, Research, Development, Training and Education Using the Ada Programming Language
• Vegdahl and Pleban, 1989, The runtime environment for Scheme, a Scheme implementation on the 88000
• Horwat, 1988, A Concurrent Smalltalk Compiler for the Message-Driven Processor
• Weiner and Ramakrishman, 1988, A piggy-back compiler for Prolog
• Harmon, 1988, An Ada implementation of Marsaglia’s universal random number generator
• Tuck, 1988, An Optimally Portable SIMD Single-Instruction Multiple-Data Programming Language
• Keutzer and Wolf, 1988, Anatomy of a hardware compiler
• Andrews and others, 1988, Design and implementation of the UW Illustrated compiler
• Sinharoy, 1988, EPL - Equational Programming Language Parsing and Dimension Propagation
• Lehman and others, 1988, Sources of Compiler Capability Information in Validation Summary Reports
• Manna, 1988, TABLOG The Deductive Tableau Programming Language
• Ghosh and Kulatilake, 1987, A FORTRAN program for generation of multivariate normally distributed random variables
• Lee and Pleban, 1987, A realistic compiler generator based on high-level semantics another progress report
• Donohoe, 1987, A Survey of Real-Time Performance Benchmarks for the Ada Programming Language
• Bonar and Liffick, 1987, A Visual Programming Language for Novices
• Kingsley, 1987, The implementation of a state machine compiler
• Guarna and Jr, 1987, VPC - A Proposal for a Vector Parallel C Programming Language
• Scott, 1986, The Interface Between Distributed Operating System and High-Level Programming Language. Revision
• Sager, 1985, A technique for creating small fast compiler frontends
• Grover, 1985, Guidelines for a Minimal Ada Runtime Environment
• Touzeau, 1984, A Fortran compiler for the FPS-164 scientific computer
• Schmidt and Völler, 1984, A multi-language compiler system with automatically generated codegenerators
• Howe, 1984, A Study of the Feasibility of Duplicating JAMPS Applications Software in the Ada Programming Language
• Blower, 1984, An efficient implementation of visibility in Ada
• Pleban, 1984, Compiler prototyping using formal semantics
• Milos and others, 1984, Direct implementation of compiler specifications or the pascal p-code compiler revisited
• Mössenböck, 1984, Ein einfacher Compiler-Compiler für Mikrocomputer / Α simple compiler-compiler for microcomputer
• Robbins, 1984, Engineering a high-capacity Pascal compiler for high performance
• Aigrain and others, 1984, Experience with a Graham-Glanville style code generator
• Christopher and others, 1984, Using dynamic programming to generate optimized code in a Graham-Glanville style code generator
• Schmeck, 1983, Algebraic semantics of recursive flowchart schemes
• CARNEY and LABAUGH, 1983, Efficient compiler implementation for a spaceborne image processing demonstration system
• Reiss, 1983, Generation of Compiler Symbol Processing Mechanisms from Specifications
• Paulson, 1982, A semantics-directed compiler generator
• Ganzinger and others, 1982, A truly generative semantics-directed compiler generator
• Moor, 1982, An applicative compiler for a parallel machine
• Auslander and Hopkins, 1982, An overview of the PL.8 compiler
• Fusaoka and Hirayama, 1982, Compiler chip
• Koskimies and others, 1982, Compiler construction using attribute grammars
• Sethi, 1982, Control flow aspects of semantics directed compiling Summary
• Falis, 1982, Design and implementation in Ada of a runtime task supervisor
• Kipps, 1982, Experience with porting techniques on a COBOL 74 compiler
• Gallaher, 1982, Investigate Capability of Ada Higher Order Programming Language for Developing Machine Independent Software
• Seyfer, 1982, Tailoring testing to a specific compiler—experiences
• Marshall, 1982, The linear graph package, a compiler building environment
• Jones and Christiansen, 1981, Control Flow Treatment in a Simple Semantics-Directed Compiler Generator
• Hart and McClanahan, 1981, JOVIAL J73 Compiler Validator
• Loy, 1981, Notes on the Implementation of MUSBOX A Compiler for the Systems Concepts Digital Synthesizer
• 1981, Ruggedized minicomputer hardware and software topics, 1981 Proceedings of the 4th ROLM MIL-SPEC Computer User’s Group Conference
• Leverett and others, 1979, An Overview of the Production Quality Compiler-Compiler Project
• Bonyun, 1979, Euclid Compiler for PDP-11
• Feldman, 1979, Implementation of a portable Fortran 77 compiler using modern tools
• Bonkowski and others, 1979, Porting the Zed compiler
• Guessarian, 1979, Program transformations and algebraic semantics
• Deransart, 1979, Proof by semantic attributes of a LISP compiler
• Abrahams, 1979, The CIMS PL/I compiler
• Pleban, 1979, The use of transition matrices in a recursive-descent compiler
• Evans and others, 1978, A Compiler Compiler and Methodology for Problem Oriented Language Compiler Implementors
• Payne, 1978, A formalised technique for expressing compiler exercisers
• Bonyun and Holt, 1978, EUCLID Compiler for PDP-11
• Lynn, 1978, Interactive Compiler Proving Using Hoare Proof Rules
• Johnson, 1978, Tools For Automatic Compiler Generation Panel Discussion
• Williams and Bulmer, 1978, Use of a formal notation for static semantics in compiler design
• Baird and Oliver, 1977, Programming Language Standards – Who Needs Them
• Lange and others, 1977, Specification for a STARAN Programming Language
• Fisher, 1976, A Common Programming Language for the Department of Defense–Background and Technical Requirements
• Krzemień and Lukasiewicz, 1976, Automatic generation of lexical analyzers in a compiler-compiler
• Goodenough and others, 1976, Evaluation of ALGOL 68, JOVIAL J3B, PASCAL, SIMULA 67, and TACPOL vs. TINMAN Requirements for a Common High Order Programming Language
• Ganzinger and others, 1976, MUG1 - an incremental compiler-compiler
• Harrison and others, 1976, Theoretical results in compiler design and implementation Tutorial Session
• Snyder, 1975, A Portable Compiler for the Language C
• Newey, 1975, Formal Sematics of LISP with Applications to Program Correctness
• Gorelik and Khukhlaev, 1975, Implementation of the incremental fortran compiler
• Zelkowitz, 1975, Third generation compiler design
• Laliotis, 1973, Implementation aspects of the symbol hardware compiler
• 1973, Implementation of a Pascal compiler for the CII IRIS 80 computer
• Malcolm, 1971, PL360 Revised . A Programming Language for the IBM360
• Cowan and Graham, 1970, Design characteristics of the WATFOR compiler
• Cheatham and Standish, 1970, Optimization aspects of compiler- compilers
• Finkelstein, 1968, A compiler optimization technique
• Moore, 1968, Data Processing with the Compiler Compiler
• Pankhurst, 1968, GULP—A compiler-compiler for verbal and graphic languages
• Bayer and others, 1968, MPL MATHEMATICAL PROGRAMMING LANGUAGE
• Trout, 1967, A compiler—compiler system
• Mondshein, 1967, VITAL COMPILER SYSTEM REFERENCE MANUAL
• Feldman, 1966, A formal semantics for computer languages and its application in a compiler-compiler
• Campbell and Beck, 1965, THE FORAST PROGRAMMING LANGUAGE FOR ORDVAC AND BRLESC REVISED
• BOOK and others, 1963, A ONE PASS JOVIAL COMPILER
• KELLY, 1963, ADVANCED MYSTIC- A COMPILER FOR MANAGEMENT CONTROL OF COMPUTER PROGRAMMING
• Jervis, 1963, MOBILE. A MOBIDIC COBOL COMPILER

The surrounding systems literature

The harvest returned a large body of work that is adjacent rather than central, being compiler, runtime and systems research that shares the article’s vocabulary without addressing its question. It is listed rather than discarded because the selection that produced it is reported in full, and a survey that presents only the records supporting its thesis has selected twice, once by query and once by judgement, while reporting one selection.

• Kuroda and Yuen, 2026, A Concurrent Extension of Reversible Imperative Programming Language with Runtime
• Attrot and others, 2026, A Pattern Generation Language for MLIR Compiler Matching and Rewriting
• bounpaserth, 2026, A Study of the Computer Programming Language Implementation in Computer Engineering Students using the Flowgorithm Platform versus Common Programming
• Sun and Staron, 2026, Agentic Pipelines in Embedded Software Engineering Emerging Practices and Challenges
• Iida and others, 2026, An Efficient Runtime Verification Toolkit for Self-Adaptive Systems Addressing Runtime System Model Changes
• Jadhav and others, 2026, Analysis of Compiler-Level Static and Dynamic Features for Automated Bug Prediction Using Transformer Models
• Aisyiyah and Eviyanti, 2026, Android-based Programming Language to Natural Language Translator App
• Qin and others, 2026, Augmenting LLM Code Translation with Compiler Analysis for C to Triton Kernel Generation
• Kahn and others, 2026, Big-Stop Semantics Small-Step Semantics in a Big-Step Judgment
• Kasaraneni and Nandivada, 2026, Compact Representation and Interleaved Solving for Scalable Constraint-Based Points-to Analysis
• Cheng and others, 2026, Denotation-based Compositional Compiler Verification
• Deng and others, 2026, Design and Implementation of an OCaml-Based Standalone SystemVerilog Preprocessor Compliant with IEEE 1800-2023
• Altan, 2026, Error-Resilient Quantum Compiler Design for Efficient Qubit Mapping, Gate Optimization, and Noise Mitigation in NISQ-Era Devices
• Wu and others, 2026, Fluctuation-guided adaptive random compiler for Hamiltonian simulation
• Arakaki and Hirokawa, 2026, Foundational Design of Multi-Modal Typed Programming Language for Quantum-Classical Hybrid Computing System
• Duţu and others, 2026, From Runtime Reflection to Compile-Time Specialization A Template-Based Approach to Runtime Libraries
• Jackson, 2026, I/O Optimisation at the Compiler Level IOOpt
• Lai and others, 2026, Interaction-aware multi-objective optimization method for LLVM compiler option sequences
• Xiang and others, 2026, LoopHint A Compiler-Assisted Loop Branch Predictor for Embedded DSPs
• 2026, NOCI-COMPILER A THEORETICAL ARCHITECTURE FOR THE SEMANTIC TRANSLATION OF NOCICEPTIVE SIGNALS INTO A DIGITAL PAIN ALPHABET
• Kishorbhai and Patel, 2026, Online Code Compiler A Modern Web Based Programming Platform
• Du, 2026, Performance Verification of BFS For Unweighted Maze Solving A Comparative Analysis with DFS and A* Via Ocaml Implementation
• Dong and others, 2026, Presynthesis Towards Scaling Up Program Synthesis with Finer-Grained Abstract Semantics
• Aziz and Labiche, 2026, ProtoSYCL A Sample Implementation of a SYCL Compiler for Conformance Test Suite Development
• Wang and others, 2026, Random test generators demystified Differences and potential for compiler reliability
• Maity and Ghose, 2026, SAGE A Compiler-assisted Reinforcement Learning-based Offloading Approach under Near-memory Processing Paradigm
• 2026, Syntax-Directed Semantics in Programming Language Design
• Arriaga and others, 2026, Tempo An ML-KEM to PAKE Compiler Resilient to Timing Attacks
• Avigad and others, 2025, A Proof-Producing Compiler for Blockchain Applications
• Petchartee, 2025, A Universal Quantum Compiler GPT Multi-Framework Optimization and Translation Using Large Language Models
• Delaët and others, 2025, Abstract machines and small-step semantics a winning ticket for proof automation?
• Fan and others, 2025, Adaptive random compiler for Hamiltonian simulation
• Pasupuleti, 2025, AI-Guided Quantum Compiler Design Using Superalgebraic Symmetries
• Bai and others, 2025, APCer An Agile Physical Compiler for Multi-Port Register File
• Liu and Lu, 2025, Bi-directional Taint Flow Analysis A High-precision Static Detection Approach for Java Deserialization Vulnerabilities
• Heo and others, 2025, Bit-level compiler optimization for ultra low-power embedded systems
• Puranik, 2025, Bridging Formal Methods and Software Engineering Through a Tagless-Final Embedded DSL for Program Semantics
• Zhang, 2025, Comparative Implementation of Binary Tree and Recursive Backtracking Maze Generation Algorithms in OCaml
• Pandey, 2025, Compiler Design and Its Construction
• Wu and others, 2025, Compiler Optimization Testing Based on Optimization-Guided Equivalence Transformations
• Matteo R. Donelli, 2025, Compiler-Assisted Optimization Using Neural Code Embeddings for Heterogeneous Architectures
• Jadhav and Falk, 2025, Compiler-level DMA-aware multi-objective dynamic SPM allocation
• Astarte, 2025, Conceptualising Programming Language Semantics
• Chen and others, 2025, De-duplicating Silent Compiler Bugs via Deep Semantic Representation
• Hensley and Elgazzar, 2025, DESIGN AND IMPLEMENTATION OF THE MOREHEAD-AZALEA COMPILER MAC
• Ghuzdewan, 2025, Development of a Python-Based Program for Pareto Analysis in Construction Project Cost Management
• He and others, 2025, Evaluating Program Semantics Reasoning with Type Inference in System F
• Seassau and others, 2025, Formal Semantics and Program Logics for a Fragment of OCaml
• Yang and others, 2025, Formal Verification of a Custom Compiler for a Fully Homomorphic Encryption Accelerator
• He and Zhong, 2025, From Bug Reports to Workarounds The Real-World Impact of Compiler Bugs
• Bourke and others, 2025, Functional Stream Semantics for a Synchronous Block-Diagram Compiler
• S and others, 2025, Impact of Peer-Based Feedback Mechanisms on Understanding Programming Language
• Minato and others, 2025, Implementation and Evaluation of a System Call Moving Target Defense Applied Multiple Times at Runtime for Binary Injections
• Sack, 2025, Interfacing Programming Language Semantics and Pragmatics What Does “Hello, World” Mean?
• Brant and others, 2025, IoT-CODIFT Compiler Optimization DIFT for IoT and Embedded Devices
• Olteanu and Oprişa, 2025, LambdaGo A Functional Extension of the Go Programming Language
• Li and others, 2025, Lightweight and Holistic-Scalable Serverless Secure Container Runtime for High-Density Deployment and High-Concurrency Startup
• Cummins and others, 2025, LLM Compiler Foundation Language Models for Compiler Optimization
• Chaplygin, 2025, Modeling and implementation of Common LISP functional language compiler
• Qassir, 2025, MyDSL Front-End Compiler Design for a User-Friendly Language Supporting Hybrid Meta-Heuristics
• Recharla, 2025, Parallel Sparse Matrix Algorithms in OCaml v5 Implementation, Performance, and Case Studies
• Midtgaard, 2025, Property-Based Testing of OCaml 5’s Runtime System
• 2025, Quantum Software Engineering Algorithm Design, Error Mitigation, and Compiler Optimization for Fault-Tolerant Quantum Computing
• Abu-Yosef and Kong, 2025, Scalable Data-Flow Modeling and Validation of Distributed-Memory Algorithms
• Austen and others, 2025, Sharing Is Scaring Linking Cloud File-Sharing to Programming Language Semantics
• Zelenova, 2025, Static Memory Layout for Real-Time Operating Systems
• Applis and others, 2025, Suspicious Types and Bad Neighborhoods Filtering Spectra with Compiler Information
• Tan and others, 2025, The Burden of Proof Automated Tooling for Rapid Iteration on Large Mechanised Proofs
• Rowland and Perugini, 2025, The Formal Semantics and Implementation of a Domain-Specific Language for Mixed-Initiative Dialogs
• S.Venkatesan, 2025, TOWARDS AUTONOMOUS CODE OPTIMIZATION A REINFORCEMENT LEARNING FRAMEWORK FOR COMPILER DESIGN
• Carlos Paradis and others, 2025, Towards Streamlining Auditing for Compliance With Requirements in Open-Source Software at NASA
• Sholihin and Hidayati, 2024, A Forward Chaining Expert System for Personalized Programming Language Selection
• Narkthong and others, 2024, ALLI/O Diagram An Action-based Visual Programming Language for Embedded System
• Liu and others, 2024, An efficient schedulability analysis based on worst-case interference time for real-time systems
• Santos and others, 2024, Assessing the Impact of Compiler Optimizations on GPUs Reliability
• Sanusi and others, 2024, Assuring Correctness, Testing, and Verification of X-Compiler by Integrating Communicating Stream X-Machine
• Johnson and others, 2024, Automating Pruning in Top-Down Enumeration for Program Synthesis Problems with Monotonic Semantics
• Hück and others, 2024, Compiler-Aided Correctness Checking of CUDA-Aware MPI Applications
• Jeong and others, 2024, Conflict-aware compiler for hierarchical register file on GPUs
• Jiang and others, 2024, DCIM Compiler - Physical Design Generator
• Chen and others, 2024, Design and Implementation of an Aspect-Oriented C Programming Language
• Zhao and others, 2024, Design and Implementation of the MTP Compiler
• Niu and others, 2024, FAIR Flow Type-Aware Pre-Training of Compiler Intermediate Representations
• Talamali and others, 2024, Formal Specification and Verification of MQTT Protocol Using CoQ Proof Assistant
• Nougrahiya and Nandivada, 2024, Homeostasis Design and Implementation of a Self-Stabilizing Compiler
• Lee and Lee, 2024, IMC-PnG Maximizing runtime performance and timing guarantee for imprecise mixed-criticality real-time scheduling
• 2024, Implementation concept of the IoT platform using C++ programming language
• Siambaton and others, 2024, Implementation Draft Programming Oriented Objects in Parking System Application using Language Programming Java
• Zhang and others, 2024, Introducing Compiler Semantics into Large Language Models as Programming Language Translators A Case Study of C to x86 Assembly
• Schlichtkrull and others, 2024, Isabelle-verified correctness of Datalog programs for program analysis
• Chirila and Sora, 2024, Java Single vs. Platform vs. Virtual Threads Runtime Performance Assessment in the Context of Key Class Detection
• Wang and others, 2024, K-RAPID A Formal Executable Semantics of the RAPID Robot Programming Language
• Gruetter and others, 2024, Live Verification in an Interactive Proof Assistant
• Shoushtary and others, 2024, Memento An Adaptive, Compiler-Assisted Register File Cache for GPUs
• 2024, Online platform learning the Java programming language development, implementation and efficiency
• Donaldson and others, 2024, Randomised Testing of the Compiler for a Verification-Aware Programming Language
• Hu and Tang, 2024, Research on compiler version recognition based on random forest algorithm
• Aneesh and others, 2024, Smart Compiler Assistant An AST based Python Code Analysis
• Xu and others, 2024, SWAT4J Generating System Call Allowlist for Java Container Attack Surface Reduction
• Vraný and Shingarov, 2024, Tinyrossa A Compiler Framework for Vertical, Verified Construction of Smalltalk VMs
• Cunha and others, 2024, Trading Runtime for Energy Efficiency Leveraging Power Caps to Save Energy across Programming Languages
• Schoenberger and others, 2024, Using Compiler Frameworks for the Evaluation of Hardware Design Choices in Trapped-Ion Quantum Computers
• Wang, 2024, Worst-Case Blocking Time Optimization in WCRT Analysis for vMPCP on Multi-Core Virtual Machines
• Makki Mohialden and others, 2023, A Comparative Analysis of Python Code-Line Bug-Finding Methods
• Wang and others, 2023, A General-Purpose Compiler Design for Instruction-Based AI Accelerator Implementation
• Roy, 2023, A Theorem Proving Approach to Programming Language Semantics
• Li and others, 2023, A unified proof technique for verifying program correctness with big-step semantics
• 2023, ADAPTIVE PROGRAMMING LANGUAGE LEARNING SYSTEM BASED ON GENERATIVE AI
• Wang and others, 2023, An Automated Verification Framework for HalideIR-Based Compiler Transformations
• Curry, 2023, An HPC-Oriented Runtime Environment for Enabling Computational Storage
• Drechsler and Schnieber, 2023, Automated Polynomial Formal Verification Human-Readable Proof Generation
• Harshithan, 2023, Batwing Compiler An Artificial Intelligence based Compiler
• Audrito and Haures, 2023, Combining Static and Runtime Verification with AC and Coq
• Zhang and others, 2023, Compiler Technologies in Deep Learning Co-Design A Survey
• Baroffio and Reghenzani, 2023, Compiler-Injected SIHFT for Embedded Operating Systems
• 2023, Development of a mobile robot control system in the Python programming language using Raspberry Pi
• Yu and others, 2023, Efficient Generation of Floating-Point Inputs for Compiler-Induced Variability
• Skarman and others, 2023, Enhancing Compiler-Driven HDL Design with Automatic Waveform Analysis
• Ceng Giap and Erviana, 2023, Implementation of Face Mask Detection Using Phyton Programming Language
• Dange and others, 2023, Implementation on A User Authentication Scheme Using Block Chain-Enabled Fog Nodes
• Abi-Karam and others, 2023, INR-Arch A Dataflow Architecture and Compiler for Arbitrary-Order Gradient Computations in Implicit Neural Representation Processing
• Sadasue and Isshiki, 2023, LLVM-C2RTL C/C++ Based System Level RTL Design Framework Using LLVM Compiler Infrastructure
• Herklotz and others, 2023, Mechanised Semantics for Gated Static Single Assignment
• Strauch, 2023, MRPHS A Verilog RTL to C++ Model Compiler Using Intermediate Representations for Object-oriented Model-driven Prototyping
• Mehdi Pourhashem Kallehbasti and Ghafari, 2023, Naturalistic Static Program Analysis
• Alpay and Heuveline, 2023, One Pass to Bind Them The First Single-Pass SYCL Compiler with Unified Code Representation Across Backends
• Vos and others, 2023, Oraqle A Depth-Aware Secure Computation Compiler
• Hirata and others, 2023, Program logic for higher-order probabilistic programs in Isabelle/HOL
• Cheng, 2023, QA4C An Intelligent Question and Answering System for the C Programming Language Based on Knowledge Graph
• Yu, 2023, Reasoning about MLIR Semantics through Effects and Handlers
• Affeldt and others, 2023, Semantics of Probabilistic Programs using s-Finite Kernels in Coq
• Stolyarov, 2023, STATIC ANALYZER IMPLEMENTATION MODEL FOR THE SOLIDTY PROGRAMMING LANGUAGE
• Denis and others, 2023, Tracing task-based runtime systems Feedbacks from the StarPU case
• Tran and others, 2023, Transport Layer Security 1.0 handshake protocol formal verification case study How to use a proof script generator for existing large proof scores
• DelVado Vírseda, 2023, Visualizing Compiler Design Theory from Implementation Through an Interactive Tutoring Tool Experiences and Results
• Vizcaino and others, 2022, Acceleration with long vector architectures Implementation and evaluation of the FFT kernel on NEC SX-Aurora and RISC-V vector extension
• 2022, Analysis on Strengthening Scheme of Office Building Based on Function Change
• Pant and others, 2022, Automatic Software Engineering Position Resume Screening using Natural Language Processing, Word Matching, Character Positioning, and Regex
• Kobusińska and Wilczynski, 2022, Blocked-based Solidity a Service for Graphically Creating the Smart Contracts in Solidity Programming Language
• Schiewe, 2022, Bridging the gap between source code and high-level concepts in static code analysis
• 2022, Cameleer A deductive verification tool for OCaml
• Zhang and others, 2022, Cape compiler-aided program transformation for HTM-based cache side-channel defense
• Ding and others, 2022, CARL Compiler Assigned Reference Leasing
• Oh and others, 2022, CASH-RF A Compiler-Assisted Hierarchical Register File in GPUs
• Ambal and others, 2022, Certified Derivation of Small-Step From Big-Step Skeletal Semantics
• Ozdemir and others, 2022, CirC Compiler infrastructure for proof systems, software verification, and more
• Sharif and others, 2022, COMPAS Compiler-assisted Software-implemented Hardware Fault Tolerance for RISC-V
• Bik and others, 2022, Compiler Support for Sparse Tensor Computations in MLIR
• Huck and others, 2022, Compiler-Aided Type Correctness of Hybrid MPI-OpenMP Applications
• Agathos and others, 2022, Compiler-assisted, adaptive runtime system for the support of OpenMP in embedded multicores
• Lenkefi and Mezei, 2022, Connections between Language Semantics and the Query-based Compiler Architecture
• Yadav and others, 2022, DISTAL the distributed tensor algebra compiler
• Chaliasos and others, 2022, Finding typing compiler bugs
• Shobaki and others, 2022, Graph transformations for register-pressure-aware instruction scheduling
• Alpay and Heuveline, 2022, How much SYCL does a compiler need? Experiences from the implementation of SYCL as a library for nvc++
• Poletanovic and others, 2022, Implementation of Machine Outliner for nanoMIPS in the LLVM Compiler Infrastructure
• Mosaner and others, 2022, Improving Vectorization Heuristics in a Dynamic Compiler with Machine Learning Models
• Hikmatyarsyah and Rahardjo, 2022, Integration of Downlink Scheme VLC Access Techniques for Low-cost Implementation Indoor Communication System A Survey
• Fayzrakhmanov, 2022, Introducing Programming Language Metrics
• Sammler and others, 2022, Islaris verification of machine code against authoritative ISA semantics
• Gordon and others, 2022, Porting the Kitten Lightweight Kernel Operating System to RISC-V
• Valiron, 2022, Semantics of quantum programming languages Classical control, quantum control
• Cho and others, 2022, Sequential reasoning for optimizing compilers under weak memory concurrency
• Postema and others, 2022, Testing a PL/I Compiler Using Precomputation-based Program Generation
• C K, 2022, Video Calling With Build-In Compiler
• De Blaere and others, 2021, A Compiler Extension to Protect Embedded Systems Against Data Flow Errors
• Myreen, 2021, A minimalistic verified bootstrapped compiler proof pearl
• Jeon and others, 2021, A practical algorithm for learning disjunctive abstraction heuristics in static program analysis
• Yvon and Feeley, 2021, A small scheme VM, compiler, and REPL in 4k
• Benito-Montoro and others, 2021, A Tool to Assist the Compiler Construction Instructor in Checking the Equivalence of Specifications Based on Regular Expressions
• Amaliah and others, 2021, Auto Clustering Source Code To Detect Plagiarism Of Student Programming Assignments in Java Programming Language
• Padmasudha Kannan and others, 2021, Automated high-order curved mesh generator with high-level dynamic programming language julia for photonic applications
• Windsor and others, 2021, C4 the C compiler concurrency checker
• Cruttwell and others, 2021, Categorical semantics of a simple differential programming language
• Hossain and others, 2021, Code Generator based on Voice Command for Multiple Programming Language
• Ploensin and others, 2021, Code Transformation Impact on Compiler-based Optimization A Case Study in the CMSSW
• Jung, 2021, CommitBERT Commit Message Generation Using Pre-Trained Programming Language Model
• Steingartner, 2021, Compiler Module of Abstract Machine Code for Formal Semantics Course
• Bruno and others, 2021, Compiler-assisted object inlining with value fields
• Han and others, 2021, Design and Implementation of a Criticality- and Heterogeneity-Aware Runtime System for Task-Parallel Applications
• Liu and others, 2021, Design and Implementation of Multi-core Parallel Compiler Based on OpenMP
• Mpeis and others, 2021, Developer and user-transparent compiler optimization for interactive applications
• Wang, 2021, Helper function inlining in dynamic binary translation
• Pizzolotto and Inoue, 2021, Identifying Compiler and Optimization Level in Binary Code From Multiple Architectures
• Bekiris, 2021, Implementation of UTASTAR Decision Support System in VΒΑ Programming Language
• del Vado Vírseda, 2021, Learning Compiler Design From the Implementation to Theory
• Lööw, 2021, Lutsig a verified Verilog compiler for verified circuit development
• Antoniadis and others, 2021, Open-Source Memory Compiler for Automatic RRAM Generation and Verification
• Nowicki and others, 2021, Performance evaluation of Java/PCJ implementation of parallel algorithms on the cloud extended version
• Chernenko and others, 2021, Proving Reflex Program Verification Conditions in Coq Proof Assistant
• Guria and others, 2021, RbSyn type- and effect-guided program synthesis
• Worthington, 2021, Reflections on a decade of MoarVM, a runtime for the Raku programming language keynote
• Zhao and others, 2021, Similarity-Aware Architecture/Compiler Co-Designed Context-Reduction Framework for Modulo-Scheduled CGRA
• 2021, Socket system in php programming language
• Rao and others, 2021, SODA A Semantics-Aware Optimization Framework for Data-Intensive Applications Using Hybrid Program Analysis
• Bourke, 2021, Specification and end-to-end proof of a reactive language and its compiler invited talk
• Yilmazer‐Metin, 2021, sRSP An efficient and scalable implementation of remote scope promotion
• Aldweesh and others, 2021, The OpBench Ethereum opcode benchmark framework Design, implementation, validation and experiments
• Tempel and others, 2021, Towards Reliable Spatial Memory Safety for Embedded Software by Combining Checked C with Concolic Testing
• Xiao, 2021, Transformation System of two Similar Syntax Programs Based on the Compiler Principle
• JEONG and others, 2021, Usage Log-Based Testing of Embedded Software and Identification of Dependencies among Environmental Components
• Geng and others, 2021, Verification of Open-Source Memory Compiler Framework with a Practical PDK
• Sorensen and others, 2020, A simulator and compiler framework for agile hardware-software co-design evaluation and exploration
• Pai T and others, 2020, A Systematic Literature Review of Lexical Analyzer Implementation Techniques in Compiler Design
• Diamantopoulos and others, 2020, Agile Autotuning of a Transprecision Tensor Accelerator Overlay for TVM Compiler Stack
• Barinov and others, 2020, Applying compiler-based binary watermarking technology to ensure binary compatibility in GNU/Linux distribution
• Suchy and others, 2020, CARAT a case for virtual memory through compiler- and runtime-based address translation
• Amarasinghe, 2020, Compiler 2.0
• Flatt and Dybvig, 2020, Compiler and runtime support for continuation marks
• Squar and others, 2020, Compiler Assisted Source Transformation of OpenMP Kernels
• Ghosh and others, 2020, Compiler compatible 5.66 Mb/mm2 8T 1R1W register file in 14 nm FinFET technology
• Kim and others, 2020, Compiler-directed soft error resilience for lightweight GPU register file protection
• Chen and others, 2020, CRAC An automatic assistant compiler of checkpoint/restart for OpenCL program
• Zhang and Meng, 2020, Design and Implementation of Multi-core DSP Parallel Compiler Based on Otsu Method
• Watanabe and others, 2020, Design and Preliminary Evaluation of OpenACC Compiler for FPGA with OpenCL and Stream Processing DSL
• Groenewegen and others, 2020, Evolution of the WebDSL runtime reliability engineering of the WebDSL web programming language
• Queiroz Junior and others, 2020, Finding Effective Compiler Optimization Sequences A Hybrid Approach
• Luo, 2020, Heap Memory Snapshot Assisted Program Analysis for Android Permission Specification
• Ranganathan and others, 2020, Hybrid Scalable Action Rule
• Bezrąk and Przyłucki, 2020, Impact of the cloud application programming language on the performance of its implementation in selected serverless environments
• Georgiou and others, 2020, Lost In Translation Exposing Hidden Compiler Optimization Opportunities
• Zaytsev, 2020, Modelling of Language Syntax and Semantics The Case of the Assembler Compiler
• Andrade Guzmán and Hernández Quiroz, 2020, Natural deduction and semantic models of justification logic in the proof assistant Coq
• Amato and others, 2020, On collecting semantics for program analysis
• Phulia and others, 2020, OOElala order-of-evaluation based alias analysis for compiler optimization
• Vasilyev and Mutilin, 2020, Predicate Extension of Symbolic Memory Graphs for the Analysis of Memory Safety Correctness
• 2020, Proceedings of the 2020 International Conference on Embedded Software EMSOFT
• Sanders and others, 2020, Robustness Analysis of Scaled Resource Allocation Models Using the Imperial PEPA Compiler
• Sulema and Glinskii, 2020, Semantics and pragmatics of programming language ASAMPL
• Cambier and others, 2020, TaskTorrent a Lightweight Distributed Task-Based Runtime System in C++
• Natarajan and Broman, 2020, Temporal Property-Based Testing of a Timed C Compiler using Time-Flow Graph Semantics
• Yin and others, 2020, The Implementation of Simple Smart Contract Language and Its Compiler Based on Ethereum Platform
• Huck and others, 2020, Towards compiler-aided correctness checking of adjoint MPI applications
• Holmes and Groce, 2020, Using mutants to help developers distinguish and debug compiler faults
• Dasgupta and others, 2019, A complete formal semantics of x86-64 user-level instruction set architecture
• Benzaken and Contejean, 2019, A Coq mechanised formal semantics for realistic SQL queries formally reconciling SQL and bag relational algebra
• Lima and others, 2019, A memory-bounded, deterministic and terminating semantics for the synchronous programming language Céu
• Feitosa and others, 2019, A monadic semantics for quantum computing in an object oriented language
• ROMPF and AMIN, 2019, A SQL to C compiler in 500 lines of code
• Ye and Delaware, 2019, A verified protocol buffer compiler
• 2019, Automatic Port to OpenACC/OpenMP for Physical Parameterization in Climate and Weather Code Using the CLAW Compiler
• Bassil, 2019, Compiler Design for Legal Document TranslationIn Digital Government
• Elkhouly and others, 2019, Compiler-support for Critical Data Persistence in NVM
• Kondratyev and Promsky, 2019, Correctness of Proof Strategy for the Sisal Program Verification
• Zwanziger, 2019, Dependently-Typed Montague Semantics in the Proof Assistant Agda-flat
• Salánki and Sarvajcz, 2019, Development of a Gait Recognition System in NI LabVIEW Programming Language
• Melnyk and Kozak, 2019, Easy Universal Translator as an Alternative Compiler-Compiler
• Thiselton and Treude, 2019, Enhancing Python Compiler Error Messages via Stack
• Mao and others, 2019, Exploiting Java Stack Forensics for Runtime Monitoring of IoT Services
• Acun and others, 2019, Fine-Grained Energy Efficiency Using Per-Core DVFS with an Adaptive Runtime System
• Facchinetti and others, 2019, Higher-order Demand-driven Program Analysis
• Duhoux and others, 2019, Implementation of a Feature-Based Context-Oriented Programming Language
• Somani and Srivastava, 2019, Implementation of SAAS Intranet compiler in PHP
• Yim and others, 2019, Implementation of Targeted Advertisement Services on ATSC 3.0 Runtime Environment
• Oshita and others, 2019, Improving User Experience of C Programming Language Learning System for Novices
• Besson and others, 2019, Information-Flow Preservation in Compiler Optimisations
• Nguyen and others, 2019, Integrating Static Program Analysis Tools for Verifying Cautions of Microcontroller
• Zhu and others, 2019, Learning to Restrict Test Range for Compiler Test
• Gorodetskiy, 2019, NEXTGEN PROGRAMMING LANGUAGE WITH PROGRAMMABLE SEMANTICS
• Campbell, 2019, Random Compiler for Fast Hamiltonian Simulation
• Wang and others, 2019, Reg An Ultra-Lightweight Container That Maximizes Memory Sharing and Minimizes the Runtime Environment
• Guerrera and others, 2019, Reproducible stencil compiler benchmarks using prova!
• Heo and others, 2019, Resource-Aware Program Analysis Via Online Abstraction Coarsening
• Choi and others, 2019, Reusable inline caching for JavaScript performance
• Ghorbani and Babamir, 2019, Runtime deadlock tracking and prevention of concurrent multithreaded programs A learning-based approach
• Roy and others, 2019, Security Analysis and Efficient Implementation of Code-based Signature Schemes
• Ivanov and others, 2019, Software Structure, Program Generation and Schedulability Analysis of Extracorporeal Perfusion Pump Embedded Controller
• Kim and Ryou, 2019, Source Code Analysis for Static Prediction of Dynamic Memory Usage
• Arceri and Mastroeni, 2019, Static Program Analysis for String Manipulation Languages
• Delgado-Pérez and Segura, 2019, Study of trivial compiler equivalence on C++ object-oriented mutation operators
• Amarasinghe, 2019, The sparse tensor algebra compiler keynote
• Ryu and others, 2019, Toward Analysis and Bug Finding in JavaScript Web Applications in the Wild
• Wang and others, 2019, Tracking runtime concurrent dependences in java threads using thread control profiling
• Tillet and others, 2019, Triton an intermediate language and compiler for tiled neural network computations
• Guan and others, 2019, Wootz a compiler-based framework for fast CNN pruning via composability
• 2018, 2018 Proceedings of the International Conference on Embedded Software EMSOFT
• Leopoldseder and others, 2018, A cost model for a graph-based intermediate-representation in a dynamic compiler
• Fradet and others, 2018, A Generic Coq Proof of Typical Worst-Case Analysis
• Waites and others, 2018, A Genetic Circuit Compiler Generating Combinatorial Genetic Circuits with Web Semantics and Inference
• Santos and others, 2018, A memory-bounded, deterministic and terminating semantics for the synchronous programming language Céu
• Asadollah and others, 2018, A Runtime Verification Tool for Detecting Concurrency Bugs in FreeRTOS Embedded Software
• Bishnu and Bhatia, 2018, Algorithmic Compiler based FPGA Implementation of Iterative Time-Domain Algorithm for Sparse Channel Estimation
• Yi and Lee, 2018, An Educational System Design to Support Learning Transfer from Block-based Programming Language to Text-based Programming Language
• Sah and others, 2018, An Efficient Hardware-Oriented Runtime Approach for Stack-based Software Buffer Overflow Attacks
• Tohid and others, 2018, Asynchronous Execution of Python Code on Task-Based Runtime Systems
• Ginsbach and others, 2018, CAnDL a domain specific language for compiler analysis
• Belyaev and others, 2018, Comparative Analysis of Two Approaches to Static Taint Analysis
• Besson and others, 2018, CompCertS A Memory-Aware Verified C Compiler Using a Pointer as Integer Semantics
• Heim, 2018, Compiler and language design for quantum computing keynote
• Zhang, 2018, Compiler Practice System Integrated with Real Open Source Compiler
• Huck and others, 2018, Compiler-aided Type Tracking for Correctness Checking of MPI Applications
• Sharrad and others, 2018, Delta Debugging Type Errors with a Blackbox Compiler
• Medeiros and others, 2018, Evaluation of Compiler Optimization Flags Effects on Soft Error Resiliency
• Beaumont and others, 2018, Fast approximation algorithms for task-based runtime systems
• Kusmenko and others, 2018, Highly-Optimizing and Multi-Target Compiler for Embedded System Models
• Terao, 2018, Lazy Abstraction for Higher-Order Program Verification
• Niephaus and others, 2018, Live Multi-language Development and Runtime Environments
• Lyamin, 2018, Method of Formal Program Verification for Post Machine Virtual Laboratory
• Oehlert and others, 2018, Mitigating Data Cache Aging through Compiler-Driven Memory Allocation
• Salama and others, 2018, Online programming language-Learning management system
• Liu and others, 2018, Research of Register Pressure Aware Loop Unrolling Optimizations for Compiler
• Deng and Namjoshi, 2018, Securing a compiler transformation
• Ismael and others, 2018, System on Chip Implementation of Compiler Stack with a Delimiter Matching Application
• Bourke and others, 2018, Towards a verified Lustre compiler with modular reset
• Bowman and Ahmed, 2018, Typed closure conversion for the calculus of constructions
• Fumero and Kotselidis, 2018, Using compiler snippets to exploit parallelism on heterogeneous hardware a Java reduction case study
• Tatsuoka and Kaneko, 2018, Wire congestion aware high level synthesis flow with source code compiler
• Takase and others, 2018, Work-in-Progress Design Concept of a Lightweight Runtime Environment for Robot Software Components Onto Embedded Devices
• Choi and others, 2018, Work-in-Progress Lightweight Deadlock Detection Technique for Embedded Systems via OS-Level Analysis
• Janetschek and Prodan, 2017, A compiler transformation-based approach to scientific workflow enactment
• Imamoglu and Cetinkaya, 2017, A rule based decision support system for programming language selection
• Cambou, 2017, A XOR data compiler Combined with physical unclonable function for true random number generation
• Shen, 2017, Android Security via Static Program Analysis
• 2017, C# Compiler for Blind
• Akdur and others, 2017, Characterizing the Development and Usage of Diagrams in Embedded Software Systems
• Lambert and Saunders, 2017, Compiler auto-vectorization of matrix multiplication modulo small primes
• Proy and others, 2017, Compiler-Assisted Loop Hardening Against Fault Attacks
• Yaneva and others, 2017, Compiler-assisted test acceleration on GPUs for embedded software
• Luo and others, 2017, Compiler-Assisted Threshold Implementation against Power Analysis Attacks
• Maurer and others, 2017, Compiling without continuations
• Akdur and others, 2017, Cross-factor analysis of software modeling practices versus practitioner demographics in the embedded software industry
• Kirichenko and Tarasov, 2017, Development of design flow for multiported register files, which includes a cell library and a compiler for SOI 0.25-μm process
• Prenzel and Provost, 2017, Dynamic Software Updating of IEC 61499 Implementation Using Erlang Runtime System
• Ruberg and others, 2017, Embedded software performance estimations at different compiler optimisation levels
• SulĂ­r and Poruban, 2017, Exposing Runtime Information through Source Code Annotations
• Ruchkin and others, 2017, Frame model of a compiler of cluster parallelism for embedded computing systems
• Pieters and others, 2017, Handlers for Non-Monadic Computations
• Tian and others, 2017, LLVM Compiler Implementation for Explicit Parallelization and SIMD Vectorization
• Endo and others, 2017, On the Interactions Between Value Prediction and Compiler Optimizations in the Context of EOLE
• Ghica and Alyahya, 2017, On the Learnability of Programming Language Semantics
• Meghzili and others, 2017, On the Verification of UML State Machine Diagrams to Colored Petri Nets Transformation Using Isabelle/HOL
• Wimmer and others, 2017, One compiler deoptimization to optimized code
• Maccabe, 2017, Operating and Runtime Systems Challenges for HPC Systems
• Würthinger and others, 2017, Practical partial evaluation for high-performance dynamic language runtimes
• Chong and others, 2017, Programming languages and compiler design for realistic quantum hardware
• Li and others, 2017, Promotion of Educational Effectiveness by Translation-based Programming Language Learning Using Java and Swift
• Baek and Kim, 2017, Prototype implementation of the OpenGL ES 2.0 shading language offline compiler
• Khatami and others, 2017, Redesigning OP2 Compiler to Use HPX Runtime Asynchronous Techniques
• Lins and others, 2017, Register File Criticality and Compiler Optimization Effects on Embedded Microprocessors Reliability
• Kiefer and others, 2017, Relational Program Reasoning Using Compiler IR
• Wang, 2017, Research on the Execution Time Analysis Technology of the Worst Case System in Real Time System
• Santhiar and Kanade, 2017, Static deadlock detection for asynchronous C# programs
• Wu and others, 2017, Two Schemes to Improve the Implementation of the Aggregation Based Algebraic Multigrid Preconditioner
• Zubarev, 2017, TYPE ANALYSIS FOR THE PREDICATE PROGRAMMING LANGUAGE
• Márton and Porkoláb, 2017, Unit Testing in C++ with Compiler Instrumentation and Friends
• Engelke and Weidendorfer, 2017, Using LLVM for Optimized Lightweight Binary Re-Writing at Runtime
• De Luca and Chen, 2017, Visual IoT/Robotics Programming Language in Pi-Calculus
• Dave and others, 2016, A 1V 800MHz 140Kb register file compiler using variation aware self-timing in 40nm bulk CMOS
• Zhou and Xue, 2016, A Compiler Approach for Exploiting Partial SIMD Parallelism
• Bispo and Cardoso, 2016, A MATLAB subset to C compiler targeting embedded systems
• Chen and others, 2016, A Process-Visible Compiler Aimed for Teaching Assistant
• Wenger and others, 2016, A Programming Language and System for Heterogeneous Cloud of Things
• Kalyur and Nagaraja, 2016, A survey of modeling techniques used in compiler design and implementation
• Hmid and others, 2016, A Transfer-Aware Runtime System for Heterogeneous Asynchronous Parallel Execution
• Horký and others, 2016, Analysis of Overhead in Dynamic Java Performance Monitoring
• Ivey and Riley, 2016, Analysis of Programming Language Overhead in DCE
• Chen and Zong, 2016, Android App Energy Efficiency The Impact of Language, Runtime, Compiler, and Implementation
• Klöckner and others, 2016, Array program transformation with Loo.py by example high-order finite elements
• Jacek and others, 2016, Assessing the limits of program-specific garbage collection performance
• Schäfer and others, 2016, Axiomatic semantics for compiler verification
• Xu and others, 2016, CAOPLE A Programming Language for Microservices SaaS
• Huang and Huang, 2016, Cell-based delay locked loop compiler
• Mäkelä and others, 2016, Compiler assisted dynamic allocation of finite hardware acceleration resources for parallel tasks
• Zhang and others, 2016, Compiler Transformation to Generate Hybrid Sparse Computations
• Tolpin and others, 2016, Design and Implementation of Probabilistic Programming Language Anglican
• Patel and Lee, 2016, Dynamic Analysis of Multi-threaded Embedded Software to Expose Atomicity Violations
• Hariri and others, 2016, Evaluating the Effects of Compiler Optimizations on Mutation Testing at the Compiler IR Level
• Sun and others, 2016, Finding compiler bugs via live code mutation
• Gotti and Mbarki, 2016, Java Swing Modernization Approach - Complete Abstract Representation based on Static and Dynamic Analysis
• Na and others, 2016, JavaScript Parallelizing Compiler for Exploiting Parallelism from Data-Parallel HTML5 Applications
• Truong and others, 2016, Latte a language, compiler, and runtime for elegant and efficient deep neural networks
• Yamamoto and others, 2016, Lightweight Ruby Framework for Improving Embedded Software Efficiency
• Guo and Si, 2016, Mechanical hydraulic characteristic analysis scheme based on lightweight crowd data in mobile embedded devices
• Tian and others, 2016, Optimizing GPU Register Usage Extensions to OpenACC and Compiler Optimizations
• Raj, 2016, Performance analysis of different specifications of copy propagation transformation using machine SUIF compiler infrastructure
• Rodríguez and others, 2016, Proving Correctness of a Compiler Using Step-indexed Logical Relations
• Gómez-Déniz and others, 2016, Random Tests Combining Mathematica Package and Latex Compiler
• Gaudet and Stoodley, 2016, Rebuilding an airliner in flight a retrospective on refactoring IBM testarossa production compiler for Eclipse OMR
• Lin and others, 2016, Rust as a language for high performance GC implementation
• Xue and Bogdan, 2016, Scalable and realistic benchmark synthesis for efficient NoC performance evaluation
• Zhang, 2016, Selection and Improvement of Computer Programming Language
• Cho, 2016, Semantics for a Quantum Programming Language by Operator Algebras
• Downen and others, 2016, Sequent calculus as a compiler intermediate language
• Ruchkin and others, 2016, Smart compiler embedded computing systems based on cluster parallelism
• Kroening and others, 2016, Sound static deadlock analysis for C/Pthreads
• Amin and others, 2016, System Verilog Assertions Synthesis Based Compiler
• Campos-López and Wannenwetsch, 2016, The PERICLES Process Compiler Linking BPMN Processes into Complex Workflows for Model-Driven Preservation in Evolving Ecosystems
• Sun and others, 2016, Toward understanding compiler bugs in GCC and LLVM
• Khaldi and Chapman, 2016, Towards Automatic HBM Allocation Using LLVM A Case Study with Knights Landing
• MORIGUCHI and others, 2016, Verification of Content-Centric Networking Using Proof Assistant
• Buchwald and others, 2016, Verified construction of static single assignment form
• Zhou and others, 2016, Worst case response time and schedulability analysis for real-time software transactional memory-lazy conflict detection STM-LCD
• Mhaske and others, 2015, A 2.48Gb/s FPGA-based QC-LDPC decoder An algorithmic compiler implementation
• Kyrtatas and others, 2015, A Basic Linear Algebra Compiler for Embedded Processors
• Murthy and Mellor-Crummey, 2015, A Compiler Transformation to Overlap Communication with Dependent Computation
• Michels and others, 2015, A new probabilistic constraint logic programming language based on a generalised distribution semantics
• Yamato, 2015, Automatic verification for plural virtual machines patches
• Verma and Bakshi, 2015, Chronological Advancement in Compiler Design A Review
• Royuela and others, 2015, Compiler analysis for OpenMP tasks correctness
• Li and others, 2015, Compiler directed automatic stack trimming for efficient non-volatile processors
• Haj-Yihia and others, 2015, Compiler-Directed Power Management for Superscalars
• Basu and others, 2015, Compiler-Directed Transformation for Higher-Order Stencils
• Mosterman and Zander, 2015, Cyber-physical systems challenges a needs analysis for collaborating embedded software systems
• Abramsky and Horsman, 2015, DEMONIC programming a computational language for single-particle equilibrium thermodynamics, and its formal semantics
• Gordon and Scholz, 2015, Dynamic adaptation of functional runtime systems through external control
• 2015, Efficient Implementation of Class Based Decomposition Schemes for Naive Bayes Classifier
• Kim, 2015, Exploiting Window Query Semantics in Scalable Data Stream Processing
• Stanisic and others, 2015, Faithful performance prediction of a dynamic task-based runtime system for heterogeneous multi-core architectures
• Le and others, 2015, Finding deep compiler bugs via guided stochastic program mutation
• Queiroz Junior and da Silva, 2015, Finding Good Compiler Optimization Sets - A Case-based Reasoning Approach
• Breitner, 2015, Formally proving a compiler transformation safe
• Cazzola and Olivares, 2015, Gradually Learning Programming Supported by a Growable Programming Language
• Jiang and others, 2015, Implementation and Comparison of the Way That Office Document Is Converted to PDF Documents in the Java Runtime Environment
• 2015, Implementation of a Motor Imagery based BCI System using Python Programming Language
• Mehta and Yew, 2015, Improving compiler scalability optimizing large programs at small price
• Leopoldseder and others, 2015, Java-to-JavaScript translation via structured control flow reconstruction of compiler IR
• Park and others, 2015, KJS a complete formal semantics of JavaScript
• Ko and others, 2015, LaminarIR compile-time queues for structured streams
• Iskra and Hoefler, 2015, Operating systems and runtime environments on supercomputers
• Ghica and Tapus, 2015, Optimized retargetable compiler for embedded processors - GCC vs LLVM
• Yang and Ruiz Varela, 2015, Qualifying non-volatile register files for embedded systems through compiler-directed write minimization and balancing
• Mosses, 2015, Semantics of programming languages Using Asf+Sdf
• Naish, 2015, Sharing analysis in the Pawns compiler
• Srinivasan and Reps, 2015, Synthesis of machine code from semantics
• D’Silva and others, 2015, The Correctness-Security Gap in Compiler Optimization
• Ricketts and others, 2015, Towards verification of hybrid systems in a foundational proof assistant
• Papadakis and others, 2015, Trivial Compiler Equivalence A Large Scale Empirical Study of a Simple, Fast and Effective Equivalent Mutant Detection Technique
• Lezuo and others, 2015, vanHelsing A Fast Proof Checker for Debuggable Compiler Verification
• Blazy and others, 2015, Verified Validation of Program Slicing

What the survey shows

The representation question is settled in the literature and the selection question is not. Four independent traditions converge on a discriminated return for terminating coroutines, and none of them addresses whether a bounded-memory artefact should pay that discrimination on every call of a construct that never terminates. The present article contributes the observation that the two source forms have different trace alphabets and that the choice can therefore be made per form rather than globally, which the surveyed work does not consider because no surveyed language separates the two forms in its type system.

That separation is Keleusma’s own contribution to the problem, and it is the reason the question is even askable here. It is also why the survey cannot answer it.

The scale of the survey should be read for what it is. It lists 1,979 references, of which 35 were selected because the argument depends on them and the rest were harvested by query across thirteen clusters. The harvested majority establishes coverage and not agreement. A reader looking for the works that carry the argument should read the 35, which are named in the prose above. A reader checking whether the survey was assembled to flatter its conclusion should note that the queries were fixed before any record was seen, that every admitted record is listed including the 680 that are merely adjacent, and that the selection procedure is reported in Method with the count it discarded.

The Source Base

The generator is a detached package inside the Keleusma repository, consuming the reference compiler’s in-memory module representation and emitting LLVM intermediate representation through the inkwell bindings. The bytecode it consumes has already passed a structural verifier, in the tradition the Java Virtual Machine Specification sets out for bytecode verification, so the backend declines what it cannot lower and does not approximate it. The classification instrument is a test in the same package, reporting rather than asserting, with one guard that fails if the corpus walk finds nothing, because a broken path and a real zero look identical in a report.

The differential oracle drives both the virtual machine and the just-in-time compiled native code over identical bytecode and compares the whole sequence of yielded values. The stream drivers are bounded by a caller-supplied count, because a productively divergent program will otherwise run until something kills it, and a hung test reports nothing at all, worse than a failing one.

Epistemic State

Measured, and reproducible from the instrument. The corpus yields 24 stream chunks, of which 22 have a single suspension at the end of the body, 0 have multiple top-level suspensions, 1 has suspensions nested in conditionals, and 1 delegates with no suspension of its own. The nested chunk has 19 suspensions, all inside conditionals and none inside a loop, at nesting depths from 2 to 11. The corpus contains exactly 1 terminating coroutine chunk, in which 9 of 9 suspensions are immediately followed by a return. Ten stream chunks are refused by the current tail-position rule for a tail sequence that is effect-free and stack-neutral.

Derived, and checkable from the definitions. That a terminating coroutine produces two distinguishable observable events while a return-based convention provides one channel, and that the second therefore cannot carry the first, by $\lvert W \times W \rvert = \lvert W \rvert^2 > \lvert W \rvert$ for $\lvert W \rvert \ge 2$. That a divergent coroutine produces one, because its trace alphabet omits the completion letter. That the admissibility rule satisfies $R \subsetneq P$, so its defect is coverage and not soundness. That $\Delta(\pi) = -1$ for both candidate tail segments. That a suspension inside a conditional is a control-flow join while one inside a loop crosses a back edge.

Assumed, and marked as such. That the return convention is cheaper at run time. The structural grounds are stated and the frame-size measurement that would establish it was not performed, because the machine-code section carrying it is not emitted on this host.

Verified, and the verification method itself produced a finding twice. All 35 hand-selected research identifiers were resolved against the registry and compared with the work they are cited as. Thirty-five of thirty-five resolve to that work, an error rate of zero. The 1,944 harvested identifiers were not audited that way and do not need to be, because they were transcribed from the registry that issued them rather than recalled, so the failure mode the audit exists to catch cannot arise. What the audit would still catch, and did not run for, is a harvested record cited for a claim it does not support, and no harvested record is cited for any claim.

Sampled, because checking all of them would be checking the registry against itself. A random sample of 250 harvested identifiers was resolved, and 250 of 250 exist. What the sample does establish is a transcription check on the pipeline in this repository, since a fault there would affect a constant fraction of records and not a rare one, and no such fraction appeared.

Twenty-two of the 250, or 8.8 percent, resolved only through the registry. The identifier resolver did not serve them. Twenty refused the connection outright, of which 14 were Defense Technical Information Center deposits, and 2 returned a not-found response from a publisher that no longer serves the landing page. In every one of the 22 the identifier is registered and the record is correct. The defect is therefore in the resolution path and not in the citation. It is reported because a reader checking a sample of these references by clicking them will meet roughly one failure in eleven, and that failure is not evidence of a bad citation.

Two passes were run with two different instruments and they flagged different records, which is itself the lesson. A title-overlap heuristic flagged four. A later check comparing author surname and year flagged five. The union is eight distinct records and every one of them was vindicated on individual inspection, for four separate reasons.

The last category is the one worth carrying forward, because it is not an instrument error at all. The identifier is correct, the work is correct, and the year genuinely differs, since a foundational paper and its journal reprint are two publications of one text. A checker comparing years will flag every reprinted classic in any bibliography, and a bibliography of foundational work is mostly reprinted classics.

Not one of the eight was a citation defect, and reporting any of them as one would have been a measurement mistake of exactly the kind this series keeps documenting. It is recorded because the previous article reported a 5.5 percent rate by the same method and did not separate these artefacts from genuine mismatches, which means that figure is an upper bound rather than an estimate and the true rate there may be lower.

Corrected during writing, and left visible. The plan this article set out to support was to unify the two conventions, and it survived until it was traced against a three-instruction example. The central claim was also stated in a form stronger than the evidence supported, assuming a one-word return until the governing application binary interface documents were read, and the correction opened an option the draft did not contain. An earlier design in this series specified a reordering transformation for bodies with several suspension points, of which the corpus contains none. A classification that called nineteen suspensions “the general case” was collapsing two structurally different situations, and the per-suspension measurement separated them.

Corrected after publication, and left visible. Two defects reached the published text and both are repaired above rather than silently.

The widened-return option was published under-costed. It was presented as costing a wider return and a host-side discrimination while preserving the frame property. A widened return does not give reentrancy. A terminating coroutine that suspends more than once must resume mid-body, which needs saved state, which is a frame. The honest interface is a triple carrying a continuation and not a pair carrying a tag, the per-call model omitted the frame term entirely, and the claim that the frame property is preserved holds only for a coroutine that suspends at most once per call. The error was in the direction that made that option look more attractive than it is, and the correction therefore strengthens the recommendation rather than disturbing it. The pigeonhole argument, the semantic-boundary finding and every measurement are unaffected.

The corpus could not have exposed it, and that is the article’s own lesson turned back on the article. The corpus holds exactly one terminating chunk and it suspends at most once per call, so a tagged pair genuinely does suffice for it, because resuming mid-body and resuming at entry after the sole suspension coincide. The general case never appears. A distribution over instances cannot answer a question about an interface, which this article establishes at length and then failed to apply when costing an option. It was raised before publication and did not reach the text.

The option count contradicted the list beneath it. The published text read that two options remained and then set out three. The sentence was introduced by a later editing pass that replaced a colon-led label with a full sentence and asserted a count the list never had. It now reads three.

What this article does not establish. Which of the remaining options is correct, since that turns on an ABI decision belonging to a workstream this article does not speak for. Whether the widened-return option is cheaper than two conventions, which is an empirical question and is not measured here. Whether the source-restructuring option is reasonable. Whether the corpus resembles the population the generator will serve.

The literature survey has two layers with different standing and only one of them bears on the argument.

The 35 hand-selected works were chosen by the author’s judgement of relevance, were read, and are the ones the prose reasons from. That layer is a narrative review. No protocol was registered and no completeness is claimed for it.

The 1,944 harvested works were retrieved by fixed queries against two registries and admitted by a stated filter, which is reproducible in a way the narrative layer is not. It is still not a systematic review. The query set was written by the same author whose judgement the narrative layer rests on, only two registries were searched, no grey literature was sought, no inclusion criteria beyond the title filter were applied, and no harvested record was read.

A reader should therefore treat the assertion that four traditions converge on a discriminated return as an observation over the works cited rather than over the field. The specific negative claim, that none of the surveyed work addresses per-form selection in a bounded-memory setting, is the one most exposed to an omission. The harvest makes that claim more exposed rather than less, because the harvested titles were not read and a paper answering the question could sit in the list unremarked. It is stated as a gap in the survey rather than a gap in the literature.

The strongest claim the evidence supports is that the return convention cannot serve terminating coroutines, on an argument that does not depend on the corpus at all. The weakest link is the cost comparison between the two remaining options, which rests on an unmeasured performance claim and on a corpus of twenty-four.

Out of Scope

The design of the lowering for any individual instruction. Register allocation, scheduling and peephole optimisation. The worst-case execution time analysis, which is a separate subject with a separate method. The exact frame-size comparison between the two conventions, which requires a target this host does not emit. Whether the delegating program should be restructured, which is a language question. The Keleusma language itself, which is covered in the getting-started article and the self-hosting strategy.

Conclusion

An apparent design wart turned out to be a semantic boundary, and the evidence that made it look like a wart was accurate. The measurement said nine out of nine, and nine out of nine was true. It was a fact about the shape of instances, offered in answer to a question about the arity of an interface, and the two are not the same question.

The check that settled it cost one traced example and produced an argument that holds independently of the corpus, which the measurement it overturned does not. Where a claim can be settled by counting the channels an interface provides against the outcomes a behaviour produces, that count dominates any distribution over instances, and it is available before any code is written.

The article also reports a rule shipped one increment earlier that is stricter than its own stated purpose, refusing ten of twenty-four cases whose tail sequence is provably harmless. It was found by building a table, not by running a test, which is now the second such finding in this series and no longer looks like a coincidence.

Equations

This section collects the 32 display equations of the article in the order they appear, each under its number and reproduced exactly as it stands in the text. A title in bold names an established result, and a title in italics beginning with the word Bespoke names a construction made for this analysis. Of the 32, 9 are established and 23 are bespoke. Cardinalities are counts of distinguishable values of the 64-bit machine word type, so a power of two here counts values while a multiple of sixty-four counts bits, and the two are related by a logarithm rather than by a factor.

Equation 1, Bespoke Partition of Chunks by Termination. The article partitions the compiled coroutine chunks into divergent stream chunks and terminating chunks, the distinction the type checker already enforces.

Equation 2, Bespoke Trace of a Terminating Chunk. The article models a terminating execution as a finite trace of suspensions that ends in exactly one completion, so it uses both letters of the trace alphabet.

Equation 3, Bespoke Trace of a Divergent Chunk. The article models a divergent execution as an infinite trace of suspensions with no completion, so it uses only one letter of the trace alphabet.

Equation 4, Bespoke Host Call Sequence Under the Return Convention. Under the return convention the host calls a stateless native function again with each resume value, so nothing carries over between calls.

Equation 5, Bespoke Faithful Encoding Required of a One-Word Return. A return convention that is faithful to a terminating trace must map the pair of a yielded value and a completion value injectively into a single machine word.

Equation 6, Cardinality of a Pair of Machine Words. The set of pairs of 64-bit words has the square of the number of words as its size, which exceeds the size of a single word, so by the pigeonhole principle no injection from pairs into one word exists.

Equation 7, Bit Count Condition for a Faithful Encoding. An interface of a given number of machine words can carry a trace faithfully only when the trace needs no more words than the interface provides, the elementary case of the channel-capacity argument. Shannon 1948

Equation 8, Bespoke Pigeonhole Test for a Calling Convention. The article states its general test, that a convention exposing fewer distinguishable channels than a chunk has observable values per call cannot be injective on that chunk’s traces.

Equation 9, Bespoke Collapse Factor for a Terminating Chunk. A terminating trace with a given number of suspensions carries one more word than suspensions while one call distinguishes a single word, so the article’s collapse factor grows as a power of the word count in the number of suspensions.

Equation 10, Return Channels Fixed by the Application Binary Interface. The System V AMD64 application binary interface and the Arm 64-bit procedure call standard return a word in one register and a two-word aggregate in a register pair, so the number of return channels depends on the declared return type. System V AMD64 application binary interface AAPCS64

Equation 11, Cardinality of a Tagged Word. Attaching a two-valued tag to a 64-bit word doubles the number of distinguishable values, which needs one bit more than a single word holds.

Equation 12, Bespoke Widened Return with a Discriminator. The article’s third option widens every coroutine entry point to return a tag that distinguishes suspension from completion together with a word, which suffices only for a coroutine that suspends at most once per call.

Equation 13, Bespoke Widened Return with a Continuation. A terminating coroutine must resume mid-body, so the article extends the widened return with a continuation in the manner of the returned-continuation lowering of the LLVM compiler infrastructure. the Low Level Virtual Machine compiler infrastructure

Equation 14, Bespoke Total Cost of One Widened Convention Against Two Conventions. The article’s cost model charges the widened return a per-call tag and frame cost over all calls and charges two conventions a single fixed metadata cost.

Equation 15, Bespoke Crossover Call Count. Equating the two totals of Equation 14 gives the number of calls below which the widened return is the cheaper design.

Equation 16, Value Space Remaining After Reserving a Sentinel. Reserving one word as a sentinel leaves one fewer than two to the sixty-fourth power usable values, a negligible loss in measure that nonetheless makes the reserved value unrepresentable as a yield.

Equation 17, Bespoke Fit of the Return Convention to a Divergent Chunk. A divergent chunk has one observable value per call and the one-word return supplies one channel, so the identity encoding suffices for every admitted stream chunk.

Equation 18, Bespoke Host Correspondence for a Divergent Chunk. The first call consumes the initial argument and each later call consumes the next resume value, exactly as the virtual machine writes the resume value into the entry chunk’s parameter slot.

Equation 19, Bespoke Admissibility Property for a Tail Segment. The article states the property that licenses the return lowering, that the tail after a suspension has no side effects and a net stack effect of minus one so that it consumes exactly the resume value.

Equation 20, Bespoke Stack Effect of the Two Candidate Tails. The admissibility property of Equation 19 is evaluated for the single discard and for the discard, constant and discard sequence, and both have a net stack effect of minus one.

Equation 21, Bespoke Soundness Without Completeness of the Shipped Rule. The set of tails the shipped whitelist admits is a proper subset of the set the property licenses, and at least ten licensed tails are refused.

Equation 22, Bespoke Coverage of the Shipped Rule Against the Property. The fractions of stream chunks admitted by the shipped rule and by the property show that ten of twenty-four chunks are refused the cheap convention without cause.

Equation 23, Bespoke Join Predicate for a Suspension. A suspension is classified as a control-flow join when no loop block is open on the enclosing block stack, so it crosses no back edge.

Equation 24, Bespoke Differential Oracle on Yielded Sequences. The native lowering is checked against the reference virtual machine by comparing the first several yielded values of the two traces for the same argument and resume values.

Equation 25, Bespoke Admissibility of a Unification as a Universal Claim. The article states admissibility of a unification as the claim that every behaviour in the class has no more observable values than the interface has channels.

Equation 26, Negation of a Universal Claim. The negation of a universal claim is an existential one, so a single behaviour that exceeds the interface refutes the unification.

Equation 27, Universal Bound as a Bound on the Maximum. A bound holds for every member of a finite class exactly when it holds for the maximum over the class, which a frequency of observed successes does not estimate.

Equation 28, Clopper-Pearson Lower Bound After No Failures. After all of a number of trials succeed, the exact one-sided lower confidence bound on the success proportion is the significance level raised to the reciprocal of the number of trials. Clopper and Pearson 1934

Equation 29, Trials Needed to Bound a Proportion Above a Threshold. Inverting the bound of Equation 28 gives the number of consecutive successes needed before a proportion of ninety-nine percent is supported at the stated confidence. Clopper and Pearson 1934 Hanley and Lippman-Hand 1983

Equation 30, Bespoke Native Frames Live During Host Execution. The article observes that the return convention leaves no native frame live while the host runs, whereas the callback convention leaves the chunk’s frame and those of its callers live.

Equation 31, Bespoke Difference in Worst-Case Native Stack. The worst-case native stack bound of the callback convention exceeds that of the return convention by the total size of the frames live during host execution.

Equation 32, Bespoke Native Calls per Iteration. The return convention makes one native call per iteration and the callback convention makes one more for each suspension in the iteration.

Notation

• $W$, the machine word type, with $\lvert W \rvert = 2^{64}$ distinguishable values on the present target
• $K_\Sigma$, the set of divergent stream chunks, which never complete
• $K_\Upsilon$, the set of terminating chunks, which complete after finitely many suspensions
• $\mathsf{Y}$, the trace letter for a suspension carrying a yielded value, with $\mathsf{F}$ the letter for a completion
• $\mathcal{T}_\Upsilon(k, a, \vec{r})$, the observable trace of chunk $k$ driven by initial argument $a$ and resume values $\vec{r}$, written with $\Sigma$ for a divergent chunk
• $\varepsilon_{\mathrm{ret}}$, the return-based calling convention, with $\varepsilon_{\mathrm{cb}}$ the callback convention
• $\mathrm{chan}(\varepsilon)$, the number of distinguishable word-valued channels a single native call exposes under convention $\varepsilon$
• $\mathrm{obs}(k)$, the number of distinct observable values a single call of chunk $k$ must convey
• $\mathsf{cont}$, a continuation identifying where and with what state a coroutine resumes
• $c_{\mathrm{tag}}$, the per-call cost of the discriminator, with $c_{\mathrm{frame}}$ the amortised per-call cost of a saved frame and $c_{\mathrm{meta}}$ the one-off cost of two conventions
• $N^{*}$, the crossover number of calls below which a single widened convention is cheaper
• $\delta(\iota)$, the net operand stack effect of instruction $\iota$, summed over a tail segment $\pi$ as $\Delta(\pi)$
• $\mathrm{eff}(\pi)$, the set of side effects of tail segment $\pi$
• $R \;\subsetneq\; P$, the set $R$ of tail segments the shipped rule admits and the set $P$ the property licenses
• $B(y)$, the stack of open blocks at suspension $y$
• $\mathcal{Y}$, the projection of a trace onto its suspension letters, applied to the virtual machine trace and the native trace
• $\mathcal{B}$, a class of behaviours $b$ that a proposed unification maps onto an interface, whose channel count is written $\mathrm{chan}(\iota)$ in Equations 25 to 27
• $\alpha$, the significance level, one minus the confidence
• $L(\varepsilon_{\mathrm{cb}})$, the set of native frames live while host code executes under the callback convention
• $\Delta M$, the difference in worst-case native stack between the callback and return conventions
• $\tau_{\mathrm{ret}}$, the native calls per iteration under the return convention, with $\tau_{\mathrm{cb}}$ the count under the callback convention and $s$ the suspensions per iteration

References

Primary Sources, Peer-Reviewed

• “2018 Proceedings of the International Conference on Embedded Software (EMSOFT).” 2018. In 2018 International Conference on Embedded Software (EMSOFT). IEEE. https://doi.org/10.1109/emsoft.2018.8537228
• “3D Pre-Stack Depth Migration V0 Analysis and Monte Carlo Automatic Velocity Picking in Depth.” 2002. Chinese Journal of Geophysics 45 (2): 247–55. https://doi.org/10.1002/cjg2.237
• Abdallah, Samer. 2018. “PRISM Revisited: Declarative Implementation of a Probabilistic Programming Language Using Multi-Prompt Delimited Control.” International Journal of Approximate Reasoning 103: 364–82. https://doi.org/10.1016/j.ijar.2018.10.012
• Abdelmaksoud, Hany, Zain A. H. Hammadeh, Goerschwin Fey, and Daniel Lüdtke. 2023. “DEL: Dynamic Symbolic Execution-Based Lifter for Enhanced Low-Level Intermediate Representation.” In 2023 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE. https://doi.org/10.23919/date56975.2023.10137253
• Abdulsalam, Sarah, Donna Lakomski, Qijun Gu, Tongdan Jin, and Ziliang Zong. 2014. “Program Energy Efficiency: The Impact of Language, Compiler and Implementation Choices.” In International Green Computing Conference. IEEE. https://doi.org/10.1109/igcc.2014.7039169
• Abe, Tatsuya. 2019. “A Type System for Data Independence of Loop Iterations in a Directive-Based PGAS Language.” In Proceedings of the 16th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3357390.3361021
• Abi-Karam, Stefan, Rishov Sarkar, Dejia Xu, Zhiwen Fan, Zhangyang Wang, and Cong Hao. 2023. “INR-Arch: A Dataflow Architecture and Compiler for Arbitrary-Order Gradient Computations in Implicit Neural Representation Processing.” In 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD). IEEE. https://doi.org/10.1109/iccad57390.2023.10323650
• Abrahams, Paul W. 1979. “The CIMS PL/I Compiler.” In Proceedings of the 1979 SIGPLAN symposium on Compiler construction - SIGPLAN ‘79. ACM Press. https://doi.org/10.1145/800229.806960
• Abu-Yosef, Raneem, and Martin Kong. 2025. “Scalable Data-Flow Modeling and Validation of Distributed-Memory Algorithms.” In Proceedings of the 34th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3708493.3712690
• Aceto, Luca, and Wan Fokkink. 2004. “Guesteditors’introduction:Specialissueon Structural Operational Semantics.” Journal of Logic and Algebraic Programming 60-61: 1–2. https://doi.org/10.1016/j.jlap.2004.03.010
• Achour, Safaa, and Mohammzed Benattou. 2018. “Constraint Based Testing and Verification of Java Bytecode Programs.” In 2018 IEEE 5th International Congress on Information Science and Technology (CiSt). IEEE. https://doi.org/10.1109/cist.2018.8596397
• Acun, Bilge, Kavitha Chandrasekar, and Laxmikant V. Kale. 2019. “Fine-Grained Energy Efficiency Using per-Core DVFS with an Adaptive Runtime System.” In 2019 Tenth International Green and Sustainable Computing Conference (IGSC). IEEE. https://doi.org/10.1109/igsc48788.2019.8957174
• Affeldt, Reynald, Cyril Cohen, and Ayumu Saito. 2023. “Semantics of Probabilistic Programs Using s-Finite Kernels in Coq.” In Proceedings of the 12th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3573105.3575691
• Agathos, Spiros N., Vassilios V. Dimakopoulos, and Ilias K. Kasmeridis. 2022. “Compiler-Assisted, Adaptive Runtime System for the Support of OpenMP in Embedded Multicores.” Parallel Computing 110: 102895. https://doi.org/10.1016/j.parco.2022.102895
• Agathos, Spiros N., Panagiotis E. Hadjidoukas, and Vassilios V. Dimakopoulos. 2011. “Design and Implementation of OpenMP Tasks in the OMPi Compiler.” In 2011 15th Panhellenic Conference on Informatics. IEEE. https://doi.org/10.1109/pci.2011.34
• Ahman, Danel, and Sam Staton. 2013. “Normalization by Evaluation and Algebraic Effects.” Electronic Notes in Theoretical Computer Science 298: 51–69. https://doi.org/10.1016/j.entcs.2013.09.007
• Aigrain, Philippe, Susan L. Graham, Robert R. Henry, Marshall Kirk McKusick, and Eduardo Pelegri-Llopart. 1984. “Experience with a Graham-Glanville Style Code Generator.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502876
• Aissa, Nadia Bel Hadj, Gilles Grimaud, and Vincent Benony. 2007. “Bringing Worst Case Execution Time Awareness to an Open Smart Card OS.” In 13th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications (RTCSA 2007). IEEE. https://doi.org/10.1109/rtcsa.2007.24
• Akdur, Deniz, Onur Demirors, and Vahid Garousi. 2017a. “Characterizing the Development and Usage of Diagrams in Embedded Software Systems.” In 2017 43rd Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2017.13
• Akdur, Deniz, Vahid Garousi, and Onur Demirors. 2017b. “Cross-Factor Analysis of Software Modeling Practices versus Practitioner Demographics in the Embedded Software Industry.” In 2017 6th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco.2017.7977123
• Aldweesh, Amjad, Maher Alharby, Maryam Mehrnezhad, and Aad van Moorsel. 2021. “The OpBench Ethereum Opcode Benchmark Framework: Design, Implementation, Validation and Experiments.” Performance Evaluation 146: 102168. https://doi.org/10.1016/j.peva.2020.102168
• Ali, Ghazi Mergani Ahmead, Hongsong Chen, Zhongru Wang, and Chunlai Du. 2025a. “CrossGuard: Runtime-Adaptive LLM Fuzzing for Cross-Contract Vulnerabilities Detection.” Concurrency and Computation: Practice and Experience 37 (27–28): e70421. https://doi.org/10.1002/cpe.70421
• Aljaafari, Fatimah K., Rafael Menezes, Edoardo Manino, Fedor Shmarov, Mustafa A. Mustafa, and Lucas C. Cordeiro. 2022. “Combining BMC and Fuzzing Techniques for Finding Software Vulnerabilities in Concurrent Programs.” IEEE Access 10: 121365–84. https://doi.org/10.1109/access.2022.3223359
• Alkhalid, Abdulaziz, and Yvan Labiche. 2018. “Towards GUI Functional Verification Using Abstract Interpretation.” In Proceedings of the 13th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006917104150422
• Alladi, Shreya, Alberto Ros, and Alexandra Jimborean. 2026. “Enabling Automatic Compiler-Driven Vectorization of Transformers.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395226
• Allamanis, Miltiadis, and Charles Sutton. 2013. “Why, When, and What: Analyzing Stack Overflow Questions by Topic, Type, and Code.” In 2013 10th Working Conference on Mining Software Repositories (MSR). IEEE. https://doi.org/10.1109/msr.2013.6624004
• Amaliah, Yusni, Wilem Musu, Suprianto, and Muhammad Fadlan. 2021. “Auto Clustering Source Code to Detect Plagiarism of Student Programming Assignments in Java Programming Language.” In 2021 3rd International Conference on Cybernetics and Intelligent System (ICORIS). IEEE. https://doi.org/10.1109/icoris52787.2021.9649465
• Amarasinghe, Saman. 2004. “Session Details: Compiler and Simulator Construction.” In Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/3244311
• Amarasinghe, Saman. 2020. “Compiler 2.0: Using Machine Learning to Modernize Compiler Technology.” In The 21st ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems. ACM. https://doi.org/10.1145/3372799.3397167
• Amato, Gianluca, Maria Chiara Meo, and Francesca Scozzari. 2020. “On Collecting Semantics for Program Analysis.” Theoretical Computer Science 823: 1–25. https://doi.org/10.1016/j.tcs.2020.02.021
• Amin, Omar, Youssef Ramzy, Omar Ibrahem, Ahmed Fouad, Khaled Mohamed, and Mohamed Abdelsalam. 2016. “System Verilog Assertions Synthesis Based Compiler.” In 2016 17th International Workshop on Microprocessor and SOC Test and Verification (MTV). IEEE. https://doi.org/10.1109/mtv.2016.22
• Anderson, Paul, and Alexey Loginov. 2013. “Static Analysis of Machine Code for Supply-Chain Risk Management.” In 2013 IEEE International Conference on Technologies for Homeland Security (HST). IEEE. https://doi.org/10.1109/ths.2013.6699090
• Andrews, K., R. R. Henry, and W. K. Yamamoto. 1988. “Design and Implementation of the UW Illustrated Compiler.” ACM SIGPLAN Notices 23 (7): 105–14. https://doi.org/10.1145/960116.54001
• Aneesh, Ch, Gembali Saumik, Kvv Varun, and Meena Belwal. 2024. “Smart Compiler Assistant: An AST Based Python Code Analysis.” In 2024 15th International Conference on Computing Communication and Networking Technologies (ICCCNT). IEEE. https://doi.org/10.1109/icccnt61001.2024.10724220
• Anier, A. 2008. “Motion Recognition with Abstract Interpretation and HMM.” In 2008 11th International Biennial Baltic Electronics Conference. IEEE. https://doi.org/10.1109/bec.2008.4657511
• Antoniadis, Dimitrios Dimitris, Peilong Feng, Andrea Mifsud, and Timothy G. Constandinou. 2021. “Open-Source Memory Compiler for Automatic RRAM Generation and Verification.” In 2021 IEEE International Midwest Symposium on Circuits and Systems (MWSCAS). IEEE. https://doi.org/10.1109/mwscas47672.2021.9531908
• Appel, A. W., and T. Jim. 1989. “Continuation-Passing, Closure-Passing Style.” In Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘89. ACM Press. https://doi.org/10.1145/75277.75303
• Appel, Andrew W., and Zhong Shao. 1992. “Callee-Save Registers in Continuation-Passing Style.” Lisp and Symbolic Computation 5 (3): 191–221. https://doi.org/10.1007/bf01807505
• Applis, Leonhard, Matthías Páll Gissurarson, and Annibale Panichella. 2025. “Suspicious Types and Bad Neighborhoods: Filtering Spectra with Compiler Information.” In 2025 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst62969.2025.10988920
• Aquino, Andrea, Giovanni Denaro, and Pasquale Salza. 2018. “Worst-Case Execution Time Testing via Evolutionary Symbolic Execution.” In 2018 IEEE 29th International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre.2018.00019
• Arakaki, Shota, and Masao Hirokawa. 2026. “Foundational Design of Multi-Modal Typed Programming Language for Quantum-Classical Hybrid Computing System.” In 2026 International Conference on Artificial Intelligence, Computer, Data Sciences and Applications (ACDSA). IEEE. https://doi.org/10.1109/acdsa67686.2026.11468027
• Arcaro, Luis Fernando, Karila Palma Silva, Romulo Silva de Oliveira, and Luis Almeida. 2020. “Reliability Test Based on a Binomial Experiment for Probabilistic Worst-Case Execution Times.” In 2020 IEEE Real-Time Systems Symposium (RTSS). IEEE. https://doi.org/10.1109/rtss49844.2020.00016
• Arnström, Daniel, David Broman, and Daniel Axehill. 2024. “Exact Worst-Case Execution-Time Analysis for Implicit Model Predictive Control.” IEEE Transactions on Automatic Control 69 (10): 7190–96. https://doi.org/10.1109/tac.2024.3395521
• Asadollah, Sara Abbaspour, Daniel Sundmark, Sigrid Eldh, and Hans Hansson. 2018. “A Runtime Verification Tool for Detecting Concurrency Bugs in FreeRTOS Embedded Software.” In 2018 17th International Symposium on Parallel and Distributed Computing (ISPDC). IEEE. https://doi.org/10.1109/ispdc2018.2018.00032
• Asai, Kenichi. 2002. “Online Partial Evaluation for Shift and Reset.” ACM SIGPLAN Notices 37 (3): 19–30. https://doi.org/10.1145/509799.503034
• Asai, Kenichi. 2004. “Offline Partial Evaluation for Shift and Reset.” In Proceedings of the 2004 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation. ACM. https://doi.org/10.1145/1014007.1014009
• Astarte, Troy Kaighin. 2025. “Conceptualising Programming Language Semantics.” Philosophies 10 (4): 90. https://doi.org/10.3390/philosophies10040090
• Ataei, Samira, and Rajit Manohar. 2019. “AMC: An Asynchronous Memory Compiler.” In 2019 25th IEEE International Symposium on Asynchronous Circuits and Systems (ASYNC). IEEE. https://doi.org/10.1109/async.2019.00009
• Aung, Yan Lin, Siew-Kei Lam, and Thambipillai Srikanthan. 2011. “Compiler-Assisted Technique for Rapid Performance Estimation of FPGA-Based Processors.” In 2011 IEEE International SOC Conference. IEEE. https://doi.org/10.1109/socc.2011.6085116
• Auslander, Marc, and Martin Hopkins. 1982. “An Overview of the PL.8 Compiler.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806977
• Austen, Skyler, Shriram Krishnamurthi, and Kathi Fisler. 2025. “Sharing Is Scaring: Linking Cloud File-Sharing to Programming Language Semantics.” In Proceedings of the 2025 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. ACM. https://doi.org/10.1145/3759429.3762621
• Avanzini, Martin, Gilles Barthe, and Ugo Dal Lago. 2021. “On Continuation-Passing Transformations and Expected Cost Analysis.” Proceedings of the ACM on Programming Languages 5 (ICFP): 1–30. https://doi.org/10.1145/3473592
• Avigad, Jeremy, Lior Goldberg, David Levit, Yoav Seginer, and Alon Titelman. 2025. “A Proof-Producing Compiler for Blockchain Applications.” Journal of Automated Reasoning 69 (2): 9. https://doi.org/10.1007/s10817-025-09723-y
• Avigad, Jeremy, Johannes Hölzl, and Luke Serafin. 2017. “A Formally Verified Proof of the Central Limit Theorem.” Journal of Automated Reasoning 59 (4): 389–423. https://doi.org/10.1007/s10817-017-9404-x
• Avvenuti, Marco, Cinzia Bernardeschi, and Nicoletta De Francesco. 2003. “Java Bytecode Verification for Secure Information Flow.” ACM SIGPLAN Notices 38 (12): 20–27. https://doi.org/10.1145/966051.966055
• Azeemi, N. 2006. “Compiler Directed Battery-Aware Implementation of Mobile Applications.” In 2006 International Conference on Emerging Technologies. IEEE. https://doi.org/10.1109/icet.2006.335979
• Baek, Nakhoon, and Kuinam J. Kim. 2017. “Prototype Implementation of the OpenGL ES 2.0 Shading Language Offline Compiler.” Cluster Computing 22 (S1): 943–48. https://doi.org/10.1007/s10586-017-1113-z
• Baek, Soyeon, and Sungho Lee. 2024. “CaLLi: OCaml Library for Static Analysis of LLVM Bitcode.” SoftwareX 27: 101810. https://doi.org/10.1016/j.softx.2024.101810
• Baev, Ivan D. 2009. “Techniques for Region-Based Register Allocation.” In 2009 International Symposium on Code Generation and Optimization. IEEE. https://doi.org/10.1109/cgo.2009.31
• Baggett, Lawrence W. 2000. “An Abstract Interpretation of the Wavelet Dimension Function Using Group Representations.” Journal of Functional Analysis 173 (1): 1–20. https://doi.org/10.1006/jfan.1999.3551
• Baghdadi, Riyadh, Jessica Ray, Malek Ben Romdhane, et al. 2019. “Tiramisu: A Polyhedral Compiler for Expressing Fast and Portable Code.” In 2019 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2019.8661197
• Bai, Na, Tianbo Ming, Biwei Liu, Yaohua Xu, and Yi Wang. 2025. “APCer: An Agile Physical Compiler for Multi-Port Register File.” In 2025 IEEE International Symposium on Circuits and Systems (ISCAS). IEEE. https://doi.org/10.1109/iscas56072.2025.11043756
• Baltes, Sebastian, and Stephan Diehl. 2018. “Usage and Attribution of Stack Overflow Code Snippets in GitHub Projects.” Empirical Software Engineering 24 (3): 1259–95. https://doi.org/10.1007/s10664-018-9650-5
• Baltes, Sebastian, Christoph Treude, and Stephan Diehl. 2019. “SOTorrent: Studying the Origin, Evolution, and Usage of Stack Overflow Code Snippets.” In 2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR). IEEE. https://doi.org/10.1109/msr.2019.00038
• Bao, Wenlei, Sanket Tavarageri, Fusun Ozguner, and P. Sadayappan. 2014. “PWCET: Power-Aware Worst Case Execution Time Analysis.” In 2014 43rd International Conference on Parallel Processing Workshops. IEEE. https://doi.org/10.1109/icppw.2014.64
• Baradaran, Sara, Liyan Huang, Mukund Raghothaman, and Weihang Wang. 2026. “Reusing Legacy Code in Wasm: Key Challenges of Compilation and Code Semantics Preservation.” In 2026 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner67736.2026.00029
• Barash, L. Yu., and L. N. Shchur. 2013. “RNGSSELIB: Program Library for Random Number Generation. More Generators, Parallel Streams of Random Numbers and Fortran Compatibility.” Computer Physics Communications 184 (10): 2367–69. https://doi.org/10.1016/j.cpc.2013.04.007
• Bardonek, Petr, and Marcela Zachariasova. 2026. “Leveraging Design Static Analysis for Vertical Reuse: Analytical Interpretation and Scalability Behavior.” Microprocessors and Microsystems 123: 105300. https://doi.org/10.1016/j.micpro.2026.105300
• Barinov, Viacheslav, Mikhail Kashkarov, and Andrey Kazmin. 2020. “Applying Compiler-Based Binary Watermarking Technology to Ensure Binary Compatibility in GNU/Linux Distribution.” In 2020 Ivannikov Ispras Open Conference (ISPRAS). IEEE. https://doi.org/10.1109/ispras51486.2020.00009
• Barrière, Aurèle, Sandrine Blazy, Olivier Flückiger, David Pichardie, and Jan Vitek. 2021. “Formally Verified Speculation and Deoptimization in a JIT Compiler.” Proceedings of the ACM on Programming Languages 5 (POPL): 1–26. https://doi.org/10.1145/3434327
• Barrière, Aurèle, Sandrine Blazy, and David Pichardie. 2023. “Formally Verified Native Code Generation in an Effectful JIT: Turning the CompCert Backend into a Formally Verified JIT Compiler.” Proceedings of the ACM on Programming Languages 7 (POPL): 249–77. https://doi.org/10.1145/3571202
• Barthe, Gilles, Sandrine Blazy, Vincent Laporte, David Pichardie, and Alix Trieu. 2017. “Verified Translation Validation of Static Analyses.” In 2017 IEEE 30th Computer Security Foundations Symposium (CSF). IEEE. https://doi.org/10.1109/csf.2017.16
• Bartlett, Mark, Iain Bate, and Dimitar Kazakov. 2010. “Accurate Determination of Loop Iterations for Worst-Case Execution Time Analysis.” IEEE Transactions on Computers 59 (11): 1520–32. https://doi.org/10.1109/tc.2010.59
• Bartsch, Christian, Stephan Wilhelm, Daniel Kastner, Dominik Stoffel, and Wolfgang Kunz. 2021. “Compositional Fault Propagation Analysis in Embedded Systems Using Abstract Interpretation.” In 2021 IEEE International Test Conference (ITC). IEEE. https://doi.org/10.1109/itc50571.2021.00057
• Basin, David, Stefan Friedrich, and Marek Gawkowski. 2003. “Bytecode Verification by Model Checking.” Journal of Automated Reasoning 30 (3–4): 399–444. https://doi.org/10.1023/a:1025059508087
• Baskaran, Muthu, Benoit Pradelle, Benoit Meister, Athanasios Konstantinidis, and Richard Lethin. 2016. “Automatic Code Generation and Data Management for an Asynchronous Task-Based Runtime.” In 2016 5th Workshop on Extreme-Scale Programming Tools (ESPT). IEEE. https://doi.org/10.1109/espt.2016.009
• Basu, Protonu, Mary Hall, Samuel Williams, Brian Van Straalen, Leonid Oliker, and Phillip Colella. 2015. “Compiler-Directed Transformation for Higher-Order Stencils.” In 2015 IEEE International Parallel and Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2015.103
• Basu, Protonu, Samuel Williams, Brian Van Straalen, Leonid Oliker, Phillip Colella, and Mary Hall. 2017. “Compiler-Based Code Generation and Autotuning for Geometric Multigrid on GPU-Accelerated Supercomputers.” Parallel Computing 64: 50–64. https://doi.org/10.1016/j.parco.2017.04.002
• Bate, Iain, and Dimitar Kazakov. 2008. “New Directions in Worst-Case Execution Time Analysis.” In 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence). IEEE. https://doi.org/10.1109/cec.2008.4631277
• Battle, Leilani, Danni Feng, and Kelli Webber. 2022. “Exploring D3 Implementation Challenges on Stack Overflow.” In 2022 IEEE Visualization and Visual Analytics (VIS). IEEE. https://doi.org/10.1109/vis54862.2022.00009
• Bau, Guillaume, Antoine Miné, Vincent Botbol, and Mehdi Bouaziz. 2022. “Abstract Interpretation of Michelson Smart-Contracts.” In Proceedings of the 11th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. ACM. https://doi.org/10.1145/3520313.3534660
• Bauer, Andrej, and Matija Pretnar. 2015. “Programming with Algebraic Effects and Handlers.” Journal of Logical and Algebraic Methods in Programming 84 (1): 108–23. https://doi.org/10.1016/j.jlamp.2014.02.001
• Bauml, Jaroslav, and Premek Brada. 2011. “Reconstruction of Type Information from Java Bytecode for Component Compatibility.” Electronic Notes in Theoretical Computer Science 264 (4): 3–18. https://doi.org/10.1016/j.entcs.2011.02.002
• Bayley, Ian, and Sam Shiel. 2005. “JVM Bytecode Verification without Dataflow Analysis.” Electronic Notes in Theoretical Computer Science 141 (1): 203–20. https://doi.org/10.1016/j.entcs.2005.02.029
• Beaumont, Olivier, Lionel Eyraud-Dubois, and Suraj Kumar. 2018. “Fast Approximation Algorithms for Task-Based Runtime Systems.” Concurrency and Computation: Practice and Experience 30 (17): e4502. https://doi.org/10.1002/cpe.4502
• Becker, Martin, Ravindra Metta, R. Venkatesh, and Samarjit Chakraborty. 2018. “Scalable and Precise Estimation and Debugging of the Worst-Case Execution Time for Analysis-Friendly Processors: A Comeback of Model Checking.” International Journal on Software Tools for Technology Transfer 21 (5): 515–43. https://doi.org/10.1007/s10009-018-0497-2
• Bekiris, Michail. 2021. “Implementation of UTASTAR Decision Support System in VΒΑ Programming Language.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.3803796
• Benito-Montoro, Raul, Xukai Chen, and Jose Luis Sierra. 2021. “A Tool to Assist the Compiler Construction Instructor in Checking the Equivalence of Specifications Based on Regular Expressions.” In 2021 International Symposium on Computers in Education (SIIE). IEEE. https://doi.org/10.1109/siie53363.2021.9583625
• Benzaken, Véronique, and Évelyne Contejean. 2019. “A Coq Mechanised Formal Semantics for Realistic SQL Queries: Formally Reconciling SQL and Bag Relational Algebra.” In Proceedings of the 8th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3293880.3294107
• Berdine, Josh, Peter O’Hearn, Uday Reddy, and Hayo Thielecke. 2002. “Linear Continuation-Passing.” Higher-Order and Symbolic Computation 15 (2–3): 181–208. https://doi.org/10.1023/a:1020891112409
• Berg, Lucas, Gonzague Yernaux, Mikel Vandeloise, and Wim Vanhoof. 2025. “Manim-DFA: Visualising Data Flow Analysis and Abstract Interpretation Algorithms with Automated Video Generation.” In Proceedings of the 17th International Conference on Computer Supported Education. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013472000003932
• Berger, Ryan, Mitch Briles, Nader Boushehrinejad Moradi, et al. 2025. “Translation Validation for LLVM’s AArch64 Backend.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 2710–35. https://doi.org/10.1145/3763147
• Berghofer, Stefan, and Martin Strecker. 2004. “Extracting a Formally Verified, Fully Executable Compiler from a Proof Assistant.” Electronic Notes in Theoretical Computer Science 82 (2): 377–94. https://doi.org/10.1016/s1571-0661(05)82598-8
• Bernardeschi, C., N. De Francesco, G. Lettieri, and L. Martini. 2004. “Checking Secure Information Flow in Java Bytecode by Code Transformation and Standard Bytecode Verification.” Software: Practice and Experience 34 (13): 1225–55. https://doi.org/10.1002/spe.611
• Bernat, Guillem, and Alan Burns. 2000. “An Approach to Symbolic Worst-Case Execution Time Analysis.” IFAC Proceedings Volumes 33 (7): 43–48. https://doi.org/10.1016/s1474-6670(17)39931-7
• Berten, Vandy, Chi-Ju Chang, and Tei-Wei Kuo. 2009. “Managing Imprecise Worst Case Execution Times on DVFS Platforms.” In 2009 15th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications. IEEE. https://doi.org/10.1109/rtcsa.2009.27
• Bertholon, Guillaume, Arthur Charguéraud, Thomas Kœhler, Begatim Bytyqi, and Damien Rouhling. 2024. “Interactive Source-to-Source Optimizations Validated Using Static Resource Analysis.” In Proceedings of the 13th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. ACM. https://doi.org/10.1145/3652588.3663320
• Besson, Frédéric, Sandrine Blazy, and Pierre Wilke. 2018. “CompCertS: A Memory-Aware Verified C Compiler Using a Pointer as Integer Semantics.” Journal of Automated Reasoning 63 (2): 369–92. https://doi.org/10.1007/s10817-018-9496-y
• Besson, Frederic, Alexandre Dang, and Thomas Jensen. 2019. “Information-Flow Preservation in Compiler Optimisations.” In 2019 IEEE 32nd Computer Security Foundations Symposium (CSF). IEEE. https://doi.org/10.1109/csf.2019.00023
• Bhamidipati, Padmaja, and Ranga Vemuri. 2023. “ASPIRE: An Intermediate Representation for Abstract Security Policies.” In 2023 36th International Conference on VLSI Design and 2023 22nd International Conference on Embedded Systems (VLSID). IEEE. https://doi.org/10.1109/vlsid57277.2023.00046
• Bhasker, J. 1988. “Implementation of an Optimizing Compiler for VHDL.” ACM SIGPLAN Notices 23 (1): 92–108. https://doi.org/10.1145/44304.44313
• Bhoyar, Chinmay, Garima Jain, Geeta Singh, Harita Bhargava, and Sanat Jain. 2025. “Sign Language Interpreter Using Long Short-Term Memory (LSTM).” In 2025 4th International Conference on Advances in Computing, Communication, Embedded and Secure Systems (ACCESS). IEEE. https://doi.org/10.1109/access65134.2025.11135621
• Bhushan, Ram Chandra, and Dharmendra K. Yadav. 2020. “Verification of Virtual Machine Architecture in a Hypervisor through Model Checking.” Procedia Computer Science 167: 67–74. https://doi.org/10.1016/j.procs.2020.03.183
• Bierman, Gavin, Claudio Russo, Geoffrey Mainland, Erik Meijer, and Mads Torgersen. 2012. “Pause ’n’ Play: Formalizing Asynchronous C ♯.” In ECOOP 2012 – Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-31057-7_12
• Biernacki, Dariusz, Maciej Piróg, Piotr Polesiuk, and Filip Sieczkowski. 2017. “Handle with Care: Relational Interpretation of Algebraic Effects and Handlers.” Proceedings of the ACM on Programming Languages 2 (POPL): 1–30. https://doi.org/10.1145/3158096
• Bird, Peter L. 1982. “An Implementation of a Code Generator Specification Language for Table Driven Code Generators.” ACM SIGPLAN Notices 17 (6): 44–55. https://doi.org/10.1145/872726.806979
• Bishnu, Abhijeet, and Vimal Bhatia. 2018. “Algorithmic Compiler Based FPGA Implementation of Iterative Time-Domain Algorithm for Sparse Channel Estimation.” In 2018 IEEE International Conference on Advanced Networks and Telecommunications Systems (ANTS). IEEE. https://doi.org/10.1109/ants.2018.8710145
• Bispo, João, and João M. P. Cardoso. 2016. “A MATLAB Subset to C Compiler Targeting Embedded Systems.” Software: Practice and Experience 47 (2): 249–72. https://doi.org/10.1002/spe.2408
• Blazy, Sandrine. 2023. “CompCert: A Journey through the Landscape of Mechanized Semantics for Verified Compilation (Keynote).” In Proceedings of the 12th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3573105.3579107
• Blieberger, Johann. 2002. “Data-Flow Frameworks for Worst-Case Execution Time Analysis.” Real-Time Systems 22 (3): 183–227. https://doi.org/10.1023/a:1014535317056
• Blower, M. I. 1984. “An Efficient Implementation of Visibility in Ada.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502899
• Boda, Yashwanth, Abhijit Chunduri, Ruchi Kumari, and Awanish Pandey. 2026. “CPerfSmith: A Randomized C Program Generator for Performance-Oriented Compiler Testing.” In Proceedings of the 35th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3771775.3786271
• Bodwin, James, Laurette Bradley, Kohji Kanda, Diane Litle, and Uwe Pleban. 1982. “Experience with an Experimental Compiler Generator Based on Denotational Semantics.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806997
• Böhme, Sascha, Michał Moskal, Wolfram Schulte, and Burkhart Wolff. 2009. “HOL-Boogie—an Interactive Prover-Backend for the Verifying C Compiler.” Journal of Automated Reasoning 44 (1–2): 111–44. https://doi.org/10.1007/s10817-009-9142-9
• Bohnet, Johannes, and Jurgen Dollner. 2007. “CGA Call Graph Analyzer: Locating and Understanding Functionality within the Gnu Compiler Collection’s Million Lines of Code.” In 2007 4th IEEE International Workshop on Visualizing Software for Understanding and Analysis. IEEE. https://doi.org/10.1109/vissof.2007.4290719
• Boldo, S., J.-H. Jourdan, X. Leroy, and G. Melquiond. 2013. “A Formally-Verified C Compiler Supporting Floating-Point Arithmetic.” In 2013 IEEE 21st Symposium on Computer Arithmetic. IEEE. https://doi.org/10.1109/arith.2013.30
• Bond, Michael D. 2013. “Session Details: Garbage Collection, Runtime, & Cache Management.” ACM SIGPLAN Notices 48 (11): 3264366. https://doi.org/10.1145/3264366
• Bonkowski, G. B., W. M. Gentleman, and M. A. Malcolm. 1979. “Porting the Zed Compiler.” In Proceedings of the 1979 SIGPLAN symposium on Compiler construction - SIGPLAN ‘79. ACM Press. https://doi.org/10.1145/800229.806958
• Boo, Kyungwook, and Byoungyoung Lee. 2025. “Finding Device Driver Bugs with Fuzzing PCIe Configuration Input.” IEEE Access 13: 150216–27. https://doi.org/10.1109/access.2025.3596641
• Boonriong, Karnbongkot, Stefan Zetzsche, and Alastair F. Donaldson. 2025. “Compiler Fuzzing in Continuous Integration: A Case Study on Dafny.” In 2025 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst62969.2025.10988954
• Bosse, Stefan. 2018. “A Unified System Modelling and Programming Language Based on JavaScript and a Semantic Type System.” Procedia Manufacturing 24: 21–39. https://doi.org/10.1016/j.promfg.2018.06.005
• Bourke, Timothy. 2021. “Specification and End-to-End Proof of a Reactive Language and Its Compiler (Invited Talk).” In Proceedings of the 8th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems. ACM. https://doi.org/10.1145/3486605.3487187
• Bourke, Timothy, Lélio Brun, Pierre-Évariste Dagand, Xavier Leroy, Marc Pouzet, and Lionel Rieg. 2017. “A Formally Verified Compiler for Lustre.” In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3062341.3062358
• Bourke, Timothy, Lélio Brun, and Marc Pouzet. 2019. “Mechanized Semantics and Verified Compilation for a Dataflow Synchronous Language with Reset.” Proceedings of the ACM on Programming Languages 4 (POPL): 1–29. https://doi.org/10.1145/3371112
• Bourke, Timothy, Paul Jeanmaire, and Marc Pouzet. 2025. “Functional Stream Semantics for a Synchronous Block-Diagram Compiler.” In 2025 40th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS). IEEE. https://doi.org/10.1109/lics65433.2025.00052
• Bowman, William J., and Amal Ahmed. 2018. “Typed Closure Conversion for the Calculus of Constructions.” In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3192366.3192372
• Boyapati, Chandrasekhar. 2004. “Session Details: Register Allocation.” In Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/3244314
• Brachthäuser, Jonathan Immanuel, Philipp Schuster, and Klaus Ostermann. 2018. “Effect Handlers for the Masses.” Proceedings of the ACM on Programming Languages 2 (OOPSLA): 1–27. https://doi.org/10.1145/3276481
• Brachthäuser, Jonathan Immanuel, Philipp Schuster, and Klaus Ostermann. 2020. “Effects as Capabilities: Effect Handlers and Lightweight Effect Polymorphism.” Proceedings of the ACM on Programming Languages 4 (OOPSLA): 1–30. https://doi.org/10.1145/3428194
• Brady, Edwin. 2013. “Programming and Reasoning with Algebraic Effects and Dependent Types.” ACM SIGPLAN Notices 48 (9): 133–44. https://doi.org/10.1145/2544174.2500581
• Brandner, Florian, and Alexander Jordan. 2014. “Refinement of Worst-Case Execution Time Bounds by Graph Pruning.” Computer Languages, Systems & Structures 40 (3–4): 155–70. https://doi.org/10.1016/j.cl.2014.09.001
• Brant, Christopher, Uday Kiran Sunkara, and Janise McNair. 2025. “IoT-CODIFT: Compiler Optimization DIFT for IoT and Embedded Devices.” In 2025 IEEE 22nd Consumer Communications & Networking Conference (CCNC). IEEE. https://doi.org/10.1109/ccnc54725.2025.10976036
• Breitner, Joachim. 2015. “Formally Proving a Compiler Transformation Safe.” ACM SIGPLAN Notices 50 (12): 35–46. https://doi.org/10.1145/2887747.2804312
• Brennan, Tegan, Nicolas Rosner, and Tevfik Bultan. 2020. “JIT Leaks: Inducing Timing Side Channels through Just-In-Time Compilation.” In 2020 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp40000.2020.00007
• Bruno, Rodrigo, Vojin Jovanovic, Christian Wimmer, and Gustavo Alonso. 2021. “Compiler-Assisted Object Inlining with Value Fields.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454034
• Bruza, Peter D. 2016. “Syntax and Operational Semantics of a Probabilistic Programming Language with Scopes.” Journal of Mathematical Psychology 74: 46–57. https://doi.org/10.1016/j.jmp.2016.06.006
• Bunkenburg, Niels, and Nicolas Wu. 2024. “Making a Curry Interpreter Using Effects and Handlers.” In Proceedings of the 17th ACM SIGPLAN International Haskell Symposium. ACM. https://doi.org/10.1145/3677999.3678279
• Burgholzer, Lukas, Daniel Haag, Yannick Stade, Damian Rovara, Patrick Hopf, and Robert Wille. 2026. “Focus Session Paper: The MQT Compiler Collection: A Blueprint for a Future-Proof Quantum-Classical Compilation Framework.” In 2026 Design, Automation & Test in Europe Conference (DATE). IEEE. https://doi.org/10.23919/date69613.2026.11539504
• Burn, Geoffrey. 1990. “A Relationship between Abstract Interpretation and Projection Analysis.” In Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘90. ACM Press. https://doi.org/10.1145/96709.96724
• Burroughs, Neil. 2016. “Register Allocation and Spilling Using the Expected Distance Heuristic.” Software: Practice and Experience 46 (11): 1499–1523. https://doi.org/10.1002/spe.2393
• Butterfield, Andrew, and Jim Woodcock. 2006. “A “Hardware Compiler” Semantics for Handel-C.” Electronic Notes in Theoretical Computer Science 161: 73–90. https://doi.org/10.1016/j.entcs.2006.04.026
• Cabrera Arteaga, Javier, Martin Monperrus, and Benoit Baudry. 2019. “Scalable Comparison of JavaScript V8 Bytecode Traces.” In Proceedings of the 11th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3358504.3361228
• Caldwell, Joseph, and Shigeru Chiba. 2017. “Reducing Calling Convention Overhead in Object-Oriented Programming on Embedded ARM Thumb-2 Platforms.” ACM SIGPLAN Notices 52 (12): 146–56. https://doi.org/10.1145/3170492.3136057
• Callahan, David, and Brian Koblenz. 1991. “Register Allocation via Hierarchical Graph Coloring.” ACM SIGPLAN Notices 26 (6): 192–203. https://doi.org/10.1145/113446.113462
• Calzarossa, Maria, Luisa Massari, and Daniele Tessera. 2001. “Performance Issues of an HPF-like Compiler.” Future Generation Computer Systems 18 (1): 147–56. https://doi.org/10.1016/s0167-739x(01)00049-8
• Cambier, Leopold, Yizhou Qian, and Eric Darve. 2020. “TaskTorrent: A Lightweight Distributed Task-Based Runtime System in C++.” In 2020 IEEE/ACM 3rd Annual Parallel Applications Workshop: Alternatives To MPI+X (PAW-ATM). IEEE. https://doi.org/10.1109/pawatm51920.2020.00007
• Cambou, Bertrand. 2017. “A XOR Data Compiler: Combined with Physical Unclonable Function for True Random Number Generation.” In 2017 Computing Conference. IEEE. https://doi.org/10.1109/sai.2017.8252190
• Campos-López, Noa, and Oliver Wannenwetsch. 2016. “The PERICLES Process Compiler: Linking BPMN Processes into Complex Workflows for Model-Driven Preservation in Evolving Ecosystems.” In Proceedings of the 12th International Conference on Web Information Systems and Technologies. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005759800760083
• Canedo, Arquimedes, Ben A. Abderazek, and Masahiro Sowa. 2009. “Design and Implementation of a Queue Compiler.” Microprocessors and Microsystems 33 (2): 129–38. https://doi.org/10.1016/j.micpro.2008.09.001
• Carminati, Andreu, Renan Augusto Starke, and Rômulo Silva de Oliveira. 2018. “On the Use of Static Branch Prediction to Reduce the Worst-Case Execution Time of Real-Time Applications.” Real-Time Systems 54 (3): 537–61. https://doi.org/10.1007/s11241-018-9306-y
• Carter, LynnRobert. 1982. “Further Analysis of Code Generation for a Single Register Machine.” Acta Informatica 18 (2). https://doi.org/10.1007/bf00264435
• Castro-Lopez, Oscar, and Ines F. Vega-Lopez. 2019. “Multi-Target Compiler for the Deployment of Machine Learning Models.” In 2019 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2019.8661199
• Cattell, Roderic G. G., Joseph M. Newcomer, and Bruce W. Leverett. 1979. “Code Generation in a Machine-Independent Compiler.” In Proceedings of the 1979 SIGPLAN symposium on Compiler construction - SIGPLAN ‘79. ACM Press. https://doi.org/10.1145/800229.806955
• Cazzola, Walter, and Diego Mathias Olivares. 2015. “Gradually Learning Programming Supported by a Growable Programming Language.” In 2015 IEEE 39th Annual Computer Software and Applications Conference. IEEE. https://doi.org/10.1109/compsac.2015.82
• Chaitin, G. J. 1982. “Register Allocation & Spilling via Graph Coloring.” ACM SIGPLAN Notices 17 (6): 98–101. https://doi.org/10.1145/872726.806984
• Chaitin, Gregory. 2004. “Register Allocation and Spilling via Graph Coloring.” ACM SIGPLAN Notices 39 (4): 66–74. https://doi.org/10.1145/989393.989403
• Chaliasos, Stefanos, Thodoris Sotiropoulos, Diomidis Spinellis, Arthur Gervais, Benjamin Livshits, and Dimitris Mitropoulos. 2022. “Finding Typing Compiler Bugs.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523427
• Chalin, Patrice. 2007. “A Sound Assertion Semantics for the Dependable Systems Evolution Verifying Compiler.” In 29th International Conference on Software Engineering (ICSE’07). IEEE. https://doi.org/10.1109/icse.2007.9
• Chalin, P. 2010. “Engineering a Sound Assertion Semantics for the Verifying Compiler.” IEEE Transactions on Software Engineering 36 (2): 275–87. https://doi.org/10.1109/tse.2009.59
• Charmanas, Konstantinos, Konstantinos Georgiou, Konstantinos Papageorgiadis, Nikolaos Mittas, and Lefteris Angelis. 2026. “A Topic-Oriented Trend Analysis Framework for Stack Exchange Questions: Case Study on ChatGPT Related Queries on Stack Overflow.” Information and Software Technology 190: 107969. https://doi.org/10.1016/j.infsof.2025.107969
• Chase, David. 2005. “Session Details: Register Allocation.” In Proceedings of the 2005 ACM SIGPLAN conference on Programming language design and implementation. ACM. https://doi.org/10.1145/3249493
• Chaumette, Serge, Olivier Ly, and Renaud Tabary. 2011. “Automated Extraction of Polymorphic Virus Signatures Using Abstract Interpretation.” In 2011 5th International Conference on Network and System Security. IEEE. https://doi.org/10.1109/icnss.2011.6059958
• Chavanon, Clément, Frédéric Besson, and Tristan Ninet. 2024. “PfComp: A Verified Compiler for Packet Filtering Leveraging Binary Decision Diagrams.” In Proceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3636501.3636954
• Chen, Yiyun, Lin Ge, Baojian Hua, Zhaopeng Li, and Cheng Liu. 2007. “Design of a Certifying Compiler Supporting Proof of Program Safety.” In First Joint IEEE/IFIP Symposium on Theoretical Aspects of Software Engineering (TASE ‘07). IEEE. https://doi.org/10.1109/tase.2007.19
• Chen, Wei, Dake Liu, and Shaohan Liu. 2022. “Register Allocation Compilation Technique for ASIP in 5G Micro Base Stations.” China Communications 19 (8): 115–26. https://doi.org/10.23919/jcc.2022.08.009
• Chen, Yue, Fei Yuan, and Husheng Liao. 2009. “Bytecode Generation for XQuery Compiler.” In 2009 First International Workshop on Database Technology and Applications. IEEE. https://doi.org/10.1109/dbta.2009.104
• Chen, Genlang, Jiajian Zhang, Zufang Zhu, Hao Wang, Hai Jiang, and Chaoyi Pang. 2020a. “CRAC: An Automatic Assistant Compiler of Checkpoint/restart for OpenCL Program.” Concurrency and Computation: Practice and Experience 34 (8): e6048. https://doi.org/10.1002/cpe.6048
• Chen, Zhe, Yunlong Zhu, and Zhemin Wang. 2024. “Design and Implementation of an Aspect-Oriented C Programming Language.” Proceedings of the ACM on Programming Languages 8 (OOPSLA1): 642–69. https://doi.org/10.1145/3649834
• Chen, Xinbo, and Ziliang Zong. 2016. “Android App Energy Efficiency: The Impact of Language, Runtime, Compiler, and Implementation.” In 2016 IEEE International Conferences on Big Data and Cloud Computing (BDCloud), Social Computing and Networking (SocialCom), Sustainable Computing and Communications (SustainCom) (BDCloud-SocialCom-SustainCom). IEEE. https://doi.org/10.1109/bdcloud-socialcom-sustaincom.2016.77
• Chen Zhao, Yunzhi Xue, Qiuming Tao, Liang Guo, and Zhaohui Wang. 2009. “Automated Test Program Generation for an Industrial Optimizing Compiler.” In 2009 ICSE Workshop on Automation of Software Test. IEEE. https://doi.org/10.1109/iwast.2009.5069039
• Cheng, Yujuan. 2023. “QA4C: An Intelligent Question and Answering System for the C Programming Language Based on Knowledge Graph.” In 2023 10th International Conference on Dependable Systems and Their Applications (DSA). IEEE. https://doi.org/10.1109/dsa59317.2023.00096
• Cheng, Zheng, Rosemary Monahan, and James F. Power. 2016. “Formalised EMFTVM Bytecode Language for Sound Verification of Model Transformations.” Software & Systems Modeling 17 (4): 1197–1225. https://doi.org/10.1007/s10270-016-0553-x
• Cheng, Junjie, and Xiaorong Wu. 2026. “Toward Unified Chinese Multi-Dialectal Speech Recognition via Pinyin Intermediate Representation.” IEEE Access 14: 55194–55208. https://doi.org/10.1109/access.2026.3681804
• Chernenko, Ivan, Igor Anureev, and Natalia Garanina. 2021. “Proving Reflex Program Verification Conditions in Coq Proof Assistant.” In 2021 IEEE 22nd International Conference of Young Professionals in Electron Devices and Materials (EDM). IEEE. https://doi.org/10.1109/edm52169.2021.9507628
• Chhak, Chr, Andrew Tolmach, and Sean Anderson. 2021. “Towards Formally Verified Compilation of Tag-Based Policy Enforcement.” In Proceedings of the 10th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3437992.3439929
• Chi, Chi-hung. 1994. “Compiler Optimization Technique for Data Cache Prefetching Using a Small CAM Array.” In 1994 International Conference on Parallel Processing-Vol 1 (ICPP’94). IEEE. https://doi.org/10.1109/icpp.1994.71
• Chi, Ya Ping, Zhao Bin Li, Zhong Hua Wang, and Yong Fang. 2009. “An Improved Bytecode Verification Algorithm on Java Card.” In 2009 International Conference on Computational Intelligence and Security. IEEE. https://doi.org/10.1109/cis.2009.193
• Chichereau, Brice, Stéphane Vialle, and Patrick Carribault. 2024. “Fully Integrated Quantum Method for Classical Register Allocation in LLVM.” In 2024 IEEE International Conference on Quantum Computing and Engineering (QCE). IEEE. https://doi.org/10.1109/qce60285.2024.10295
• Chirila, Ciprian-Bogdan, and Ioana Sora. 2024. “Java Single vs. Platform vs. Virtual Threads Runtime Performance Assessment in the Context of Key Class Detection.” In 2024 IEEE 18th International Symposium on Applied Computational Intelligence and Informatics (SACI). IEEE. https://doi.org/10.1109/saci60582.2024.10619722
• Chlipala, Adam. 2010. “A Verified Compiler for an Impure Functional Language.” ACM SIGPLAN Notices 45 (1): 93–106. https://doi.org/10.1145/1707801.1706312
• Chlipala, Adam. 2015. “Session Details: Session 4A: Compiler Correctness.” ACM SIGPLAN Notices 50 (1): 3264293. https://doi.org/10.1145/3264293
• Cho, Kenta. 2016. “Semantics for a Quantum Programming Language by Operator Algebras.” New Generation Computing 34 (1–2): 25–68. https://doi.org/10.1007/s00354-016-0204-3
• Cho, Minki, Sung-Hwan Lee, Dongjae Lee, Chung-Kil Hur, and Ori Lahav. 2022. “Sequential Reasoning for Optimizing Compilers under Weak Memory Concurrency.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523718
• Choi, GyeongTaek, and Seungho Jeon. 2026. “Stack-Based Static WebAssembly Binary Slicing and Mutation for Generating Valid Sub-Binaries.” Scientific Reports 16 (1): 10910. https://doi.org/10.1038/s41598-026-45837-y
• Choi, Youngho, Jaeook Kwon, Seokjae Jeong, Hansub Park, and Young Ik Eom. 2018. “Work-in-Progress: Lightweight Deadlock Detection Technique for Embedded Systems via OS-Level Analysis.” In 2018 International Conference on Embedded Software (EMSOFT). IEEE. https://doi.org/10.1109/emsoft.2018.8537214
• Choi, Jongwoo, Wan-Ki Park, Jinsoo Han, Sangbyeong An, Sihyun Park, and Chool Yu. 2024. “Accelerating Sensor Software Performance on Edge Devices through Just-in-Time Compilation.” In 2024 15th International Conference on Information and Communication Technology Convergence (ICTC). IEEE. https://doi.org/10.1109/ictc62082.2024.10827129
• Choi, Jiho, Thomas Shull, and Josep Torrellas. 2019. “Reusable Inline Caching for JavaScript Performance.” In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3314221.3314587
• Chong, Frederic T., Diana Franklin, and Margaret Martonosi. 2017. “Programming Languages and Compiler Design for Realistic Quantum Hardware.” Nature 549 (7671): 180–87. https://doi.org/10.1038/nature23459
• Christopher, Thomas W., Philip J. Hatcher, and Ronald C. Kukuk. 1984. “Using Dynamic Programming to Generate Optimized Code in a Graham-Glanville Style Code Generator.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502877
• Chudnov, Andrey, George Kuan, and David A. Naumann. 2014. “Information Flow Monitoring as Abstract Interpretation for Relational Logic.” In 2014 IEEE 27th Computer Security Foundations Symposium. IEEE. https://doi.org/10.1109/csf.2014.12
• Ciaffaglione, Alberto. 2016. “Towards Turing Computability via Coinduction.” Science of Computer Programming 126: 31–51. https://doi.org/10.1016/j.scico.2016.02.004
• Coglio, Alessandro. 2003. “Improving the Official Specification of Java Bytecode Verification.” Concurrency and Computation: Practice and Experience 15 (2): 155–79. https://doi.org/10.1002/cpe.714
• Coglio, Alessandro. 2004. “Simple Verification Technique for Complex Java Bytecode Subroutines.” Concurrency and Computation: Practice and Experience 16 (7): 647–70. https://doi.org/10.1002/cpe.798
• Colin, Antoine, and Isabelle Puaut. 2000. “Worst Case Execution Time Analysis for a Processor with Branch Prediction.” Real-Time Systems 18 (2–3): 249–74. https://doi.org/10.1023/a:1008149332687
• Colvin, Robert J., and Ian J. Hayes. 2011. “Structural Operational Semantics through Context-Dependent Behaviour.” Journal of Logic and Algebraic Programming 80 (7): 392–426. https://doi.org/10.1016/j.jlap.2011.05.001
• “Compiler Technology: Tools, Translators and Language Implementation.” 1998. Computers & Mathematics with Applications 36 (6): 143. https://doi.org/10.1016/s0898-1221(98)90103-1
• “A Compositional Scheme and Framework for Safety Critical Systems Verification.” 2012. In Proceedings of the 10th International Workshop on Modelling, Simulation, Verification and Validation of Enterprise Information Systems and 1st International Workshop on Web Intelligence. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0004097300150026
• Cong, Youyou, and Kenichi Asai. 2023. “Towards a Reflection for Effect Handlers.” In Proceedings of the 2023 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3571786.3573015
• Consel, Charles, and Siau Cheng Khoo. 1993. “Semantics-Directed Generation of a Prolog Compiler.” Science of Computer Programming 21 (3): 263–91. https://doi.org/10.1016/0167-6423(93)90011-d
• Coppo, Mario, and Alberto Ferrari. 1993. “Type Inference, Abstract Interpretation and Strictness Analysis.” Theoretical Computer Science 121 (1–2): 113–43. https://doi.org/10.1016/0304-3975(93)90086-9
• Cordes, Daniel, Heiko Falk, and Peter Marwedel. 2009. “A Fast and Precise Static Loop Analysis Based on Abstract Interpretation, Program Slicing and Polytope Models.” In 2009 International Symposium on Code Generation and Optimization. IEEE. https://doi.org/10.1109/cgo.2009.17
• Correnson, Arthur, and Bernd Finkbeiner. 2025. “Coinductive Proofs for Temporal Hyperliveness.” Proceedings of the ACM on Programming Languages 9 (POPL): 1568–95. https://doi.org/10.1145/3704889
• Corrias, Lorenzo, Lorenzo Pisu, Davide Maiorca, and Giorgio Giacinto. 2026. “An Analysis of Modern Web Security Vulnerabilities inside WebAssembly Applications.” In Proceedings of the 12th International Conference on Information Systems Security and Privacy. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0014597200004061
• Cortesi, Agostino. 2008. “Widening Operators for Abstract Interpretation.” In 2008 Sixth IEEE International Conference on Software Engineering and Formal Methods. IEEE. https://doi.org/10.1109/sefm.2008.20
• Cortesi, Agostino, and Gilbert Filé. 1991. “Abstract Interpretation of Logic Programs: An Abstract Domain for Groundness, Sharing, Freeness and Compoundness Analysis.” ACM SIGPLAN Notices 26 (9): 52–61. https://doi.org/10.1145/115866.115872
• Costa, Jessica Junia Santillo, Romulo Silva de Oliveira, and Luis Fernando Arcaro. 2021. “Use of Measurements in Worst-Case Execution Time Estimation for Real-Time Systems.” In 2021 XI Brazilian Symposium on Computing Systems Engineering (SBESC). IEEE. https://doi.org/10.1109/sbesc53686.2021.9628230
• Costagliola, Gennaro, Vincenzo Deufemia, and Giuseppe Polese. 2007. “Visual Language Implementation through Standard Compiler–compiler Techniques.” Journal of Visual Languages & Computing 18 (2): 165–226. https://doi.org/10.1016/j.jvlc.2006.06.002
• Couch, J., and T. Hamm. 1977. “Semantic Structures for Efficient Code Generation on a Stack Machine.” Computer 10 (5): 42–48. https://doi.org/10.1109/mc.1977.315872
• Cousot, Patrick. 1997. “Program Analysis: The Abstract Interpretation Perspective.” ACM SIGPLAN Notices 32 (1): 73–76. https://doi.org/10.1145/251595.251601
• Cousot, Patrick. 2015a. “On Various Abstract Understandings of Abstract Interpretation.” In 2015 International Symposium on Theoretical Aspects of Software Engineering. IEEE. https://doi.org/10.1109/tase.2015.29
• Cousot, Patrick, and Radhia Cousot. 1977. “Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints.” In Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL ‘77. ACM Press. https://doi.org/10.1145/512950.512973
• Cousot, Patrick, and Radhia Cousot. 2000. “Temporal Abstract Interpretation.” In Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/325694.325699
• Cousot, Patrick, and Radhia Cousot. 2001. “A Case Study in Abstract Interpretation Based Program Transformation.” Electronic Notes in Theoretical Computer Science 45: 41–64. https://doi.org/10.1016/s1571-0661(04)80954-x
• Cousot, Patrick, and Radhia Cousot. 2002. “Systematic Design of Program Transformation Frameworks by Abstract Interpretation.” ACM SIGPLAN Notices 37 (1): 178–90. https://doi.org/10.1145/565816.503290
• Cousot, Patrick, and Radhia Cousot. 2011. “Grammar Semantics, Analysis and Parsing by Abstract Interpretation.” Theoretical Computer Science 412 (44): 6135–92. https://doi.org/10.1016/j.tcs.2011.06.005
• Cousot, Patrick, and Radhia Cousot. 2012. “An Abstract Interpretation Framework for Termination.” In Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/2103656.2103687
• Cousot, Patrick`, and Radhia Cousot. 2014. “A Galois Connection Calculus for Abstract Interpretation.” In Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM. https://doi.org/10.1145/2535838.2537850
• Coward, Samuel, George A. Constantinides, and Theo Drane. 2023. “Combining E-Graphs with Abstract Interpretation.” In Proceedings of the 12th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. ACM. https://doi.org/10.1145/3589250.3596144
• Cummins, Chris, Volker Seeker, Dejan Grubisic, et al. 2025. “LLM Compiler: Foundation Language Models for Compiler Optimization.” In Proceedings of the 34th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3708493.3712691
• Cunha, Simão, Luís Silva, João Saraiva, and João Paulo Fernandes. 2024. “Trading Runtime for Energy Efficiency: Leveraging Power Caps to Save Energy across Programming Languages.” In Proceedings of the 17th ACM SIGPLAN International Conference on Software Language Engineering. ACM. https://doi.org/10.1145/3687997.3695638
• D’Silva, Vijay, Mathias Payer, and Dawn Song. 2015. “The Correctness-Security Gap in Compiler Optimization.” In 2015 IEEE Security and Privacy Workshops. IEEE. https://doi.org/10.1109/spw.2015.33
• Dalla Preda, M., and R. Giacobazzi. 2005. “Control Code Obfuscation by Abstract Interpretation.” In Third IEEE International Conference on Software Engineering and Formal Methods (SEFM’05). IEEE. https://doi.org/10.1109/sefm.2005.13
• Danvy, Olivier, and Lasse R. Nielsen. 2001. “Defunctionalization at Work.” In Proceedings of the 3rd ACM SIGPLAN international conference on Principles and practice of declarative programming. ACM. https://doi.org/10.1145/773184.773202
• Das, Dibyendu, Shahid Asghar Ahmad, and Venkataramanan Kumar. 2020. “Deep Learning-Based Approximate Graph-Coloring Algorithm for Register Allocation.” In 2020 IEEE/ACM 6th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC) and Workshop on Hierarchical Parallelism for Exascale Computing (HiPar). IEEE. https://doi.org/10.1109/llvmhpchipar51896.2020.00008
• Dasgupta, Sandeep, Daejun Park, Theodoros Kasampalis, Vikram S. Adve, and Grigore Roşu. 2019. “A Complete Formal Semantics of x86-64 User-Level Instruction Set Architecture.” In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3314221.3314601
• Dave, Rachit, Vivek Kumar Dikshit, and Prshant Dubey. 2016. “A 1V 800MHz 140Kb Register File Compiler Using Variation Aware Self-Timing in 40nm Bulk CMOS.” In 2016 International Symposium on VLSI Design, Automation and Test (VLSI-DAT). IEEE. https://doi.org/10.1109/vlsi-dat.2016.7482553
• De Blaere, Brent, Elias Verstappe, Jens Vankeirsbilck, and Jeroen Boydens. 2021. “A Compiler Extension to Protect Embedded Systems against Data Flow Errors.” In 2021 XXX International Scientific Conference Electronics (ET). IEEE. https://doi.org/10.1109/et52713.2021.9580074
• de Ferrière, François, Yves Janin, and Sirine Mechmech. 2026. “SecSwift, a Compiler-Based Framework for Software Countermeasures in Cybersecurity.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395204
• De Francesco, Nicoletta, Giuseppe Lettieri, and Luca Martini. 2010. “Using Abstract Interpretation to Add Type Checking for Interfaces in Java Bytecode Verification.” Theoretical Computer Science 411 (22–24): 2174–2201. https://doi.org/10.1016/j.tcs.2010.01.026
• De Luca, Gennaro, and Yinong Chen. 2017. “Visual IoT/Robotics Programming Language in Pi-Calculus.” In 2017 IEEE 13th International Symposium on Autonomous Decentralized System (ISADS). IEEE. https://doi.org/10.1109/isads.2017.32
• De Macedo, Joao, Rui Abreu, Rui Pereira, and Joao Saraiva. 2021. “On the Runtime and Energy Performance of WebAssembly: Is WebAssembly Superior to JavaScript Yet?” In 2021 36th IEEE/ACM International Conference on Automated Software Engineering Workshops (ASEW). IEEE. https://doi.org/10.1109/asew52652.2021.00056
• De Macedo, Joao, Rui Abreu, Rui Pereira, and Joao Saraiva. 2022. “WebAssembly versus JavaScript: Energy and Runtime Performance.” In 2022 International Conference on ICT for Sustainability (ICT4S). IEEE. https://doi.org/10.1109/ict4s55073.2022.00014
• de Vilhena, Paulo Emílio, and François Pottier. 2021. “A Separation Logic for Effect Handlers.” Proceedings of the ACM on Programming Languages 5 (POPL): 1–28. https://doi.org/10.1145/3434314
• de Werra, D., Ch. Eisenbeis, S. Lelait, and B. Marmol. 1999. “On a Graph-Theoretical Model for Cyclic Register Allocation.” Discrete Applied Mathematics 93 (2–3): 191–203. https://doi.org/10.1016/s0166-218x(99)00105-5
• Debnath, Joyanta, Christa Jenkins, Yuteng Sun, Sze Yiu Chau, and Omar Chowdhury. 2024. “ARMOR: A Formally Verified Implementation of X.509 Certificate Chain Validation.” In 2024 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp54263.2024.00220
• Debray, Saumya. 1995. “Abstract Interpretation and Low-Level Code Optimization.” In Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation - PEPM ‘95. ACM Press. https://doi.org/10.1145/215465.215571
• DeBuhr, Jackson, Bo Zhang, and Luke D’Alessandro. 2017. “Scalable Hierarchical Multipole Methods Using an Asynchronous Many-Tasking Runtime System.” In 2017 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). IEEE. https://doi.org/10.1109/ipdpsw.2017.88
• DelVado Vírseda, Rafael. 2023. “Visualizing Compiler Design Theory from Implementation through an Interactive Tutoring Tool: Experiences and Results.” In Proceedings of the 15th International Conference on Computer Supported Education. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011709800003470
• Demmler, Daniel, Stefan Katzenbeisser, Thomas Schneider, Tom Schuster, and Christian Weinert. 2021. “Improved Circuit Compilation for Hybrid MPC via Compiler Intermediate Representation.” In Proceedings of the 18th International Conference on Security and Cryptography. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010540504440451
• Deng, Hao, Zhiqiang He, Yang Liu, Jiaojiao Xu, Mingxu Song, and Gang Chen. 2026. “Design and Implementation of an OCaml-Based Standalone SystemVerilog Preprocessor Compliant with IEEE 1800-2023.” Electronics 15 (14): 3234. https://doi.org/10.3390/electronics15143234
• Deng, Chaoqiang, and Kedar S. Namjoshi. 2018. “Securing a Compiler Transformation.” Formal Methods in System Design 53 (2): 166–88. https://doi.org/10.1007/s10703-017-0313-8
• Denis, Alexandre, Emmanuel Jeannot, Philippe Swartvagher, and Samuel Thibault. 2023. “Tracing Task-Based Runtime Systems: Feedbacks from theStarPUcase.” Concurrency and Computation: Practice and Experience 36 (3): e7920. https://doi.org/10.1002/cpe.7920
• Denzler, Patrick, Thomas Fruhwirth, Andreas Kirchberger, Martin Schoeberl, and Wolfgang Kastner. 2021. “Experiences from Adjusting Industrial Software for Worst-Case Execution Time Analysis.” In 2021 IEEE 24th International Symposium on Real-Time Distributed Computing (ISORC). IEEE. https://doi.org/10.1109/isorc52013.2021.00019
• Derakhshan, Farzaneh, Zichao Zhang, Amit Vasudevan, and Limin Jia. 2023. “Towards End-to-End Verified TEEs via Verified Interface Conformance and Certified Compilers.” In 2023 IEEE 36th Computer Security Foundations Symposium (CSF). IEEE. https://doi.org/10.1109/csf57540.2023.00021
• Desai, Nikita P. 2009. “A Novel Technique for Orchestration of Compiler Optimization Functions Using Branch and Bound Strategy.” In 2009 IEEE International Advance Computing Conference. IEEE. https://doi.org/10.1109/iadcc.2009.4809056
• Deutsch, Alain. 1995. “Semantic Models and Abstract Interpretation Techniques for Inductive Data Structures and Pointers.” In Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation - PEPM ‘95. ACM Press. https://doi.org/10.1145/215465.215594
• DeVries, Brian W., Gopal Gupta, Kevin W. Hamlen, Scott Moore, and Meera Sridhar. 2009a. “ActionScript Bytecode Verification with Co-Logic Programming.” In Proceedings of the ACM SIGPLAN Fourth Workshop on Programming Languages and Analysis for Security. ACM. https://doi.org/10.1145/1554339.1554342
• DeVries, Brian W., Gopal Gupta, Kevin W. Hamlen, Scott Moore, and Meera Sridhar. 2009b. “ActionScript Bytecode Verification with Co-Logic Programming (Abstract Only).” ACM SIGPLAN Notices 44 (8): 4–4. https://doi.org/10.1145/1667209.1667212
• Di Pierro, Alessandra, Pascal Sotin, and Herbert Wiklicky. 2008. “Relational Analysis and Precision via Probabilistic Abstract Interpretation.” Electronic Notes in Theoretical Computer Science 220 (3): 23–42. https://doi.org/10.1016/j.entcs.2008.11.017
• Diamantopoulos, Dionysios, Burkhard Ringlein, Mitra Purandare, Gagandeep Singh, and Christoph Hagleitner. 2020. “Agile Autotuning of a Transprecision Tensor Accelerator Overlay for TVM Compiler Stack.” In 2020 30th International Conference on Field-Programmable Logic and Applications (FPL). IEEE. https://doi.org/10.1109/fpl50879.2020.00058
• Diehl, Patrick, Dominic Marcello, Parsa Amini, et al. 2021. “Performance Measurements within Asynchronous Task-Based Runtime Systems: A Double White Dwarf Merger as an Application.” Computing in Science & Engineering 23 (3): 73–81. https://doi.org/10.1109/mcse.2021.3073626
• Dimovski, Aleksandar S. 2021. “Lifted Termination Analysis by Abstract Interpretation and Its Applications.” In Proceedings of the 20th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences. ACM. https://doi.org/10.1145/3486609.3487202
• Dimovski, Aleksandar S. 2025. “Imperative Program Synthesis by Abstract Static Analysis and SMT Mutations.” In Proceedings of the 24th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences. ACM. https://doi.org/10.1145/3742876.3742884
• Ding, Haotong, Anni Li, and Rexford Nii Ayitey Sosu. 2025. “HFF-JIT: A Hybrid Fuzzing Framework for JIT Compiler Vulnerability Detection in JavaScript.” In 2025 25th International Conference on Software Quality, Reliability, and Security Companion (QRS-C). IEEE. https://doi.org/10.1109/qrs-c65679.2025.00099
• Ding, Yiqiang, and Wei Zhang. 2010. “Loop-Based Instruction Prefetching to Reduce the Worst-Case Execution Time.” IEEE Transactions on Computers 59 (6): 855–64. https://doi.org/10.1109/tc.2010.44
• Ditu, Bogdan. 2015. “Model-Based Function Call Code Generation and Stack Management in Retargetable Compilers: Application Binary Interface Modeling of Stack Layout and Function Call Sequence.” In 2015 20th International Conference on Control Systems and Computer Science. IEEE. https://doi.org/10.1109/cscs.2015.38
• Dixon, Douglas F. 1982. “A Pascal Compiler Testing Facility.” ACM SIGPLAN Notices 17 (1): 23–26. https://doi.org/10.1145/947886.947889
• Djalali, Hans, Wajdi Aljedaani, and Stephanie Ludi. 2025. “The Evolution of Software Usability in Developer Communities: An Empirical Study on Stack Overflow.” Software 4 (4): 27. https://doi.org/10.3390/software4040027
• Donaldson, Alastair F., Ben Clayton, Ryan Harrison, et al. 2023. “Industrial Deployment of Compiler Fuzzing Techniques for Two GPU Shading Languages.” In 2023 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst57152.2023.00042
• Donaldson, Alastair F., Dilan Sheth, Jean-Baptiste Tristan, and Alex Usher. 2024. “Randomised Testing of the Compiler for a Verification-Aware Programming Language.” In 2024 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst60714.2024.00044
• Donegan, Michael K., Robert E. Noonan, and Stefan Feyock. 1979. “A Code Generator Generator Language.” ACM SIGPLAN Notices 14 (8): 58–64. https://doi.org/10.1145/872732.806954
• Dong, Yukun. 2015. “RSTVL: A Sound Abstract Memory Model for Program Static Analysis.” In 2015 International Conference on Computational Intelligence and Communication Networks (CICN). IEEE. https://doi.org/10.1109/cicn.2015.263
• Dong, Rui, Qingyue Wu, Danny Ding, Zheng Guo, Ruyi Ji, and Xinyu Wang. 2026. “Presynthesis: Towards Scaling up Program Synthesis with Finer-Grained Abstract Semantics.” Proceedings of the ACM on Programming Languages 10 (PLDI): 1029–53. https://doi.org/10.1145/3808288
• Downen, Paul, Luke Maurer, Zena M. Ariola, and Simon Peyton Jones. 2016. “Sequent Calculus as a Compiler Intermediate Language.” ACM SIGPLAN Notices 51 (9): 74–88. https://doi.org/10.1145/3022670.2951931
• Drechsler, Rolf, and Martha Schnieber. 2023. “Automated Polynomial Formal Verification: Human-Readable Proof Generation.” In 2023 IEEE International Symposium on Smart Electronic Systems (iSES). IEEE. https://doi.org/10.1109/ises58672.2023.00012
• Drescher, Florian, and Alexis Engelke. 2024. “Fast Template-Based Code Generation for MLIR.” In Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3640537.3641567
• Duhamel, Alexis, and Sébastien Pillement. 2024. “Runtime Task Scheduling for FPGA-Based Embedded Systems Using Just-in-Time Bitstream Prefetching.” IEEE Access 12: 184303–10. https://doi.org/10.1109/access.2024.3507376
• Duţu, Teodor-Ștefan, Albert Guiman, Răzvan-George Niţu, and Constantin-Eduard Stăniloiu. 2026. “From Runtime Reflection to Compile-Time Specialization: A Template-Based Approach to Runtime Libraries.” In Proceedings of the 21st International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0015065300004088
• Edalat, Abbas, and Dirk Pattinson. 2007. “Denotational Semantics of Hybrid Automata.” Journal of Logic and Algebraic Programming 73 (1–2): 3–21. https://doi.org/10.1016/j.jlap.2007.01.002
• Eichenberger, A. E., and E. S. Davidson. 1995. “Register Allocation for Predicated Code.” In Proceedings of the 28th Annual International Symposium on Microarchitecture. IEEE. https://doi.org/10.1109/micro.1995.476825
• Eisl, Josef. 2015. “Trace Register Allocation.” In Companion Proceedings of the 2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity. ACM. https://doi.org/10.1145/2814189.2814199
• Elizarov, Roman, Mikhail Belyaev, Marat Akhin, and Ilmir Usmanov. 2021. “Kotlin Coroutines: Design and Implementation.” In Proceedings of the 2021 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. ACM. https://doi.org/10.1145/3486607.3486751
• Engblom, Jakob, Andreas Ermedahl, Mikael Sjödin, Jan Gustafsson, and Hans Hansson. 2003. “Worst-Case Execution-Time Analysis for Embedded Real-Time Systems.” International Journal on Software Tools for Technology Transfer 4 (4): 437–55. https://doi.org/10.1007/s100090100054
• Engelke, Alexis, and Tobias Schwarz. 2024. “Compile-Time Analysis of Compiler Frameworks for Query Compilation.” In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo57630.2024.10444856
• Engelke, Alexis, and Josef Weidendorfer. 2017. “Using LLVM for Optimized Lightweight Binary Re-Writing at Runtime.” In 2017 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). IEEE. https://doi.org/10.1109/ipdpsw.2017.103
• Enrici, Andrea, Ludovic Apvrille, and Renaud Pacalet. 2019. “Efficient Data-Flow Analysis of UML/SysML Diagrams for Optimized Model Compilation of Hardware-Software Systems.” In Proceedings of the 7th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0007377900840095
• Ermedahl, Andreas, Johan Fredriksson, Jan Gustafsson, and Peter Altenbernd. 2009. “Deriving the Worst-Case Execution Time Input Values.” In 2009 21st Euromicro Conference on Real-Time Systems. IEEE. https://doi.org/10.1109/ecrts.2009.32
• Ermedahl, Andreas, and Peter Puschner. 2011. “Preface to the Special Issue on Worst-Case Execution-Time Analysis.” Journal of Systems Architecture 57 (7): 675–76. https://doi.org/10.1016/j.sysarc.2011.06.001
• Ertl, M. Anton. 1995. “Stack Caching for Interpreters.” In Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/207110.207165
• Evansi, D. J., and M. N. Sulaiman. 1996. “Solving Optimisation Problems Using Neucomp-a Neural Network Compiler.” International Journal of Computer Mathematics 62 (1–2): 1–21. https://doi.org/10.1080/00207169608804522
• Falk, Heiko, and Paul Lokuciejewski. 2010. “A Compiler Framework for the Reduction of Worst-Case Execution Times.” Real-Time Systems 46 (2): 251–300. https://doi.org/10.1007/s11241-010-9101-x
• Falk, Heiko, and Paul Lokuciejewski. 2019. “Correction To: A Compiler Framework for the Reduction of Worst-Case Execution Times.” Real-Time Systems 55 (4): 925–925. https://doi.org/10.1007/s11241-019-09337-9
• Fan, Zhenye, Guixin Ye, Tianmin Hu, and Zhanyong Tang. 2024. “History-Driven Compiler Fuzzing via Assembling and Scheduling Bug-Triggering Code Segments.” In 2024 IEEE 35th International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre62328.2024.00040
• Fang, Xiangxin, Jiaqin Kang, Rodrigo Rocha, Sam Ainsworth, and Lev Mukhanov. 2026. “LLM-VeriOpt: Verification-Guided Reinforcement Learning for LLM-Based Compiler Optimization.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395239
• Farkas, Izabella Ingrid, Kristóf Szabados, and Attila Kovács. 2021. “Improving Productivity in Large Scale Testing at the Compiler Level by Changing the Intermediate Language from C++ to Java.” Acta Universitatis Sapientiae, Informatica 13 (1): 134–79. https://doi.org/10.2478/ausi-2021-0007
• Fedasyuk, Dmytro, Ratybor Chopey, and Bohdan Knysh. 2017. “Architecture of a Tool for Automated Testing the Worst-Case Execution Time of Real-Time Embedded Systems’ Firmware.” In 2017 14th International Conference The Experience of Designing and Application of CAD Systems in Microelectronics (CADSM). IEEE. https://doi.org/10.1109/cadsm.2017.7916134
• Feitosa, Samuel da Silva, Juliana Kaizer Vizzotto, Eduardo Kessler Piveta, and Andre Rauber Du Bois. 2019. “A Monadic Semantics for Quantum Computing in an Object Oriented Language.” Science of Computer Programming 173: 37–55. https://doi.org/10.1016/j.scico.2018.03.003
• Feldman, Stuart I. 1979. “Implementation of a Portable Fortran 77 Compiler Using Modern Tools.” ACM SIGPLAN Notices 14 (8): 98–106. https://doi.org/10.1145/872732.806959
• Felker, Nicholas. 2020. “Design of Cyanobyte: An Intermediate Representation to Standardize Digital Peripheral Datasheets for Automatic Code Generation.” In 2020 IEEE Sensors Applications Symposium (SAS). IEEE. https://doi.org/10.1109/sas48726.2020.9220074
• Felleisen, M. 1988. “The Theory and Practice of First-Class Prompts.” In Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘88. ACM Press. https://doi.org/10.1145/73560.73576
• Feng, Qiong, Xiaotian Ma, Ziyuan Feng, Marat Akhin, Wei Song, and Peng Liang. 2025. “Finding Compiler Bugs through Cross-Language Code Generator and Differential Testing.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 2843–69. https://doi.org/10.1145/3763152
• Ferdinand, Christian, and Reinhold Heckmann. 2008. “Worst-Case Execution Time: A Tool Provider’s Perspective.” In 2008 11th IEEE International Symposium on Object and Component-Oriented Real-Time Distributed Computing (ISORC). IEEE. https://doi.org/10.1109/isorc.2008.16
• Ferrante, Richard D., and James R. Allard. 1996. “Introducing a CPS Style Optimizer into an Existing Compiler.” ACM SIGPLAN Notices 31 (12): 73–79. https://doi.org/10.1145/242604.242621
• “Fifth IEEE International Workshop on Source Code Analysis and Manipulation.” 2005. In Fifth IEEE International Workshop on Source Code Analysis and Manipulation (SCAM’05). IEEE. https://doi.org/10.1109/scam.2005.13
• Finkel, Hal, David Poliakoff, Jean-Sylvain Camier, and David F. Richards. 2019. “ClangJIT: Enhancing C++ with Just-in-Time Compilation.” In 2019 IEEE/ACM International Workshop on Performance, Portability and Productivity in HPC (P3HPC). IEEE. https://doi.org/10.1109/p3hpc49587.2019.00013
• Flatt, Matthew, and R. Kent Dybvig. 2020. “Compiler and Runtime Support for Continuation Marks.” In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3385412.3385981
• Flatt, Matthew, Gang Yu, Robert Bruce Findler, and Matthias Felleisen. 2007. “Adding Delimited and Composable Control to a Production Programming Environment.” In Proceedings of the 12th ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/1291151.1291178
• “Fourth IEEE International Workshop on Source Code Analysis and Manipulation.” 2004. In Source Code Analysis and Manipulation, Fourth IEEE International Workshop on. IEEE. https://doi.org/10.1109/scam.2004.10
• Fox, Anthony, Magnus O. Myreen, Yong Kiam Tan, and Ramana Kumar. 2017. “Verified Compilation of CakeML to Multiple Machine-Code Targets.” In Proceedings of the 6th ACM SIGPLAN Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3018610.3018621
• Fradet, Pascal, Maxime Lesourd, Jean-Francois Monin, and Sophie Quinton. 2018. “A Generic Coq Proof of Typical Worst-Case Analysis.” In 2018 IEEE Real-Time Systems Symposium (RTSS). IEEE. https://doi.org/10.1109/rtss.2018.00039
• Francalanza, Adrian, and Gerard Tabone. 2023. “ElixirST: A Session-Based Type System for Elixir Modules.” Journal of Logical and Algebraic Methods in Programming 135: 100891. https://doi.org/10.1016/j.jlamp.2023.100891
• Fraser, Christopher W., and Alan L. Wendt. 1986. “Integrating Code Generation and Optimization.” In Proceedings of the 1986 SIGPLAN symposium on Compiler construction. ACM. https://doi.org/10.1145/12276.13335
• Frąszczak, Damian, and Edyta Frąszczak. 2026. “PhishingWebCollector: Async Python Library for Automated Phishing Feed Collection.” SoftwareX 33: 102463. https://doi.org/10.1016/j.softx.2025.102463
• Freier, Matthias, and Jian-Jia Chen. 2013. “Prioritization for Real-Time Embedded Systems on Dual-Core Platforms by Exploiting the Typical- and Worst-Case Execution Times.” In 2013 8th IEEE International Symposium on Industrial Embedded Systems (SIES). IEEE. https://doi.org/10.1109/sies.2013.6601467
• Freund, Stephen N., and John C. Mitchell. 1998a. “A Type System for Object Initialization in the Java Bytecode Language.” ACM SIGPLAN Notices 33 (10): 310–27. https://doi.org/10.1145/286942.286972
• Freund, Stephen N., and John C. Mitchell. 1998b. “A Type System for Object Initialization in the Java Bytecode Language (Summary).” Electronic Notes in Theoretical Computer Science 10: 242–45. https://doi.org/10.1016/s1571-0661(05)80703-0
• Freund, Stephen N., and John C. Mitchell. 2003. “A Type System for the Java Bytecode Language and Verifier.” Journal of Automated Reasoning 30 (3–4): 271–321. https://doi.org/10.1023/a:1025011624925
• Fried, Andreas, Maximilian Stemmer-Grabow, and Julian Wachter. 2023. “Register Allocation for Compressed ISAs in LLVM.” In Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3578360.3580261
• Friers, Florian, Michael Becher, Guido Reina, and Thomas Ertl. 2021. “Amortised Encoding for Large High-Resolution Displays.” In 2021 IEEE 11th Symposium on Large Data Analysis and Visualization (LDAV). IEEE. https://doi.org/10.1109/ldav53230.2021.00013
• Friese, Ryan D., Roberto Gioiosa, Joseph Cottam, et al. 2024. “Lamellar: A Rust-Based Asynchronous Tasking and PGAS Runtime for High Performance Computing.” In SC24-W: Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/scw63240.2024.00165
• Frigo, Matteo. 1999. “A Fast Fourier Transform Compiler.” In Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/301618.301661
• Fumero, Juan, and Christos Kotselidis. 2018. “Using Compiler Snippets to Exploit Parallelism on Heterogeneous Hardware: A Java Reduction Case Study.” In Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3281287.3281292
• Fumero, Juan, Michel Steuwer, Lukas Stadler, and Christophe Dubach. 2017. “Just-In-Time GPU Compilation for Interpreted Languages with Partial Evaluation.” ACM SIGPLAN Notices 52 (7): 60–73. https://doi.org/10.1145/3140607.3050761
• Fusaoka, Akira, and Masaharu Hirayama. 1982. “Compiler Chip: A Hardware Implementation of Compiler.” ACM SIGPLAN Notices 17 (4): 92–95. https://doi.org/10.1145/960120.801831
• Fusi, Matteo, Fabio Mazzocchetti, Albert Farres, et al. 2020. “On the Use of Probabilistic Worst-Case Execution Time Estimation for Parallel Applications in High Performance Systems.” Mathematics 8 (3): 314. https://doi.org/10.3390/math8030314
• Gaál, Tamás. 1993. “Parallel Compiler Generation.” Microprocessing and Microprogramming 39 (2–5): 147–50. https://doi.org/10.1016/0165-6074(93)90076-w
• Gaißert, Marcial, Cf Bolz-Tereick, and Jonathan Immanuel Brachthäuser. 2025. “Tracing Just-in-Time Compilation for Effects and Handlers.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 978–1006. https://doi.org/10.1145/3763085
• Gal, Andreas, Christian W. Probst, and Michael Franz. 2005. “Integrated Java Bytecode Verification.” Electronic Notes in Theoretical Computer Science 131: 27–38. https://doi.org/10.1016/j.entcs.2005.01.020
• Galloway, Michael, Gabriel Loewen, and Susan Vrbsky. 2015. “Performance Metrics of Virtual Machine Live Migration.” In 2015 IEEE 8th International Conference on Cloud Computing. IEEE. https://doi.org/10.1109/cloud.2015.90
• Gan, Wee Liang, and Liping Li. 2015. “Coinduction Functor in Representation Stability Theory.” Journal of the London Mathematical Society 92 (3): 689–711. https://doi.org/10.1112/jlms/jdv043
• Ganzinger, Harald, Robert Giegerich, Ulrich Möncke, and Reinhard Wilhelm. 1982. “A Truly Generative Semantics-Directed Compiler Generator.” ACM SIGPLAN Notices 17 (6): 172–84. https://doi.org/10.1145/872726.806993
• Gao, Cunyuan, and Lionel Parreaux. 2025. “A Lightweight Type-and-Effect System for Invalidation Safety: Tracking Permanent and Temporary Invalidation with Constraint-Based Subtype Inference.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 2623–53. https://doi.org/10.1145/3763144
• Gao, Hongyan, Yibiao Yang, Maolin Sun, Jiangchang Wu, Yuming Zhou, and Baowen Xu. 2025. “Clozemaster: Fuzzing Rust Compiler by Harnessing Llms for Infilling Masked Real Programs.” In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse55347.2025.00175
• Garcia, Ronald, Andrew Lumsdaine, and Amr Sabry. 2009. “Lazy Evaluation and Delimited Control.” ACM SIGPLAN Notices 44 (1): 153–64. https://doi.org/10.1145/1594834.1480903
• Geeson, Luke, and Lee Smith. 2024. “Compiler Testing with Relaxed Memory Models.” In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo57630.2024.10444836
• Genaim, Samir, and Damiano Zanardini. 2013. “Reachability-Based Acyclicity Analysis by Abstract Interpretation.” Theoretical Computer Science 474: 60–79. https://doi.org/10.1016/j.tcs.2012.12.018
• Geng, Chao, Daiki Ishikawa, Shoya Kudo, and Shigetoshi Nakatake. 2021. “Verification of Open-Source Memory Compiler Framework with a Practical PDK.” In 2021 4th International Conference on Circuits, Systems and Simulation (ICCSS). IEEE. https://doi.org/10.1109/iccss51193.2021.9464193
• Ghadesi, Amin, Maxime Lamothe, and Heng Li. 2024. “What Causes Exceptions in Machine Learning Applications? Mining Machine Learning-Related Stack Traces on Stack Overflow.” Empirical Software Engineering 29 (5): 107. https://doi.org/10.1007/s10664-024-10499-9
• Ghica, Dan, Sam Lindley, Marcos Maroñas Bravo, and Maciej Piróg. 2022. “High-Level Effect Handlers in C++.” Proceedings of the ACM on Programming Languages 6 (OOPSLA2): 1639–67. https://doi.org/10.1145/3563445
• Ghica, Lavinia, and Nicolae Tapus. 2015. “Optimized Retargetable Compiler for Embedded Processors: GCC vs LLVM.” In 2015 IEEE International Conference on Intelligent Computer Communication and Processing (ICCP). IEEE. https://doi.org/10.1109/iccp.2015.7312613
• Ghorbani, Mehrdad, and Seyed Morteza Babamir. 2019. “Runtime Deadlock Tracking and Prevention of Concurrent Multithreaded Programs: A Learning-Based Approach.” Concurrency and Computation: Practice and Experience 32 (10): e5324. https://doi.org/10.1002/cpe.5324
• Ghosh, Arindrajit, Uddalak Bhattacharya, Manish Kumar, and Swapna Banerjee. 2020. “Compiler Compatible 5.66 Mb/mm2 8T 1R1W Register File in 14 Nm FinFET Technology.” Integration 70: 126–37. https://doi.org/10.1016/j.vlsi.2019.08.006
• Ghosh, Amitava, and Pinnaduwa H. S. W. Kulatilake. 1987. “A FORTRAN Program for Generation of Multivariate Normally Distributed Random Variables.” Computers & Geosciences 13 (3): 221–33. https://doi.org/10.1016/0098-3004(87)90043-4
• Giacobazzi, Roberto. 2008. “Abstract Interpretation in Code Security.” In 2008 Sixth IEEE International Conference on Software Engineering and Formal Methods. IEEE. https://doi.org/10.1109/sefm.2008.49
• Gillard, Antonino Yann William, Tetsuro Yamazaki, and Tomoharu Ugawa. 2026. “Dynamic Wind for OCaml Effect Handlers with Escaping Continuation Support.” In Proceedings of the 19th ACM SIGPLAN International Conference on Software Language Engineering. ACM. https://doi.org/10.1145/3806383.3815525
• Godboley, Sangharatna, Kanika Gupta, and . G. Monika. 2022. “AV-AFL: A Vulnerability Detection Fuzzing Approach by Proving Non-Reachable Vulnerabilities Using Sound Static Analyser.” In Proceedings of the 17th International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011032900003176
• Goos, Gerhard. 2002. “Compiler Verification and Compiler Architecture.” Electronic Notes in Theoretical Computer Science 65 (2): 1. https://doi.org/10.1016/s1571-0661(04)80392-x
• Gordon, Nicholas, Kevin Pedretti, and John R. Lange. 2022. “Porting the Kitten Lightweight Kernel Operating System to RISC-V.” In 2022 IEEE/ACM International Workshop on Runtime and Operating Systems for Supercomputers (ROSS). IEEE. https://doi.org/10.1109/ross56639.2022.00008
• Gorelik, A. M., and E. V. Khukhlaev. 1975. “Implementation of the Incremental Fortran Compiler.” USSR Computational Mathematics and Mathematical Physics 15 (3): 175–82. https://doi.org/10.1016/0041-5553(75)90084-1
• Gorringe, Chris, and Anand Jain. 2013. “Architectural Considerations for Implementation of the ATML Standards in an Open Systems Architecture Runtime Environment (OSA-RTS) Using a Graphical Environment.” In 2013 IEEE Autotestcon. IEEE. https://doi.org/10.1109/autest.2013.6645070
• Gotti, Zineb, and Samir Mbarki. 2016. “Java Swing Modernization Approach: Complete Abstract Representation Based on Static and Dynamic Analysis.” In Proceedings of the 11th International Joint Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0005986002100219
• Grabowski, Adam. 2025. “Encoding Triangular Norms on Bounded Trellises with Mizar Proof Assistant.” In 2025 IEEE International Conference on Fuzzy Systems (FUZZ). IEEE. https://doi.org/10.1109/fuzz62266.2025.11152116
• Groce, Alex, Rijnard van Tonder, Goutamkumar Tulajappa Kalburgi, and Claire Le Goues. 2022. “Making No-Fuss Compiler Fuzzing Effective.” In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3497776.3517765
• Gruetter, Samuel, Viktor Fukala, and Adam Chlipala. 2024. “Live Verification in an Interactive Proof Assistant.” Proceedings of the ACM on Programming Languages 8 (PLDI): 1535–58. https://doi.org/10.1145/3656439
• Guan, Hui, Xipeng Shen, and Seung-Hwan Lim. 2019. “Wootz: A Compiler-Based Framework for Fast CNN Pruning via Composability.” In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3314221.3314652
• Guerrera, Danilo, Antonio Maffia, and Helmar Burkhart. 2019. “Reproducible Stencil Compiler Benchmarks Using Prova!” Future Generation Computer Systems 92: 933–46. https://doi.org/10.1016/j.future.2018.05.023
• Guessarian, Irène. 1979. “Program Transformations and Algebraic Semantics.” Theoretical Computer Science 9 (1): 39–65. https://doi.org/10.1016/0304-3975(79)90005-7
• Gunadi, Hendra. 2015. “Formal Certification of Non-Interferent Android Bytecode (DEX Bytecode).” In 2015 20th International Conference on Engineering of Complex Computer Systems (ICECCS). IEEE. https://doi.org/10.1109/iceccs.2015.36
• Gundersen, Tom, Willem Heijltjes, and Michel Parigot. 2013. “Atomic Lambda Calculus: A Typed Lambda-Calculus with Explicit Sharing.” In 2013 28th Annual ACM/IEEE Symposium on Logic in Computer Science. IEEE. https://doi.org/10.1109/lics.2013.37
• Guo, Jie, Jun Liu, Bjorn Mennenga, and Gerhard P. Fettweis. 2007. “A Phase-Coupled Compiler Backend for a New VLIW Processor Architecture Using Two-Step Register Allocation.” In 2007 IEEE International Conf. on Application-specific Systems, Architectures and Processors (ASAP). IEEE. https://doi.org/10.1109/asap.2007.4459288
• Guo, Shu-yi, and Qi Si. 2016. “Mechanical Hydraulic Characteristic Analysis Scheme Based on Lightweight Crowd Data in Mobile Embedded Devices.” EURASIP Journal on Embedded Systems 2017 (1): 13. https://doi.org/10.1186/s13639-016-0049-3
• Guria, Sankha Narayan, Jeffrey S. Foster, and David Van Horn. 2021. “RbSyn: Type- and Effect-Guided Program Synthesis.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454048
• Gustafsson, Jan. 2006. “The Worst Case Execution Time Tool Challenge 2006.” In Second International Symposium on Leveraging Applications of Formal Methods, Verification and Validation (isola 2006). IEEE. https://doi.org/10.1109/isola.2006.72
• Guyer, S. Z., and C. Lin. 2005. “Broadway: A Compiler for Exploiting the Domain-Specific Semantics of Software Libraries.” Proceedings of the IEEE 93 (2): 342–57. https://doi.org/10.1109/jproc.2004.840489
• Haas, Thomas, René Maseli, Roland Meyer, and Hernán Ponce de León. 2023. “Static Analysis of Memory Models for SMT Encodings.” Proceedings of the ACM on Programming Languages 7 (OOPSLA2): 1618–47. https://doi.org/10.1145/3622855
• Haas, Andreas, Andreas Rossberg, Derek L. Schuff, et al. 2017. “Bringing the Web up to Speed with WebAssembly.” In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3062341.3062363
• Haikun Liu, Hai Jin, Xiaofei Liao, Chen Yu, and Cheng-Zhong Xu. 2011. “Live Virtual Machine Migration via Asynchronous Replication and State Synchronization.” IEEE Transactions on Parallel and Distributed Systems 22 (12): 1986–99. https://doi.org/10.1109/tpds.2011.86
• Hale, Sandra, Jane Goodman-Delahunty, and Natalie Martschuk. 2018. “Interpreter Performance in Police Interviews. Differences between Trained Interpreters and Untrained Bilinguals.” Interpreter and Translator Trainer 13 (2): 107–31. https://doi.org/10.1080/1750399x.2018.1541649
• Hammer, Maximilian, Ralph Maschotta, and Armin Zimmermann. 2025. “Compiler-Like Code Generation for fUML: Reducing Overhead in Executable UML.” IEEE Access 13: 173267–97. https://doi.org/10.1109/access.2025.3615249
• Han, Chao. 2016. “Building the Validity Foundation for Interpreter Certification Performance Testing.” Interpreter and Translator Trainer 10 (2): 248–49. https://doi.org/10.1080/1750399x.2016.1204883
• Han, Ruidong, Siqi Ma, Juanru Li, et al. 2024b. “Range Specification Bug Detection in Flight Control System through Fuzzing.” IEEE Transactions on Software Engineering 50 (3): 461–73. https://doi.org/10.1109/tse.2024.3354739
• Han, Myeonggyun, Jinsu Park, and Woongki Baek. 2021a. “Design and Implementation of a Criticality- and Heterogeneity-Aware Runtime System for Task-Parallel Applications.” IEEE Transactions on Parallel and Distributed Systems 32 (5): 1117–32. https://doi.org/10.1109/tpds.2020.3031911
• Han, Jixin, Tomofumi Yuki, Michelle Mills Strout, Dan Umeda, Hironori Kasahara, and Keiji Kimura. 2021b. “Parallelizing Compiler Translation Validation Using Happens-Before and Task-Set.” In 2021 Ninth International Symposium on Computing and Networking Workshops (CANDARW). IEEE. https://doi.org/10.1109/candarw53999.2021.00022
• Han, Ruobing, Jisheng Zhao, and Hyesoon Kim. 2024a. “Enabling Fine-Grained Incremental Builds by Making Compiler Stateful.” In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo57630.2024.10444865
• Hansen, René Rydhof, and Igor A. Siveroni. 2005. “Towards Verification of Well-Formed Transactions in Java Card Bytecode.” Electronic Notes in Theoretical Computer Science 141 (1): 145–62. https://doi.org/10.1016/j.entcs.2005.02.032
• Hanson, David R. 1976. “A Simple Variant of the Boundary-Tag Algorithm for the Allocation of Coroutine Environments.” Information Processing Letters 4 (4): 109–12. https://doi.org/10.1016/0020-0190(76)90057-0
• Hara, Kazuki, Takeshi Takahashi, Motoya Ishimaki, and Kazumasa Omote. 2021. “Machine-Learning Approach Using Solidity Bytecode for Smart-Contract Honeypot Detection in the Ethereum.” In 2021 IEEE 21st International Conference on Software Quality, Reliability and Security Companion (QRS-C). IEEE. https://doi.org/10.1109/qrs-c55045.2021.00099
• Hardy, Damien, and Isabelle Puaut. 2014. “Static Probabilistic Worst Case Execution Time Estimation for Architectures with Faulty Instruction Caches.” Real-Time Systems 51 (2): 128–52. https://doi.org/10.1007/s11241-014-9212-x
• Hariri, Farah, August Shi, Hayes Converse, Sarfraz Khurshid, and Darko Marinov. 2016. “Evaluating the Effects of Compiler Optimizations on Mutation Testing at the Compiler IR Level.” In 2016 IEEE 27th International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre.2016.51
• Hariri, Farah, August Shi, Vimuth Fernando, Suleman Mahmood, and Darko Marinov. 2019. “Comparing Mutation Testing at the Levels of Source Code and Compiler Intermediate Representation.” In 2019 12th IEEE Conference on Software Testing, Validation and Verification (ICST). IEEE. https://doi.org/10.1109/icst.2019.00021
• Harlin, Ismail Rizky, Hironori Washizaki, and Yoshiaki Fukazawa. 2017. “Impact of Using a Static-Type System in Computer Programming.” In 2017 IEEE 18th International Symposium on High Assurance Systems Engineering (HASE). IEEE. https://doi.org/10.1109/hase.2017.17
• Harmon, Trevor, and Raymond Klefstad. 2007a. “Interactive Back-Annotation of Worst-Case Execution Time Analysis for Java Microprocessors.” In 13th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications (RTCSA 2007). IEEE. https://doi.org/10.1109/rtcsa.2007.44
• Harmon, Trevor, and Raymond Klefstad. 2007b. “A Survey of Worst-Case Execution Time Analysis for Real-Time Java.” In 2007 IEEE International Parallel and Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2007.370422
• Harmon, Trevor, and Raymond Klefstad. 2007c. “Toward a Unified Standard for Worst-Case Execution Time Annotations in Real-Time Java.” In 2007 IEEE International Parallel and Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2007.370346
• Harmon, Trevor, Martin Schoeberl, Raimund Kirner, and Raymond Klefstad. 2008. “A Modular Worst-Case Execution Time Analysis Tool for Java Processors.” In 2008 IEEE Real-Time and Embedded Technology and Applications Symposium. IEEE. https://doi.org/10.1109/rtas.2008.34
• Harmon, Trevor, Martin Schoeberl, Raimund Kirner, Raymond Klefstad, Kwang H. Kim, and Michael R. Lowry. 2012. “Fast, Interactive Worst-Case Execution Time Analysis with Back-Annotation.” IEEE Transactions on Industrial Informatics 8 (2): 366–77. https://doi.org/10.1109/tii.2012.2187457
• Harnes, Håkon, and Donn Morrison. 2024. “SoK: Analysis Techniques for WebAssembly.” Future Internet 16 (3): 84. https://doi.org/10.3390/fi16030084
• Harshithan, K. S. 2023. “Batwing Compiler: An Artificial Intelligence Based Compiler.” In 2023 Second International Conference on Advances in Computational Intelligence and Communication (ICACIC). IEEE. https://doi.org/10.1109/icacic59454.2023.10434977
• Hatcliff, John, and Olivier Danvy. 1994. “A Generic Account of Continuation-Passing Styles.” In Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘94. ACM Press. https://doi.org/10.1145/174675.178053
• Hazott, Christoph, Florian Stögmüller, and Daniel Große. 2025. “Using Virtual Prototypes and Metamorphic Testing to Verify the Hardware/software-Stack of Embedded Graphics Libraries.” Integration 101: 102320. https://doi.org/10.1016/j.vlsi.2024.102320
• He, Jiahao, Shuangyin Li, Xinming Wang, Shing-Chi Cheung, Gansen Zhao, and Jinji Yang. 2023a. “Neural-FEBI: Accurate Function Identification in Ethereum Virtual Machine Bytecode.” Journal of Systems and Software 199: 111627. https://doi.org/10.1016/j.jss.2023.111627
• He, Zhixing, and Hao Zhong. 2025. “From Bug Reports to Workarounds: The Real-World Impact of Compiler Bugs.” In 2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner64311.2025.00032
• Heck, Petra, and Andy Zaidman. 2015. “Quality Criteria for Just-in-Time Requirements: Just Enough, Just-in-Time?” In 2015 IEEE Workshop on Just-In-Time Requirements Engineering (JITRE). IEEE. https://doi.org/10.1109/jitre.2015.7330170
• Heinrich, Tiago, Newton Will, Rafael Obelheiro, and Carlos Maziero. 2024. “A Categorical Data Approach for Anomaly Detection in WebAssembly Applications.” In Proceedings of the 10th International Conference on Information Systems Security and Privacy. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0012252800003648
• Henriksen, Kim, and John Gallagher. 2006. “Abstract Interpretation of PIC Programs through Logic Programming.” In 2006 Sixth IEEE International Workshop on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2006.1
• Henry, Julien, Mihail Asavoae, David Monniaux, and Claire Maïza. 2014. “How to Compute Worst-Case Execution Time by Optimization Modulo Theory and a Clever Encoding of Program Semantics.” ACM SIGPLAN Notices 49 (5): 43–52. https://doi.org/10.1145/2666357.2597817
• Heo, Seonyeong, Jiho Kim, Woohyeop Im, Jiyun Moon, and Daehee Jang. 2025. “Bit-Level Compiler Optimization for Ultra Low-Power Embedded Systems.” Journal of Systems Architecture 168: 103546. https://doi.org/10.1016/j.sysarc.2025.103546
• Heo, Kihong, Hakjoo Oh, and Hongseok Yang. 2019. “Resource-Aware Program Analysis via Online Abstraction Coarsening.” In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse.2019.00027
• Hepp, Stefan, and Martin Schoeberl. 2012. “Worst-Case Execution Time Based Optimization of Real-Time Java Programs.” In 2012 IEEE 15th International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing. IEEE. https://doi.org/10.1109/isorc.2012.17
• Herklotz, Yann, Delphine Demange, and Sandrine Blazy. 2023. “Mechanised Semantics for Gated Static Single Assignment.” In Proceedings of the 12th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3573105.3575681
• Heumann, Stephen T., Alexandros Tzannes, and Vikram S. Adve. 2015. “Scalable Task Scheduling and Synchronization Using Hierarchical Effects.” In 2015 International Conference on Parallel Architecture and Compilation (PACT). IEEE. https://doi.org/10.1109/pact.2015.25
• Hikmatyarsyah, ., and Sasono Rahardjo. 2022. “Integration of Downlink Scheme VLC Access Techniques for Low-Cost Implementation Indoor Communication System: A Survey.” In Proceedings of the 10th International Conference on Photonics, Optics and Laser Technology. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010776200003121
• Hirata, Michikazu, Yasuhiko Minamide, and Tetsuya Sato. 2023. “Program Logic for Higher-Order Probabilistic Programs in Isabelle/HOL.” Science of Computer Programming 230: 102993. https://doi.org/10.1016/j.scico.2023.102993
• Hiroyuki, Sato. 2009. “Idiom Recognition and Program Scheme Recognition Based Program Transformations for Performance Tuning–Beyond Compiler Optimizations–.” In 2009 International Conference on Parallel and Distributed Computing, Applications and Technologies. IEEE. https://doi.org/10.1109/pdcat.2009.66
• Hirschowitz, Tom. 2019. “Familial Monads and Structural Operational Semantics.” Proceedings of the ACM on Programming Languages 3 (POPL): 1–28. https://doi.org/10.1145/3290334
• Hoang, P., and J. Rabaey. 1992. “A Compiler for Multiprocessor DSP Implementation.” In [Proceedings] ICASSP-92: 1992 IEEE International Conference on Acoustics, Speech, and Signal Processing. IEEE. https://doi.org/10.1109/icassp.1992.226553
• Holmes, Josie, and Alex Groce. 2018. “Causal Distance-Metric-Based Assistance for Debugging after Compiler Fuzzing.” In 2018 IEEE 29th International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre.2018.00027
• Holmes, Josie, and Alex Groce. 2020. “Using Mutants to Help Developers Distinguish and Debug (Compiler) Faults.” Software Testing, Verification and Reliability 30 (2): e1727. https://doi.org/10.1002/stvr.1727
• Hong, Jinpyo, and J. Ramanujam. 2008. “Address Register Allocation in Digital Signal Processors.” In 2008 International Conference on Embedded Software and Systems. IEEE. https://doi.org/10.1109/icess.2008.88
• Horvat, Marko, Iva Ursić, and Klara Krmpotić. 2026. “Comparative Evaluation of Gemini and DeepSeek for LLM-Generated Code Quality and Architectural Robustness in Backend Software Engineering.” Electronics 15 (13): 2805. https://doi.org/10.3390/electronics15132805
• Hossain, Sakib, Mabia Akter Emi, Mohsina Hossain Mishu, Raihana Zannat, and Ohidujjaman. 2021. “Code Generator Based on Voice Command for Multiple Programming Language.” In 2021 12th International Conference on Computing Communication and Networking Technologies (ICCCNT). IEEE. https://doi.org/10.1109/icccnt51525.2021.9579880
• Hsu, Chung-Hsing, and Ulrich Kremer. 2003. “The Design, Implementation, and Evaluation of a Compiler Algorithm for CPU Energy Reduction.” In Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/781131.781137
• Hu, Tianmin, Zhenye Fan, Zhanbo Ye, Guixin Ye, and Lu He. 2025. “SSFuzz: Synthesizing and Scheduling Bug-Triggering Code Segments for History-Driven Compiler Testing.” Empirical Software Engineering 31 (2): 27. https://doi.org/10.1007/s10664-025-10777-0
• Hu, Yunfei, Fei Gu, Puyu Han, Zhihao Wei, and Zhijun Li. 2026. “QJWasm: A Lightweight Runtime System for Efficient WebAssembly Execution in Resource-Constrained Environments.” Journal of Systems Architecture 179: 103926. https://doi.org/10.1016/j.sysarc.2026.103926
• Hu, Xinbang, Guanjun Liu, Xiaofeng Li, Kaiwen Zhang, Jian Guan, and Bin Gu. 2024. “An Abstract Interpretation-Based Framework for WCET Analysis of Parallel Programs.” In 2024 International Conference on Networking, Sensing and Control (ICNSC). IEEE. https://doi.org/10.1109/icnsc62968.2024.10759926
• Hu, Xinyun, and Yuxian Tang. 2024. “Research on Compiler Version Recognition Based on Random Forest Algorithm.” In 2024 IEEE 6th International Conference on Civil Aviation Safety and Information Technology (ICCASIT). IEEE. https://doi.org/10.1109/iccasit62299.2024.10828126
• Hu, Yonghua, Xin Zhang, Shuying Wang, Wei Liang, and Kuan-Ching Li. 2022. “Research on Global Register Allocation for Code Containing Array-Unit Dual-Usage Register Names.” Concurrency and Computation: Practice and Experience 35 (19): e7519. https://doi.org/10.1002/cpe.7519
• Hua, Jingyu, Takashi Nishide, and Kouichi Sakurai. 2010. “Model-Based Intrusion Detection by Abstract Interpretation.” In 2010 10th IEEE/IPSJ International Symposium on Applications and the Internet. IEEE. https://doi.org/10.1109/saint.2010.107
• Huang, Pei-Ching, and Shi-Yu Huang. 2016. “Cell-Based Delay Locked Loop Compiler.” In 2016 International SoC Design Conference (ISOCC). IEEE. https://doi.org/10.1109/isocc.2016.7799748
• Huber, Benedikt, Wolfgang Puffitsch, and Martin Schoeberl. 2011. “Worst-Case Execution Time Analysis-Driven Object Cache Design.” Concurrency and Computation: Practice and Experience 24 (8): 753–71. https://doi.org/10.1002/cpe.1763
• Huch, Frank. 1999. “Verification of Erlang Programs Using Abstract Interpretation and Model Checking.” In Proceedings of the fourth ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/317636.317908
• Huck, Alexander, Sebastian Kreutzer, Joachim Protze, et al. 2022. “Compiler-Aided Type Correctness of Hybrid MPI-OpenMP Applications.” IT Professional 24 (2): 45–51. https://doi.org/10.1109/mitp.2021.3093949
• Huck, Alexander, Jan-Patrick Lehr, Sebastian Kreutzer, et al. 2018. “Compiler-Aided Type Tracking for Correctness Checking of MPI Applications.” In 2018 IEEE/ACM 2nd International Workshop on Software Correctness for HPC Applications (Correctness). IEEE. https://doi.org/10.1109/correctness.2018.00011
• Huck, Alexander, Joachim Protze, Jan-Patrick Lehr, Christian Terboven, Christian Bischof, and Matthias S. Muller. 2020. “Towards Compiler-Aided Correctness Checking of Adjoint MPI Applications.” In 2020 IEEE/ACM 4th International Workshop on Software Correctness for HPC Applications (Correctness). IEEE. https://doi.org/10.1109/correctness51934.2020.00010
• Hück, Alexander, Tim Ziegler, Simon Schwitanski, Joachim Jenke, and Christian Bischof. 2024. “Compiler-Aided Correctness Checking of CUDA-Aware MPI Applications.” In SC24-W: Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/scw63240.2024.00032
• Hui Zhao, Qinghua Zheng, Weizhan Zhang, Yuxuan Chen, and Yunhui Huang. 2015. “Virtual Machine Placement Based on the VM Performance Models in Cloud.” In 2015 IEEE 34th International Performance Computing and Communications Conference (IPCCC). IEEE. https://doi.org/10.1109/pccc.2015.7410296
• Hura, G. S. 1982. “Optimization of Assembly Code Generation in a Compiler.” Microelectronics Reliability 22 (5): 1035–36. https://doi.org/10.1016/s0026-2714(82)80471-x
• Hussain, Ishtiaque, Christoph Csallner, Mark Grechanik, et al. 2014. “RUGRAT: Evaluating Program Analysis and Testing Tools and Compilers with Large Generated Random Benchmark Applications.” Software: Practice and Experience 46 (3): 405–31. https://doi.org/10.1002/spe.2290
• Huynh, Thuan Quang, and Abhik Roychoudhury. 2007. “Memory Model Sensitive Bytecode Verification.” Formal Methods in System Design 31 (3): 281–305. https://doi.org/10.1007/s10703-007-0041-6
• Huynh, An, and Kenjiro Taura. 2017. “Delay Spotter: A Tool for Spotting Scheduler-Caused Delays in Task Parallel Runtime Systems.” In 2017 IEEE International Conference on Cluster Computing (CLUSTER). IEEE. https://doi.org/10.1109/cluster.2017.82
• Hyatt, Sarah Canto, and Kyle Dewey. 2025. “Mutation-Based Fuzzing of the Swift Compiler with Incomplete Type Information.” In 2025 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst62969.2025.10989032
• Hyland, Martin, Paul Blain Levy, Gordon Plotkin, and John Power. 2007. “Combining Algebraic Effects with Continuations.” Theoretical Computer Science 375 (1–3): 20–40. https://doi.org/10.1016/j.tcs.2006.12.026
• Iida, Ryuichi, Keiichiro Oishi, and Hiroyuki Nakagawa. 2026. “An Efficient Runtime Verification Toolkit for Self-Adaptive Systems Addressing Runtime System Model Changes.” IEEE Access 14: 56858–69. https://doi.org/10.1109/access.2026.3682704
• Ilik, Danko. 2012. “Delimited Control Operators Prove Double-Negation Shift.” Annals of Pure and Applied Logic 163 (11): 1549–59. https://doi.org/10.1016/j.apal.2011.12.008
• Ilik, Danko. 2013a. “Continuation-Passing Style Models Complete for Intuitionistic Logic.” Annals of Pure and Applied Logic 164 (6): 651–62. https://doi.org/10.1016/j.apal.2012.05.003
• Imamoglu, Meltem Yildirim, and Deniz Cetinkaya. 2017. “A Rule Based Decision Support System for Programming Language Selection.” In 2017 2nd International Conference on Knowledge Engineering and Applications (ICKEA). IEEE. https://doi.org/10.1109/ickea.2017.8169904
• “Implementation of a Motor Imagery Based BCI System Using Python Programming Language.” 2015. In Proceedings of the 2nd International Conference on Physiological Computing Systems. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005211500350043
• “Implementation of a Pascal Compiler for the CII IRIS 80 Computer.” 1973. ACM SIGPLAN Notices 8 (6): 89–90. https://doi.org/10.1145/986953.986994
• Inoue, Hiroshi, Hiroshige Hayashizaki, Peng Wu, and Toshio Nakatani. 2011. “A Trace-Based Java JIT Compiler Retrofitted from a Method-Based Compiler.” In International Symposium on Code Generation and Optimization (CGO 2011). IEEE. https://doi.org/10.1109/cgo.2011.5764692
• Inoue, Hiroaki, and Atsushi Igarashi. 2019. “A Type System for First-Class Layers with Inheritance, Subtyping, and Swapping.” Science of Computer Programming 179: 54–86. https://doi.org/10.1016/j.scico.2019.03.008
• Inoue, Keisuke, and Mineo Kaneko. 2015. “Bitwidth-Aware Register Allocation and Binding for Clock Period Minimization.” In 2015 IEEE 58th International Midwest Symposium on Circuits and Systems (MWSCAS). IEEE. https://doi.org/10.1109/mwscas.2015.7282093
• Ishio, Chiaki, and Kenichi Asai. 2022. “Type System for Four Delimited Control Operators.” In Proceedings of the 21st ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences. ACM. https://doi.org/10.1145/3564719.3568691
• Ismael, Sarmad F., Omar T. Zyad, and Yahya T. Qassim. 2018. “System on Chip Implementation of Compiler Stack with a Delimiter Matching Application.” In 2018 Third Scientific Conference of Electrical Engineering (SCEE). IEEE. https://doi.org/10.1109/scee.2018.8684137
• Isoda, Kanaru, Ayato Yokoyama, and Yukiyoshi Kameyama. 2024. “Type-Safe Code Generation with Algebraic Effects and Handlers.” In Proceedings of the 23rd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences. ACM. https://doi.org/10.1145/3689484.3690731
• Israel, Joel Alfred, R. Nithin, Aravinda Kannan Ks, Shanjay Ravikumar, and K. Kumaran. 2026. “Exploring WebAssembly as a Runtime Platform for Safety-Critical Edge Systems.” In 2026 6th International Conference on Trends in Material Science and Inventive Materials (ICTMIM). IEEE. https://doi.org/10.1109/ictmim68190.2026.11507665
• Ito, Hiromasa, Yutaka Matsubara, and Hiroaki Takada. 2023. “Schfuzz: Detecting Concurrency Bugs with Feedback-Guided Fuzzing.” In Proceedings of the 18th International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011722100003464
• Ivanov, Ivan Evg., Vesselin Gueorguiev, and Desislava Georgieva. 2019. “Software Structure, Program Generation and Schedulability Analysis of Extracorporeal Perfusion Pump Embedded Controller.” In 2019 8th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco.2019.8760025
• Iwasaki, Shintaro, Abdelhalim Amer, Kenjiro Taura, and Pavan Balaji. 2018. “Lessons Learned from Analyzing Dynamic Promotion for User-Level Threading.” In SC18: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/sc.2018.00026
• Iyenghar, Padma, Nils Baumgartner, Marlena Schmidt, and Elke Pulvermüller. 2026. “Incremental Static Analysis for Detecting and Refactoring Data Clumps in TypeScript.” In Proceedings of the 21st International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0014853500004015
• Jacek, Nicholas, Meng-Chieh Chiu, Benjamin Marlin, and Eliot Moss. 2016. “Assessing the Limits of Program-Specific Garbage Collection Performance.” In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2908080.2908120
• Jadhav, Shashank, and Heiko Falk. 2025. “Compiler-Level DMA-Aware Multi-Objective Dynamic SPM Allocation.” Real-Time Systems 61 (1): 53–117. https://doi.org/10.1007/s11241-025-09436-w
• Jain, Abhishek Kumar, Douglas L. Maskell, and Suhaib A. Fahmy. 2022. “Coarse Grained FPGA Overlay for Rapid Just-In-Time Accelerator Compilation.” IEEE Transactions on Parallel and Distributed Systems 33 (6): 1478–90. https://doi.org/10.1109/tpds.2021.3116859
• Jamieson, Maurice, and Nick Brown. 2021. “Compact Native Code Generation for Dynamic Languages on Micro-Core Architectures.” In Proceedings of the 30th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3446804.3446853
• Jamil, Tariq. 2018. “Design of a Real-Time Interpreter for Arabic Sign Language.” In SoutheastCon 2018. IEEE. https://doi.org/10.1109/secon.2018.8479201
• Janssens, G., and M. Bruynooghe. 1992. “Deriving Descriptions of Possible Values of Program Variables by Means of Abstract Interpretation.” Journal of Logic Programming 13 (2–3): 205–58. https://doi.org/10.1016/0743-1066(92)90032-x
• Jay, Nathan, and Barton P. Miller. 2018. “Structured Random Differential Testing of Instruction Decoders.” In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner.2018.8330199
• Jeon, Donghoon, Minseok Jeon, and Hakjoo Oh. 2021. “A Practical Algorithm for Learning Disjunctive Abstraction Heuristics in Static Program Analysis.” Information and Software Technology 135: 106564. https://doi.org/10.1016/j.infsof.2021.106564
• Jeong, Dae R., Kyungtae Kim, Basavesh Shivakumar, Byoungyoung Lee, and Insik Shin. 2019. “Razzer: Finding Kernel Race Bugs through Fuzzing.” In 2019 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp.2019.00017
• Jeong, Eunbi, Eun Seong Park, Gunjae Koo, Yunho Oh, and Myung Kuk Yoon. 2024. “Conflict-Aware Compiler for Hierarchical Register File on GPUs.” Journal of Systems Architecture 149: 103099. https://doi.org/10.1016/j.sysarc.2024.103099
• Jha, Surabhi, Meenakshi D’Souza, Raoul Jetley, and Sreeja Nairy. 2018. “Worst Case Execution Time Estimation for Control Code of Automation Systems.” In 2018 International Conference on Advances in Computing and Communication Engineering (ICACCE). IEEE. https://doi.org/10.1109/icacce.2018.8441723
• Jiang, Zhewei, Hungkei Chow, and Dragan Samardzija. 2024. “DCIM Compiler: Physical Design Generator.” In 2024 22nd IEEE Interregional NEWCAS Conference (NEWCAS). IEEE. https://doi.org/10.1109/newcas58973.2024.10666342
• Jiang, Shuyao, Ruiying Zeng, Yangfan Zhou, and Michael R. Lyu. 2025. “Distinguishability-Guided Test Program Generation for WebAssembly Runtime Performance Testing.” In 2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner64311.2025.00078
• Jiang, Shujuan, Hongchang Zhang, Qingtan Wang, and Yanmei Zhang. 2010. “A Debugging Approach for Java Runtime Exceptions Based on Program Slicing and Stack Traces.” In 2010 10th International Conference on Quality Software. IEEE. https://doi.org/10.1109/qsic.2010.23
• Jimenez Gil, Samuel, Iain Bate, George Lima, Luca Santinelli, Adriana Gogonel, and Liliana Cucu-Grosjean. 2017. “Open Challenges for Probabilistic Measurement-Based Worst-Case Execution Time.” IEEE Embedded Systems Letters 9 (3): 69–72. https://doi.org/10.1109/les.2017.2712858
• Jodogne, Sébastien. 2022. “Rendering Medical Images Using WebAssembly.” In Proceedings of the 15th International Joint Conference on Biomedical Engineering Systems and Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010833300003123
• Johann, Patricia, Alex Simpson, and Janis Voigtländer. 2010. “A Generic Operational Metatheory for Algebraic Effects.” In 2010 25th Annual IEEE Symposium on Logic in Computer Science. IEEE. https://doi.org/10.1109/lics.2010.29
• Johnson, Keith J. C., Rahul Krishnan, Thomas Reps, and Loris D’Antoni. 2024. “Automating Pruning in Top-Down Enumeration for Program Synthesis Problems with Monotonic Semantics.” Proceedings of the ACM on Programming Languages 8 (OOPSLA2): 935–61. https://doi.org/10.1145/3689744
• Johnson, Evan, Evan Laufer, Zijie Zhao, et al. 2023. “WaVe: A Verifiably Secure WebAssembly Sandboxing Runtime.” In 2023 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp46215.2023.10179357
• Jong-In Lee, Su-Hyun Park, Ho-Jung Bang, Tai-Hyo Kim, and Sung-Deok Cha. 2005. “A Hybrid Framework of Worst-Case Execution Time Analysis for Real-Time Embedded System Software.” In 2005 IEEE Aerospace Conference. IEEE. https://doi.org/10.1109/aero.2005.1559632
• “JSIMIL: A Java Bytecode Clone Detector.” 2010. In Proceedings of the 5th International Conference on Software and Data Technologies. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0003013403330336
• Julián-Iranzo, Pascual, and Clemente Rubio-Manzano. 2017. “A Sound and Complete Semantics for a Similarity-Based Logic Programming Language.” Fuzzy Sets and Systems 317: 1–26. https://doi.org/10.1016/j.fss.2016.12.016
• Kaestner, Daniel. 2007. “Safe Worst-Case Execution Time Analysis by Abstract Interpretation of Executable Code.” ACM SIGPLAN Notices 42 (7): 135–135. https://doi.org/10.1145/1273444.1254787
• Kahn, David M., Jan Hoffmann, and Runming Li. 2026. “Big-Stop Semantics: Small-Step Semantics in a Big-Step Judgment.” Proceedings of the ACM on Programming Languages 10 (POPL): 2204–32. https://doi.org/10.1145/3776718
• Kakati, Sangeeta, and Mats Brorsson. 2025. “Performance and Usability Implications of Multiplatform and WebAssembly Containers.” In Proceedings of the 15th International Conference on Cloud Computing and Services Science. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013203200003950
• Kalebe, Rubem, Gustavo Girao, and Itamir Filho. 2017. “A Library for Scheduling Lightweight Threads in Internet of Things Microcontrollers.” In 2017 International Conference on Computing Networking and Informatics (ICCNI). IEEE. https://doi.org/10.1109/iccni.2017.8123793
• Kalyur, Sesha, and G. S. Nagaraja. 2016. “A Survey of Modeling Techniques Used in Compiler Design and Implementation.” In 2016 International Conference on Computation System and Information Technology for Sustainable Solutions (CSITSS). IEEE. https://doi.org/10.1109/csitss.2016.7779385
• Kameyama, Yukiyoshi, and Asami Tanaka. 2010. “Equational Axiomatization of Call-by-Name Delimited Control.” In Proceedings of the 12th international ACM SIGPLAN symposium on Principles and practice of declarative programming. ACM. https://doi.org/10.1145/1836089.1836100
• Kanabar, Hrutvik, Samuel Vivien, Oskar Abrahamsson, et al. 2023. “PureCake: A Verified Compiler for a Lazy Functional Language.” Proceedings of the ACM on Programming Languages 7 (PLDI): 952–76. https://doi.org/10.1145/3591259
• Kandemir, Mahmut Taylan. 2001. “A Compiler Technique for Improving Whole-Program Locality.” ACM SIGPLAN Notices 36 (3): 179–92. https://doi.org/10.1145/373243.360219
• Kang, Byeongjee, Harsh Desai, Limin Jia, and Brandon Lucia. 2026. “WAMI: Compilation to WebAssembly through MLIR without Losing Abstraction.” In Proceedings of the 23rd ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3828170.3828172
• Karachalias, Georgios, Filip Koprivec, Matija Pretnar, and Tom Schrijvers. 2021. “Efficient Compilation of Algebraic Effect Handlers.” Proceedings of the ACM on Programming Languages 5 (OOPSLA): 1–28. https://doi.org/10.1145/3485479
• Karr, Michael. 1984. “Code Generation by Coagulation.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502875
• Kasaraneni, Ramya, and V. Krishna Nandivada. 2026. “Compact Representation and Interleaved Solving for Scalable Constraint-Based Points-to Analysis.” In Proceedings of the 35th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3771775.3786280
• Katel, Navdeep, Vivek Khandelwal, and Uday Bondhugula. 2022. “MLIR-Based Code Generation for GPU Tensor Cores.” In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3497776.3517770
• Kawamata, Fuga, Hiroshi Unno, Taro Sekiyama, and Tachio Terauchi. 2024. “Answer Refinement Modification: Refinement Type System for Algebraic Effects and Handlers.” Proceedings of the ACM on Programming Languages 8 (POPL): 115–47. https://doi.org/10.1145/3633280
• Kaynaroglu, Burak, Arturas Razinkovas-Baziukas, Rasa Idzelytė, et al. 2025. “EUTROPY: A Python-Based Software Optimized with Just-In-Time Compilation for Simulating Eutrophication Dynamics in Aquatic Systems.” SoftwareX 32: 102430. https://doi.org/10.1016/j.softx.2025.102430
• Ke, Chun-Sheng, and Yean-Ru Chen. 2020. “Instruction Verification of Ethereum Virtual Machine by Formal Method.” In 2020 Indo – Taiwan 2nd International Conference on Computing, Analytics and Networks (Indo-Taiwan ICAN). IEEE. https://doi.org/10.1109/indo-taiwanican48429.2020.9181334
• Kearns, JohnP., and Mary Lou Soffa. 1983. “The Implementation of Retention in a Coroutine Environment.” Acta Informatica 19 (3). https://doi.org/10.1007/bf00265556
• Keidel, Sven, Casper Bach Poulsen, and Sebastian Erdweg. 2018. “Compositional Soundness Proofs of Abstract Interpreters.” Proceedings of the ACM on Programming Languages 2 (ICFP): 1–26. https://doi.org/10.1145/3236767
• Kelsey, Richard A. 1995. “A Correspondence between Continuation Passing Style and Static Single Assignment Form.” ACM SIGPLAN Notices 30 (3): 13–22. https://doi.org/10.1145/202530.202532
• Kennedy, Andrew, and Don Syme. 2001. “Design and Implementation of Generics for the .NET Common Language Runtime.” In Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/378795.378797
• Kerneis, Gabriel, and Juliusz Chroboczek. 2011. “Continuation-Passing C, Compiling Threads to Events through Continuations.” Higher-Order and Symbolic Computation 24 (3): 239–79. https://doi.org/10.1007/s10990-012-9084-5
• Keutzer, K., and W. Wolf. 1988. “Anatomy of a Hardware Compiler.” In Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/53990.54000
• Khaldi, Dounia, and Barbara Chapman. 2016. “Towards Automatic HBM Allocation Using LLVM: A Case Study with Knights Landing.” In 2016 Third Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc.2016.007
• Khatami, Zahra, Hartmut Kaiser, and J. Ramanujam. 2017. “Redesigning OP2 Compiler to Use HPX Runtime Asynchronous Techniques.” In 2017 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). IEEE. https://doi.org/10.1109/ipdpsw.2017.14
• Khorasani, Farzad, Rajiv Gupta, and Laxmi N. Bhuyan. 2015. “Scalable SIMD-Efficient Graph Processing on GPUs.” In 2015 International Conference on Parallel Architecture and Compilation (PACT). IEEE. https://doi.org/10.1109/pact.2015.15
• Kidney, Donnacha Oisín, and Nicolas Wu. 2025. “Formalising Graph Algorithms with Coinduction.” Proceedings of the ACM on Programming Languages 9 (POPL): 1657–86. https://doi.org/10.1145/3704892
• Kiefer, Moritz, Vladimir Klebanov, and Mattias Ulbrich. 2017. “Relational Program Reasoning Using Compiler IR: Combining Static Verification and Dynamic Analysis.” Journal of Automated Reasoning 60 (3): 337–63. https://doi.org/10.1007/s10817-017-9433-5
• Kim, Hansoo, Kanchi Gopinath, and Vinod Kathail. 2000. “Register Allocation in Hyper-Block for Epic Processors.” In Parallel Computing. PUBLISHED BY IMPERIAL COLLEGE PRESS AND DISTRIBUTED BY WORLD SCIENTIFIC PUBLISHING CO. https://doi.org/10.1142/9781848160170_0065
• Kim, Jeewoong, and Shin Hong. 2023. “Poster: BugOss: A Regression Bug Benchmark for Empirical Study of Regression Fuzzing Techniques.” In 2023 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst57152.2023.00053
• Kim, Yooseong, Mohammad Khayatian, and Aviral Shrivastava. 2019. “WCET-Aware Stack Frame Management of Embedded Systems Using Scratchpad Memories.” In 2019 32nd International Conference on VLSI Design and 2019 18th International Conference on Embedded Systems (VLSID). IEEE. https://doi.org/10.1109/vlsid.2019.00127
• Kim, Donggyu, Taemin Kim, Jiho Shin, Song Wang, Heeyoul Choi, and Jaechang Nam. 2025c. “Pre-Trained Models for Bytecode Instructions.” In 2025 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst62969.2025.10989012
• Kim, Sanggyu, and Hong Seong Park. 2023. “A Multi-Core Based Real-Time Scheduler Supporting Periodic and Sporadic Threads and Processes.” International Journal of Control, Automation and Systems 21 (9): 3048–56. https://doi.org/10.1007/s12555-022-0737-9
• Kim, Sangwho, and Jaecheol Ryou. 2019. “Source Code Analysis for Static Prediction of Dynamic Memory Usage.” In 2019 International Conference on Platform Technology and Service (PlatCon). IEEE. https://doi.org/10.1109/platcon.2019.8669417
• Kim, Giyeol, Dohyun Ryu, Seungjin Bae, Changyul Lee, and Taegyu Kim. 2025b. “Fuzzing Acceleration for Memory Safety Bug Discovery with Slicer.” In 2025 IEEE Annual Computer Security Applications Conference (ACSAC). IEEE. https://doi.org/10.1109/acsac67867.2025.00020
• Kim, Jiwon, Dave Jing Tian, and Benjamin E. Ujcich. 2025a. “Chimera: Fuzzing P4 Network Infrastructure for Multi-Plane Bug Detection and Vulnerability Discovery.” In 2025 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp61157.2025.00194
• Kim, Hongjune, Jianping Zeng, Qingrui Liu, Mohammad Abdel-Majeed, Jaejin Lee, and Changhee Jung. 2020a. “Compiler-Directed Soft Error Resilience for Lightweight GPU Register File Protection.” In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3385412.3386033
• Kipps, I. M. 1982. “Experience with Porting Techniques on a COBOL 74 Compiler.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806976
• Kirner, Raimund, Albrecht Kadlec, and Peter Puschner. 2009. “Precise Worst-Case Execution Time Analysis for Processors with Timing Anomalies.” In 2009 21st Euromicro Conference on Real-Time Systems. IEEE. https://doi.org/10.1109/ecrts.2009.8
• Kirner, Raimund, Jens Knoop, Adrian Prantl, Markus Schordan, and Albrecht Kadlec. 2010. “Beyond Loop Bounds: Comparing Annotation Languages for Worst-Case Execution Time Analysis.” Software & Systems Modeling 10 (3): 411–37. https://doi.org/10.1007/s10270-010-0161-0
• Kirner, Raimund, and Peter Puschner. 2008. “Obstacles in Worst-Case Execution Time Analysis.” In 2008 11th IEEE International Symposium on Object and Component-Oriented Real-Time Distributed Computing (ISORC). IEEE. https://doi.org/10.1109/isorc.2008.65
• Kirner, Raimund, and Martin Schoeberl. 2007. “Modeling the Function Cache for Worst-Case Execution Time Analysis.” In 2007 44th ACM/IEEE Design Automation Conference. IEEE. https://doi.org/10.1109/dac.2007.375211
• Kiselyov, Oleg. 2012. “Delimited Control in OCaml, Abstractly and Concretely.” Theoretical Computer Science 435: 56–76. https://doi.org/10.1016/j.tcs.2012.02.025
• Klein, Gerwin, and Tobias Nipkow. 2001. “Verified Lightweight Bytecode Verification.” Concurrency and Computation: Practice and Experience 13 (13): 1133–51. https://doi.org/10.1002/cpe.597
• Klein, Gerwin, and Martin Strecker. 2004. “Verified Bytecode Verification and Type-Certifying Compilation.” Journal of Logic and Algebraic Programming 58 (1–2): 27–60. https://doi.org/10.1016/j.jlap.2003.07.004
• Kleinsorge, Jan C., Heiko Falk, and Peter Marwedel. 2013. “Simple Analysis of Partial Worst-Case Execution Paths on General Control Flow Graphs.” In 2013 Proceedings of the International Conference on Embedded Software (EMSOFT). IEEE. https://doi.org/10.1109/emsoft.2013.6658594
• Klöckner, Andreas, Lucas C. Wilcox, and T. Warburton. 2016. “Array Program Transformation with Loo.py by Example: High-Order Finite Elements.” In Proceedings of the 3rd ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming. ACM. https://doi.org/10.1145/2935323.2935325
• Klohs, Karsten, and Uwe Kastens. 2005. “Memory Requirements of Java Bytecode Verification on Limited Devices.” Electronic Notes in Theoretical Computer Science 132 (1): 95–111. https://doi.org/10.1016/j.entcs.2005.01.031
• Knoblock, Todd B., and Jakob Rehof. 2000. “Type Elaboration and Subtype Completion for Java Bytecode.” In Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/325694.325725
• Knoop, Jens, Laura Kovács, and Jakob Zwirchmayr. 2017. “Replacing Conjectures by Positive Knowledge: Inferring Proven Precise Worst-Case Execution Time Bounds Using Symbolic Execution.” Journal of Symbolic Computation 80: 101–24. https://doi.org/10.1016/j.jsc.2016.07.023
• Ko, Yousun, Bernd Burgstaller, and Bernhard Scholz. 2015. “LaminarIR: Compile-Time Queues for Structured Streams.” In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2737924.2737994
• Ko, Gaeun, and Seonyeong Heo. 2026. “TinyGen: Portable and Compact Code Generation for Tiny Machine Learning.” In Proceedings of the 35th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3771775.3786278
• Kobayashi, Naoki, Étienne Lozes, and Florian Bruse. 2017. “On the Relationship between Higher-Order Recursion Schemes and Higher-Order Fixpoint Logic.” In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages. ACM. https://doi.org/10.1145/3009837.3009854
• Kocourek, Matěj, Filip Křikava, and Jan Vitek. 2025. “Copy-and-Patch Just-in-Time Compiler for R.” In Proceedings of the 17th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3759548.3763370
• Koehler, Thomas, and Michel Steuwer. 2021. “Towards a Domain-Extensible Compiler: Optimizing an Image Processing Pipeline on Mobile CPUs.” In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo51591.2021.9370337
• Kokkonis, Dimitri, Michaël Marcozzi, Emilien Decoux, and Stefano Zacchiroli. 2025. “ROSA: Finding Backdoors with Fuzzing.” In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse55347.2025.00183
• Kolek, Jozef, Zoran Jovanovic, Nenad Sljivic, and Dragan Narancic. 2013. “Adding microMIPS Backend to the LLVM Compiler Infrastructure.” In 2013 21st Telecommunications Forum Telfor (TELFOR). IEEE. https://doi.org/10.1109/telfor.2013.6716404
• Kolesar, John C., Shan Ali, Timos Antonopoulos, and Ruzica Piskac. 2025. “Coinductive Proofs of Regular Expression Equivalence in Zero Knowledge.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 357–85. https://doi.org/10.1145/3763063
• Kondratyev, Dmitry, and Alexei Promsky. 2019. “Correctness of Proof Strategy for the Sisal Program Verification.” In 2019 International Multi-Conference on Engineering, Computer and Information Sciences (SIBIRCON). IEEE. https://doi.org/10.1109/sibircon48586.2019.8958225
• Koroglu, Yavuz, and Franz Wotawa. 2019. “Fully Automated Compiler Testing of a Reasoning Engine via Mutated Grammar Fuzzing.” In 2019 IEEE/ACM 14th International Workshop on Automation of Software Test (AST). IEEE. https://doi.org/10.1109/ast.2019.00010
• Koskimies, Kai, Kari-Jouko Räihä, and Matti Sarjakoski. 1982. “Compiler Construction Using Attribute Grammars.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806991
• Kot, Łucja, and Dexter Kozen. 2005. “Kleene Algebra and Bytecode Verification.” Electronic Notes in Theoretical Computer Science 141 (1): 221–36. https://doi.org/10.1016/j.entcs.2005.02.028
• Kovačević, Željko, Miha Ravber, Shih-Hsi Liu, and Matej Črepinšek. 2022. “Automatic Compiler/interpreter Generation from Programs for Domain-Specific Languages: Code Bloat Problem and Performance Improvement.” Journal of Computer Languages 70: 101105. https://doi.org/10.1016/j.cola.2022.101105
• Kowalewski, Stefan, Anna Philippou, and Jörg Brauer. 2013. “Model Checking and Abstract Interpretation as Building Blocks of Advanced Program Analysis Techniques: Selected Papers from TACAS 2009.” International Journal on Software Tools for Technology Transfer 15 (4): 287–89. https://doi.org/10.1007/s10009-013-0280-3
• Krebs, Nico, and Lothar Schmitz. 2014. “Jaccie: A Java-Based Compiler–compiler for Generating, Visualizing and Debugging Compiler Components.” Science of Computer Programming 79: 101–15. https://doi.org/10.1016/j.scico.2012.03.001
• Krogstie, Håvard Rognebakke, Helge Bahmann, Magnus Själander, and Nico Reissmann. 2026. “PIP: Making Andersen’s Points-to Analysis Sound and Practical for Incomplete C Programs.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395202
• Krzemień, Roman, and Andrzej Lukasiewicz. 1976. “Automatic Generation of Lexical Analyzers in a Compiler-Compiler.” Information Processing Letters 4 (6): 165–68. https://doi.org/10.1016/0020-0190(76)90088-0
• Kuang, Kaiyuan, Zhanyong Tang, Xiaoqing Gong, Dingyi Fang, Xiaojiang Chen, and Zheng Wang. 2018. “Enhance Virtual-Machine-Based Code Obfuscation Security through Dynamic Bytecode Scheduling.” Computers & Security 74: 202–20. https://doi.org/10.1016/j.cose.2018.01.008
• Kumar, Vikash. 2021. “Deep Neural Network Approach to Estimate Early Worst-Case Execution Time.” In 2021 IEEE/AIAA 40th Digital Avionics Systems Conference (DASC). IEEE. https://doi.org/10.1109/dasc52595.2021.9594326
• Kumar, Ramana, Magnus O. Myreen, Michael Norrish, and Scott Owens. 2014. “CakeML: A Verified Implementation of ML.” In Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM. https://doi.org/10.1145/2535838.2535841
• Kumar, Vikash, Behnaz Ranjbar, and Akash Kumar. 2024. “Utilizing Machine Learning Techniques for Worst-Case Execution Time Estimation on GPU Architectures.” IEEE Access 12: 41464–78. https://doi.org/10.1109/access.2024.3379018
• Kwon, Jaeseong, Bongjun Jang, Juneyoung Lee, and Kihong Heo. 2025. “Optimization-Directed Compiler Fuzzing for Continuous Translation Validation.” Proceedings of the ACM on Programming Languages 9 (PLDI): 627–50. https://doi.org/10.1145/3729275
• Kwon, Hyunho, Sanggyu Shin, Ju Min Lee, et al. 2026. “Compiler-Runtime Co-Operative Chain of Verification for LLM-Based Code Optimization.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395240
• Kyriakou, Kyriakos-Ioannis D., and Nikolaos D. Tselikas. 2022. “Complementing JavaScript in High-Performance Node.js and Web Applications with Rust and WebAssembly.” Electronics 11 (19): 3217. https://doi.org/10.3390/electronics11193217
• Lai, Yuanjie, Shuke Qiao, Youcong Ni, Xin Du, Ruliang Xiao, and Dingbang Fang. 2026. “Interaction-Aware Multi-Objective Optimization Method for LLVM Compiler Option Sequences.” Performance Evaluation 171: 102543. https://doi.org/10.1016/j.peva.2026.102543
• Lambert, Jacob, Mohammad Alaul Haque Monil, Seyong Lee, Allen D. Malony, and Jeffrey S. Vetter. 2022. “Leveraging Compiler-Based Translation to Evaluate a Diversity of Exascale Platforms.” In 2022 IEEE/ACM International Workshop on Performance, Portability and Productivity in HPC (P3HPC). IEEE. https://doi.org/10.1109/p3hpc56579.2022.00007
• Lancellotti, Giacomo, Filippo Buda, Giacomo Carugati, et al. 2026. “Quantum Oracle Synthesis from HDL Designs via Multi Level Intermediate Representation.” In 2026 31st Asia and South Pacific Design Automation Conference (ASP-DAC). IEEE. https://doi.org/10.1109/asp-dac66049.2026.11420750
• Larus, James. 2011. “Session Details: Compiler Correctness.” In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3249146
• Larus, James R., and Paul N. Hilfinger. 1986. “Register Allocation in the SPUR Lisp Compiler.” In Proceedings of the 1986 SIGPLAN symposium on Compiler construction. ACM. https://doi.org/10.1145/12276.13337
• Lasnier, Pascal Y., Jeremy Yallop, and Magnus O. Myreen. 2026. “Brack: A Verified Compiler for Scheme via CakeML.” In Proceedings of the 15th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3779031.3779098
• Lawall, Julia L., and Olivier Danvy. 1993. “Separating Stages in the Continuation-Passing Style Transformation.” In Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘93. ACM Press. https://doi.org/10.1145/158511.158613
• Le, Vu, Mehrdad Afshari, and Zhendong Su. 2014. “Compiler Validation via Equivalence Modulo Inputs.” In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2594291.2594334
• Le, Vu, Chengnian Sun, and Zhendong Su. 2015. “Finding Deep Compiler Bugs via Guided Stochastic Program Mutation.” ACM SIGPLAN Notices 50 (10): 386–99. https://doi.org/10.1145/2858965.2814319
• Lee, Sang-Bin. 2017. “Exploring a Relationship between Students’ Interpreting Self-Efficacy and Performance: Triangulating Data on Interpreter Performance Assessment.” Interpreter and Translator Trainer 12 (2): 166–87. https://doi.org/10.1080/1750399x.2017.1359763
• Lee, Jay, Joongwon Ahn, and Kwangkeun Yi. 2025b. “React-tRace: A Semantics for Understanding React Hooks: An Operational Semantics and a Visualizer for Clarifying React Hooks.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 471–98. https://doi.org/10.1145/3763067
• Lee, Hyunsei, Shinhyoung Jang, Jaewoo Gwak, Jongho Park, and Yeseong Kim. 2025a. “Bit-Level Semantics: Scalable RAG Retrieval with Neurosymbolic Hyperdimensional Computing.” In 2025 34th International Conference on Parallel Architectures and Compilation Techniques (PACT). IEEE. https://doi.org/10.1109/pact65351.2025.00039
• Lee, YangSun, Junho Jeong, and Yunsik Son. 2017. “Design and Implementation of the Secure Compiler and Virtual Machine for Developing Secure IoT Services.” Future Generation Computer Systems 76: 350–57. https://doi.org/10.1016/j.future.2016.03.014
• Lee, Jaewoo, and Jinkyu Lee. 2024. “IMC-PnG: Maximizing Runtime Performance and Timing Guarantee for Imprecise Mixed-Criticality Real-Time Scheduling.” Future Generation Computer Systems 160: 406–19. https://doi.org/10.1016/j.future.2024.06.015
• Lee, Seong-Won, Soo-Mook Moon, and Seong-Moo Kim. 2015. “Flow-Sensitive Runtime Estimation: An Enhanced Hot Spot Detection Heuristics for Embedded Java Just-in-Time Compilers.” Software: Practice and Experience 46 (6): 841–64. https://doi.org/10.1002/spe.2315
• Lee, P., and U. Pleban. 1987. “A Realistic Compiler Generator Based on High-Level Semantics: Another Progress Report.” In Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL ‘87. ACM Press. https://doi.org/10.1145/41625.41651
• Lehmann, Can Joshua, Lars Bauer, Hassan Nassar, Heba Khdr, and Jörg Henkel. 2025. “Hardware/Software Co-Analysis for Worst Case Execution Time Bounds.” In 2025 Design, Automation & Test in Europe Conference (DATE). IEEE. https://doi.org/10.23919/date64628.2025.10992765
• Lehmann, Daniel, and Michael Pradel. 2022. “Finding the Dwarf: Recovering Precise Types from WebAssembly Binaries.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523449
• Leijen, Daan. 2017a. “Structured Asynchrony with Algebraic Effects.” In Proceedings of the 2nd ACM SIGPLAN International Workshop on Type-Driven Development. ACM. https://doi.org/10.1145/3122975.3122977
• Leijen, Daan. 2017b. “Type Directed Compilation of Row-Typed Algebraic Effects.” In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages. ACM. https://doi.org/10.1145/3009837.3009872
• Leijen, Daan. 2018. “First Class Dynamic Effect Handlers: Or, Polymorphic Heaps with Dynamic Effect Handlers.” In Proceedings of the 3rd ACM SIGPLAN International Workshop on Type-Driven Development. ACM. https://doi.org/10.1145/3240719.3241789
• Leinenbach, Dirk, and Elena Petrova. 2008. “Pervasive Compiler Verification – from Verified Programs to Verified Systems.” Electronic Notes in Theoretical Computer Science 217: 23–40. https://doi.org/10.1016/j.entcs.2008.06.040
• Lenkefi, Peter, and Gergely Mezei. 2022. “Connections between Language Semantics and the Query-Based Compiler Architecture.” In Proceedings of the 17th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011260400003266
• Leopoldseder, David, Lukas Stadler, Manuel Rigger, Thomas Würthinger, and Hanspeter Mössenböck. 2018a. “A Cost Model for a Graph-Based Intermediate-Representation in a Dynamic Compiler.” In Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3281287.3281290
• Leopoldseder, David, Lukas Stadler, Christian Wimmer, and Hanspeter Mössenböck. 2015. “Java-to-JavaScript Translation via Structured Control Flow Reconstruction of Compiler IR.” ACM SIGPLAN Notices 51 (2): 91–103. https://doi.org/10.1145/2936313.2816715
• Leroy, Xavier. 2002. “Bytecode Verification on Java Smart Cards.” Software: Practice and Experience 32 (4): 319–40. https://doi.org/10.1002/spe.438
• Leroy, Xavier. 2003. “Java Bytecode Verification: Algorithms and Formalizations.” Journal of Automated Reasoning 30 (3–4): 235–69. https://doi.org/10.1023/a:1025055424017
• Leroy, Xavier. 2006. “Formal Certification of a Compiler Back-End Or: Programming a Compiler with a Proof Assistant.” ACM SIGPLAN Notices 41 (1): 42–54. https://doi.org/10.1145/1111320.1111042
• Leroy, Xavier. 2009b. “A Formally Verified Compiler Back-End.” Journal of Automated Reasoning 43 (4): 363–446. https://doi.org/10.1007/s10817-009-9155-4
• Leroy, Xavier, and Hervé Grall. 2009. “Coinductive Big-Step Operational Semantics.” Information and Computation 207 (2): 284–304. https://doi.org/10.1016/j.ic.2007.12.004
• Levy, H. 1996. “Should Caches Be Split or Shared? Analysis Using the Superposition of Bursty Stack Depth Processes.” Performance Evaluation 27-28 (1): 175–88. https://doi.org/10.1016/0166-5316(96)00016-8
• Lezuo, Roland, Ioan Dragan, Gergo Barany, and Andreas Krall. 2015. “vanHelsing: A Fast Proof Checker for Debuggable Compiler Verification.” In 2015 17th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC). IEEE. https://doi.org/10.1109/synasc.2015.34
• Li, Jianan, Xiaonan Chai, and Wei Gao. 2026. “Unleashing Triton on CPUs: Compilation and Runtime Co-Optimization for Scalable Vector Architectures.” Computers 15 (7): 406. https://doi.org/10.3390/computers15070406
• Li, Xiaochen, Shikai Guo, Hongyi Cheng, and He Jiang. 2024b. “Simulink Compiler Testing via Configuration Diversification with Reinforcement Learning.” IEEE Transactions on Reliability 73 (2): 1060–74. https://doi.org/10.1109/tr.2023.3317643
• Li, Lantian, Zhihao Liu, and Zhongxing Yu. 2025b. “Solsmith: Solidity Random Program Generator for Compiler Testing.” In 2025 25th International Conference on Software Quality, Reliability, and Security Companion (QRS-C). IEEE. https://doi.org/10.1109/qrs-c65679.2025.00031
• Li, Zijun, Chenyang Wu, Chuhao Xu, et al. 2025a. “Lightweight and Holistic-Scalable Serverless Secure Container Runtime for High-Density Deployment and High-Concurrency Startup.” IEEE Transactions on Computers 74 (8): 2621–34. https://doi.org/10.1109/tc.2025.3566912
• Li, Ximeng, Qianying Zhang, Guohui Wang, Zhiping Shi, and Yong Guan. 2023. “A Unified Proof Technique for Verifying Program Correctness with Big-Step Semantics.” Journal of Systems Architecture 136: 102820. https://doi.org/10.1016/j.sysarc.2022.102820
• Liang, Hongliang, Shirun Liu, Yini Zhang, and Meilin Wang. 2017. “Improving the Precision of Static Analysis: Symbolic Execution Based on GCC Abstract Syntax Tree.” In 2017 18th IEEE/ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD). IEEE. https://doi.org/10.1109/snpd.2017.8022752
• Liangliang, Li, and Ci Yungui. 1990. “Clause Representations in a Compiler-Based Prolog Database.” Future Generation Computer Systems 6 (1): 17–23. https://doi.org/10.1016/0167-739x(90)90005-x
• Lidbury, Christopher, Andrei Lascu, Nathan Chong, and Alastair F. Donaldson. 2015. “Many-Core Compiler Fuzzing.” In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2737924.2737986
• Lim, HeuiChan, and Saumya Debray. 2023. “Automatically Localizing Dynamic Code Generation Bugs in JIT Compiler Back-End.” In Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3578360.3580260
• Lima, Guilherme F., Rodrigo C. M. Santos, Roberto Ierusalimschy, Edward H. Haeusler, and Francisco Sant’Anna. 2019. “A Memory-Bounded, Deterministic and Terminating Semantics for the Synchronous Programming Language Céu.” Journal of Systems Architecture 97: 239–57. https://doi.org/10.1016/j.sysarc.2019.01.014
• Lin, Yi, Stephen M. Blackburn, Antony L. Hosking, and Michael Norrish. 2016. “Rust as a Language for High Performance GC Implementation.” ACM SIGPLAN Notices 51 (11): 89–98. https://doi.org/10.1145/3241624.2926707
• Lin, Mian, YouCong Ni, Yu Lin, and Xin Du. 2025. “Intermediate Representation-Based Approach for Code Refactoring and Quality Evaluation.” In 2025 IEEE 5th International Conference on Software Engineering and Artificial Intelligence (SEAI). IEEE. https://doi.org/10.1109/seai65851.2025.11108763
• Lin, Yuan, and David Padua. 2000. “Compiler Analysis of Irregular Memory Accesses.” In Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/349299.349322
• Lin, Kuiliang, Xiangpu Song, Yingpei Zeng, and Shanqing Guo. 2023. “DeepDiffer: Find Deep Learning Compiler Bugs via Priority-Guided Differential Fuzzing.” In 2023 IEEE 23rd International Conference on Software Quality, Reliability, and Security (QRS). IEEE. https://doi.org/10.1109/qrs60937.2023.00066
• Lindley, Sam. 2014. “Algebraic Effects and Effect Handlers for Idioms and Arrows.” In Proceedings of the 10th ACM SIGPLAN workshop on Generic programming. ACM. https://doi.org/10.1145/2633628.2633636
• Lins, Filipe, Lucas Tambara, Fernanda Lima Kastensmidt, and Paolo Rech. 2017. “Register File Criticality and Compiler Optimization Effects on Embedded Microprocessors Reliability.” IEEE Transactions on Nuclear Science: 1–1. https://doi.org/10.1109/tns.2017.2705150
• Lintzmayer, C. N., M. H. Mulati, and A. F. da Silva. 2011. “Register Allocation with Graph Coloring by Ant Colony Optimization.” In 2011 30th International Conference of the Chilean Computer Science Society. IEEE. https://doi.org/10.1109/sccc.2011.32
• Lion, Benjamin, and David Broman. 2026. “Making Time Observable: Compiler Correctness for Real-Time C Programs.” In 2026 IEEE Workshop on Formal Arguments for CPS Certification (FACCT). IEEE. https://doi.org/10.1109/facct71761.2026.00011
• Liu, Dongxi. 2007. “Bytecode Verification for Enhanced JVM Access Control.” In The Second International Conference on Availability, Reliability and Security (ARES’07). IEEE. https://doi.org/10.1109/ares.2007.55
• Liu, Ji, Luciano Bello, and Huiyang Zhou. 2021b. “Relaxed Peephole Optimization: A Novel Compiler Optimization for Quantum Circuits.” In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo51591.2021.9370310
• Liu, Amanda, Gilbert Bernstein, Adam Chlipala, and Jonathan Ragan-Kelley. 2024c. “A Verified Compiler for a Functional Tensor Language.” Proceedings of the ACM on Programming Languages 8 (PLDI): 320–42. https://doi.org/10.1145/3656390
• Liu, Hui, Hanbin Guo, Peng Liu, and Tongding Hou. 2025a. “BoostPolyGlot: A Structured IR Generation-Based Fuzz Testing Framework for GCC Compiler Frontend.” Applied Sciences 15 (11): 5935. https://doi.org/10.3390/app15115935
• Liu, Fengyun, Ondřej Lhoták, Aggelos Biboudis, Paolo G. Giarrusso, and Martin Odersky. 2020. “A Type-and-Effect System for Object Initialization.” Proceedings of the ACM on Programming Languages 4 (OOPSLA): 1–28. https://doi.org/10.1145/3428243
• Liu, Ji, Jie Liu, Lingyun Luo, Fei Yang, Mingxing Liu, and Yu Tu. 2024b. “Research on Higher-Order Operator Transformation Algorithms for Syntax Transformation-Based Model Checking.” In 2024 IEEE 7th International Conference on Automation, Electronics and Electrical Engineering (AUTEEE). IEEE. https://doi.org/10.1109/auteee62881.2024.10869702
• Liu, Haihua, and Yanrong Lu. 2025. “Bi-Directional Taint Flow Analysis: A High-Precision Static Detection Approach for Java Deserialization Vulnerabilities.” In 2025 4th International Symposium on Computer Applications and Information Technology (ISCAIT). IEEE. https://doi.org/10.1109/iscait64916.2025.11010573
• Liu, Lun, Todd Millstein, and Madanlal Musuvathi. 2019. “Accelerating Sequential Consistency for Java with Speculative Compilation.” In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3314221.3314611
• Liu, Jiawei, Yuxiang Wei, Sen Yang, Yinlin Deng, and Lingming Zhang. 2022. “Coverage-Guided Tensor Compiler Fuzzing with Joint IR-Pass Mutation.” Proceedings of the ACM on Programming Languages 6 (OOPSLA1): 1–26. https://doi.org/10.1145/3527317
• Liu, Weichen, Jiang Xu, Jogesh K. Muppala, Wei Zhang, Xiaowen Wu, and Yaoyao Ye. 2011. “Coroutine-Based Synthesis of Efficient Embedded Software from SystemC Models.” IEEE Embedded Systems Letters 3 (1): 46–49. https://doi.org/10.1109/les.2011.2112634
• Liu, Hongbiao, Mengfei Yang, Lei Qiao, Xi Chen, and Jian Gong. 2024a. “An Efficient Schedulability Analysis Based on Worst-Case Interference Time for Real-Time Systems.” Science China Information Sciences 67 (9): 192103. https://doi.org/10.1007/s11432-022-3891-4
• Liu, Xinxin, Tingting Yu, and Wenhui Zhang. 2017. “Analyzing Divergence in Bisimulation Semantics.” ACM SIGPLAN Notices 52 (1): 735–47. https://doi.org/10.1145/3093333.3009870
• Liu, Peng, Huibiao Zhu, Shengchao Qin, Phillip J. Brooke, and Xi Wu. 2013. “Linking Algebraic Semantics and Operational Semantics for Web Services Using Maude.” In 2013 18th International Conference on Engineering of Complex Computer Systems. IEEE. https://doi.org/10.1109/iceccs.2013.46
• Lochbihler, Andreas. 2018. “Mechanising a Type-Safe Model of Multithreaded Java with a Verified Compiler.” Journal of Automated Reasoning 61 (1–4): 243–332. https://doi.org/10.1007/s10817-018-9452-x
• Lööw, Andreas. 2021. “Lutsig: A Verified Verilog Compiler for Verified Circuit Development.” In Proceedings of the 10th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3437992.3439916
• Lopes, Nuno P. 2023. “Torchy: A Tracing JIT Compiler for PyTorch.” In Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3578360.3580266
• Loring, Blake, Duncan Mitchell, and Johannes Kinder. 2019. “Sound Regular Expression Semantics for Dynamic Symbolic Execution of JavaScript.” In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3314221.3314645
• Louise, Stephane. 2011. “Improving Branch Prediction Related WCET Abstract Interpretation.” In 2011 IEEE 17th International Conference on Embedded and Real-Time Computing Systems and Applications. IEEE. https://doi.org/10.1109/rtcsa.2011.74
• Lowther, Duncan, Dejice Jacob, and Jeremy Singer. 2023. “CHERI Performance Enhancement for a Bytecode Interpreter.” In Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3623507.3623552
• Lu, Yue, Thomas Nolte, Iain Bate, and Liliana Cucu-Grosjean. 2011b. “A Trace-Based Statistical Worst-Case Execution Time Analysis of Component-Based Real-Time Embedded Systems.” In ETFA2011. IEEE. https://doi.org/10.1109/etfa.2011.6059190
• Lu, Xinyi, Zhide Zhou, Xiaochen Li, et al. 2025. “Detecting WebAssembly Runtime Bugs with Grammar-Guided Program Mutation.” IEEE Transactions on Reliability 74 (4): 5056–69. https://doi.org/10.1109/tr.2025.3614352
• Lucanu, Dorel. 2018. “Proving Reachability Properties by Coinduction (Extended Abstract).” In 2018 20th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC). IEEE. https://doi.org/10.1109/synasc.2018.00066
• Lucchi, Roberto, and Manuel Mazzara. 2007. “A Pi-Calculus Based Semantics for WS-BPEL.” Journal of Logic and Algebraic Programming 70 (1): 96–118. https://doi.org/10.1016/j.jlap.2006.05.007
• Luo, Lannan. 2020. “Heap Memory Snapshot Assisted Program Analysis for Android Permission Specification.” In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner48275.2020.9054795
• Luo, Pei, Konstantinos Athanasiou, Liwei Zhang, et al. 2017. “Compiler-Assisted Threshold Implementation against Power Analysis Attacks.” In 2017 IEEE International Conference on Computer Design (ICCD). IEEE. https://doi.org/10.1109/iccd.2017.94
• Luo, Qianqian, Qingming Lin, Liuchang Xu, et al. 2026. “GeoJSON Agents: A Multi-Agent LLM Architecture for Geospatial Analysis—Function Calling vs. Code Generation.” Big Earth Data 10 (3): 1731–84. https://doi.org/10.1080/20964471.2026.2615511
• Lv, Mingsong, Nan Guan, Qingxu Deng, Ge Yu, and Yi Wang. 2010. “Static Worst-Case Execution Time Analysis of the μC/OS-II Real-Time Kernel.” Frontiers of Computer Science in China 4 (1): 17–27. https://doi.org/10.1007/s11704-009-0073-8
• Ma, Cong. 2025. “Lexical Effect Handlers: Fast by Design, Correct by Proof.” In Companion Proceedings of the 2025 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM. https://doi.org/10.1145/3758316.3762822
• Ma, Cong, Zhaoyi Ge, Max Jung, and Yizhou Zhang. 2025. “Zero-Overhead Lexical Effect Handlers.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 3533–59. https://doi.org/10.1145/3763177
• Ma, Cong, Zhaoyi Ge, Edward Lee, and Yizhou Zhang. 2024. “Lexical Effect Handlers, Directly.” Proceedings of the ACM on Programming Languages 8 (OOPSLA2): 1670–98. https://doi.org/10.1145/3689770
• Mahajan, Anjah, and M. S. Ali. 2008. “Hybrid Evolutionary Algorithm for Graph Coloring Register Allocation.” In 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence). IEEE. https://doi.org/10.1109/cec.2008.4630943
• Mahajan, Sonal, and Mukul R. Prasad. 2022. “Providing Real-Time Assistance for Repairing Runtime Exceptions Using Stack Overflow Posts.” In 2022 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst53961.2022.00030
• Maia, Luís, Simão Cunha, and João Saraiva. 2026. “Why Just-In-Time Compilation Matters: Evaluating Runtime and Energy Efficiency.” In Proceedings of the 19th ACM SIGPLAN International Conference on Software Language Engineering. ACM. https://doi.org/10.1145/3806383.3815520
• Mainland, Geoffrey. 2017. “Better Living through Operational Semantics: An Optimizing Compiler for Radio Protocols.” Proceedings of the ACM on Programming Languages 1 (ICFP): 1–26. https://doi.org/10.1145/3110263
• Maldonado, Javier, and José L. Carrasco-Sáez. 2026. “A Reusable J48-Targeting Python Backend for Scikit-Learn Workflows: Differential Validation against WEKA J48.” IEEE Access 14: 83128–38. https://doi.org/10.1109/access.2026.3698445
• Male, Chris, David J. Pearce, Alex Potanin, and Constantine Dymnikov. 2011. “Formalisation and Implementation of an Algorithm for Bytecode Verification of @NonNull Types.” Science of Computer Programming 76 (7): 587–608. https://doi.org/10.1016/j.scico.2010.10.004
• Mamdouh, Ahmed, Ayman M. Bahaa-Eldin, and Mohamed Sobh. 2014. “On-Demand Distributed on-Card Bytecode Verification.” In 2014 9th International Conference on Computer Engineering & Systems (ICCES). IEEE. https://doi.org/10.1109/icces.2014.7030964
• Mao, Yu, Zhishen Chen, and Xiangjun Ma. 2025. “Research on a Lightweight Full-Stack Edge Execution Optimization Framework Based on Serverless and WebAssembly.” In 2025 5th International Symposium on Artificial Intelligence and Big Data (AIBDF). IEEE. https://doi.org/10.1109/aibdf67964.2025.11440757
• Mao, Yan-fang, Yang Zhang, Jun-liang Chen, and Kong-yang Zhao. 2019. “Exploiting Java Stack Forensics for Runtime Monitoring of IoT Services.” In ICC 2019 - 2019 IEEE International Conference on Communications (ICC). IEEE. https://doi.org/10.1109/icc.2019.8761196
• Marcozzi, Michaël, Qiyi Tang, Alastair F. Donaldson, and Cristian Cadar. 2019. “Compiler Fuzzing: How Much Does It Matter?” Proceedings of the ACM on Programming Languages 3 (OOPSLA): 1–29. https://doi.org/10.1145/3360581
• Marref, Amine. 2011. “Fully-Automatic Derivation of Exact Program-Flow Constraints for a Tighter Worst-Case Execution-Time Analysis.” In 2011 International Conference on Embedded Computer Systems: Architectures, Modeling and Simulation. IEEE. https://doi.org/10.1109/samos.2011.6045462
• Marshall, Howard Z. 1982. “The Linear Graph Package, a Compiler Building Environment.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.807003
• Martinsen, Jan Kasper, Håkan Grahn, and Anders Isberg. 2016. “Combining Thread-Level Speculation and Just-in-Time Compilation in Google’s V8 JavaScript Engine.” Concurrency and Computation: Practice and Experience 29 (1): e3826. https://doi.org/10.1002/cpe.3826
• Massey, Ewan, and Pierre Olivier. 2026. “WASP: Stack Protection for WebAssembly.” Journal of Systems Architecture 172: 103666. https://doi.org/10.1016/j.sysarc.2025.103666
• Massidda, Emmanuele, Lorenzo Pisu, Davide Maiorca, and Giorgio Giacinto. 2024. “Bringing Binary Exploitation at Port 80: Understanding C Vulnerabilities in WebAssembly.” In Proceedings of the 21st International Conference on Security and Cryptography. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0012852400003767
• Mastorou, Lykourgos, Nikolaos Papaspyrou, and Niki Vazou. 2022. “Coinduction Inductively: Mechanizing Coinductive Proofs in Liquid Haskell.” In Proceedings of the 15th ACM SIGPLAN International Haskell Symposium. ACM. https://doi.org/10.1145/3546189.3549922
• Masuko, Moe, and Kenichi Asai. 2009. “Direct Implementation of Shift and Reset in the MinCaml Compiler.” In Proceedings of the 2009 ACM SIGPLAN workshop on ML. ACM. https://doi.org/10.1145/1596627.1596636
• Matsubara, Katsuya, Yuzuki Saito, Daigo Fujii, and Yuki Nakata. 2025. “Seamless Self-Healing in WebAssembly Container Orchestration with Runtime-Neutral Checkpointing.” In 2025 Thirteenth International Symposium on Computing and Networking Workshops (CANDARW). IEEE. https://doi.org/10.1109/candarw68385.2025.00013
• Maurer, Luke, Paul Downen, Zena M. Ariola, and Simon Peyton Jones. 2017. “Compiling without Continuations.” In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3062341.3062380
• Mazaher, Shahrzade, and Daniel M. Berry. 1985. “Deriving a Compiler from an Operational Semantics Written in VDL.” Computer Languages 10 (2): 147–64. https://doi.org/10.1016/0096-0551(85)90004-9
• McNerney, Timothy S. 1991. “Verifying the Correctness of Compiler Transformations on Basic Blocks Using Abstract Interpretation.” In Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation - PEPM ‘91. ACM Press. https://doi.org/10.1145/115865.115877
• Medeiros, Guilherme E., Felis T. Bortolon, Ricardo Reis, and Luciano Ost. 2018. “Evaluation of Compiler Optimization Flags Effects on Soft Error Resiliency.” In 2018 31st Symposium on Integrated Circuits and Systems Design (SBCCI). IEEE. https://doi.org/10.1109/sbcci.2018.8533246
• Meghzili, Said, Allaoua Chaoui, Martin Strecker, and Elhillali Kerkouche. 2017. “On the Verification of UML State Machine Diagrams to Colored Petri Nets Transformation Using Isabelle/HOL.” In 2017 IEEE International Conference on Information Reuse and Integration (IRI). IEEE. https://doi.org/10.1109/iri.2017.63
• Mehdi Pourhashem Kallehbasti, Mohammad, and Mohammad Ghafari. 2023. “Naturalistic Static Program Analysis.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00083
• Mehta, Sanyam, and Pen-Chung Yew. 2015. “Improving Compiler Scalability: Optimizing Large Programs at Small Price.” In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2737924.2737954
• Meier, Wolfgang, Martin Jensen, Jean Pichon-Pharabod, and Bas Spitters. 2025. “CertiCoq-Wasm: A Verified WebAssembly Backend for CertiCoq.” In Proceedings of the 14th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3703595.3705879
• Melo Alves, Maicon, Luan Teylo, Yuri Frota, and Lucia M. A. Drummond. 2018. “An Interference-Aware Virtual Machine Placement Strategy for High Performance Computing Applications in Clouds.” In 2018 Symposium on High Performance Computing Systems (WSCAD). IEEE. https://doi.org/10.1109/wscad.2018.00024
• Melquiond, Guillaume, and Josué Moreau. 2024. “A Safe Low-Level Language for Computer Algebra and Its Formally Verified Compiler.” Proceedings of the ACM on Programming Languages 8 (ICFP): 121–46. https://doi.org/10.1145/3674629
• Melrose, Susan, Stefanie Sachsenmaier, and Rosemary Butcher. 2015. “Just in Time: Rosemary Butcher, Making Memories and Marks.” Performance Research 20 (6): 87–94. https://doi.org/10.1080/13528165.2015.1111060
• Menetrey, James, Marcelo Pasin, Pascal Felber, and Valerio Schiavoni. 2021. “Twine: An Embedded Trusted Runtime for WebAssembly.” In 2021 IEEE 37th International Conference on Data Engineering (ICDE). IEEE. https://doi.org/10.1109/icde51399.2021.00025
• Menetrey, James, Marcelo Pasin, Pascal Felber, and Valerio Schiavoni. 2022. “WaTZ: A Trusted WebAssembly Runtime Environment with Remote Attestation for TrustZone.” In 2022 IEEE 42nd International Conference on Distributed Computing Systems (ICDCS). IEEE. https://doi.org/10.1109/icdcs54860.2022.00116
• Ménétrey, Jämes, Marcelo Pasin, Pascal Felber, et al. 2024. “A Comprehensive Trusted Runtime for WebAssembly with Intel SGX.” IEEE Transactions on Dependable and Secure Computing 21 (4): 3562–79. https://doi.org/10.1109/tdsc.2023.3334516
• Meng, Fanqi, Haochen Sun, and Jingdong Wang. 2020. “Survey on Estimation and Optimization of Worst-Case Execution Time with Energy Consumption Constraint.” In 2020 12th International Conference on Computational Intelligence and Communication Networks (CICN). IEEE. https://doi.org/10.1109/cicn49253.2020.9242624
• Meyer, Roland, and Sebastian Wolff. 2019. “Decoupling Lock-Free Data Structures from Memory Reclamation for Static Analysis.” Proceedings of the ACM on Programming Languages 3 (POPL): 1–31. https://doi.org/10.1145/3290371
• Mguidich, Achraf, Vladimir-Alexandru Paun, Bruno Monsuez, and Philippe Baufreton. 2016. “Time-Accurate ASM as a Refinement Scheme for Worst-Case Execution Time Estimation in Hard Real-Time Systems.” In 2016 IEEE Real-Time Systems Symposium (RTSS). IEEE. https://doi.org/10.1109/rtss.2016.051
• Mhaske, Swapnil, David Uliana, Hojin Kee, Tai Ly, Ahsan Aziz, and Predrag Spasojevic. 2015. “A 2.48Gb/s FPGA-Based QC-LDPC Decoder: An Algorithmic Compiler Implementation.” In 2015 36th IEEE Sarnoff Symposium. IEEE. https://doi.org/10.1109/sarnof.2015.7324649
• Michaud, Quentin, Yohan Pipereau, Olivier Levillain, and Dhouha Ayed. 2024. “Robust Stack Smashing Protection for WebAssembly.” In 2024 IEEE Future Networks World Forum (FNWF). IEEE. https://doi.org/10.1109/fnwf63303.2024.11028722
• Michels, Steffen, Arjen Hommersom, Peter J. F. Lucas, and Marina Velikova. 2015. “A New Probabilistic Constraint Logic Programming Language Based on a Generalised Distribution Semantics.” Artificial Intelligence 228: 1–44. https://doi.org/10.1016/j.artint.2015.06.008
• Milano, Mae, Julia Turcotti, and Andrew C. Myers. 2022. “A Flexible Type System for Fearless Concurrency.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523443
• Milos, Don, Uwe Pleban, and George Loegel. 1984. “Direct Implementation of Compiler Specifications or the Pascal p-Code Compiler Revisited.” In Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL ‘84. ACM Press. https://doi.org/10.1145/800017.800531
• Mittal, Rakshit, Rochishnu Banerjee, Dominique Blouin, and Soumyadip Bandyopadhyay. 2021. “Towards an Approach for Translation Validation of Thread-Level Parallelizing Transformations Using Colored Petri Nets.” In Proceedings of the 16th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010581005330541
• Mizobuchi, Yuji, and Kuniharu Takayama. 2017. “Two Improvements to Detect Duplicates in Stack Overflow.” In 2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner.2017.7884678
• “Modern Compiler Implementation in C: Basic Techniques.” 1997a. Computers & Mathematics with Applications 33 (7): 139. https://doi.org/10.1016/s0898-1221(97)84605-6
• “Modern Compiler Implementation in Java: Basic Techniques.” 1997b. Computers & Mathematics with Applications 33 (7): 139. https://doi.org/10.1016/s0898-1221(97)84609-3
• “Modern Compiler Implementation in Java: Revised and Expanded Edition.” 1998. Computers & Mathematics with Applications 36 (3): 124. https://doi.org/10.1016/0898-1221(98)90193-6
• “Modern Compiler Implementation in ML: Basic Techniques.” 1997c. Computers & Mathematics with Applications 33 (7): 139. https://doi.org/10.1016/s0898-1221(97)84606-8
• Mondal, Saikat, Debajyoti Mondal, and Chanchal K. Roy. 2023. “Investigating Technology Usage Span by Analyzing Users’ Q&A Traces in Stack Overflow.” In 2023 30th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec60848.2023.00076
• Monniaux, David. 2024. “Memory Simulations, Security and Optimization in a Verified Compiler.” In Proceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3636501.3636952
• Monsuez, B. 1995. “Using Abstract Interpretation to Define a Strictness Type Inference System.” In Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation - PEPM ‘95. ACM Press. https://doi.org/10.1145/215465.215574
• Montenegro, Manuel, Ricardo Peña, and Clara Segura. 2015. “Space Consumption Analysis by Abstract Interpretation: Reductivity Properties.” Science of Computer Programming 111: 458–82. https://doi.org/10.1016/j.scico.2014.04.014
• Moody, Ken, and Martin Richards. 1980. “A Coroutine Mechanism for BCPL.” Software: Practice and Experience 10 (10): 765–71. https://doi.org/10.1002/spe.4380101002
• Moor, Ian W. 1982. “An Applicative Compiler for a Parallel Machine.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.807002
• Moriguchi, Sosuke, Takashi Morishima, Mizuki Goto, and Kazuko Takahashi. 2016. “Verification of Content-Centric Networking Using Proof Assistant.” IEICE Transactions on Communications E99.B (11): 2297–2304. https://doi.org/10.1587/transcom.2016nep0013
• Moron, Konrad, and Stefan Wallentowitz. 2023. “Support for Just-in-Time Compilation of WebAssembly for Embedded Systems.” In 2023 12th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco58584.2023.10155088
• Mosaner, Raphael, Gergö Barany, David Leopoldseder, and Hanspeter Mössenböck. 2022. “Improving Vectorization Heuristics in a Dynamic Compiler with Machine Learning Models.” In Proceedings of the 14th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3563838.3567679
• Moser, Georg, and Manuel Schneckenreither. 2020. “Automated Amortised Resource Analysis for Term Rewrite Systems.” Science of Computer Programming 185: 102306. https://doi.org/10.1016/j.scico.2019.102306
• Moss, Nick, Kei Davis, and Patrick McCormick. 2016. “The ARES High-Level Intermediate Representation.” In 2016 Third Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc.2016.009
• Mosses, Peter D. 2004. “Modular Structural Operational Semantics.” Journal of Logic and Algebraic Programming 60-61: 195–228. https://doi.org/10.1016/j.jlap.2004.03.008
• Mosses, Peter D. 2015. “Semantics of Programming Languages: Using Asf+Sdf.” Science of Computer Programming 97: 2–10. https://doi.org/10.1016/j.scico.2013.11.038
• Mosterman, Pieter J., and Justyna Zander. 2015. “Cyber-Physical Systems Challenges: A Needs Analysis for Collaborating Embedded Software Systems.” Software & Systems Modeling 15 (1): 5–16. https://doi.org/10.1007/s10270-015-0469-x
• Mpeis, Paschalis, Pavlos Petoumenos, Kim Hazelwood, and Hugh Leather. 2021. “Developer and User-Transparent Compiler Optimization for Interactive Applications.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454043
• Mückenschnabel, Maya. 2024. “Algebraic Effect Handlers with Bidirectional Type-Checking.” In Companion Proceedings of the 2024 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM. https://doi.org/10.1145/3689491.3689967
• Müller, Kilian, Siddharth Mane, Peter Wägemann, and Norman Franchi. 2026. “WasmWeaver: A Framework for Runtime-Aware WebAssembly Program Generation with Reinforcement Learning.” In 2026 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner67736.2026.00045
• Müller, Marius, Philipp Schuster, Jonathan Lindegaard Starup, Klaus Ostermann, and Jonathan Immanuel Brachthäuser. 2023. “From Capabilities to Regions: Enabling Efficient Compilation of Lexical Effect Handlers.” Proceedings of the ACM on Programming Languages 7 (OOPSLA2): 941–70. https://doi.org/10.1145/3622831
• Munley, Christian, Aaron Jarmusch, and Sunita Chandrasekaran. 2024. “LLM4VV: Developing LLM-Driven Testsuite for Compiler Validation.” Future Generation Computer Systems 160: 1–13. https://doi.org/10.1016/j.future.2024.05.034
• Murthy, Karthik, and John Mellor-Crummey. 2015. “A Compiler Transformation to Overlap Communication with Dependent Computation.” In 2015 9th International Conference on Partitioned Global Address Space Programming Models. IEEE. https://doi.org/10.1109/pgas.2015.17
• Mushtaq, Hamid, Zaid Al-Ars, and Koen Bertels. 2015. “Calculation of Worst-Case Execution Time for Multicore Processors Using Deterministic Execution.” In 2015 25th International Workshop on Power and Timing Modeling, Optimization and Simulation (PATMOS). IEEE. https://doi.org/10.1109/patmos.2015.7347584
• Müssig, Carsten. 2019. “Just enough, just in time, just for me: Lernen während der Arbeit.” ProCare 24 (1–2): 30–31. https://doi.org/10.1007/s00735-019-1022-x
• Musumbu, Kaninda. 2008. “Static Checking by Means of Abstract Interpretation.” In 2008 International Conference on Computer Science and Information Technology. IEEE. https://doi.org/10.1109/iccsit.2008.10
• Mycroft, Alan. 1993. “Completeness and Predicate-Based Abstract Interpretation.” In Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation - PEPM ‘93. ACM Press. https://doi.org/10.1145/154630.154648
• Myreen, Magnus O. 2010. “Verified Just-in-Time Compiler on x86.” ACM SIGPLAN Notices 45 (1): 107–18. https://doi.org/10.1145/1707801.1706313
• Myreen, Magnus O. 2021. “A Minimalistic Verified Bootstrapped Compiler (Proof Pearl).” In Proceedings of the 10th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3437992.3439915
• Mzid, Rania, Asma Charfi, and Najmeddine Etteyeb. 2022. “Use of Compiler Intermediate Representation for Reverse Engineering: A Case Study for GCC Compiler and UML Activity Diagram.” In Proceedings of the 10th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010821700003119
• Nadi, Sarah, and Christoph Treude. 2020. “Essential Sentences for Navigating Stack Overflow Answers.” In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner48275.2020.9054828
• Naik, Mayur. 2013. “Session Details: Compiler Validation.” In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3245331
• Nair, Premchand S. 2012. “A Formal Semantics for Ciset and Ciset Relation Operators.” Procedia Computer Science 12: 206–10. https://doi.org/10.1016/j.procs.2012.09.055
• Nair, Premchand S., and Suseela T. Sarasamma. 2006. “Formal Semantics of Ciset Relational Operators.” In NAFIPS 2006 - 2006 Annual Meeting of the North American Fuzzy Information Processing Society. IEEE. https://doi.org/10.1109/nafips.2006.365407
• Nanthaamornphong, Aziz, Anawat Leatongkam, Thanyarat Kitpanich, and Pongsakorn Thongnuan. 2015. “Bytecode-Based Class Dependency Extraction Tool: Bytecode-CDET.” In 2015 7th International Conference on Information Technology and Electrical Engineering (ICITEE). IEEE. https://doi.org/10.1109/iciteed.2015.7408903
• Nappa, Patrick, David Zhao, Pavle Subotic, and Bernhard Scholz. 2019. “Fast Parallel Equivalence Relations in a Datalog Compiler.” In 2019 28th International Conference on Parallel Architectures and Compilation Techniques (PACT). IEEE. https://doi.org/10.1109/pact.2019.00015
• Narkthong, Nuntipat, Chattriya Jariyavajee, and Xiaolin Xu. 2024. “ALLI/O Diagram: An Action-Based Visual Programming Language for Embedded System.” In 2024 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE. https://doi.org/10.1109/vl/hcc60511.2024.00031
• Natarajan, Saranya, and David Broman. 2020. “Temporal Property-Based Testing of a Timed C Compiler Using Time-Flow Graph Semantics.” In 2020 Forum for Specification and Design Languages (FDL). IEEE. https://doi.org/10.1109/fdl50818.2020.9232935
• Necula, George C. 1997. “Proof-Carrying Code.” In Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘97. ACM Press. https://doi.org/10.1145/263699.263712
• Necula, George C. 2000. “Translation Validation for an Optimizing Compiler.” In Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/349299.349314
• Necula, George C., and Peter Lee. 1998. “The Design and Implementation of a Certifying Compiler.” ACM SIGPLAN Notices 33 (5): 333–44. https://doi.org/10.1145/277652.277752
• Necula, George C., and Peter Lee. 2004. “The Design and Implementation of a Certifying Compiler.” ACM SIGPLAN Notices 39 (4): 612–25. https://doi.org/10.1145/989393.989454
• Negrini, Luca. 2026. “Whole-Value Analysis by Abstract Interpretation.” Frontiers in Computer Science 7: 1655377. https://doi.org/10.3389/fcomp.2025.1655377
• Neis, Georg, Chung-Kil Hur, Jan-Oliver Kaiser, Craig McLaughlin, Derek Dreyer, and Viktor Vafeiadis. 2015. “Pilsner: A Compositionally Verified Compiler for a Higher-Order Imperative Language.” ACM SIGPLAN Notices 50 (9): 166–78. https://doi.org/10.1145/2858949.2784764
• Nejjar, Mohamed, Luca Zacharias, Fabian Stiehle, and Ingo Weber. 2024. “LLMs for Science: Usage for Code Generation and Data Analysis.” Journal of Software: Evolution and Process 37 (1): e2723. https://doi.org/10.1002/smr.2723
• Nemer, Fadia, Hugues Casse, Pascal Sainrat, and Ali Awada. 2007. “Improving the Worst-Case Execution Time Accuracy by Inter-Task Instruction Cache Analysis.” In 2007 International Symposium on Industrial Embedded Systems. IEEE. https://doi.org/10.1109/sies.2007.4297313
• New, Max S., Eric Giovannini, and Daniel R. Licata. 2023. “Gradual Typing for Effect Handlers.” Proceedings of the ACM on Programming Languages 7 (OOPSLA2): 1758–86. https://doi.org/10.1145/3622860
• Nezamabadi, Daniel, Magnus O. Myreen, and Yong Kiam Tan. 2026. “Verified VCG and Verified Compiler for Dafny.” In Proceedings of the 15th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3779031.3779092
• Nguyen, Thuy, Toshiaki Aoki, Takashi Tomita, and Junpei Endo. 2019. “Integrating Static Program Analysis Tools for Verifying Cautions of Microcontroller.” In 2019 26th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec48747.2019.00021
• Nguyen, Minh, Roly Perera, Meng Wang, and Steven Ramsay. 2023. “Effect Handlers for Programmable Inference.” In Proceedings of the 16th ACM SIGPLAN International Haskell Symposium. ACM. https://doi.org/10.1145/3609026.3609729
• Ni, Yunbo, and Shaohua Li. 2025. “Interleaving Large Language Models for Compiler Testing.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 815–41. https://doi.org/10.1145/3763079
• Nickerson, Brian R. 1990. “Graph Coloring Register Allocation for Processors with Multi-Register Operands.” ACM SIGPLAN Notices 25 (6): 40–52. https://doi.org/10.1145/93548.93552
• Nielson, F. 1987. “Strictness Analysis and Denotational Abstract Interpretation.” In Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL ‘87. ACM Press. https://doi.org/10.1145/41625.41636
• Nielson, Flemming. 1988. “Strictness Analysis and Denotational Abstract Interpretation.” Information and Computation 76 (1): 29–92. https://doi.org/10.1016/0890-5401(88)90041-7
• Nilsen, Kelvin D., and Bernt Rygg. 1995. “Worst-Case Execution Time Analysis on Modern Processors.” ACM SIGPLAN Notices 30 (11): 20–30. https://doi.org/10.1145/216633.216650
• Nipkow, Tobias. 2003. “Java Bytecode Verification.” Journal of Automated Reasoning 30 (3–4): 233–233. https://doi.org/10.1023/a:1025086804452
• Nishizaki, Shin-Ya. 2017b. “Type Inference of Linear Lambda Calculus with First-Class Continuations.” In 2017 International Conference on Computer Technology, Electronics and Communication (ICCTEC). IEEE. https://doi.org/10.1109/icctec.2017.00040
• Noguchi, Ryu, Noriko Matsumoto, and Norihiko Yoshida. 2021. “Implementing Algebraic Effects and Handlers in Non-Functional Programming Languages.” In 2021 IEEE Asia-Pacific Conference on Computer Science and Data Engineering (CSDE). IEEE. https://doi.org/10.1109/csde53843.2021.9718480
• Norris, Cindy, and Lori L. Pollock. 1994. “Register Allocation over the Program Dependence Graph.” ACM SIGPLAN Notices 29 (6): 266–77. https://doi.org/10.1145/773473.178427
• Nowicki, Marek, Łukasz Górski, and Piotr Bała. 2021. “Performance Evaluation of Java/PCJ Implementation of Parallel Algorithms on the Cloud (Extended Version).” Concurrency and Computation: Practice and Experience 35 (15): e6536. https://doi.org/10.1002/cpe.6536
• Nyangaresi, Vincent Omollo, and Junchao Ma. 2022. “A Formally Verified Message Validation Protocol for Intelligent IoT E-Health Systems.” In 2022 IEEE World Conference on Applied Intelligence and Computing (AIC). IEEE. https://doi.org/10.1109/aic55036.2022.9848874
• O’Callahan, Robert. 1999. “A Simple, Comprehensive Type System for Java Bytecode Subroutines.” In Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/292540.292549
• O’Loughlin, John, and Lee Gillam. 2015. “Addressing Issues of Cloud Resilience, Security and Performance through Simple Detection of Co-Locating Sibling Virtual Machine Instances.” In Proceedings of the 5th International Conference on Cloud Computing and Services Science. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005485000600067
• Oh, Yunho, Ipoom Jeong, Won Woo Ro, and Myung Kuk Yoon. 2022. “CASH-RF: A Compiler-Assisted Hierarchical Register File in GPUs.” IEEE Embedded Systems Letters 14 (4): 187–90. https://doi.org/10.1109/les.2022.3163749
• Oiwa, Yutaka. 2009. “Implementation of the Memory-Safe Full ANSI-C Compiler.” ACM SIGPLAN Notices 44 (6): 259–69. https://doi.org/10.1145/1543135.1542505
• Okasaki, Chris, Peter Lee, and David Tarditi. 1994. “Call-by-Need and Continuation-Passing Style.” LISP and Symbolic Computation 7 (1): 57–81. https://doi.org/10.1007/bf01019945
• Oliva, Dino P., John D. Ramsdell, and Mitchell Wand. 1995. “The VLISP Verified PreScheme Compiler.” LISP and Symbolic Computation 8 (1–2): 111–82. https://doi.org/10.1007/bf01128408
• Olteanu, Vlad, and Ciprian Oprişa. 2025. “LambdaGo: A Functional Extension of the Go Programming Language.” In 2025 29th International Conference on System Theory, Control and Computing (ICSTCC). IEEE. https://doi.org/10.1109/icstcc66753.2025.11240319
• Ooashi, Masahiro, Kenichi Taniguchi, and Yuji Sugiyama. 1992. “ASL Program Written in Abstract Sequential Machine Style and Its Compiler.” Systems and Computers in Japan 23 (7): 1–11. https://doi.org/10.1002/scj.4690230701
• Orlic, Aleksandar. 2010. “Implementation by Capture with Executable UML.” In 2010 6th Central and Eastern European Software Engineering Conference (CEE-SECR). IEEE. https://doi.org/10.1109/cee-secr.2010.5783159
• Orlitsky, A. 2002. “Scalar versus Vector Quantization: Worst Case Analysis.” IEEE Transactions on Information Theory 48 (6): 1393–1409. https://doi.org/10.1109/tit.2002.1003829
• Oshita, Masanori, Kosuke Kaida, and Shimpei Matsumoto. 2019. “Improving User Experience of C Programming Language Learning System for Novices.” In 2019 8th International Congress on Advanced Applied Informatics (IIAI-AAI). IEEE. https://doi.org/10.1109/iiai-aai.2019.00068
• Ottoni, Guilherme. 2018. “HHVM JIT: A Profile-Guided, Region-Based Compiler for PHP and Hack.” In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3192366.3192374
• Ouadjaout, Abdelraouf, Antoine Miné, Noureddine Lasla, and Nadjib Badache. 2016. “Static Analysis by Abstract Interpretation of Functional Properties of Device Drivers in TinyOS.” Journal of Systems and Software 120: 114–32. https://doi.org/10.1016/j.jss.2016.07.030
• Ozdemir, Alex, Fraser Brown, and Riad S. Wahby. 2022. “CirC: Compiler Infrastructure for Proof Systems, Software Verification, and More.” In 2022 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp46214.2022.9833782
• Padmasudha Kannan, G., T. V. Smitha, and K. V. Nagaraja. 2021. “Automated High-Order Curved Mesh Generator with High-Level Dynamic Programming Language Julia for Photonic Applications.” Materials Today: Proceedings 46: 4553–58. https://doi.org/10.1016/j.matpr.2020.09.706
• Pallavi, M. S., G. V. Bhoomika, S. Chaitra, and Vinayak Hegde. 2025. “Impact of Peer-Based Feedback Mechanisms on Understanding Programming Language.” In 2025 Control Instrumentation System Conference (CISCON). IEEE. https://doi.org/10.1109/ciscon66933.2025.11337437
• Pan, Chen, Mimi Xie, Chengmo Yang, Zili Shao, and Jingtong Hu. 2015. “Nonvolatile Main Memory Aware Garbage Collection in High-Level Language Virtual Machine.” In 2015 International Conference on Embedded Software (EMSOFT). IEEE. https://doi.org/10.1109/emsoft.2015.7318275
• Panigrahi, Priyanka, and Chandan Karfa. 2023a. “An Investigation into the Security of Register Allocation with Spilling and Splitting.” In 2023 IEEE Computer Society Annual Symposium on VLSI (ISVLSI). IEEE. https://doi.org/10.1109/isvlsi59464.2023.10238662
• Panigrahi, Priyanka, and Chandan Karfa. 2023b. “Translation Validation of Information Leakage of Compiler Optimizations.” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 42 (11): 3585–98. https://doi.org/10.1109/tcad.2023.3269954
• Pant, Dipendra, Dhiraj Pokhrel, and Prakash Poudyal. 2022. “Automatic Software Engineering Position Resume Screening Using Natural Language Processing, Word Matching, Character Positioning, and Regex.” In 2022 5th International Conference on Advanced Systems and Emergent Technologies (IC_ASET). IEEE. https://doi.org/10.1109/ic_aset53395.2022.9765916
• Papadakis, Mike, Yue Jia, Mark Harman, and Yves Le Traon. 2015. “Trivial Compiler Equivalence: A Large Scale Empirical Study of a Simple, Fast and Effective Equivalent Mutant Detection Technique.” In 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering. IEEE. https://doi.org/10.1109/icse.2015.103
• Papadimitriou, Michail, Juan Fumero, Athanasios Stratikopoulos, and Christos Kotselidis. 2021. “Automatically Exploiting the Memory Hierarchy of GPUs through Just-in-Time Compilation.” In Proceedings of the 17th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments. ACM. https://doi.org/10.1145/3453933.3454014
• Pape, Tobias, Carl Friedrich Bolz, and Robert Hirschfeld. 2017. “Adaptive Just-in-Time Value Class Optimization for Lowering Memory Consumption and Improving Execution Time Performance.” Science of Computer Programming 140: 17–29. https://doi.org/10.1016/j.scico.2016.08.003
• Park, Joonseok, Sumin Jeong, and Keunhyuk Yeom. 2023. “Bespoke Virtual Machine Orchestrator: An Approach for Constructing and Reconfiguring Bespoke Virtual Machine in Private Cloud Environment.” Applied Sciences 13 (16): 9161. https://doi.org/10.3390/app13169161
• Park, Jinpyo, Je-Hyung Lee, and Soo-Mook Moon. 2001. “Register Allocation for Banked Register File.” In Proceedings of the ACM SIGPLAN workshop on Languages, compilers and tools for embedded systems. ACM. https://doi.org/10.1145/384197.384205
• Park, Daejun, Andrei Stefănescu, and Grigore Roşu. 2015. “KJS: A Complete Formal Semantics of JavaScript.” In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2737924.2737991
• Parra, Francisco. 2026. “SurtGIS: A High-Performance Raster Geospatial Analysis Library in Rust with WebAssembly and Python Support.” Environmental Modelling & Software 204: 107102. https://doi.org/10.1016/j.envsoft.2026.107102
• Parwez, Laiba, Hina Abrar, and Muhammad Ali. 2025. “Signease: Machine Learning Based Sign Language Interpreter.” In 2025 International Conference on Engineering & Computing Technologies (ICECT). IEEE. https://doi.org/10.1109/icect66235.2025.11381681
• Patel, Jay, and Yann-Hang Lee. 2016. “Dynamic Analysis of Multi-Threaded Embedded Software to Expose Atomicity Violations.” In 2016 13th International Conference on Embedded Software and Systems (ICESS). IEEE. https://doi.org/10.1109/icess.2016.30
• Pathiran, Arun R., and Jagadeesan Prakash. 2014. “Design and Implementation of a Model-Based PI-like Control Scheme in a Reset Configuration for Stable Single-Loop Systems.” Canadian Journal of Chemical Engineering 92 (9): 1651–60. https://doi.org/10.1002/cjce.22014
• Patterson, Daniel, and Amal Ahmed. 2019. “The Next 700 Compiler Correctness Theorems (Functional Pearl).” Proceedings of the ACM on Programming Languages 3 (ICFP): 1–29. https://doi.org/10.1145/3341689
• Pauli, W., and M. L. Soffa. 1980. “Coroutine Behaviour and Implementation.” Software: Practice and Experience 10 (3): 189–204. https://doi.org/10.1002/spe.4380100305
• Paulson, Lawrence. 1982. “A Semantics-Directed Compiler Generator.” In Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘82. ACM Press. https://doi.org/10.1145/582153.582178
• Payne, A. J. 1978. “A Formalised Technique for Expressing Compiler Exercisers.” ACM SIGPLAN Notices 13 (1): 59–69. https://doi.org/10.1145/953428.953435
• Pečimúth, Andrej. 2023. “Remote Just-in-Time Compilation for Dynamic Languages.” In Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM. https://doi.org/10.1145/3618305.3623593
• Pelsmaeker, Daniel A. A., Hendrik van Antwerpen, and Eelco Visser. 2019. “Towards Language-Parametric Semantic Editor Services Based on Declarative Type System Specifications.” In Proceedings Companion of the 2019 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM. https://doi.org/10.1145/3359061.3362782
• Penev, Ivailo, and Dimitar Dimitrov. 2021. “Design of a Virtual Machine for Training Compilers.” In 2021 International Conference Automatics and Informatics (ICAI). IEEE. https://doi.org/10.1109/icai52893.2021.9639831
• Petchartee, Somrak. 2025. “A Universal Quantum Compiler GPT: Multi-Framework Optimization and Translation Using Large Language Models.” In 2025 29th International Computer Science and Engineering Conference (ICSEC). IEEE. https://doi.org/10.1109/icsec67360.2025.11298108
• Petrosino, Giuseppe, Stefania Monica, and Federico Bergenti. 2023. “Cross-Paradigm Interoperability between Jadescript and Java.” In Proceedings of the 15th International Conference on Agents and Artificial Intelligence. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011619300003393
• Phulia, Ankush, Vaibhav Bhagee, and Sorav Bansal. 2020. “OOElala: Order-of-Evaluation Based Alias Analysis for Compiler Optimization.” In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3385412.3385962
• Pichler, Christoph, Paley Li, Roland Schatz, and Hanspeter Mössenböck. 2023. “Hybrid Execution: Combining Ahead-of-Time and Just-in-Time Compilation.” In Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3623507.3623554
• Pinckney, Donald, Arjun Guha, and Yuriy Brun. 2020. “Wasm/k: Delimited Continuations for WebAssembly.” In Proceedings of the 16th ACM SIGPLAN International Symposium on Dynamic Languages. ACM. https://doi.org/10.1145/3426422.3426978
• Pizzolotto, Davide, and Katsuro Inoue. 2021. “Identifying Compiler and Optimization Level in Binary Code from Multiple Architectures.” IEEE Access 9: 163461–75. https://doi.org/10.1109/access.2021.3132950
• Pleban, Uwe F. 1979. “The Use of Transition Matrices in a Recursive-Descent Compiler.” In Proceedings of the 1979 SIGPLAN symposium on Compiler construction - SIGPLAN ‘79. ACM Press. https://doi.org/10.1145/800229.806964
• Pleban, Uwe F. 1984. “Compiler Prototyping Using Formal Semantics.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502883
• Plotkin, G. 2004. “The Origins of Structural Operational Semantics.” Journal of Logic and Algebraic Programming. https://doi.org/10.1016/s1567-8326(04)00026-8
• Plotkin, Gordon, and Matija Pretnar. 2008. “A Logic for Algebraic Effects.” In 2008 23rd Annual IEEE Symposium on Logic in Computer Science. IEEE. https://doi.org/10.1109/lics.2008.45
• Plotkin, Gordon, and Matija Pretnar. 2009. “Handlers of Algebraic Effects.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-00590-9_7
• Pockstaller, Dennis, Stefan Huber, and Lukas Demetz. 2023. “Comparing the Energy Consumption of WebAssembly and JavaScript in Mobile Browsers.” In Proceedings of the 19th International Conference on Web Information Systems and Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0012205600003584
• Poletanovic, Miloc, Miodrag Dukic, Dragan Mladenovic, and Zoran Jovanovic. 2022. “Implementation of Machine Outliner for nanoMIPS in the LLVM Compiler Infrastructure.” In 2022 IEEE Zooming Innovation in Consumer Technologies Conference (ZINC). IEEE. https://doi.org/10.1109/zinc55034.2022.9840726
• Polito, Guillermo, Stéphane Ducasse, and Pablo Tesone. 2022. “Interpreter-Guided Differential JIT Compiler Unit Testing.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523457
• Popeea, Corneliu, and Wei-Ngan Chin. 2004. “A Type System for Resource Protocol Verification and Its Correctness Proof.” In Proceedings of the 2004 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation. ACM. https://doi.org/10.1145/1014007.1014021
• Porcher, Thierry. 1995. “Benchmarking the POMPC Compiler on the Connection Machine CM-2.” Future Generation Computer Systems 11 (1): 19–26. https://doi.org/10.1016/0167-739x(94)00044-f
• Posner, Jonas, Tim Ellersiek, Nick Bietendorf, Dominik Huber, Martin Schreiber, and Martin Schulz. 2025. “Toward Dynamic Resource Management: An Asynchronous Many-Task (AMT) Runtime System Leveraging Dynamic Processes with PSets (DPP).” SN Computer Science 6 (8): 941. https://doi.org/10.1007/s42979-025-04405-3
• Postema, Jesse, Johan Fabry, Yannick Barthol, and Ana Oprescu. 2022. “Testing a PL/I Compiler Using Precomputation-Based Program Generation.” In 2022 IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst53961.2022.00042
• Powell, Michael L. 1984. “A Portable Optimizing Compiler for Modula-2.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502905
• Prenzel, Laurin, and Julien Provost. 2017. “Dynamic Software Updating of IEC 61499 Implementation Using Erlang Runtime System.” IFAC-PapersOnLine 50 (1): 12416–21. https://doi.org/10.1016/j.ifacol.2017.08.2429
• Pretnar, Matija. 2015. “An Introduction to Algebraic Effects and Handlers. Invited Tutorial Paper.” Electronic Notes in Theoretical Computer Science 319: 19–35. https://doi.org/10.1016/j.entcs.2015.12.003
• Prinz, Thomas. 2023. “Compilation of Distributed Programs to Services Using Multiple Programming Languages.” In Proceedings of the 19th International Conference on Web Information Systems and Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0012151500003584
• Pritchard, Paul A. 1976. “A Proof Rule for Multiple Coroutine Systems.” Information Processing Letters 4 (6): 141–43. https://doi.org/10.1016/0020-0190(76)90082-x
• “Proceedings of the 2020 International Conference on Embedded Software (EMSOFT).” 2020. In 2020 International Conference on Embedded Software (EMSOFT). IEEE. https://doi.org/10.1109/emsoft51651.2020.9244035
• “Proceedings Second IEEE International Workshop on Source Code Analysis and Manipulation.” 2002. In Proceedings. Second IEEE International Workshop on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2002.1134099
• “Proceedings Third IEEE International Workshop on Source Code Analysis and Manipulation.” 2003. In Proceedings Third IEEE International Workshop on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2003.1238025
• Puffitsch, Wolfgang. 2016. “Efficient Worst-Case Execution Time Analysis of Dynamic Branch Prediction.” In 2016 28th Euromicro Conference on Real-Time Systems (ECRTS). IEEE. https://doi.org/10.1109/ecrts.2016.23
• Punchihewa, Hashan, and Nicolas Wu. 2021. “Safe Mutation with Algebraic Effects.” In Proceedings of the 14th ACM SIGPLAN International Symposium on Haskell. ACM. https://doi.org/10.1145/3471874.3472988
• Puranik, Rohit Sanjay. 2025. “Bridging Formal Methods and Software Engineering through a Tagless-Final Embedded DSL for Program Semantics.” In 2025 IEEE 2nd International Conference on Information Technology, Electronics and Intelligent Communication Systems (ICITEICS). IEEE. https://doi.org/10.1109/iciteics64870.2025.11341094
• Puschner, Peter. 1997. “Worst-Case Execution Time Analysis at Low Cost.” IFAC Proceedings Volumes 30 (15): 17–22. https://doi.org/10.1016/s1474-6670(17)42661-9
• Puschner, Peter. 1998. “Worst-Case Execution-Time Analysis at Low Cost.” Control Engineering Practice 6 (1): 129–35. https://doi.org/10.1016/s0967-0661(97)10050-8
• Qian, Siyuan Brant, Vimarsh Sathia, Ivan R. Ivanov, Jan Hückelheim, Paul Hovland, and William S. Moses. 2026. “Thinking Fast and Correct: Automated Rewriting of Numerical Code through Compiler Augmentation.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395228
• Qu, Rong, Jiangang Huang, Long Zhang, Tianlu Qiao, and Jian Zhang. 2023. “Scope-Based Compiler Differential Testing.” In 2023 IEEE 23rd International Conference on Software Quality, Reliability, and Security (QRS). IEEE. https://doi.org/10.1109/qrs60937.2023.00043
• Queiroz Junior, Nilton Luiz, and Anderson Faustino da Silva. 2015. “Finding Good Compiler Optimization Sets: A Case-Based Reasoning Approach.” In Proceedings of the 17th International Conference on Enterprise Information Systems. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005380605040515
• Radonić, Slavko, Miodrag Đukić, and Nenad Četić. 2014. “One Solution of Loop Invariant Code Motion Compiler Optimisation.” In 2014 22nd Telecommunications Forum Telfor (TELFOR). IEEE. https://doi.org/10.1109/telfor.2014.7034599
• Raj, P. Dhanya. 2016. “Performance Analysis of Different Specifications of Copy Propagation Transformation Using Machine SUIF Compiler Infrastructure.” In 2016 International Conference on Emerging Technological Trends (ICETT). IEEE. https://doi.org/10.1109/icett.2016.7873638
• Ramesh, Sreyas, B. N. Sukanth, Sathyavarapu Sri Jaswanth, Vishwash Sharma, and Meena Belwal. 2024. “ThriveJIT: Dynamic Just-In-Time Compilation for Efficient Execution of Arithmetic Expressions.” In 2024 15th International Conference on Computing Communication and Networking Technologies (ICCCNT). IEEE. https://doi.org/10.1109/icccnt61001.2024.10725306
• Ramkumar, B., and L. V. Kale. 1990. “A Chare Kernel Implementation of a Parallel Prolog Compiler.” ACM SIGPLAN Notices 25 (3): 99–108. https://doi.org/10.1145/99164.99175
• Rand, Robert. 2022. “Writing and Verifying a Quantum Optimizing Compiler (Keynote).” In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3497776.3526941
• Ranzato, Francesco. 2013. “Session Details: Abstract Interpretation.” In Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/3260312
• Rao, Bingbing, Zixia Liu, Hong Zhang, Siyang Lu, and Liqiang Wang. 2021. “SODA: A Semantics-Aware Optimization Framework for Data-Intensive Applications Using Hybrid Program Analysis.” In 2021 IEEE 14th International Conference on Cloud Computing (CLOUD). IEEE. https://doi.org/10.1109/cloud53861.2021.00058
• Raskovsky, Martin R. 1982. “Denotational Semantics as a Specification of Code Generators.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806998
• Reb, Henrique, Ricardo Lima, M. Corn, and S. Soares. 2008. “A JML Compiler Based on AspectJ.” In 2008 International Conference on Software Testing, Verification, and Validation. IEEE. https://doi.org/10.1109/icst.2008.14
• Recharla, Rakesh. 2025. “Parallel Sparse Matrix Algorithms in OCaml v5: Implementation, Performance, and Case Studies.” In 2025 International Conference on Wireless Communications Signal Processing and Networking (WiSPNET). IEEE. https://doi.org/10.1109/wispnet64060.2025.11004864
• Reddy, Ravikiran Ravindranath, Sawan Singh, Arthur Perais, Alberto Ros, and Alexandra Jimborean. 2026. “Compiler-Assisted Instruction Fusion.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11394845
• Reynolds, John C. (1972) 1998. “Definitional Interpreters for Higher-Order Programming Languages.” Higher-Order and Symbolic Computation 11 (4): 363–97. https://doi.org/10.1023/a:1010027404223
• Ricketts, Daniel, Gregory Malecha, Mario M. Alvarez, Vignesh Gowda, and Sorin Lerner. 2015. “Towards Verification of Hybrid Systems in a Foundational Proof Assistant.” In 2015 ACM/IEEE International Conference on Formal Methods and Models for Codesign (MEMOCODE). IEEE. https://doi.org/10.1109/memcod.2015.7340492
• Rinard, Martin C. 2026. “Testing, Credible Compilation, and Verification in the Axon Verified Compiler in Lean and Claude Code.” In Proceedings of the 2026 ACM SIGPLAN International Workshop on Principles of Agentic Engineering. ACM. https://doi.org/10.1145/3819802.3820579
• Rivera, Joao, Franz Franchetti, and Markus Puschel. 2021. “An Interval Compiler for Sound Floating-Point Computations.” In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo51591.2021.9370307
• Rivera, Joao, Franz Franchetti, and Markus Puschel. 2022. “A Compiler for Sound Floating-Point Computations Using Affine Arithmetic.” In 2022 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo53902.2022.9741286
• Robbins, David C. 1984. “Engineering a High-Capacity Pascal Compiler for High Performance.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502904
• Robin, Debobroto Das, and Javed I. Khan. 2024. “An Open-Source P416 Compiler Backend for Reconfigurable Match-Action Table Switches: Making Networking Innovation Accessible.” Computer Networks 242: 110246. https://doi.org/10.1016/j.comnet.2024.110246
• Rodríguez, Gabriel, María J. Martín, Patricia González, Juan Touriño, and Ramón Doallo. 2009. “CPPC: A Compiler-Assisted Tool for Portable Checkpointing of Message-Passing Applications.” Concurrency and Computation: Practice and Experience 22 (6): 749–66. https://doi.org/10.1002/cpe.1541
• Rodríguez, Leonardo, Miguel Pagano, and Daniel Fridlender. 2016. “Proving Correctness of a Compiler Using Step-Indexed Logical Relations.” Electronic Notes in Theoretical Computer Science 323: 197–214. https://doi.org/10.1016/j.entcs.2016.06.013
• Roessle, Ian, Freek Verbeek, and Binoy Ravindran. 2019. “Formally Verified Big Step Semantics out of x86-64 Binaries.” In Proceedings of the 8th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3293880.3294102
• Rohr, David, and Volker Lindenstruth. 2017. “Fast Failure Erasure Encoding Using Just in Time Compilation for CPUs, GPUs, and FPGAs.” In 2017 IEEE International Conference on Cluster Computing (CLUSTER). IEEE. https://doi.org/10.1109/cluster.2017.101
• “The Role of Abstract Interpretation in Formal Methods.” 2007. In Fifth IEEE International Conference on Software Engineering and Formal Methods (SEFM 2007). IEEE. https://doi.org/10.1109/sefm.2007.42
• Rong, Yuyang, Zhanghan Yu, Zhenkai Weng, Stephen Neuendorffer, and Hao Chen. 2025. “IRFuzzer: Specialized Fuzzing for LLVM Backend Code Generation.” In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse55347.2025.00130
• Rosà, Andrea, Matteo Basso, Leonardo Bohnhoff, and Walter Binder. 2023. “Automated Runtime Transition between Virtual and Platform Threads in the Java Virtual Machine.” In 2023 30th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec60848.2023.00080
• Rose, Eva. 2003. “Lightweight Bytecode Verification.” Journal of Automated Reasoning 31 (3–4): 303–34. https://doi.org/10.1023/b:jars.0000021015.15794.82
• Rosenblum, Nathan E., Barton P. Miller, and Xiaojin Zhu. 2010. “Extracting Compiler Provenance from Program Binaries.” In Proceedings of the 9th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. ACM. https://doi.org/10.1145/1806672.1806678
• Roşu, Grigore. 2018. “Finite-Trace Linear Temporal Logic: Coinductive Completeness.” Formal Methods in System Design 53 (1): 138–63. https://doi.org/10.1007/s10703-018-0321-3
• Rot, Jurriaan, Marcello Bonsangue, and Jan Rutten. 2016. “Proving Language Inclusion and Equivalence by Coinduction.” Information and Computation 246: 62–76. https://doi.org/10.1016/j.ic.2015.11.009
• Roy, Subhajit. 2023. “A Theorem Proving Approach to Programming Language Semantics.” In 2023 IEEE/ACM 45th International Conference on Software Engineering: Software Engineering Education and Training (ICSE-SEET). IEEE. https://doi.org/10.1109/icse-seet58685.2023.00021
• Roy, Partha, Kirill Morozov, Kazuhide Fukushima, Shinsaku Kiyomoto, and Tsuyoshi Takagi. 2019. “Security Analysis and Efficient Implementation of Code-Based Signature Schemes.” In Proceedings of the 5th International Conference on Information Systems Security and Privacy. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0007259102130220
• Royer, Veronique. 1986. “Transformations of Denotational Semantics in Semantics Directed Compiler Generation.” In Proceedings of the 1986 SIGPLAN symposium on Compiler construction. ACM. https://doi.org/10.1145/12276.13318
• Ruan, Xiaojun, and Haiquan Chen. 2015. “Performance-to-Power Ratio Aware Virtual Machine (VM) Allocation in Energy-Efficient Clouds.” In 2015 IEEE International Conference on Cluster Computing. IEEE. https://doi.org/10.1109/cluster.2015.46
• Ruberg, Priit, Keijo Lass, Elvar Liiv, and Peeter Ellervee. 2017. “Embedded Software Performance Estimations at Different Compiler Optimisation Levels.” In 2017 5th IEEE Workshop on Advances in Information, Electronic and Electrical Engineering (AIEEE). IEEE. https://doi.org/10.1109/aieee.2017.8270530
• Ruchkin, Vladimir, Marat Mahmudov, Vitaly Romanchuk, Vladimir Fulin, Boris Kostrov, and Ekaterina Ruchkina. 2016. “Smart Compiler Embedded Computing Systems Based on Cluster Parallelism.” In 2016 5th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco.2016.7525697
• Ruchkin, Vladimir, Vitaly Romanchuk, Vladimir Fulin, Vladislav Lukashenko, Boris Kostrov, and Ekaterina Ruchkina. 2017. “Frame Model of a Compiler of Cluster Parallelism for Embedded Computing Systems.” In 2017 6th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco.2017.7977243
• Rudmik, A., and E. S. Lee. 1979. “Compiler Design for Efficient Code Generation and Program Optimization.” ACM SIGPLAN Notices 14 (8): 127–38. https://doi.org/10.1145/872732.806962
• Rudolph, Johannes, and Peter Thiemann. 2010. “Mnemonics: Type-Safe Bytecode Generation at Run Time.” Higher-Order and Symbolic Computation 23 (3): 371–407. https://doi.org/10.1007/s10990-011-9077-9
• Russinoff, David M. 1992. “A Verified Prolog Compiler for the Warren Abstract Machine.” Journal of Logic Programming 13 (4): 367–412. https://doi.org/10.1016/0743-1066(92)90054-7
• Ryu, Sukyoung, Jihyeok Park, and Joonyoung Park. 2019. “Toward Analysis and Bug Finding in JavaScript Web Applications in the Wild.” IEEE Software 36 (3): 74–82. https://doi.org/10.1109/ms.2018.110113408
• Sabry, Amr, and Matthias Felleisen. 1992. “Reasoning about Programs in Continuation-Passing Style.” ACM SIGPLAN Lisp Pointers V (1): 288–98. https://doi.org/10.1145/141478.141563
• Sabry, Amr, and Matthias Felleisen. 1993. “Reasoning about Programs in Continuation-Passing Style.” LISP and Symbolic Computation 6 (3–4): 289–360. https://doi.org/10.1007/bf01019462
• Sabry, Amr, and Matthias Felleisen. 1994. “Is Continuation-Passing Useful for Data Flow Analysis?” ACM SIGPLAN Notices 29 (6): 1–12. https://doi.org/10.1145/773473.178244
• Sack, Warren. 2025. “Interfacing Programming Language Semantics and Pragmatics: What Does “Hello, World” Mean?” Philosophies 10 (4): 86. https://doi.org/10.3390/philosophies10040086
• Sadanand Giri, Yash, Alsha Subash, and Balasubramanian Kandasubramanian. 2024. “Green Threads of Progress: Natural Fibers Reshaping Wastewater Cleanup Strategies, a Review.” Hybrid Advances 6: 100237. https://doi.org/10.1016/j.hybadv.2024.100237
• Saetchnikov, I., E. Tcherniavskaia, and A. Saetchnikov. 2026. “Microresonator Clusters for Spectral Analysis with Machine-Learning Interpreter.” In 2026 International Conference Laser Optics (ICLO). IEEE. https://doi.org/10.1109/iclo69056.2026.11624498
• Sager, Thomas J. 1985. “A Technique for Creating Small Fast Compiler Frontends.” ACM SIGPLAN Notices 20 (10): 87–94. https://doi.org/10.1145/382286.382384
• Sah, Love Kumar, Sheikh Ariful Islam, and Srinivas Katkoori. 2018. “An Efficient Hardware-Oriented Runtime Approach for Stack-Based Software Buffer Overflow Attacks.” In 2018 Asian Hardware Oriented Security and Trust Symposium (AsianHOST). IEEE. https://doi.org/10.1109/asianhost.2018.8607169
• Sai, Manoj, Aakansha Tyagi, Kajal Panda, and Sanjeev Kumar. 2022. “Machine Learning-Based Malware Detection Using Stacking of Opcodes and Bytecode Sequences.” In 2022 Seventh International Conference on Parallel, Distributed and Grid Computing (PDGC). IEEE. https://doi.org/10.1109/pdgc56933.2022.10053307
• Salapura, Valentina, and Richard Harper. 2015a. “High Performance Virtual Machine Recovery in the Cloud.” In Proceedings of the 5th International Conference on Cloud Computing and Services Science. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005493405590564
• Salapura, Valentina, and Richard Harper. 2015b. “Remote Restart for a High Performance Virtual Machine Recovery in a Cloud.” In 2015 IEEE 8th International Conference on Cloud Computing. IEEE. https://doi.org/10.1109/cloud.2015.52
• Salim, Salim S., Andy Nisbet, and Mikel Luján. 2019. “Towards a WebAssembly Standalone Runtime on GraalVM.” In Proceedings Companion of the 2019 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM. https://doi.org/10.1145/3359061.3362780
• Samiei, Arvin, Nafiseh Kahani, Mohammadreza Dehghanitafti, and Mojtaba Ahmadi. 2024. “Worst-Case Execution Time Analysis of Real-Time Robotic Algorithms Using Reinforcement Learning.” In 2024 34th International Conference on Collaborative Advances in Software and COmputiNg (CASCON). IEEE. https://doi.org/10.1109/cascon62161.2024.10838116
• Sammler, Michael, Angus Hammond, Rodolphe Lepigre, et al. 2022. “Islaris: Verification of Machine Code against Authoritative ISA Semantics.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523434
• Sanders, William S., Srishti Srivastava, and Ioana Banicescu. 2020. “Robustness Analysis of Scaled Resource Allocation Models Using the Imperial PEPA Compiler.” In 2020 19th International Symposium on Parallel and Distributed Computing (ISPDC). IEEE. https://doi.org/10.1109/ispdc51135.2020.00018
• Sangiorgi, Davide. 2022. “From Enhanced Coinduction towards Enhanced Induction.” Proceedings of the ACM on Programming Languages 6 (POPL): 1–29. https://doi.org/10.1145/3498679
• Sanmorino, Ahmad. 2012. “Development of Computer Assisted Instruction (CAI) for Compiler Model: The Simulation of Stack on Code Generation.” In 2012 International Conference on Green and Ubiquitous Technology. IEEE. https://doi.org/10.1109/gut.2012.6344164
• Santhi, Nandakishore, Stephan Eidenbenz, and Jason Liu. 2015. “The Simian Concept: Parallel Discrete Event Simulation with Interpreted Languages and Just-in-Time Compilation.” In 2015 Winter Simulation Conference (WSC). IEEE. https://doi.org/10.1109/wsc.2015.7408405
• Santhiar, Anirudh, and Aditya Kanade. 2017. “Static Deadlock Detection for Asynchronous C# Programs.” In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3062341.3062361
• SanthiKumar, R., M. Sahaya Sheela, Bekzod Madaminov, G. Rajesh, C. Navaneetha, and Haritha Ks. 2025. “Enhancing Machine Learning Performance with AI-Based Virtual Machine Load Balancing.” In 2025 International Conference on Emerging Technologies in Engineering Applications (ICETEA). IEEE. https://doi.org/10.1109/icetea64585.2025.11099995
• Santos, Rodrigo C. M., Guilherme F. Lima, Francisco Sant’Anna, Roberto Ierusalimschy, and Edward H. Haeusler. 2018. “A Memory-Bounded, Deterministic and Terminating Semantics for the Synchronous Programming Language Céu.” In Proceedings of the 19th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, and Tools for Embedded Systems. ACM. https://doi.org/10.1145/3211332.3211334
• Sato, Ryosuke, Naoki Iwayama, and Naoki Kobayashi. 2019. “Combining Higher-Order Model Checking with Refinement Type Inference.” In Proceedings of the 2019 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3294032.3294081
• Schäfer, Steven, Sigurd Schneider, and Gert Smolka. 2016. “Axiomatic Semantics for Compiler Verification.” In Proceedings of the 5th ACM SIGPLAN Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/2854065.2854083
• Scheidl, Fabian. 2020. “Valent-Blocks: Scalable High-Performance Compilation of WebAssembly Bytecode for Embedded Systems.” In 2020 International Conference on Computing, Electronics & Communications Engineering (iCCECE). IEEE. https://doi.org/10.1109/iccece49321.2020.9231154
• Schlägl, Manfred, and Daniel Groβe. 2025. “Fast Interpreter-Based Instruction Set Simulation for Virtual Prototypes.” In 2025 Design, Automation & Test in Europe Conference (DATE). IEEE. https://doi.org/10.23919/date64628.2025.10992929
• Schliephake, Michael, Xavier Aguilar, and Erwin Laure. 2011. “Design and Implementation of a Runtime System for Parallel Numerical Simulations on Large-Scale Clusters.” Procedia Computer Science 4: 2105–14. https://doi.org/10.1016/j.procs.2011.04.230
• Schmale, Tobias, Bence Temesi, Alakesh Baishya, et al. 2022. “Backend Compiler Phases for Trapped-Ion Quantum Computers.” In 2022 IEEE International Conference on Quantum Software (QSW). IEEE. https://doi.org/10.1109/qsw55613.2022.00020
• Schmeck, Hartmut. 1983. “Algebraic Semantics of Recursive Flowchart Schemes.” Information and Control 59 (1–3): 108–26. https://doi.org/10.1016/s0019-9958(83)80032-1
• Schmidt, Uwe, and Reinhard Völler. 1984. “A Multi-Language Compiler System with Automatically Generated Codegenerators.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502894
• Schmitz, Lothar. 1992. “The Visual Compiler-Compiler SIC (Abstract).” ACM SIGPLAN OOPS Messenger 4 (2): 236. https://doi.org/10.1145/157710.157814
• Schnakenbeck, Aron, Robin Mroß, Marcus Völker, Stefan Kowalewski, and Alexander Fay. 2023. “A Control Flow Based Static Analysis of GRAFCET Using Abstract Interpretation.” In 2023 IEEE 21st International Conference on Industrial Informatics (INDIN). IEEE. https://doi.org/10.1109/indin51400.2023.10218176
• Schneider, Klaus, Jens Brandt, and Tobias Schuele. 2006. “A Verified Compiler for Synchronous Programs with Local Declarations.” Electronic Notes in Theoretical Computer Science 153 (4): 71–97. https://doi.org/10.1016/j.entcs.2006.02.028
• Schoeberl, Martin, Wolfgang Puffitsch, Rasmus Ulslev Pedersen, and Benedikt Huber. 2010. “Worst-Case Execution Time Analysis for a Java Processor.” Software: Practice and Experience 40 (6): 507–42. https://doi.org/10.1002/spe.968
• Schoenberger, Daniel, Stefan Hillmich, Matthias Brand, and Robert Wille. 2024. “Using Compiler Frameworks for the Evaluation of Hardware Design Choices in Trapped-Ion Quantum Computers.” In 2024 IEEE International Conference on Quantum Computing and Engineering (QCE). IEEE. https://doi.org/10.1109/qce60285.2024.00129
• Schuiki, Fabian, Andreas Kurth, Tobias Grosser, and Luca Benini. 2020. “LLHD: A Multi-Level Intermediate Representation for Hardware Description Languages.” In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3385412.3386024
• Schuster, Philipp, Jonathan Immanuel Brachthäuser, Marius Müller, and Klaus Ostermann. 2022. “A Typed Continuation-Passing Translation for Lexical Effect Handlers.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523710
• Schuster, Philipp, Jonathan Immanuel Brachthäuser, and Klaus Ostermann. 2020. “Compiling Effect Handlers in Capability-Passing Style.” Proceedings of the ACM on Programming Languages 4 (ICFP): 1–28. https://doi.org/10.1145/3408975
• Schwarz, Tobias, Tobias Kamm, and Alexis Engelke. 2026. “TPDE: A Fast Adaptable Compiler Back-End Framework.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395208
• Seassau, Remy, Irene Yoon, Jean-Marie Madiot, and François Pottier. 2025. “Formal Semantics and Program Logics for a Fragment of OCaml.” Proceedings of the ACM on Programming Languages 9 (ICFP): 128–59. https://doi.org/10.1145/3747509
• Segura, J. J. 2026. “Algebraic Effects for Bounded Prompt Pipelines: Lawvere Theories, Handlers, and Outcome Traces.” Computing 108 (7): 107. https://doi.org/10.1007/s00607-026-01699-w
• Seidler, Maximilian, Martin Michelis, Peter Wägemann, and Rüdiger Kapitza. 2026. “Wasm-WCET: Worst-Case Execution-Time Analysis of WebAssembly Modules on Updatable Resource-Constrained Embedded Devices.” In 2026 IEEE 32nd Real-Time and Embedded Technology and Applications Symposium (RTAS). IEEE. https://doi.org/10.1109/rtas68450.2026.00024
• Sekiyama, Taro, and Hiroshi Unno. 2023. “Temporal Verification with Answer-Effect Modification: Dependent Temporal Type-and-Effect System with Delimited Continuations.” Proceedings of the ACM on Programming Languages 7 (POPL): 2079–2110. https://doi.org/10.1145/3571264
• Seo, Yongjin, and Hyeon Soo Kim. 2016b. “Operator-Data Type Pair Based Execution Environments Independent Worst-Case Execution Time Measuring Method.” In 2016 IEEE/ACIS 15th International Conference on Computer and Information Science (ICIS). IEEE. https://doi.org/10.1109/icis.2016.7550831
• Serrano, Manuel. 2021. “Of JavaScript AOT Compilation Performance.” Proceedings of the ACM on Programming Languages 5 (ICFP): 1–30. https://doi.org/10.1145/3473575
• Sethi, Ravi. 1982. “Control Flow Aspects of Semantics Directed Compiling (Summary).” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806999
• Sewell, Thomas Arthur Leck, Magnus O. Myreen, and Gerwin Klein. 2013. “Translation Validation for a Verified OS Kernel.” In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2491956.2462183
• Seyfer, Harlan K. 1982. “Tailoring Testing to a Specific Compiler—Experiences.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806990
• Shaikhha, Amir, Mathieu Huot, and Shideh Hashemian. 2024. “A Tensor Algebra Compiler for Sparse Differentiation.” In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo57630.2024.10444787
• Shan, Chung-chieh. 2007. “A Static Simulation of Dynamic Delimited Control.” Higher-Order and Symbolic Computation 20 (4): 371–401. https://doi.org/10.1007/s10990-007-9010-4
• Shannon, C. E. 1948. “A Mathematical Theory of Communication.” Bell System Technical Journal 27 (4): 623–56. https://doi.org/10.1002/j.1538-7305.1948.tb00917.x
• Sharif, Uzair, Daniel Mueller-Gritschneder, and Ulf Schlichtmann. 2022. “COMPAS: Compiler-Assisted Software-Implemented Hardware Fault Tolerance for RISC-V.” In 2022 11th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco55406.2022.9797144
• Sharma, Kavita, and S. R. N. Reddy. 2025. “Analysis of FreeRTOS and Contiki Scheduler Performance with Scalable Task Loads on a Uniform Platform.” In 2025 International Conference on Emerging Technologies in Electronics and Green Energy (ICETEG). IEEE. https://doi.org/10.1109/iceteg66194.2025.11473223
• Sheinidashtegol, Pezhman, and Michael Galloway. 2017. “Performance Impact of DDoS Attacks on Three Virtual Machine Hypervisors.” In 2017 IEEE International Conference on Cloud Engineering (IC2E). IEEE. https://doi.org/10.1109/ic2e.2017.18
• Sheth, Viral, and Kostadin Damevski. 2022. “Grouping Related Stack Overflow Comments for Software Developer Recommendation.” Automated Software Engineering 29 (2): 40. https://doi.org/10.1007/s10515-022-00339-9
• Shih, Timothy K. 1998. “An Operational Semantic Approach to Continuation Style Interpreter of Logic Programs.” Information Sciences 107 (1–4): 15–36. https://doi.org/10.1016/s0020-0255(97)10040-8
• Shih, Ruey-Chyuan, and Wen-Chi Chen. 1996. “Iterative Pre-Stack Depth Migration with Velocity Analysis.” Terrestrial, Atmospheric and Oceanic Sciences 7 (2): 149. https://doi.org/10.3319/tao.1996.7.2.149(t)
• Shiina, Shumpei, Shintaro Iwasaki, Kenjiro Taura, and Pavan Balaji. 2021. “Lightweight Preemptive User-Level Threads.” In Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. ACM. https://doi.org/10.1145/3437801.3441610
• Shimchik, N. V., V. N. Ignatyev, and A. A. Belevantsev. 2021. “Improving Accuracy and Completeness of Source Code Static Taint Analysis.” In 2021 Ivannikov Ispras Open Conference (ISPRAS). IEEE. https://doi.org/10.1109/ispras53967.2021.00014
• Shivers, Olin. 1991. “The Semantics of Scheme Control-Flow Analysis.” In Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation - PEPM ‘91. ACM Press. https://doi.org/10.1145/115865.115884
• Shobaki, Ghassan, Justin Bassett, Mark Heffernan, and Austin Kerbow. 2022. “Graph Transformations for Register-Pressure-Aware Instruction Scheduling.” In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3497776.3517771
• Sholihin, Andi, and Shintami Chusnul Hidayati. 2024. “A Forward Chaining Expert System for Personalized Programming Language Selection.” In 2024 International Conference on Innovation and Intelligence for Informatics, Computing, and Technologies (3ICT). IEEE. https://doi.org/10.1109/3ict64318.2024.10824631
• Shoushtary, Mojtaba Abaie, Jose Maria Arnau, Jordi Tubella Murgadas, and Antonio Gonzalez. 2024. “Memento: An Adaptive, Compiler-Assisted Register File Cache for GPUs.” In 2024 ACM/IEEE 51st Annual International Symposium on Computer Architecture (ISCA). IEEE. https://doi.org/10.1109/isca59077.2024.00075
• Sianipar, Johannes, Christian Willems, and Christoph Meinel. 2018. “Virtual Machine Integrity Verification in Crowd-Resourcing Virtual Laboratory.” In 2018 IEEE 11th Conference on Service-Oriented Computing and Applications (SOCA). IEEE. https://doi.org/10.1109/soca.2018.00032
• Silva, Lucas, José Metrôlho, and Fernando Ribeiro. 2024. “Efficient Data Exchange between WebAssembly Modules.” Future Internet 16 (9): 341. https://doi.org/10.3390/fi16090341
• Simon, Hendrik, and Stefan Kowalewski. 2016. “Static Analysis of Sequential Function Charts Using Abstract Interpretation.” In 2016 IEEE 21st International Conference on Emerging Technologies and Factory Automation (ETFA). IEEE. https://doi.org/10.1109/etfa.2016.7733648
• Simonnet, Julien, Matthieu Lemerre, and Mihaela Sighireanu. 2024. “A Dependent Nominal Physical Type System for Static Analysis of Memory in Low Level Code.” Proceedings of the ACM on Programming Languages 8 (OOPSLA2): 30–59. https://doi.org/10.1145/3689712
• Sites, Richard L. 1979. “Machine-Independent Register Allocation.” In Proceedings of the 1979 SIGPLAN symposium on Compiler construction - SIGPLAN ‘79. ACM Press. https://doi.org/10.1145/800229.806973
• Sivaramakrishnan, Kc, Stephen Dolan, Leo White, Tom Kelly, Sadiq Jaffer, and Anil Madhavapeddy. 2021. “Retrofitting Effect Handlers onto OCaml.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454039
• Siveroni, Igor A. 2004. “Operational Semantics of the Java Card Virtual Machine.” Journal of Logic and Algebraic Programming 58 (1–2): 3–25. https://doi.org/10.1016/j.jlap.2003.07.003
• Skarman, Frans, Lucas Klemmer, Oscar Gustafsson, and Daniel Große. 2023. “Enhancing Compiler-Driven HDL Design with Automatic Waveform Analysis.” In 2023 Forum on Specification & Design Languages (FDL). IEEE. https://doi.org/10.1109/fdl59689.2023.10272204
• Smith, Michael D., Norman Ramsey, and Glenn Holloway. 2004. “A Generalized Algorithm for Graph-Coloring Register Allocation.” ACM SIGPLAN Notices 39 (6): 277–88. https://doi.org/10.1145/996893.996875
• Smith, Scott, and Robert Zhang. 2024. “A Pure Demand Operational Semantics with Applications to Program Analysis.” Proceedings of the ACM on Programming Languages 8 (OOPSLA1): 1154–80. https://doi.org/10.1145/3649852
• Sohrabi, Mohammad Karim, Vahid Ghods, and Seyed Yahya Zahedi Fard. 2018. “A Novel Virtual Machine Selection Policy for Virtual Machine Consolidation.” In 2018 6th International Symposium on Computational and Business Intelligence (ISCBI). IEEE. https://doi.org/10.1109/iscbi.2018.00016
• Soleimani, Mehrdad, and Morteza Balarostaghi. 2016. “Seismic Image Enhancement in Post Stack Depth Migration by Finite Offset CDS Stack Method.” Journal of Petroleum Exploration and Production Technology 6 (4): 605–15. https://doi.org/10.1007/s13202-016-0235-9
• Somani, Antariksh, and Swati Srivastava. 2019. “Implementation of SAAS Intranet Compiler in PHP.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.3366275
• Souha, Adnane, Charaf Ouaddi, Lamya Benaddi, and Abdeslam Jakimi. 2025. “Modeling and Automated Code Generation of the Backend of Tourism Applications.” In 2025 12th International Conference on Wireless Networks and Mobile Communications (WINCOM). IEEE. https://doi.org/10.1109/wincom65874.2025.11313419
• Spivey, Michael. 2017. “Faster Coroutine Pipelines.” Proceedings of the ACM on Programming Languages 1 (ICFP): 1–23. https://doi.org/10.1145/3110249
• Squar, Jannek, Tim Jammer, Michael Blesel, Michael Kuhn, and Thomas Ludwig. 2020. “Compiler Assisted Source Transformation of OpenMP Kernels.” In 2020 19th International Symposium on Parallel and Distributed Computing (ISPDC). IEEE. https://doi.org/10.1109/ispdc51135.2020.00016
• Squire, Megan, and Christian Funkhouser. 2014. “‘A Bit of Code’: How the Stack Overflow Community Creates Quality Postings.” In 2014 47th Hawaii International Conference on System Sciences. IEEE. https://doi.org/10.1109/hicss.2014.185
• Srinivasan, Venkatesh, and Thomas Reps. 2015. “Synthesis of Machine Code from Semantics.” In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2737924.2737960
• Stanisic, Luka, Samuel Thibault, Arnaud Legrand, Brice Videau, and Jean-François Méhaut. 2015. “Faithful Performance Prediction of a Dynamic Task-Based Runtime System for Heterogeneous Multi-Core Architectures.” Concurrency and Computation: Practice and Experience 27 (16): 4075–90. https://doi.org/10.1002/cpe.3555
• Stappert, Friedhelm, and Peter Altenbernd. 2000. “Complete Worst-Case Execution Time Analysis of Straight-Line Hard Real-Time Programs.” Journal of Systems Architecture 46 (4): 339–55. https://doi.org/10.1016/s1383-7621(99)00010-7
• Stata, Raymie, and Martín Abadi. 1998. “A Type System for Java Bytecode Subroutines.” In Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘98. ACM Press. https://doi.org/10.1145/268946.268959
• Steingartner, William. 2021. “Compiler Module of Abstract Machine Code for Formal Semantics Course.” In 2021 IEEE 19th World Symposium on Applied Machine Intelligence and Informatics (SAMI). IEEE. https://doi.org/10.1109/sami50585.2021.9378696
• Stepanov, Daniil, Marat Akhin, and Mikhail Belyaev. 2021. “Type-Centric Kotlin Compiler Fuzzing: Preserving Test Program Correctness by Preserving Types.” In 2021 14th IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst49551.2021.00044
• Stöhr, E. A., and M. F. P. O’Boyle. 1998. “First Fast Sink: A Compiler Algorithm for Barrier Placement Optimisation.” Future Generation Computer Systems 13 (4–5): 397–406. https://doi.org/10.1016/s0167-739x(97)00040-x
• Strachey, Christopher, and Christopher P. Wadsworth. (1974) 2000. “Continuations: A Mathematical Semantics for Handling Full Jumps.” Higher-Order and Symbolic Computation 13 (1–2): 135–52. https://doi.org/10.1023/a:1010026413531
• “A Structural Approach to Operational Semantics.” 2004. Journal of Logic and Algebraic Programming 60-61: 17–139. https://doi.org/10.1016/j.jlap.2004.05.001
• Su, Xing, Xiangke Liao, and Jingling Xue. 2017. “Automatic Generation of Fast BLAS3-GEMM: A Portable Compiler Approach.” In 2017 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2017.7863734
• Subha, S. 2009. “A Modified Linear Scan Register Allocation Algorithm.” In 2009 Sixth International Conference on Information Technology: New Generations. IEEE. https://doi.org/10.1109/itng.2009.90
• Subha, S. 2010. “A Register Allocation Algorithm.” In 2010 IEEE International Conference on Electro/Information Technology. IEEE. https://doi.org/10.1109/eit.2010.5612127
• Suchy, Brian, Simone Campanoni, Nikos Hardavellas, and Peter Dinda. 2020. “CARAT: A Case for Virtual Memory through Compiler- and Runtime-Based Address Translation.” In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3385412.3385987
• Suetterlein, Joshua, Joseph Manzano, Andres Marquez, and Guang R. Gao. 2022. “Extending an Asynchronous Runtime System for High Throughput Applications: A Case Study.” Journal of Parallel and Distributed Computing 163: 214–31. https://doi.org/10.1016/j.jpdc.2022.01.027
• Suganuma, Toshio, Toshiaki Yasue, and Toshio Nakatani. 2003. “A Region-Based Compilation Technique for a Java Just-in-Time Compiler.” In Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/781131.781166
• Sun, Chengnian, Vu Le, and Zhendong Su. 2016a. “Finding Compiler Bugs via Live Code Mutation.” ACM SIGPLAN Notices 51 (10): 849–63. https://doi.org/10.1145/3022671.2984038
• Sun, Simin, and Miroslaw Staron. 2026. “Agentic Pipelines in Embedded Software Engineering: Emerging Practices and Challenges.” In 2026 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner67736.2026.00024
• Sun, Xin, Ming Zhong, Lulin Wang, Fang Lv, and Xianbo He. 2025b. “Automating Target Description Processing for Efficient Compiler Backend Development.” In 2025 International Conference on Electrical, Control and Artificial Intelligence (ICOECAI). IEEE. https://doi.org/10.1109/icoecai67333.2025.11335621
• Susca, Mircea, Vlad Mihaly, Dora Morar, and Petru Dobra. 2022. “Worst-Case Execution Time Estimation for Numerical Controllers.” In 2022 IEEE International Conference on Automation, Quality and Testing, Robotics (AQTR). IEEE. https://doi.org/10.1109/aqtr55203.2022.9802027
• Suwa, Takashi, Takeshi Tsukada, Naoki Kobayashi, and Atsushi Igarashi. 2017. “Verification of Code Generators via Higher-Order Model Checking.” In Proceedings of the 2017 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3018882.3018886
• Swillus, Mark, and Andy Zaidman. 2023. “Sentiment Overflow in the Testing Stack: Analyzing Software Testing Posts on Stack Overflow.” Journal of Systems and Software 205: 111804. https://doi.org/10.1016/j.jss.2023.111804
• Syme, Don, Tomas Petricek, and Dmitry Lomov. 2011. “The F# Asynchronous Programming Model.” In Practical Aspects of Declarative Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-18378-2_15
• Tabassam, Nadra, and Roman Obermaisser. 2017. “Class-Based Query-Optimization for Minimizing Worst-Case Execution Times of Diagnostic Queries in Embedded Real-Time Systems.” In 2017 IEEE 15th International Conference on Industrial Informatics (INDIN). IEEE. https://doi.org/10.1109/indin.2017.8104849
• Taft, S. Tucker. 2024. “Sound and Precise Static Analysis Using a Generalization of Static Single Assignment and Value Numbering.” International Journal on Software Tools for Technology Transfer 26 (5): 621–32. https://doi.org/10.1007/s10009-024-00762-1
• Tahat, Amer, Sarang Joshi, Pronnoy Goswami, and Binoy Ravindran. 2019. “Scalable Translation Validation of Unverified Legacy OS Code.” In 2019 Formal Methods in Computer Aided Design (FMCAD). IEEE. https://doi.org/10.23919/fmcad.2019.8894252
• Takase, Hideki, Tomoya Mori, Kazuyoshi Takagi, and Naofumi Takagi. 2018. “Work-in-Progress: Design Concept of a Lightweight Runtime Environment for Robot Software Components onto Embedded Devices.” In 2018 International Conference on Embedded Software (EMSOFT). IEEE. https://doi.org/10.1109/emsoft.2018.8537199
• Talaat, Mohamed Gamal, Mostafa Hassan, Mohamed Sayed, Mohanad Mohamed, and Islam Ahmed. 2025. “GrammLLM: Grammar-Guided LLM Test Generation for Compiler Validation.” In 2025 37th International Conference on Microelectronics (ICM). IEEE. https://doi.org/10.1109/icm66518.2025.11322450
• Talamali, Ibtissem, Razika Lounas, and Mohamed Mezghiche. 2024. “Formal Specification and Verification of MQTT Protocol Using CoQ Proof Assistant.” In 2024 International Conference on Advanced Aspects of Software Engineering (ICAASE). IEEE. https://doi.org/10.1109/icaase64542.2024.10850926
• Tamura, Raiki, Daisuke Kotani, Kazuyuki Shudo, and Yasuo Okabe. 2025. “Bringing Together Cross-ISA Checkpoint/Restoration and AOT Compilation of WebAssembly Programs.” In Proceedings of the 22nd ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3759426.3760985
• Tan, Lili. 2009. “The Worst-Case Execution Time Tool Challenge 2006.” International Journal on Software Tools for Technology Transfer 11 (2): 133–52. https://doi.org/10.1007/s10009-008-0095-9
• Tan, Chengsong, Alastair F. Donaldson, Jonathan Julián Huerta y Munive, and John Wickerson. 2025. “The Burden of Proof: Automated Tooling for Rapid Iteration on Large Mechanised Proofs.” In 2025 IEEE/ACM 13th International Conference on Formal Methods in Software Engineering (FormaliSE). IEEE. https://doi.org/10.1109/formalise66629.2025.00010
• Tan, Yong Kiam, Magnus O. Myreen, Ramana Kumar, Anthony Fox, Scott Owens, and Michael Norrish. 2016. “A New Verified Compiler Backend for CakeML.” ACM SIGPLAN Notices 51 (9): 60–73. https://doi.org/10.1145/3022670.2951924
• Tang, Yixuan, Zhilei Ren, Weiqiang Kong, and He Jiang. 2019. “Compiler Testing: A Systematic Literature Analysis.” Frontiers of Computer Science 14 (1): 1–20. https://doi.org/10.1007/s11704-019-8231-0
• Tang, Feilong, Ilsun You, Minyi Guo, Song Guo, and Long Zheng. 2010. “Balanced Bipartite Graph Based Register Allocation for Network Processors in Mobile and Wireless Networks.” Mobile Information Systems 6 (1): 65–83. https://doi.org/10.1155/2010/986192
• Tang, Yixuan, Junwei Zeng, Jingxuan Zhang, Weiwei Li, and Zhiqiu Huang. 2025. “CTDip: A Diversity-Guided Test Program Synthesis Approach for Boosting Compiler Bug Detection.” Empirical Software Engineering 30 (3): 88. https://doi.org/10.1007/s10664-025-10642-0
• Tant, Yiming, Aditya Diwakar, Jason Jagielo, and Vincent Mooney. 2023. “Software Compilation Using FPGA Hardware: Register Allocation.” In 2023 12th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco58584.2023.10155001
• Tao, Qiuming, Wei Wu, Chen Zhao, and Wuwei Shen. 2010. “An Automatic Testing Approach for Compiler Based on Metamorphic Testing Technique.” In 2010 Asia Pacific Software Engineering Conference. IEEE. https://doi.org/10.1109/apsec.2010.39
• Tardieu, Olivier. 2014. “Session Details: Compiler Optimizations.” In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3251064
• Tatsuoka, Masato, and Mineo Kaneko. 2018. “Wire Congestion Aware High Level Synthesis Flow with Source Code Compiler.” In 2018 International Conference on IC Design & Technology (ICICDT). IEEE. https://doi.org/10.1109/icicdt.2018.8399766
• Tempel, Soren, Vladimir Herdt, and Rolf Drechsler. 2021. “Towards Reliable Spatial Memory Safety for Embedded Software by Combining Checked C with Concolic Testing.” In 2021 58th ACM/IEEE Design Automation Conference (DAC). IEEE. https://doi.org/10.1109/dac18074.2021.9586170
• ten Hagen, Klaus, Dirk Steinberg, and Heinrich Meyr. 1996. “Codesign of a Parallel Architecture and an Optimizing Compiler Backend: SIN Rete Processing as a Case Study.” Design Automation for Embedded Systems 1 (1–2): 147–76. https://doi.org/10.1007/bf00134686
• Terci, Gizem Süngü. 2023. “A Learning-Based Coloring Algorithm for Register Allocation Problem.” In 2023 31st Signal Processing and Communications Applications Conference (SIU). IEEE. https://doi.org/10.1109/siu59756.2023.10223961
• Thielecke, Hayo. 2003. “From Control Effects to Typed Continuation Passing.” ACM SIGPLAN Notices 38 (1): 139–49. https://doi.org/10.1145/640128.604144
• Thiselton, Emillie, and Christoph Treude. 2019. “Enhancing Python Compiler Error Messages via Stack.” In 2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). IEEE. https://doi.org/10.1109/esem.2019.8870155
• Thomas, Jay, Ehsan Salehi, Alex Lim, and Stephen Di Camillo. 2024. “Analyzing Data Flow and Control Flow of Multicore Software: A Solution for Efficient Worst-Case Execution Time Analysis.” In 2024 AIAA DATC/IEEE 43rd Digital Avionics Systems Conference (DASC). IEEE. https://doi.org/10.1109/dasc62030.2024.10749649
• Tian, Xiaonan, Dounia Khaldi, Deepak Eachempati, Rengan Xu, and Barbara Chapman. 2016. “Optimizing GPU Register Usage: Extensions to OpenACC and Compiler Optimizations.” In 2016 45th International Conference on Parallel Processing (ICPP). IEEE. https://doi.org/10.1109/icpp.2016.72
• Tian, Zhenzhou, Fanfan Wang, Yanping Chen, and Lingwei Chen. 2024. “Differential Testing Solidity Compiler through Deep Contract Manipulation and Mutation.” Software Quality Journal 32 (2): 765–90. https://doi.org/10.1007/s11219-024-09673-5
• Tillet, Philippe, H. T. Kung, and David Cox. 2019. “Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations.” In Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages. ACM. https://doi.org/10.1145/3315508.3329973
• Tine, Blaise-Pascal, Sudhakar Yalamanchili, Hyesoon Kim, and Jeff Vetter. 2019. “POSTER: Tango: An Optimizing Compiler for Just-In-Time RTL Simulation.” In 2019 28th International Conference on Parallel Architectures and Compilation Techniques (PACT). IEEE. https://doi.org/10.1109/pact.2019.00055
• Tirichine, Mohammed, Nassim Ameur, Nazim Bendib, et al. 2026. “A Reinforcement Learning Environment for Automatic Code Optimization in the MLIR Compiler.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11394838
• Titzer, Ben L. 2024. “Whose Baseline Compiler Is It Anyway?” In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo57630.2024.10444855
• Todoran, Eneia Nicolae. 2020. “Metric Semantics for Concurrent Languages Designed in Continuation-Passing Style.” In 2020 IEEE 16th International Conference on Intelligent Computer Communication and Processing (ICCP). IEEE. https://doi.org/10.1109/iccp51029.2020.9266182
• Todoran, Eneia Nicolae, and Gabriel Ciobanu. 2025. “Metric Continuation-Passing Semantics for Multiparty Interactions.” In 2025 27th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC). IEEE. https://doi.org/10.1109/synasc69064.2025.00028
• Tohid, R., Bibek Wagle, Shahrzad Shirzad, et al. 2018. “Asynchronous Execution of Python Code on Task-Based Runtime Systems.” In 2018 IEEE/ACM 4th International Workshop on Extreme Scale Programming Models and Middleware (ESPM2). IEEE. https://doi.org/10.1109/espm2.2018.00009
• Tokumoto, Susumu, Hiroaki Yoshida, Kazunori Sakamoto, and Shinichi Honiden. 2016. “MuVM: Higher Order Mutation Analysis Virtual Machine for C.” In 2016 IEEE International Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst.2016.18
• Touzeau, Roy F. 1984. “A Fortran Compiler for the FPS-164 Scientific Computer.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502879
• Trifanov, Alexandru, and Tom Schrijvers. 2026. “Staging Effect Handlers for Modular Search.” In Proceedings of the 2026 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3779209.3779536
• Truong, Leonard, Rajkishore Barik, Ehsan Totoni, et al. 2016. “Latte: A Language, Compiler, and Runtime for Elegant and Efficient Deep Neural Networks.” In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2908080.2908105
• Tsuyama, Syouki, Youyou Cong, and Hidehiko Masuhara. 2024. “An Intrinsically Typed Compiler for Algebraic Effect Handlers.” In Proceedings of the 2024 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3635800.3636968
• Tu, Haoxin, He Jiang, Xiaochen Li, Zhilei Ren, Zhide Zhou, and Lingxiao Jiang. 2022. “Remgen: Remanufacturing a Random Program Generator for Compiler Testing.” In 2022 IEEE 33rd International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre55969.2022.00057
• Tu, Haoxin, He Jiang, Zhide Zhou, et al. 2023. “Detecting C++ Compiler Front-End Bugs via Grammar Mutation and Differential Testing.” IEEE Transactions on Reliability 72 (1): 343–57. https://doi.org/10.1109/tr.2022.3171220
• “Tutorial on SSA-Based Register Allocation.” 2009. In 2009 International Symposium on Code Generation and Optimization. IEEE. https://doi.org/10.1109/cgo.2009.46
• Uddin, Gias, Foutse Khomh, and Chanchal K. Roy. 2020. “Mining API Usage Scenarios from Stack Overflow.” Information and Software Technology 122: 106277. https://doi.org/10.1016/j.infsof.2020.106277
• Ueno, Katsuhiro, and Atsushi Ohori. 2022. “Concurrent and Parallel Garbage Collection for Lightweight Threads on Multicore Processors.” In Proceedings of the 2022 ACM SIGPLAN International Symposium on Memory Management. ACM. https://doi.org/10.1145/3520263.3534652
• Uh, Gang-Ryung. 2003. “Session Details: Compiler Optimizations.” In Proceedings of the 2003 ACM SIGPLAN conference on Language, compiler, and tool for embedded systems. ACM. https://doi.org/10.1145/3244027
• Upadhyaya, Ganesha, and Hridesh Rajan. 2015. “Effectively Mapping Linguistic Abstractions for Message-Passing Concurrency to Threads on the Java Virtual Machine.” In Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications. ACM. https://doi.org/10.1145/2814270.2814289
• Urban, Caterina, Pavle Subotić, and Filip Drobnjaković. 2025. “Static Analysis by Abstract Interpretation against Data Leakage in Machine Learning.” Science of Computer Programming 246: 103338. https://doi.org/10.1016/j.scico.2025.103338
• Utting, Mark, Brae J. Webb, and Ian J. Hayes. 2023. “Differential Testing of a Verification Framework for Compiler Optimizations (Case Study).” In 2023 IEEE/ACM 11th International Conference on Formal Methods in Software Engineering (FormaliSE). IEEE. https://doi.org/10.1109/formalise58978.2023.00015
• Valiron, Benoît. 2022. “Semantics of Quantum Programming Languages: Classical Control, Quantum Control.” Journal of Logical and Algebraic Methods in Programming 128: 100790. https://doi.org/10.1016/j.jlamp.2022.100790
• van Deursen, Arie. 1999. “Modern Compiler Implementation in Java.” Science of Computer Programming 34 (2): 159–61. https://doi.org/10.1016/s0167-6423(99)00003-9
• van Rooij, Orpheas, and Robbert Krebbers. 2025. “Affect: An Affine Type and Effect System.” Proceedings of the ACM on Programming Languages 9 (POPL): 126–54. https://doi.org/10.1145/3704841
• Vandercammen, Maarten, Stefan Marr, and Coen De Roover. 2018. “A Flexible Framework for Studying Trace-Based Just-in-Time Compilation.” Computer Languages, Systems & Structures 51: 22–47. https://doi.org/10.1016/j.cl.2017.07.005
• Velazquez-Rodriguez, Camilo, Eleni Constantinou, and Coen De Roover. 2022. “Uncovering Library Features from API Usage on Stack Overflow.” In 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner53432.2022.00035
• VenkataKeerthy, S., Siddharth Jain, Anilava Kundu, Rohit Aggarwal, Albert Cohen, and Ramakrishna Upadrasta. 2023. “RL4ReAl: Reinforcement Learning for Register Allocation.” In Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3578360.3580273
• Ventovaara, Marcus, Arman Hasanbegovic, Jimmie Wiklandert, and Saad Mubeen. 2020. “Worst-Case Execution Time Estimation of Legacy Vehicular Embedded Functions: An Industrial Case Study.” In 2020 IEEE International Conference on Industrial Technology (ICIT). IEEE. https://doi.org/10.1109/icit45562.2020.9067160
• Vepuri, Nikhil, and Xunfei Jiang. 2023. “Performance Analysis of Virtual Machine Monitoring System.” In 2023 IEEE Green Energy and Smart Systems Conference (IGESSC). IEEE. https://doi.org/10.1109/igessc59090.2023.10321757
• Verdejo, Alberto, and Narciso Martí-Oliet. 2006. “Executable Structural Operational Semantics in Maude.” Journal of Logic and Algebraic Programming 67 (1–2): 226–93. https://doi.org/10.1016/j.jlap.2005.09.008
• Verma, Shubham, Harpreet Kaur, Marius Pirvu, and Kenneth B. Kent. 2023. “Array Bytecode Support in MicroJIT.” In Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3623507.3623557
• Vizcaino, Pablo, Filippo Mantovani, Roger Ferrer, and Jesus Labarta. 2022. “Acceleration with Long Vector Architectures: Implementation and Evaluation of the FFT Kernel on NEC SX-Aurora and RISC-V Vector Extension.” Concurrency and Computation: Practice and Experience 35 (20): e7424. https://doi.org/10.1002/cpe.7424
• Voigt, David, Philipp Schuster, and Jonathan Immanuel Brachthäuser. 2025. “Dynamic Wind for Effect Handlers.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 2927–53. https://doi.org/10.1145/3763155
• Vu, Thuy Duong. 2008. “Denotational Semantics for Thread Algebra.” Journal of Logic and Algebraic Programming 74 (2): 94–111. https://doi.org/10.1016/j.jlap.2007.05.002
• Wall, David W. 1986. “Global Register Allocation at Link Time.” In Proceedings of the 1986 SIGPLAN symposium on Compiler construction. ACM. https://doi.org/10.1145/12276.13338
• Wall, D. W. 1988. “Register Windows vs. Register Allocation.” ACM SIGPLAN Notices 23 (7): 67–78. https://doi.org/10.1145/960116.53997
• Wall, David W. 2004. “Register Windows vs. Register Allocation.” ACM SIGPLAN Notices 39 (4): 270–82. https://doi.org/10.1145/989393.989422
• Wang, Yingjie. 2017. “Research on the Execution Time Analysis Technology of the Worst Case System in Real Time System.” In 2017 9th International Conference on Measuring Technology and Mechatronics Automation (ICMTMA). IEEE. https://doi.org/10.1109/icmtma.2017.0102
• Wang, Zhaoyang. 2019. “Web Crawler Scheduler Based on Coroutine.” In 2019 International Conference on Intelligent Computing, Automation and Systems (ICICAS). IEEE. https://doi.org/10.1109/icicas48597.2019.00118
• Wang, Zicheng. 2021a. “Can “Micro VM” Become the Next Generation Computing Platform?: Performance Comparison between Light Weight Virtual Machine, Container, and Traditional Virtual Machine.” In 2021 IEEE International Conference on Computer Science, Artificial Intelligence and Electronic Engineering (CSAIEE). IEEE. https://doi.org/10.1109/csaiee54046.2021.9543457
• Wang, Wenwen. 2021b. “Helper Function Inlining in Dynamic Binary Translation.” In Proceedings of the 30th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3446804.3446851
• Wang, Sumei. 2024. “Worst-Case Blocking Time Optimization in WCRT Analysis for vMPCP on Multi-Core Virtual Machines.” IEEE Access 12: 118427–41. https://doi.org/10.1109/access.2024.3432811
• Wang, Haoyu, Junjie Chen, Chuyue Xie, et al. 2023d. “MLIRSmith: Random Program Generation for Fuzzing MLIR Compiler Infrastructure.” In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE. https://doi.org/10.1109/ase56229.2023.00120
• Wang, Arne, and Ole-Johan Dahl. 1971. “Coroutine Sequencing in a Block Structured Environment.” BIT 11 (4): 425–49. https://doi.org/10.1007/bf01939412
• Wang, Zhu, Zonghua Gu, and Zili Shao. 2015. “WCET-Aware Energy-Efficient Data Allocation on Scratchpad Memory for Real-Time Embedded Systems.” IEEE Transactions on Very Large Scale Integration (VLSI) Systems 23 (11): 2700–2704. https://doi.org/10.1109/tvlsi.2014.2379635
• Wang, Shiyu, Lin Han, Mengyao Chen, and Haoran Li. 2025. “Research on Compiler Fuzzing Based on Syntax-Semantics Dual-Dimensional Classification.” In 2025 5th International Conference on Electronic Information Engineering and Computer Communication (EIECC). IEEE. https://doi.org/10.1109/eiecc67963.2025.11409518
• Wang, Xinyuan, and Hejiao Huang. 2022a. “SGPM: A Coroutine Framework for Transaction Processing.” Parallel Computing 114: 102980. https://doi.org/10.1016/j.parco.2022.102980
• Wang, Yiqun, Hongyang Jia, Yongpan Liu, Qing’an Li, Chun Jason Xue, and Huazhong Yang. 2014. “Register Allocation for Hybrid Register Architecture in Nonvolatile Processors.” In 2014 IEEE International Symposium on Circuits and Systems (ISCAS). IEEE. https://doi.org/10.1109/iscas.2014.6865319
• Wang, Qian, and Ralf Jung. 2024. “Rustlantis: Randomized Differential Testing of the Rust Compiler.” Proceedings of the ACM on Programming Languages 8 (OOPSLA2): 1955–81. https://doi.org/10.1145/3689780
• Wang, Lulu, Jingyue Li, and Bixin Li. 2019b. “Tracking Runtime Concurrent Dependences in Java Threads Using Thread Control Profiling.” Journal of Systems and Software 148: 116–31. https://doi.org/10.1016/j.jss.2018.11.003
• Wang, Mengxuan, Yuan Linghu, and Chang Wu. 2023c. “A General-Purpose Compiler Design for Instruction-Based AI Accelerator Implementation.” In 2023 IEEE 15th International Conference on ASIC (ASICON). IEEE. https://doi.org/10.1109/asicon58565.2023.10396051
• Wang, Bowen, Kangjie Lu, Qiushi Wu, and Aditya Pakki. 2022. “Unleashing Coveraged-Based Fuzzing through Comprehensive, Efficient, and Faithful Exploitable-Bug Exposing.” IEEE Transactions on Dependable and Secure Computing 19 (5): 2998–3010. https://doi.org/10.1109/tdsc.2021.3079857
• Wang, Yang, Zeyu Lu, Beining Wu, Yibiao Yang, Hongmin Lu, and Yuming Zhou. 2026. “Random Test Generators Demystified: Differences and Potential for Compiler Reliability.” Science of Computer Programming 247: 103359. https://doi.org/10.1016/j.scico.2025.103359
• Wang, Shengyi, Zongyan Qiu, Shengchao Qin, and Wei-Ngan Chin. 2010. “Stack Bound Inference for Abstract Java Bytecode.” In 2010 4th IEEE International Symposium on Theoretical Aspects of Software Engineering. IEEE. https://doi.org/10.1109/tase.2010.24
• Wang, Xuhao, Qingni Shen, Wu Luo, and Pengfei Wu. 2020. “RSDS: Getting System Call Whitelist for Container through Dynamic and Static Analysis.” In 2020 IEEE 13th International Conference on Cloud Computing (CLOUD). IEEE. https://doi.org/10.1109/cloud49709.2020.00089
• Wang, Jyh-Shian, I-Wei Wu, Yu-Sheng Chen, Jean Jyh-Jiun Shann, and Wei-Chung Hsu. 2009. “Reducing Code Size by Graph Coloring Register Allocation and Assignment Algorithm for Mixed-Width ISA Processor.” In 2009 International Conference on Computational Science and Engineering. IEEE. https://doi.org/10.1109/cse.2009.100
• Wang, Yanzhao, Fei Xie, Zhenkun Yang, Jeremy Casas, Pasquale Cocchini, and Jin Yang. 2023a. “An Automated Verification Framework for HalideIR-Based Compiler Transformations.” In 2023 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE. https://doi.org/10.23919/date56975.2023.10137308
• Wang, Wei, Liqing Zhang, Dong Guo, Shaoling Wu, Haibo Cui, and Fenglin Bi. 2019a. “Reg: An Ultra-Lightweight Container That Maximizes Memory Sharing and Minimizes the Runtime Environment.” In 2019 IEEE International Conference on Web Services (ICWS). IEEE. https://doi.org/10.1109/icws.2019.00024
• Wang, Yue, Zhide Zhou, Zhilei Ren, Dong Liu, and He Jiang. 2023b. “A Comprehensive Study of WebAssembly Runtime Bugs.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00041
• Wang, Qian, and Huibiao Zhu. 2011. “Animating the Approach of Deriving Operational Semantics from Algebraic Semantics for Web Services.” In 2011 IEEE 13th International Symposium on High-Assurance Systems Engineering. IEEE. https://doi.org/10.1109/hase.2011.56
• WanXin, Shang, Wu Tao, Yang Fei, Chen Xi, Chen JingJue, and Yu ZhenXia. 2022. “CUDA Acceleration of Worst-Case Execution Time Analysis Based on Model Checking.” In 2022 Tenth International Conference on Advanced Cloud and Big Data (CBD). IEEE. https://doi.org/10.1109/cbd58033.2022.00044
• Weber, Dorian, Paula Wiesner, and Joachim Fischer. 2022. “A Closer Look at Process-Based Simulation with Stackless Coroutines.” Information and Software Technology 141: 106695. https://doi.org/10.1016/j.infsof.2021.106695
• Wei, Guannan, Songlin Jia, Ruiqi Gao, et al. 2023. “Compiling Parallel Symbolic Execution with Continuations.” In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse48619.2023.00116
• Weiner, J. L., and S. Ramakrishman. 1988. “A Piggy-Back Compiler for Prolog.” In Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/53990.54019
• Wenger, Robert, Xiru Zhu, Jayanth Krishnamurthy, and Muthucumaru Maheswaran. 2016. “A Programming Language and System for Heterogeneous Cloud of Things.” In 2016 IEEE 2nd International Conference on Collaboration and Internet Computing (CIC). IEEE. https://doi.org/10.1109/cic.2016.033
• Wheeler, Sitsofe, Iain Bate, and Mark Bartlett. 2011. “Video Subset Selection for Measurement Based Worst Case Execution Time Analysis.” In 2011 6th IEEE International Symposium on Industrial and Embedded Systems. IEEE. https://doi.org/10.1109/sies.2011.5953664
• Wibowo, Junno Tantra Pratama, Bayu Hendradjaya, and Yani Widyani. 2015. “Unit Test Code Generator for Lua Programming Language.” In 2015 International Conference on Data and Software Engineering (ICoDSE). IEEE. https://doi.org/10.1109/icodse.2015.7437005
• Williams, M. H., and A. R. Bulmer. 1978. “Use of a Formal Notation for Static Semantics in Compiler Design.” Software: Practice and Experience 8 (5): 579–84. https://doi.org/10.1002/spe.4380080507
• Williams, Conor J., and James Elliott. 2025. “Libfork: Portable Continuation-Stealing with Stackless Coroutines.” IEEE Transactions on Parallel and Distributed Systems 36 (5): 877–88. https://doi.org/10.1109/tpds.2025.3543442
• Williams, Nicky, and Muriel Roger. 2009. “Test Generation Strategies to Measure Worst-Case Execution Time.” In 2009 ICSE Workshop on Automation of Software Test. IEEE. https://doi.org/10.1109/iwast.2009.5069045
• Woronow, Alex. 1989. “Correction for a “FORTRAN Program for Generation of Multivariate Normally Distributed Random Variables”.” Computers & Geosciences 15 (6): 1033. https://doi.org/10.1016/0098-3004(89)90019-8
• Worthington, Jonathan. 2021. “Reflections on a Decade of MoarVM, a Runtime for the Raku Programming Language (Keynote).” In Proceedings of the 13th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3486606.3488073
• Wu, Aiqing, Mengni Bie, Longmei Nan, and Wei Li. 2021. “Effective Register Allocation for Configurable VLIW Crypto-Processor.” In 2021 IEEE 14th International Conference on ASIC (ASICON). IEEE. https://doi.org/10.1109/asicon52560.2021.9620475
• Wu, Shengning, and Sikun Li. 2007. “Extending Traditional Graph-Coloring Register Allocation Exploiting Meta-Heuristics for Embedded Systems.” In Third International Conference on Natural Computation (ICNC 2007). IEEE. https://doi.org/10.1109/icnc.2007.366
• Wu, Qiuping, Mugeng Liu, Yixuan Zhang, et al. 2026c. “Reconfigurable Computing Challenge: FPGA-Based WebAssembly Stack Co-Processor.” In 2026 IEEE 34th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm68464.2026.00077
• Wu, Nicolas, Tom Schrijvers, and Ralf Hinze. 2014. “Effect Handlers in Scope.” In Proceedings of the 2014 ACM SIGPLAN symposium on Haskell. ACM. https://doi.org/10.1145/2633357.2633358
• Wu, Jiangchang, Yibiao Yang, and Yuming Zhou. 2023. “Boosting Compiler Testing via Eliminating Test Programs with Long-Execution-Time.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00061
• Wu, Lan, and Wei Zhang. 2013. “Reducing Worst-Case Execution Time of Hybrid SPM-Caches.” In 2013 IEEE 32nd International Performance Computing and Communications Conference (IPCCC). IEEE. https://doi.org/10.1109/pccc.2013.6742770
• Würthinger, Thomas, Christian Wimmer, Christian Humer, et al. 2017. “Practical Partial Evaluation for High-Performance Dynamic Language Runtimes.” In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3062341.3062381
• Xiang, Yuanyang, Chen Xu, Ruozhou Xiao, and Zhiwei Zhang. 2026. “LoopHint: A Compiler-Assisted Loop Branch Predictor for Embedded DSPs.” In Proceedings of the 27th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, and Tools for Embedded Systems. ACM. https://doi.org/10.1145/3814943.3816166
• Xiao, Fengwei. 2021. “Transformation System of Two Similar Syntax Programs Based on the Compiler Principle.” In 2021 International Conference on Intelligent Transportation, Big Data & Smart City (ICITBS). IEEE. https://doi.org/10.1109/icitbs53129.2021.00153
• Xie, Ningning, Jonathan Immanuel Brachthäuser, Daniel Hillerström, Philipp Schuster, and Daan Leijen. 2020. “Effect Handlers, Evidently.” Proceedings of the ACM on Programming Languages 4 (ICFP): 1–29. https://doi.org/10.1145/3408981
• Xie, Ningning, Youyou Cong, Kazuki Ikemori, and Daan Leijen. 2022. “First-Class Names for Effect Handlers.” Proceedings of the ACM on Programming Languages 6 (OOPSLA2): 30–59. https://doi.org/10.1145/3563289
• Xie, Ningning, Daniel D. Johnson, Dougal Maclaurin, and Adam Paszke. 2024. “Parallel Algebraic Effect Handlers.” Proceedings of the ACM on Programming Languages 8 (ICFP): 756–88. https://doi.org/10.1145/3674651
• Xie, Ningning, and Daan Leijen. 2020. “Effect Handlers in Haskell, Evidently.” In Proceedings of the 13th ACM SIGPLAN International Symposium on Haskell. ACM. https://doi.org/10.1145/3406088.3409022
• Xie, Ningning, and Daan Leijen. 2021. “Generalized Evidence Passing for Effect Handlers: Efficient Compilation of Effect Handlers to C.” Proceedings of the ACM on Programming Languages 5 (ICFP): 1–30. https://doi.org/10.1145/3473576
• Xu, Shixiong, and David Gregg. 2015. “An Efficient Vectorization Approach to Nested Thread-Level Parallelism for CUDA GPUs.” In 2015 International Conference on Parallel Architecture and Compilation (PACT). IEEE. https://doi.org/10.1109/pact.2015.56
• Xu, Haoran, and Fredrik Kjolstad. 2021. “Copy-and-Patch Compilation: A Fast Compilation Algorithm for High-Level Languages and Bytecode.” Proceedings of the ACM on Programming Languages 5 (OOPSLA): 1–30. https://doi.org/10.1145/3485513
• Xu, Haoran, Yongjun Wang, Shuhui Fan, Peidai Xie, and Aizhi Liu. 2020. “DSmith: Compiler Fuzzing through Generative Deep Learning Model with Attention.” In 2020 International Joint Conference on Neural Networks (IJCNN). IEEE. https://doi.org/10.1109/ijcnn48605.2020.9206911
• Xu, Lili, and Hong Zhang. 2014. “Formal Verification of Software Safety Criteria Using Event-B.” In 2014 10th International Conference on Reliability, Maintainability and Safety (ICRMS). IEEE. https://doi.org/10.1109/icrms.2014.7107200
• Xu, Yijiang, Muxian Zhou, Qing Gao, Shikun Zhang, and Zhonghai Wu. 2024. “SWAT4J: Generating System Call Allowlist for Java Container Attack Surface Reduction.” In 2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner60148.2024.00101
• Xu, Chengzhi, Hong Zhu, Ian Bayley, David Lightfoot, Mark Green, and Peter Marshall. 2016. “CAOPLE: A Programming Language for Microservices SaaS.” In 2016 IEEE Symposium on Service-Oriented System Engineering (SOSE). IEEE. https://doi.org/10.1109/sose.2016.46
• Yadav, Rohan, Alex Aiken, and Fredrik Kjolstad. 2022. “DISTAL: The Distributed Tensor Algebra Compiler.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523437
• Yallop, Jeremy, David Sheets, and Anil Madhavapeddy. 2018. “A Modular Foreign Function Interface.” Science of Computer Programming 164: 82–97. https://doi.org/10.1016/j.scico.2017.04.002
• Yamamoto, Takuro, Hiroshi Oyama, and Takuya Azumi. 2016. “Lightweight Ruby Framework for Improving Embedded Software Efficiency.” In 2016 IEEE 4th International Conference on Cyber-Physical Systems, Networks, and Applications (CPSNA). IEEE. https://doi.org/10.1109/cpsna.2016.23
• Yamane, Satoshi, Junpei Kobashi, and Kosuke Uemura. 2020. “Verification Method of Safety Properties of Embedded Assembly Program by Combining SMT-Based Bounded Model Checking and Reduction of Interrupt Handler Executions.” Electronics 9 (7): 1060. https://doi.org/10.3390/electronics9071060
• Yamato, Yoji. 2015. “Automatic Verification for Plural Virtual Machines Patches.” In 2015 Seventh International Conference on Ubiquitous and Future Networks. IEEE. https://doi.org/10.1109/icufn.2015.7182660
• Yang, Zhenkun, Suvadeep Banerjee, Jeremy Casas, and Jin Yang. 2025. “Formal Verification of a Custom Compiler for a Fully Homomorphic Encryption Accelerator.” In 2025 26th International Symposium on Quality Electronic Design (ISQED). IEEE. https://doi.org/10.1109/isqed65160.2025.11014422
• Yang, Zhibin, Jean-Paul Bodeveix, Mamoun Filali, Kai Hu, Yongwang Zhao, and Dianfu Ma. 2015. “Towards a Verified Compiler Prototype for the Synchronous Language SIGNAL.” Frontiers of Computer Science 10 (1): 37–53. https://doi.org/10.1007/s11704-015-4364-y
• Yang, Xuejun, Yang Chen, Eric Eide, and John Regehr. 2011. “Finding and Understanding Bugs in C Compilers.” In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/1993498.1993532
• Yang, Chenyuan, Yinlin Deng, Runyu Lu, et al. 2024. “WhiteFox: White-Box Compiler Fuzzing Empowered by Large Language Models.” Proceedings of the ACM on Programming Languages 8 (OOPSLA2): 709–35. https://doi.org/10.1145/3689736
• Yang, Xiaoxiao, and Zhenhua Duan. 2008. “Operational Semantics of Framed Tempura.” Journal of Logic and Algebraic Programming 78 (1): 22–51. https://doi.org/10.1016/j.jlap.2008.08.001
• Yang, Chengmo, and Maria Ruiz Varela. 2015. “Qualifying Non-Volatile Register Files for Embedded Systems through Compiler-Directed Write Minimization and Balancing.” In 2015 IFIP/IEEE International Conference on Very Large Scale Integration (VLSI-SoC). IEEE. https://doi.org/10.1109/vlsi-soc.2015.7314397
• Yang, Yuting, Rui Wang, Youchen Wang, Xu Miao, Bing Liu, and Shan Jiang. 2022. “Simulink Model Static Analysis Results Based on Abstract Interpretation.” In 2022 9th International Conference on Dependable Systems and Their Applications (DSA). IEEE. https://doi.org/10.1109/dsa56465.2022.00087
• Ye, Qianchuan, and Benjamin Delaware. 2019. “A Verified Protocol Buffer Compiler.” In Proceedings of the 8th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3293880.3294105
• Ye, Kai, Xiaogang Zhu, Xi Xiao, Sheng Wen, Minhui Xue, and Yang Xiang. 2025. “BazzAFL: Moving Fuzzing Campaigns towards Bugs via Grouping Bug-Oriented Seeds.” IEEE Transactions on Dependable and Secure Computing 22 (1): 179–91. https://doi.org/10.1109/tdsc.2024.3391795
• Yi, Qing. 2011. “Automated Programmable Control and Parameterization of Compiler Optimizations.” In International Symposium on Code Generation and Optimization (CGO 2011). IEEE. https://doi.org/10.1109/cgo.2011.5764678
• Yi, Zijian, Cheng Ding, August Shi, and Milos Gligoric. 2026. “Understanding and Finding JIT Compiler Performance Bugs.” Proceedings of the ACM on Programming Languages 10 (OOPSLA1): 1237–65. https://doi.org/10.1145/3798245
• Yildiz, Abdullah, Deniz Iskender, Gulce Ozlu, H. Fatih Ugurdag, Baris Aktemur, and Sezer Goren. 2019. “Software UART: A Use Case for VSCPU Worst-Case Execution Time Analyzer.” In 2019 4th International Conference on Computer Science and Engineering (UBMK). IEEE. https://doi.org/10.1109/ubmk.2019.8907220
• Yilmazer-Metin, Ayse. 2021. “sRSP: An Efficient and Scalable Implementation of Remote Scope Promotion.” Concurrency and Computation: Practice and Experience 34 (9): e6483. https://doi.org/10.1002/cpe.6483
• Yim, Hyun-Jeong, Soonchoul Kim, Sung Ik Park, Namho Hur, and Heung Mook Kim. 2019. “Implementation of Targeted Advertisement Services on ATSC 3.0 Runtime Environment.” In 2019 IEEE International Symposium on Broadband Multimedia Systems and Broadcasting (BMSB). IEEE. https://doi.org/10.1109/bmsb47279.2019.8971863
• Yoshikawa, T., K. Shimura, and T. Ozawa. 2003. “Random Program Generator for Java JIT Compiler Test System.” In Third International Conference on Quality Software, 2003. Proceedings.. IEEE. https://doi.org/10.1109/qsic.2003.1319081
• Yoshioka, Takuma, Taro Sekiyama, and Atsushi Igarashi. 2024. “Abstracting Effect Systems for Algebraic Effect Handlers.” Proceedings of the ACM on Programming Languages 8 (ICFP): 455–84. https://doi.org/10.1145/3674641
• You, Yi-Ping, and Szu-Chieh Chen. 2015. “Vector-Aware Register Allocation for GPU Shader Processors.” In 2015 International Conference on Compilers, Architecture and Synthesis for Embedded Systems (CASES). IEEE. https://doi.org/10.1109/cases.2015.7324550
• You, Liang, and Yansheng Lu. 2012. “A Markup Language for Java Bytecode.” In 2012 International Conference on Systems and Informatics (ICSAI2012). IEEE. https://doi.org/10.1109/icsai.2012.6223542
• Yu, Weihai. 2009. “Scalable Services Orchestration with Continuation-Passing Messaging.” In 2009 First International Conference on Intensive Applications and Services. IEEE. https://doi.org/10.1109/intensive.2009.8
• Yu, Tingting, and Myra Cohen. 2015. “Guided Test Generation for Finding Worst-Case Stack Usage in Embedded Systems.” In 2015 IEEE 8th International Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst.2015.7102592
• Yu, Hengbiao, Xin Yi, Banghu Yin, Fa Li, Zhenbang Chen, and Chun Huang. 2023. “Efficient Generation of Floating-Point Inputs for Compiler-Induced Variability.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00030
• Yvon, Samuel, and Marc Feeley. 2021. “A Small Scheme VM, Compiler, and REPL in 4k.” In Proceedings of the 13th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3486606.3486783
• Zakowski, Yannick, Paul He, Chung-Kil Hur, and Steve Zdancewic. 2020. “An Equational Theory for Weak Bisimulation via Generalized Parameterized Coinduction.” In Proceedings of the 9th ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/3372885.3373813
• Zaks, Anna, and Amir Pnueli. 2008. “Program Analysis for Compiler Validation.” In Proceedings of the 8th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. ACM. https://doi.org/10.1145/1512475.1512477
• Zanardini, Damiano. 2008. “The Semantics of Abstract Program Slicing.” In 2008 Eighth IEEE International Working Conference on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2008.19
• Zapanov, Rinchin. 2025. “Foreign Function Interface for Managed Runtime Systems with Lightweight Threading.” In 2025 IEEE 26th International Conference of Young Professionals in Electron Devices and Materials (EDM). IEEE. https://doi.org/10.1109/edm65517.2025.11096859
• Zaytsev, Vadim. 2018. “An Industrial Case Study in Compiler Testing (Tool Demo).” In Proceedings of the 11th ACM SIGPLAN International Conference on Software Language Engineering. ACM. https://doi.org/10.1145/3276604.3276619
• Zendra, Olivier, and Dominique Colnet. 2001. “Coping with Aliasing in the GNU Eiffel Compiler Implementation.” Software: Practice and Experience 31 (6): 601–13. https://doi.org/10.1002/spe.373
• Zhang, Jie. 2016. “Selection and Improvement of Computer Programming Language.” In ISME 2016 - Information Science and Management Engineering IV. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0006448202420245
• Zhang, Hengrui. 2025. “Comparative Implementation of Binary Tree and Recursive Backtracking Maze Generation Algorithms in OCaml.” In Proceedings of the 2nd International Conference on Engineering Management, Information Technology and Intelligence. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0014350200004718
• Zhang, Rui, Michael D. Bond, and Yinqian Zhang. 2022. “Cape: Compiler-Aided Program Transformation for HTM-Based Cache Side-Channel Defense.” In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3497776.3517778
• Zhang, N., A. Burns, and M. Nicholson. 1993. “Pipelined Processors and Worst Case Execution Times.” Real-Time Systems 5 (4): 319–43. https://doi.org/10.1007/bf01088834
• Zhang, Chaolin, Jiqiu Deng, Hui Zhang, Longbo Li, Liji Sun, and Xiao Ma. 2026a. “GeoIR-Compiler: A Geospatial Intermediate Representation and Compilation Framework for Chinese Urban Spatial Question Answering.” ISPRS International Journal of Geo-Information 15 (7): 310. https://doi.org/10.3390/ijgi15070310
• Zhang, Yi, He Jiang, Shikai Guo, et al. 2026d. “Transformation-Recipe-Based FPGA Synthesis Compiler Testing.” IEEE Transactions on Reliability 75: 1064–78. https://doi.org/10.1109/tr.2026.3662048
• Zhang, Zhenkai, and Xenofon Koutsoukos. 2015. “Improving the Precision of Abstract Interpretation Based Cache Persistence Analysis.” ACM SIGPLAN Notices 50 (5): 1–10. https://doi.org/10.1145/2808704.2754967
• Zhang, Peng, Yueming Liu, and Meikang Qiu. 2019. “SNC: A Cloud Service Platform for Symbolic-Numeric Computation Using Just-In-Time Compilation.” IEEE Transactions on Cloud Computing 7 (2): 580–92. https://doi.org/10.1109/tcc.2017.2656088
• Zhang, Yizhou, and Andrew C. Myers. 2019. “Abstraction-Safe Effect Handlers via Tunneling.” Proceedings of the ACM on Programming Languages 3 (POPL): 1–29. https://doi.org/10.1145/3290318
• Zhang, Yang, Gaojie Shen, Liyan Zhang, Meiyan Zheng, and Kun Zheng. 2025. “Refactoring for Java-Structured Concurrency.” Applied Sciences 15 (5): 2407. https://doi.org/10.3390/app15052407
• Zhang, Qirun, Chengnian Sun, and Zhendong Su. 2017a. “Skeletal Program Enumeration for Rigorous Compiler Testing.” In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3062341.3062379
• Zhang, Huihui, Anand Venkat, and Mary Hall. 2016. “Compiler Transformation to Generate Hybrid Sparse Computations.” In 2016 6th Workshop on Irregular Applications: Architecture and Algorithms (IA3). IEEE. https://doi.org/10.1109/ia3.2016.011
• Zhang, Sizhuo, Muralidaran Vijayaraghavan, and Arvind. 2017b. “Weak Memory Models: Balancing Definitional Simplicity and Implementation Flexibility.” In 2017 26th International Conference on Parallel Architectures and Compilation Techniques (PACT). IEEE. https://doi.org/10.1109/pact.2017.29
• Zhang, Xuemeng, Hui Wu, and Haiyan Sun. 2013. “Register Allocation by Incremental Graph Colouring for Clustered VLIW Processors.” In 2013 12th IEEE International Conference on Trust, Security and Privacy in Computing and Communications. IEEE. https://doi.org/10.1109/trustcom.2013.113
• Zhang, Kunpeng, Dongwei Xiao, Daoyuan Wu, et al. 2026c. “LLM-Powered Silent Bug Fuzzing in Deep Learning Libraries via Versatile and Controlled Bug Transfer.” Proceedings of the ACM on Programming Languages 10 (OOPSLA1): 1599–1626. https://doi.org/10.1145/3798258
• Zhang, Wei, and Jun Yan. 2009. “Accurately Estimating Worst-Case Execution Time for Multi-Core Processors with Shared Direct-Mapped Instruction Caches.” In 2009 15th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications. IEEE. https://doi.org/10.1109/rtcsa.2009.55
• Zhang, Shuoming, Jiacheng Zhao, Qiuchu Yu, et al. 2026b. “LEGO-Compiler: Enhancing Neural Compilation through Translation Composability.” CCF Transactions on High Performance Computing 8 (4): 410–36. https://doi.org/10.1007/s42514-025-00272-9
• Zhang, Tingxu, Wenguang Zheng, Yingyuan Xiao, and Guangping Xu. 2020. “A Dynamic Instruction Cache Locking Approach for Minimizing Worst Case Execution Time of a Single Task.” IEEE Access 8: 208003–15. https://doi.org/10.1109/access.2020.3038170
• Zhao, Jingwen, Yan Fu, Yanxia Wu, Jibin Dong, and Ruize Hong. 2025. “Thread-Sensitive Fuzzing for Concurrency Bug Detection.” Computers & Security 148: 104171. https://doi.org/10.1016/j.cose.2024.104171
• Zhao, Yuan, Yunlong He, Jianhao Xiao, Zhongbo He, Zuochang Ye, and Yan Wang. 2024b. “Design and Implementation of the MTP Compiler.” In 2024 2nd International Symposium of Electronics Design Automation (ISEDA). IEEE. https://doi.org/10.1109/iseda62518.2024.10617942
• Zhao, Fangliang, Donghai Liao, Jingbang Wu, Huimei Lu, and Yong Xiang. 2024a. “COPS: A Coroutine-Based Priority Scheduling Framework Perceived by the Operating System.” In 2024 International Conference on Ubiquitous Computing and Communications (IUCC). IEEE. https://doi.org/10.1109/iucc65928.2024.00031
• Zhao, Zhongyuan, Weiguang Sheng, Jinchao Li, Pengfei Ye, Qin Wang, and Zhigang Mao. 2021b. “Similarity-Aware Architecture/Compiler Co-Designed Context-Reduction Framework for Modulo-Scheduled CGRA.” Electronics 10 (18): 2210. https://doi.org/10.3390/electronics10182210
• Zheng, Xiaoying, and Ye Xia. 2019. “Exploring Mixed Integer Programming Reformulations for Virtual Machine Placement with Disk Anti-Colocation Constraints.” Performance Evaluation 135: 102035. https://doi.org/10.1016/j.peva.2019.102035
• Zhong, Ziyuan, Gail Kaiser, and Baishakhi Ray. 2023. “Neural Network Guided Evolutionary Fuzzing for Finding Traffic Violations of Autonomous Vehicles.” IEEE Transactions on Software Engineering 49 (4): 1860–75. https://doi.org/10.1109/tse.2022.3195640
• Zhong, Ming, Fang Lv, Hongna Geng, et al. 2026b. “A Multi-Modal Retrieval-Augmented Framework for Compiler Backend Generation with LLMs.” In 2026 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner67736.2026.00069
• Zhou, Zhen, and Lei Mu. 2016. “Representative Virtual Machine Templates: An Optimized Virtual Machine Templates Management Mechanism for an Cloud System Based on K-Medoids Clustering.” In 2016 35th Chinese Control Conference (CCC). IEEE. https://doi.org/10.1109/chicc.2016.7554171
• Zhu, Ming-Yuan. 2001. “Denotational Semantics of Programming Languages and Compiler Generation in PowerEpsilon.” ACM SIGPLAN Notices 36 (9): 39–53. https://doi.org/10.1145/609769.609777
• Zhu, Huibiao, Jifeng He, and Jonathan P. Bowen. 2007. “Algebraic Approach to Operational Semantics and Observation-Oriented Semantics for a Timed Shared-Variable Language with Probability.” In 31st IEEE Software Engineering Workshop (SEW 2007). IEEE. https://doi.org/10.1109/sew.2007.52
• Zhu, Huibiao, Jifeng He, and Jonathan P. Bowen. 2008. “From Algebraic Semantics to Denotational Semantics for Verilog.” Innovations in Systems and Software Engineering 4 (4): 341–60. https://doi.org/10.1007/s11334-008-0069-9
• Zhu, Junhua, Limin Wang, Yu Gu, and Xiaojun Lin. 2019. “Learning to Restrict Test Range for Compiler Test.” In 2019 IEEE International Conference on Software Testing, Verification and Validation Workshops (ICSTW). IEEE. https://doi.org/10.1109/icstw.2019.00064
• Zhu, Bin, and Kun Xie. 2025. “A Domain-Specific Compiler for Embedded DSP Development Based on Component Code Generation: Architecture and Correctness.” In 2025 6th International Conference on Machine Learning and Computer Application (ICMLCA). IEEE. https://doi.org/10.1109/icmlca66850.2025.11336697
• Zhu, Huibiao, Fan Yang, Jifeng He, Jonathan P. Bowen, and Jeff W. Sanders. 2009a. “Animating the Link between Operational Semantics and Algebraic Semantics for a Probabilistic Timed Shared-Variable Language.” In 2009 33rd Annual IEEE Software Engineering Workshop. IEEE. https://doi.org/10.1109/sew.2009.17
• Zhu, Huibiao, Fan Yang, Jifeng He, Jonathan P. Bowen, Jeff W. Sanders, and Shengchao Qin. 2012. “Linking Operational Semantics and Algebraic Semantics for a Probabilistic Timed Shared-Variable Language.” Journal of Logic and Algebraic Programming 81 (1): 2–25. https://doi.org/10.1016/j.jlap.2011.06.003
• Zhu, Huibiao, Yongxin Zhao, and Jifeng He. 2009b. “Locality-Based Normal Form Approach to Linking Algebraic Semantics and Operational Semantics for an Event-Driven System-Level Language.” In 2009 Australian Software Engineering Conference. IEEE. https://doi.org/10.1109/aswec.2009.20
• Zolda, Michael, Sven Bunte, and Raimund Kirner. 2011. “Context-Sensitive Measurement-Based Worst-Case Execution Time Estimation.” In 2011 IEEE 17th International Conference on Embedded and Real-Time Computing Systems and Applications. IEEE. https://doi.org/10.1109/rtcsa.2011.73
• Zolduoarrati, Elijah, Sherlock A. Licorish, and John Grundy. 2025. “A Cross-Continental Analysis of How Regional Cues Shape Top Stack Overflow Contributors.” Journal of Systems and Software 223: 112338. https://doi.org/10.1016/j.jss.2025.112338
• Zou, Jie, Ling Xu, Mengning Yang, Xiaohong Zhang, and Dan Yang. 2017. “Towards Comprehending the Non-Functional Requirements through Developers’ Eyes: An Exploration of Stack Overflow Using Topic Analysis.” Information and Software Technology 84: 19–32. https://doi.org/10.1016/j.infsof.2016.12.003
• Zuepke, Alexander, and Robert Kaiser. 2019. “Deterministic Futexes: Addressing WCET and Bounded Interference Concerns.” In 2019 IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS). IEEE. https://doi.org/10.1109/rtas.2019.00014
• Zúñiga, Angel, and Gemma Bel-Enguix. 2020. “Coinductive Natural Semantics for Compiler Verification in Coq.” Mathematics 8 (9): 1573. https://doi.org/10.3390/math8091573
• Zyuzin, Nikita, and Aleksandar Nanevski. 2021. “Contextual Modal Types for Algebraic Effects and Handlers.” Proceedings of the ACM on Programming Languages 5 (ICFP): 1–29. https://doi.org/10.1145/3473580

Primary Sources, Non-Peer-Reviewed

• Abdulaziz, Mohammad, and Lukas Koller. 2022. “Formal Semantics and Formally Verified Validation for Temporal Planning.” Proceedings of the AAAI Conference on Artificial Intelligence 36 (9): 9635–43. https://doi.org/10.1609/aaai.v36i9.21197
• Abella, Jaume, Maria Padilla, Joan Del Castillo, and Francisco J. Cazorla. 2017. “Measurement-Based Worst-Case Execution Time Estimation Using the Coefficient of Variation.” ACM Transactions on Design Automation of Electronic Systems 22 (4): 1–29. https://doi.org/10.1145/3065924
• Abramsky, Samson, and Dominic Horsman. 2015. “DEMONIC Programming: A Computational Language for Single-Particle Equilibrium Thermodynamics, and Its Formal Semantics.” Electronic Proceedings in Theoretical Computer Science 195: 1–16. https://doi.org/10.4204/eptcs.195.1
• Achour, Safaa, Ali Chouenyib, and Mohammed Benattou. 2018. “A Constraint-Based Verification Approach for Java Bytecode Programs.” International Journal of Software Engineering and Its Applications 12 (2): 1–17. https://doi.org/10.14257/ijseia.2018.12.2.01
• Ada Joint Program Office Arlington VA. 1988a. Ada (Trade Name) Compiler Validation Summary Report. Certificate Number: 880620W1.09092, Encore Computer Corporation, Encore Verdix Ada Development System, Version 5.5, Encore Multimax 320. Defense Technical Information Center. https://doi.org/10.21236/ada204645
• Ada Joint Program Office Arlington VA. 1988b. Ada (Tradename) Compiler Validation Summary Report: Certificate Number: 880201W1.09019 Verdix Corporation VAda-010-2323, Version 5.5 Sequent Balance 8000. Defense Technical Information Center. https://doi.org/10.21236/ada205959
• Ada Joint Program Office Arlington VA. 1988c. Ada (Tradename) Compiler Validation Summary Report: Certificate Number: 880429W1.09053 Telesoft, Inc. TeleGen2 Ada Compiler for VAX/VMS to 1750A, Version 3.22 MicroVAX 2 to MIL-STD-1750A ECSPO RAID Simulator. Defense Technical Information Center. https://doi.org/10.21236/ada205958
• Ada Joint Program Office Arlington VA. 1988d. Ada (Tradename) Compiler Validation Summary Report: Certificate Number: 880815W1.09143 Rational VAX-VMS, Version 2.0.45 Rational R1000 Series 200 Model 20 and VAX-11/750 (Host) and (Target). Defense Technical Information Center. https://doi.org/10.21236/ada205908
• Ada Joint Program Office Arlington VA. 1989a. Ada Compiler Validation Procedures Version 2.0. Defense Technical Information Center. https://doi.org/10.21236/ada210406
• Ada Joint Program Office Arlington VA. 1989b. Ada Compiler Validation Summary Report. CONVEX Computer Corporation, CONVEX Ada, Version 1.1 C210, (Host and Target) 890508W1.10077. Defense Technical Information Center. https://doi.org/10.21236/ada209882
• Ada Joint Program Office Arlington VA. 1989c. Ada Compiler Validation Summary Report. Meridian Software Systems, Inc., AdaVantage, Version 3.0, IBM PS/2 Model 80 (with Floating Point Co-Processor) (Host and Target) 890405W1.10049. Defense Technical Information Center. https://doi.org/10.21236/ada209883
• Ada Joint Program Office Arlington VA. 1989d. Ada Compiler Validation Summary Report. Verdix Corporation, VAda-110-2323, Version 5.5, Sequent Balance 8000 (Host and Target), 890216W1.10029. Defense Technical Information Center. https://doi.org/10.21236/ada209881
• Ada Joint Program Office Arlington VA. 1989e. Ada Compiler Validation Summary Report: Certificate Number: 890329I1. 10076 SYSTEAM KG, SYSTEAM Ada Compiler VAX/VMS x MC68020/05-9 Version 1.81. Defense Technical Information Center. https://doi.org/10.21236/ada210423
• Ada Joint Program Office Arlington VA. 1990. Ada Compiler Validation Procedures. Version 2.1. Defense Technical Information Center. https://doi.org/10.21236/ada228614
• Ada Joint Program Office Arlington VA. 1991. Ada Compiler Validation Summary Report: Certificate Number: 910612W1. 11168 Telesoft, IBM Ada/370, Version 1.2.0 (without Optimization) IBM 3080, V</ SP HPO Rel 5.0 (Unopt) (Host & Target). Defense Technical Information Center. https://doi.org/10.21236/ada246532
• Ada Joint Program Office Arlington VA. 1992. Ada Compiler Validation Procedures, Version 3.1. Defense Technical Information Center. https://doi.org/10.21236/ada257705
• “Adaptive Programming Language Learning System Based on Generative Ai.” 2023. Issues In Information Systems. https://doi.org/10.48009/3_iis_2023_119
• Aisyiyah, Rosydah Rihadhatu, and Ade Eviyanti. 2026. “Android-Based Programming Language to Natural Language Translator App.” SAGA: Journal of Technology and Information System 3 (1): 363–72. https://doi.org/10.58905/saga.v3i1.476
• Akanbi, Johnson Oluwatobi, Allen Akinkitan Ajose, and Kareem Afiss Emiola. 2022. “Code Generation Techniques in Compiler Design: Conceptual and Structural Review.” International Journal of Recent Engineering Science 9 (3): 1–6. https://doi.org/10.14445/23497157/ijres-v9i3p101
• Al-Bataineh, Omar, Mark Reynolds, and Tim French. 2015. “Accelerating Worst Case Execution Time Analysis of Timed Automata Models with Cyclic Behaviour.” Formal Aspects of Computing 27 (5–6): 917–49. https://doi.org/10.1007/s00165-015-0340-4
• Alatawi, Eman, Tim Miller, and Harald Søndergaard. 2016. “Generating Source Inputs for Metamorphic Testing Using Dynamic Symbolic Execution.” In Proceedings of the 1st International Workshop on Metamorphic Testing. ACM. https://doi.org/10.1145/2896971.2896980
• Albert, Elvira, Jesús Correas, Pablo Gordillo, Guillermo Román-Díez, and Albert Rubio. 2024. “Synthesis of Sound and Precise Storage Cost Bounds via Unsound Resource Analysis and Max-SMT.” In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3650212.3680352
• Alexander, Forrest, and Andrew P. Black. 2016. “The Performance of Object Encodings in JavaScript.” In Proceedings of the 11th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems. ACM. https://doi.org/10.1145/3012408.3012417
• Ali, Muaz, Tugay Bilgis, Nimet Beyza Bozdag, Saumya Debray, and Sazzadur Rahaman. 2025b. “Does Coding Style Really Survive Compilation? Stylometry of Executable Code Revisited.” Proceedings on Privacy Enhancing Technologies 2025 (3): 349–60. https://doi.org/10.56553/popets-2025-0102
• Allen, M., R. Malaguti, A. Litvin, and C. Gregory. 2000. “Subsalt Imaging Using 3D Pre-Stack Depth Migration in the UK Southern North Sea: A Case History.” In 62nd EAGE Conference & Exhibition. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.28.l42
• Alpay, Aksel, and Vincent Heuveline. 2022. “How Much SYCL Does a Compiler Need? Experiences from the Implementation of SYCL as a Library for Nvc++.” In International Workshop on OpenCL. ACM. https://doi.org/10.1145/3529538.3529556
• Alpay, Aksel, and Vincent Heuveline. 2023. “One Pass to Bind Them: The First Single-Pass SYCL Compiler with Unified Code Representation across Backends.” In International Workshop on OpenCL. ACM. https://doi.org/10.1145/3585341.3585351
• Altan, Beyza. 2026. “Error-Resilient Quantum Compiler Design for Efficient Qubit Mapping, Gate Optimization, and Noise Mitigation in NISQ-Era Devices,.” Next Generation Journal for The Young Researchers 10 (1). https://doi.org/10.62802/w6gg1c44
• Altassan, Megren Abdullah, and Aqeel Ahmad. 2024. “Green Threads of Change: Unravelling the Gendered and Experienced Moderators in the Sustainable Symphony of Green HR Practices and Environmental Responsibility.” International Journal of Innovative Research and Scientific Studies 7 (2): 852–62. https://doi.org/10.53894/ijirss.v7i2.2956
• Amarasinghe, Saman. 2019. “The Sparse Tensor Algebra Compiler (Keynote).” In Proceedings of the 28th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3302516.3307361
• Ambal, Guillaume, Sergueï Lenglet, Alan Schmitt, and Camille NoûS. 2022. “Certified Derivation of Small-Step from Big-Step Skeletal Semantics.” In Proceedings of the 24th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3551357.3551384
• “Analysis on Strengthening Scheme of Office Building Based on Function Change.” 2022. Foreign Language Science and Technology Journal Database Engineering Technology. https://doi.org/10.47939/et.v3i5(10).09
• “Analytics of Application Resource Utilization within the Virtual Machine.” 2016. International Journal of Science and Research (IJSR) 5 (4): 1690–94. https://doi.org/10.21275/v5i4.nov162978
• Anderton, Craig. 2022. “Investigating Sign Language Interpreter Rendering and Guiding Methods in Virtual Reality 360-Degree Content.” In Proceedings of the 24th International ACM SIGACCESS Conference on Computers and Accessibility. ACM. https://doi.org/10.1145/3517428.3563373
• Andrade Guzmán, Jesús Mauricio, and Francisco Hernández Quiroz. 2020. “Natural Deduction and Semantic Models of Justification Logic in the Proof Assistant Coq.” Logic Journal of the IGPL: jzaa007. https://doi.org/10.1093/jigpal/jzaa007
• Aparanji, Koduri, Manta Radhasundari, and Kommula Gopalakrishna. 2017. “Induction of Propofol with Coinduction of Propofol, Midazolam versus Propofol Auto Coinduction- a Comparative Study.” Journal of Evidence Based Medicine and Healthcare 4 (93): 5670–74. https://doi.org/10.18410/jebmh/2017/1138
• Arceri, Vincenzo, and Isabella Mastroeni. 2019. “Static Program Analysis for String Manipulation Languages.” Electronic Proceedings in Theoretical Computer Science 299: 19–33. https://doi.org/10.4204/eptcs.299.5
• Arendsee, Zebulun. 2026. “Morloc: A Workflow Language for Multi-Lingual Programming under a Common Type System.” PeerJ Computer Science 12: e3435. https://doi.org/10.7717/peerj-cs.3435
• Aristizábal, Andrés, Dariusz Biernacki, Sergueï Lenglet, and Piotr Polesiuk. 2017. “Environmental Bisimulations for Delimited-Control Operators with Dynamic Prompt Generation.” Logical Methods in Computer Science Volume 13, Issue 3: 2563. https://doi.org/10.23638/lmcs-13(3:27)2017
• Arm. n.d. “Application Binary Interface for the Arm® Architecture.” GitHub. Accessed October 24, 2026. https://github.com/ARM-software/abi-aa
• Arriaga, Afonso, Manuel Barbosa, and Stanislaw Jarecki. 2026. “Tempo: An ML-KEM to PAKE Compiler Resilient to Timing Attacks.” IACR Transactions on Cryptographic Hardware and Embedded Systems 2026 (3): 744–68. https://doi.org/10.46586/tches.v2026.i3.744-768
• “ART: An Implementation on the Active_object RunTime Systems Applicable for the Embedded Systems.” 2003. KIPS Transactions:PartA 10A (4): 295–304. https://doi.org/10.3745/kipsta.2003.10a.4.295
• Asai, Kenichi, and Maika Fujii. 2025. “Defining Algebraic Effects and Handlers via Trails and Metacontinuations.” In Proceedings of the Workshop Dedicated to Olivier Danvy on the Occasion of His 64th Birthday. ACM. https://doi.org/10.1145/3759427.3760364
• Askim, O. J., S. Brandsberg-Dahl, and O. Barkved. 2004. “4D Seismic Analysis Using Pre Stack Depth Migration.” In 66th EAGE Conference & Exhibition. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.3.p205
• Assistant Professor (Computer Science and Application, ICST-SHEPA, Varanasi) and Pankaj Pandey. 2025. “Compiler Design and Its Construction.” International Journal of Scientific Research in Engineering and Management 09 (09): 1–9. https://doi.org/10.55041/ijsrem52649
• Atapattu, Daya. 1994. Design of a Parallel Object Oriented Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada284924
• Attrapadung, Nuttapong, Goichiro Hanaoka, Shigeo Mitsunari, Yusuke Sakai, Kana Shimizu, and Tadanori Teruya. 2018. “Efficient Two-Level Homomorphic Encryption in Prime-Order Bilinear Groups and a Fast Implementation in WebAssembly.” In Proceedings of the 2018 on Asia Conference on Computer and Communications Security. ACM. https://doi.org/10.1145/3196494.3196552
• Attrot, Wesley, Luciano Zago, Marcio Pereira, Vinícius Couto, Hervé Yviquel, and Guido Araujo. 2026. “A Pattern Generation Language for MLIR Compiler Matching and Rewriting.” ACM Transactions on Architecture and Code Optimization 23 (1): 1–25. https://doi.org/10.1145/3777905
• Auchterlonie, L., V. Vinje, and R. Taylor. 2007. “Velocity Model Building for Pre-Stack Depth Migration: An Onshore Libya Case Study.” In 3rd EAGE North African/Mediterranean Petroleum and Geosciences Conference and Exhibition. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.20146495
• Audrito, Giorgio, and Daniel Haures. 2023. “Combining Static and Runtime Verification with AC and Coq.” In Proceedings of the 6th International Workshop on Verification and Monitoring at Runtime Execution. ACM. https://doi.org/10.1145/3605159.3605857
• Auguston, Mikhail, Valdis Berzins, and Barrett Bryant. 2001. Visual Meta-Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada529617
• “Automatic Port to OpenACC/OpenMP for Physical Parameterization in Climate and Weather Code Using the CLAW Compiler.” 2019. Supercomputing Frontiers and Innovations 6 (3). https://doi.org/10.14529/jsfi190303
• Avigad, Jeremy, Kevin Donnelly, David Gray, and Paul Raff. 2007. “A Formally Verified Proof of the Prime Number Theorem.” ACM Transactions on Computational Logic 9 (1): 2. https://doi.org/10.1145/1297658.1297660
• Aziz, Michael, and Yvan Labiche. 2026. “ProtoSYCL: A Sample Implementation of a SYCL Compiler for Conformance Test Suite Development.” In Proceedings of the International Workshop on OpenCL and SYCL. ACM. https://doi.org/10.1145/3811257.3811263
• Azmi, Syed Khundmir. 2025. “LLM-Aware Static Analysis: Adapting Program Analysis to Mixed Human/AI Codebases at Scale.” Global Journal of Engineering and Technology Advances 24 (3): 260–69. https://doi.org/10.30574/gjeta.2025.24.3.0284
• Azzahra, Attikah, Bagus Sapto Mulyatno, and Bambang Mujihardi. 2020. “Pre Stack Depth Migration Untuk Koreksi Efek Pull up Dengan Menggunakan Metode Horizon Based Depth Tomography Pada Lapangan ‘A1 Dan A2’.” JGE (Jurnal Geofisika Eksplorasi) 4 (1): 46–59. https://doi.org/10.23960/jge.v4i1.6
• Badler, Norman I. 1996. A Task Networking and Visual Programming Language for Jack. Defense Technical Information Center. https://doi.org/10.21236/ada396354
• Bailin, Sydney, Frank Paterra, Scott Henderson, and Walt Truszkowski. 1993. “Model-Based Reasoning for System and Software Engineering: The Knowledge from Pictures (KFP) Environment.” In The 1993 Goddard Conference on Space Applications of Artificial Intelligence. https://ntrs.nasa.gov/citations/19930016789
• Baird, George, and Arnold Johnson. 1977. COBOL Compiler Validation System, 1974. Version 3.0. Defense Technical Information Center. https://doi.org/10.21236/ada046600
• Baird, George N., and Paul Oliver. 1977. Programming Language Standards – Who Needs Them. Defense Technical Information Center. https://doi.org/10.21236/ada039740
• Balamurugan, E. 2020. “Modified Support Vector Machine Based Efficient Virtual Machine Consolidation Procedure for Cloud Data Centers.” Journal of Advanced Research in Dynamical and Control Systems 12 (SP4): 501–8. https://doi.org/10.5373/jardcs/v12sp4/20201515
• Balu, V., and M. Saraswathi. 2014. “Implementation of SAAS Compiler in Intranet.” International Journal of Computer Applications 107 (8): 17–19. https://doi.org/10.5120/18771-0075
• Banerjee, Kunal, and Chandan Karfa. 2018. “Compiler-Agnostic Translation Validation.” In Proceedings of the 11th Innovations in Software Engineering Conference. ACM. https://doi.org/10.1145/3172871.3180078
• Bansal, K. L., and Chaman Singh. 2011. “Dual Stack Implementation of Mobile IPv6 Software Architecture.” International Journal of Computer Applications 25 (9): 6–13. https://doi.org/10.5120/3062-4182
• Barai, Atanu, Nandakishore Santhi, Abdur Razzak, Stephan Eidenbenz, and Abdel-Hameed A. Badawy. 2023. “LLVM Static Analysis for Program Characterization and Memory Reuse Profile Estimation.” In Proceedings of the International Symposium on Memory Systems. ACM. https://doi.org/10.1145/3631882.3631885
• Baramashetru, Chinmayi Prabhu, Paola Giannini, Silvia Lizeth Tapia Tarifa, and Olaf Owe. 2025. “A Type System for Data Privacy Compliance in Active Object Languages.” Art, Science, and Engineering of Programming 10 (2): 18. https://doi.org/10.22152/programming-journal.org/2025/10/18
• Barany, Gergö. 2018. “Finding Missed Compiler Optimizations by Differential Testing.” In Proceedings of the 27th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3178372.3179521
• Barbosa, Manuel, Matthias J. Kannwischer, Thing-han Lim, Peter Schwabe, and Pierre-Yves Strub. 2025. “Formally Verified Correctness Bounds for Lattice-Based Cryptography.” In Proceedings of the 2025 ACM SIGSAC Conference on Computer and Communications Security. ACM. https://doi.org/10.1145/3719027.3765218
• Barbuti, Roberto, and Stefano Cataudella. 2004. “Java Bytecode Verification on Java Cards.” In Proceedings of the 2004 ACM symposium on Applied computing. ACM. https://doi.org/10.1145/967900.967991
• Barbuti, Roberto, Luca Tesei, Cinzia Bernardeschi, and Nicoletta De Francesco. 2002. “Fixing the Java Bytecode Verifier by a Suitable Type Domain.” In Proceedings of the 14th international conference on Software engineering and knowledge engineering. ACM. https://doi.org/10.1145/568760.568826
• Baroffio, Davide, and Federico Reghenzani. 2023. “Compiler-Injected SIHFT for Embedded Operating Systems.” In Proceedings of the 20th ACM International Conference on Computing Frontiers. ACM. https://doi.org/10.1145/3587135.3589944
• Basold, Henning, and Herman Geuvers. 2016. “Type Theory Based on Dependent Inductive and Coinductive Types.” In Proceedings of the 31st Annual ACM/IEEE Symposium on Logic in Computer Science. ACM. https://doi.org/10.1145/2933575.2934514
• Bassil, Youssef. 2019. “Compiler Design for Legal Document TranslationIn Digital Government.” International Journal of Engineering Trends and Technology 67 (3): 100–104. https://doi.org/10.14445/22315381/ijett-v67i3p219
• Bauckholt, Florian, and Thorsten Holz. 2024. “WebAssembly as a Fuzzing Compilation Target (Registered Report).” In Proceedings of the 3rd ACM International Fuzzing Workshop. ACM. https://doi.org/10.1145/3678722.3685531
• Bauer, Andrej, and Matija Pretnar. 2014. “An Effect System for Algebraic Effects and Handlers.” Logical Methods in Computer Science Volume 10, Issue 4: 1153. https://doi.org/10.2168/lmcs-10(4:9)2014
• Bavera, Francisco, and Eduardo Bonelli. 2008. “Type-Based Information Flow Analysis for Bytecode Languages with Variable Object Field Policies.” In Proceedings of the 2008 ACM symposium on Applied computing. ACM. https://doi.org/10.1145/1363686.1363776
• Bayer, Rudolf, James H. Bigelow, George B. Dantzig, David J. Gries, and Michael B. McGrath. 1968. Mpl: Mathematical Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ad0692681
• Becker, Martin, and Samarjit Chakraborty. 2018. “Optimizing Worst-Case Execution Times Using Mainstream Compilers.” In Proceedings of the 21st International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/3207719.3207739
• Bee, Bee, and d. Bernardo. 2018. “Predicting Fork Visibility Performance on Programming Language Interoperability in Open Source Projects.” International Journal of Advanced Computer Science and Applications 9 (1). https://doi.org/10.14569/ijacsa.2018.090105
• Belyaev, M. V., N. V. Shimchik, V. N. Ignatyev, and A. A. Belevantsev. 2018. “Comparative Analysis of Two Approaches to Static Taint Analysis.” Programming and Computer Software 44 (6): 459–66. https://doi.org/10.1134/s036176881806004x
• Béra, Clément, Eliot Miranda, Marcus Denker, and Stéphane Ducasse. 2016. “Practical Validation of Bytecode to Bytecode JIT Compiler Dynamic Deoptimization.” Journal of Object Technology 15 (2): 1:1. https://doi.org/10.5381/jot.2016.15.2.a1
• Berger, Ulrich, and Dieter Spreen. 2016. “A Coinductive Approach to Computing with Compact Sets.” Journal of Logic and Analysis. https://doi.org/10.4115/jla.2016.8.3
• Berkhout, A. J. 1992. “True Amplitude Aspects of Pre-Stack Depth Migration.” In 54th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201410434
• Berlakovich, Felix, Florian Schwarcz, Gergö Barany, Hanspeter Mössenböck, and Stefan Brunthaler. 2026a. “LOOL: Low-Overhead, Optimization-Log-Guided Compiler Fuzzing.” ACM Transactions on Software Engineering and Methodology: 3807508. https://doi.org/10.1145/3807508
• Berlakovich, Felix, Florian Schwarcz, Gergö Barany, Hanspeter Mössenböck, and Stefan Brunthaler. 2026b. “LOOL: Low-Overhead, Optimization-Log-Guided Compiler Fuzzing: RCR Report.” ACM Transactions on Software Engineering and Methodology: 3806058. https://doi.org/10.1145/3806058
• Bernardeschi, C., N. De Francesco, G. Lettieri, L. Martini, and P. Masci. 2008. “Decomposing Bytecode Verification by Abstract Interpretation.” ACM Transactions on Programming Languages and Systems 31 (1): 1–63. https://doi.org/10.1145/1452044.1452047
• Bernardeschi, C., G. Lettieri, L. Martini, and P. Masci. 2006. “Using Control Dependencies for Space-Aware Bytecode Verification.” Computer Journal 49 (2): 234–48. https://doi.org/10.1093/comjnl/bxh161
• Bertrane, Julien, Patrick Cousot, Radhia Cousot, et al. 2010. “Static Analysis and Verification of Aerospace Software by Abstract Interpretation.” In AIAA Infotech@Aerospace 2010. AIAA 2010-3385. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.2010-3385
• Bertrane, Julien, Patrick Cousot, Radhia Cousot, et al. 2015. “Static Analysis and Verification of Aerospace Software by Abstract Interpretation.” Foundations and Trends® in Programming Languages 2 (2–3): 71–190. https://doi.org/10.1561/2500000002
• Bezrąk, Krzysztof, and Sławomir Przyłucki. 2020. “Impact of the Cloud Application Programming Language on the Performance of Its Implementation in Selected Serverless Environments.” Journal of Computer Sciences Institute 14: 31–36. https://doi.org/10.35784/jcsi.1572
• Bicarregui, J. C., C. A. R. Hoare, and J. C. P. Woodcock. 2006. “The Verified Software Repository: A Step towards the Verifying Compiler.” Formal Aspects of Computing 18 (2): 143–51. https://doi.org/10.1007/s00165-005-0079-4
• Biernacki, Dariusz, and Olivier Danvy. 2005. “A Simple Proof of a Folklore Theorem about Delimited Control.” BRICS Report Series 12 (10). https://doi.org/10.7146/brics.v12i10.21876
• Biernacki, Dariusz, and Olivier Danvy. 2006. “THEORETICAL PEARL: A Simple Proof of a Folklore Theorem about Delimited Control.” Journal of Functional Programming 16 (3): 269–80. https://doi.org/10.1017/s0956796805005782
• Biernacki, Dariusz, Olivier Danvy, and Kevin Millikin. 2005a. “A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations.” BRICS Report Series 12 (16). https://doi.org/10.7146/brics.v12i16.21882
• Biernacki, Dariusz, Olivier Danvy, and Kevin Millikin. 2005b. “A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations (Preliminary Version).” BRICS Report Series 12 (5). https://doi.org/10.7146/brics.v12i5.21871
• Biernacki, Dariusz, Olivier Danvy, and Kevin Millikin. 2006. “A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations.” BRICS Report Series 13 (15). https://doi.org/10.7146/brics.v13i15.21920
• Biernacki, Dariusz, Olivier Danvy, and Kevin Millikin. 2015. “A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations.” ACM Transactions on Programming Languages and Systems 38 (1): 1–25. https://doi.org/10.1145/2794078
• Biernacki, Dariusz, Sergueï Lenglet, and Piotr Polesiuk. 2019. “Bisimulations for Delimited-Control Operators.” Logical Methods in Computer Science Volume 15, Issue 2: 4458. https://doi.org/10.23638/lmcs-15(2:18)2019
• Bik, Aart, Penporn Koanantakool, Tatiana Shpeisman, Nicolas Vasilache, Bixia Zheng, and Fredrik Kjolstad. 2022. “Compiler Support for Sparse Tensor Computations in MLIR.” ACM Transactions on Architecture and Code Optimization 19 (4): 1–25. https://doi.org/10.1145/3544559
• Biradar, Vijayalaxmi, Krishna Dhikale, Shivendra Ghadge, and Atish Shinde. 2026. “Design and Development of an AI-Powered Code Generation System with Persistent Memory and Multi-Agent Architecture.” International Journal of Research Publication and Reviews 7 (6): 3726–30. https://doi.org/10.55248/gengpi.07.0626.16a13
• Blaak, Olav, and Tom Van Cutsem. 2026. “Towards Least-Privilege WebAssembly Applications: Transparent Interposition for WebAssembly Components.” In Companion Proceedings of the 10th International Conference on the Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3801119.3801125
• Blanc, Gregory, and Youki Kadobayashi. 2010. “Towards Revealing JavaScript Program Intents Using Abstract Interpretation.” In Proceedings of the Sixth Asian Internet Engineering Conference on - AINTEC ‘10. ACM Press. https://doi.org/10.1145/1930286.1930298
• Blaß, Thorsten, and Michael Philippsen. 2019. “GPU-Accelerated Fixpoint Algorithms for Faster Compiler Analyses.” In Proceedings of the 28th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3302516.3307352
• Blazy, Sandrine. 2020. “From Verified Compilation to Secure Compilation: A Semantic Approach.” In Proceedings of the 15th Workshop on Programming Languages and Analysis for Security. ACM. https://doi.org/10.1145/3411506.3417601
• Blazy, Sandrine, Andre Maroneze, and David Pichardie. 2015. “Verified Validation of Program Slicing.” In Proceedings of the 2015 Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/2676724.2693169
• Bockisch, Christoph, Gabriele Taentzer, Nebras Nassar, and Lukas Wydra. 2020. “Java Bytecode Verification with OCL Why, How and Whenc.” Journal of Object Technology 19 (3): 3:1. https://doi.org/10.5381/jot.2020.19.3.a13
• Bodin, Martin, Thomas Jensen, and Alan Schmitt. 2015. “Certified Abstract Interpretation with Pretty-Big-Step Semantics.” In Proceedings of the 2015 Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/2676724.2693174
• Boding, R. Phillip. 1996. “Pre-Stack Depth Migration in Three Dimensions with the Imaging Wave Machine.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/1.1826252
• Bonar, Jeffrey G., and Blaise W. Liffick. 1987. A Visual Programming Language for Novices. Defense Technical Information Center. https://doi.org/10.21236/ada218940
• Bonchi, Filippo, and Damien Pous. 2015. “Hacking Nondeterminism with Induction and Coinduction.” Communications of the ACM 58 (2): 87–95. https://doi.org/10.1145/2713167
• Bonyun, David A. 1979. Euclid Compiler for PDP-11. Defense Technical Information Center. https://doi.org/10.21236/ada068542
• Bonyun, David, and R. C. Holt. 1978. EUCLID Compiler for PDP-11. Defense Technical Information Center. https://doi.org/10.21236/ada061052
• Book, E., H. Bratman, and J. Schwartz. 1963. A One Pass Jovial Compiler. Defense Technical Information Center. https://doi.org/10.21236/ad0296834
• Bounpaserth, somchit. 2026. “A Study of the Computer Programming Language Implementation in Computer Engineering Students Using the Flowgorithm Platform versus Common Programming.” Souphanouvong University Journal Multidisciplinary Research and Development 12 (2): 275–83. https://doi.org/10.69692/sujmrd1202275
• Bourke, Timothy, Lélio Brun, and Marc Pouzet. 2018. “Towards a Verified Lustre Compiler with Modular Reset.” In Proceedings of the 21st International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/3207719.3207732
• BrachthÄUser, Jonathan Immanuel, Philipp Schuster, and Klaus Ostermann. 2020. “Effekt: Capability-Passing Style for Type- and Effect-Safe, Extensible Effect Handlers in Scala.” Journal of Functional Programming 30: e8. https://doi.org/10.1017/s0956796820000027
• Brady, Edwin, and Kevin Hammond. 2006. “A Verified Staged Interpreter Is a Verified Compiler.” In Proceedings of the 5th international conference on Generative programming and component engineering. ACM. https://doi.org/10.1145/1173706.1173724
• Briggs, Preston, Keith D. Cooper, and Linda Torczon. 1994. “Improvements to Graph Coloring Register Allocation.” ACM Transactions on Programming Languages and Systems 16 (3): 428–55. https://doi.org/10.1145/177492.177575
• Brock, Jacob, Chen Ding, Xiaoran Xu, and Yan Zhang. 2018. “PAYJIT: Space-Optimal JIT Compilation and Its Practical Implementation.” In Proceedings of the 27th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3178372.3179523
• Brodersen, Robert W. 1994. Anatomy of a Silicon Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada285395
• Bryant, Randal E., Wojciech Nawrocki, Jeremy Avigad, and Marijn J. H. Heule. 2025. “Certified Knowledge Compilation with Application to Formally Verified Model Counting.” Journal of Artificial Intelligence Research 82. https://doi.org/10.1613/jair.1.15958
• Buchwald, Sebastian, Denis Lohner, and Sebastian Ullrich. 2016. “Verified Construction of Static Single Assignment Form.” In Proceedings of the 25th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/2892208.2892211
• Bulej, Lubomír, Yudi Zheng, and Walter Binder. 2016. “Beneath the Bytecode: Observing the JVM at Work Using Bytecode Instrumentation.” In Proceedings of the 11th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems. ACM. https://doi.org/10.1145/3012408.3012409
• Búr, Márton, Kristóf Marussy, Brett H. Meyer, and Dániel Varró. 2021. “Worst-Case Execution Time Calculation for Query-Based Monitors by Witness Generation.” ACM Transactions on Embedded Computing Systems 20 (6): 1–36. https://doi.org/10.1145/3471904
• Burdy, Lilian, and Mariela Pavlova. 2006. “Java Bytecode Specification and Verification.” In Proceedings of the 2006 ACM symposium on Applied computing. ACM. https://doi.org/10.1145/1141277.1141708
• Bushnell, David Henry, Corina Pasareanu, and Ryan M. Mackey. 2008. “Automatic Testcase Generation for Flight Software.” NASA Planetary Spacecraft Fault Management Workshop, April 13. https://ntrs.nasa.gov/citations/20090026335
• Butler, Ricky W., and Sally C. Johnson. 1993. “Formal Methods for Life-Critical Software.” In AIAA Computing in Aerospace 9 Conference, San Diego, CA, October 19-21, 1993. https://ntrs.nasa.gov/citations/20040129612
• “C# Compiler for Blind.” 2017. In ICSESD-2017. Infogain Publication. https://doi.org/10.24001/ijaems.icsesd2017.58
• Caamaño, Juan Manuel Martinez, and Serge Guelton. 2018. “Easy::Jit: Compiler Assisted Library to Enable Just-in-Time Compilation in C++ Codes.” In Conference Companion of the 2nd International Conference on Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3191697.3191725
• Cabrera, J., W. Perkins, W. Lynn, D. Ratcliffe, and W. French. 1992. “3-D Pre-Stack Depth Migration: Implementation and Case History.” Exploration Geophysics 23 (1): 43–46. https://doi.org/10.1071/eg992043
• Caliskan, Aylin, Fabian Yamaguchi, Edwin Dauber, et al. 2018. “When Coding Style Survives Compilation: De-Anonymizing Programmers from Executable Binaries.” In Proceedings 2018 Network and Distributed System Security Symposium. Internet Society. https://doi.org/10.14722/ndss.2018.23304
• “Cameleer a Deductive Verification Tool for OCaml.” 2022. Research Outreach, no. 130. https://doi.org/10.32907/ro-130-2767435612
• Campbell, Earl. 2019. “Random Compiler for Fast Hamiltonian Simulation.” Physical Review Letters 123 (7): 070503. https://doi.org/10.1103/physrevlett.123.070503
• Campbell, Lloyd W., and Glenn A. Beck. 1965. The Forast Programming Language for Ordvac and Brlesc (Revised). Defense Technical Information Center. https://doi.org/10.21236/ad0465805
• Carlotto, Talvany, Zuhaitz Beloki, Xabier Artola, and Aitor Soroa. 2016. “Interoperability of Annotation Schemes: Using the Pepper Framework to Display AWA Documents in the ANNIS Interface.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/5k2zxvthjp7h
• Carminati, Andreu, Renan Augusto Starke, and Rômulo Silva de Oliveira. 2017. “Combining Loop Unrolling Strategies and Code Predication to Reduce the Worst-Case Execution Time of Real-Time Software.” Applied Computing and Informatics 13 (2): 184–93. https://doi.org/10.1016/j.aci.2017.03.002
• Carney, P., and R. Labaugh. 1983. “Efficient Compiler Implementation for a Spaceborne Image Processing Demonstration System.” In 4th Computers in Aerospace Conference. AIAA 1983-2379. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.1983-2379
• Carvalho, Caio B. G., Victor C. Ferreira, Felipe M. G. França, et al. 2019. “A Dataflow Runtime Environment and Static Scheduler for Edge, Fog and in-Situ Computing.” International Journal of Grid and Utility Computing 10 (3): 235. https://doi.org/10.1504/ijguc.2019.099685
• Cassola, Mauricio, Agustín Talagorria, Alberto Pardo, and Marcos Viera. 2020. “A Gradual Type System for Elixir.” In Proceedings of the 24th Brazilian Symposium on Context-Oriented Programming and Advanced Modularity. ACM. https://doi.org/10.1145/3427081.3427084
• Castagna, Giuseppe, Guillaume Duboc, and José Valim. 2023. “The Design Principles of the Elixir Type System.” Art, Science, and Engineering of Programming 8 (2): 4. https://doi.org/10.22152/programming-journal.org/2024/8/4
• Castañeda, Armando, and Gilde Valeria Rodríguez. 2023. “Asynchronous Wait-Free Runtime Verification and Enforcement of Linearizability.” In Proceedings of the 2023 ACM Symposium on Principles of Distributed Computing. ACM. https://doi.org/10.1145/3583668.3594563
• Castañeda, Armando, and Gilde Valeria Rodríguez. 2026. “Asynchronous Wait-Free Runtime Verification and Enforcement of Linearizability.” Journal of the ACM 73 (1): 1–37. https://doi.org/10.1145/3777409
• Ceng Giap, Yo, and Erviana. 2023. “Implementation of Face Mask Detection Using Phyton Programming Language.” bit-Tech 6 (1): 51–58. https://doi.org/10.32877/bt.v6i1.893
• Chaplygin, A. A. 2025. “Modeling and Implementation of Common LISP Functional Language Compiler.” Proceedings of the Southwest State University 29 (3): 99–112. https://doi.org/10.21869/2223-1560-2025-29-3-99-112
• Chatterjee, Sanjay. 2013. Runtime Systems for Extreme Scale Platforms. Defense Technical Information Center. https://doi.org/10.21236/ad1000607
• Chawla, Davinder, Reiya Goyal, Parmod Kumar, and Mandeep Kaur. 2024. “Comparative Study of Propofol Auto-Coinduction versus Ketamine Propofol Coinduction Using Priming Principle by Bispectral Index Analysis for Day Care Surgery.” International Journal of Advanced Research 12 (11): 1093–99. https://doi.org/10.21474/ijar01/19924
• Cheatham, T. E., and Thomas A. Standish. 1970. “Optimization Aspects of Compiler- Compilers.” In Proceedings of a symposium on Compiler optimization -. ACM Press. https://doi.org/10.1145/800028.808482
• Chen, Junjie. 2018. “Learning to Accelerate Compiler Testing.” In Proceedings of the 40th International Conference on Software Engineering: Companion Proceeedings. ACM. https://doi.org/10.1145/3183440.3183456
• Chen, Junjie, Xingyu Fan, Chen Yang, Shuang Liu, and Jun Sun. 2025. “De-Duplicating Silent Compiler Bugs via Deep Semantic Representation.” Proceedings of the ACM on Software Engineering 2 (FSE): 2359–81. https://doi.org/10.1145/3729375
• Chen, Xiwen, Hanfei Lin, Yufei Liang, and Xiaoming Ju. 2016. “A Process-Visible Compiler Aimed for Teaching Assistant.” In Proceedings of the 2015 Conference on Education and Teaching in Colleges and Universities. Atlantis Press. https://doi.org/10.2991/cetcu-15.2016.12
• Chen, Junjie, Haoyang Ma, and Lingming Zhang. 2020b. “Enhanced Compiler Bug Isolation via Memoized Search.” In Proceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. ACM. https://doi.org/10.1145/3324884.3416570
• Chen, Junjie, Jibesh Patra, Michael Pradel, et al. 2020c. “A Survey of Compiler Testing.” ACM Computing Surveys 53 (1): 1–36. https://doi.org/10.1145/3363562
• Chen, Junjie, and Chenyao Suo. 2022. “Boosting Compiler Testing via Compiler Optimization Exploration.” ACM Transactions on Software Engineering and Methodology 31 (4): 1–33. https://doi.org/10.1145/3508362
• Chen, J., C. Wang, Q. Shi, and G. Lv. 2010. “Implementation of Bytecode-Based Software Watermarking for Java Programs.” In Informatics. ACTAPRESS. https://doi.org/10.2316/p.2010.726-026
• Cheng, Zhang, Jiyang Wu, Di Wang, and Qinxiang Cao. 2026. “Denotation-Based Compositional Compiler Verification.” ACM Transactions on Programming Languages and Systems 48 (1): 1–65. https://doi.org/10.1145/3797874
• Ching, Wai-Mee. 1986. “Program Analysis and Code Generation in an APL/370 Compiler.” IBM Journal of Research and Development 30 (6): 594–602. https://doi.org/10.1147/rd.306.0594
• Ching, Wai-Mee, and Alex Katz. 1993. “The Testing of an APL Compiler.” In Proceedings of the international conference on APL. ACM. https://doi.org/10.1145/166197.166205
• Chmiel, Agnieszka, and Nicoletta Spinolo. 2022. “Testing the Impact of Remote Interpreting Settings on Interpreter Experience and Performance: Methodological Challenges inside the Virtual Booth.” Translation, Cognition & Behavior 5 (2): 250–74. https://doi.org/10.1075/tcb.00068.chm
• Choi, Yoonseo, and Hwansoo Han. 2006. “Optimal Register Reassignment for Register Stack Overflow Minimization.” ACM Transactions on Architecture and Code Optimization 3 (1): 90–114. https://doi.org/10.1145/1132462.1132467
• Choi, Eunseok, and Jiman Hong. 2019. “Design and Implementation of Virtual Machine Control and Streaming Scheme Using Linux Kernel-Based Virtual Machine Hypercall for Virtual Mobile Infrastructure.” In Proceedings of the Conference on Research in Adaptive and Convergent Systems. ACM. https://doi.org/10.1145/3338840.3355690
• Christodorescu, Mihai, and Somesh Jha. 2006. Static Analysis of Executables to Detect Malicious Patterns. Defense Technical Information Center. https://doi.org/10.21236/ada449067
• Chung Seo, Seog, and HeeSeok Kim. 2023. “Portable and Efficient Implementation of CRYSTALS-Kyber Based on WebAssembly.” Computer Systems Science and Engineering 46 (2): 2091–2107. https://doi.org/10.32604/csse.2023.035064
• Ciesko, Jan, and Adrien Roussel. 2023. “User-Level Threading for HPC Applications.” In CEA-NNSA Meeting 2023 - Asheville, North Carolina, United States of America - June - 2023. US DOE. https://doi.org/10.2172/2564061
• Cieszewski, Radosław. 2025. “PyHLS: Intermediate Representation for Versatile High-Level Synthesis.” International Journal of Electronics and Telecommunications: 1–7. https://doi.org/10.24425/ijet.2025.156531
• Clerc, Xavier. 2016. “OCaml-Java: The Java Virtual Machine as the Target of an OCaml Compiler.” Journal of Functional Programming 26: e7. https://doi.org/10.1017/s0956796816000095
• Clinger, William. 1984. “The Scheme 311 Compiler an Exercise in Denotational Semantics.” In Proceedings of the 1984 ACM Symposium on LISP and functional programming - LFP ‘84. ACM Press. https://doi.org/10.1145/800055.802052
• Clopper, C. J., and E. S. Pearson. 1934. “The Use of Confidence or Fiducial Limits Illustrated in the Case of the Binomial.” Biometrika 26 (4): 404–13. https://doi.org/10.1093/biomet/26.4.404
• Colombet, Quentin, Benoit Boissinot, Philip Brisk, Sebastian Hack, and Fabrice Rastello. 2011. “Graph-Coloring and Treescan Register Allocation Using Repairing.” In Proceedings of the 14th international conference on Compilers, architectures and synthesis for embedded systems. ACM. https://doi.org/10.1145/2038698.2038708
• “Comparative Study of Virtual Machine Migration Techniques and Challenges in Post Copy Live Virtual Machine Migration.” 2016. International Journal of Science and Research (IJSR) 5 (3): 117–1211. https://doi.org/10.21275/v5i3.nov161797
• Conway, Melvin E. 1963. “Design of a Separable Transition-Diagram Compiler.” Communications of the ACM 6 (7): 396–408. https://doi.org/10.1145/366663.366704
• “Coroutines.” n.d. Kotlin Documentation. Accessed October 24, 2026. https://kotlinlang.org/docs/coroutines-overview.html
• “Coroutines (C++20).” n.d. cppreference.com. Accessed October 24, 2026. https://en.cppreference.com/w/cpp/language/coroutines
• Corrodi, Claudio, Alexander Heußner, and Christopher M. Poskitt. 2018. “A Semantics Comparison Workbench for a Concurrent, Asynchronous, Distributed Programming Language.” Formal Aspects of Computing 30 (1): 163–92. https://doi.org/10.1007/s00165-017-0443-1
• Cortesi, Agostino, Gilberto Filé, Francesco Ranzato, Roberto Giacobazzi, and Catuscia Palamidessi. 1997. “Complementation in Abstract Interpretation.” ACM Transactions on Programming Languages and Systems 19 (1): 7–47. https://doi.org/10.1145/239912.239914
• Corti, Matteo, and Thomas Gross. 2004. “Approximation of the Worst-Case Execution Time Using Structural Analysis.” In Proceedings of the 4th ACM international conference on Embedded software. ACM. https://doi.org/10.1145/1017753.1017797
• Cousot, Patrick. 1996. “Program Analysis: The Abstract Interpretation Perspective.” ACM Computing Surveys 28 (4es): 165. https://doi.org/10.1145/242224.242433
• Cousot, Patrick. 2015b. “Verification by Abstract Interpretation, Soundness and Abstract Induction.” In Proceedings of the 17th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/2790449.2790451
• Cousot, Patrick, and Radhia Cousot. 1995. “Formal Language, Grammar and Set-Constraint-Based Program Analysis by Abstract Interpretation.” In Proceedings of the seventh international conference on Functional programming languages and computer architecture - FPCA ‘95. ACM Press. https://doi.org/10.1145/224164.224199
• Cowan, D. D., and J. W. Graham. 1970. “Design Characteristics of the WATFOR Compiler.” In Proceedings of a symposium on Compiler optimization -. ACM Press. https://doi.org/10.1145/800028.808481
• Cruttwell, Geoffrey, Jonathan Gallagher, and Dorette Pronk. 2021. “Categorical Semantics of a Simple Differential Programming Language.” Electronic Proceedings in Theoretical Computer Science 333: 289–310. https://doi.org/10.4204/eptcs.333.20
• Cummins, Chris, Pavlos Petoumenos, Alastair Murray, and Hugh Leather. 2018. “Compiler Fuzzing through Deep Learning.” In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3213846.3213848
• Curry, Matthew. 2023. “An HPC-Oriented Runtime Environment for Enabling Computational Storage.” In Computational I/O Stack Workshop - Santa Cruz, California, United States of America - August - 2023. US DOE. https://doi.org/10.2172/2463070
• Curtis, Christopher, Daniel Grissom, and Philip Brisk. 2018. “A Compiler for Cyber-Physical Digital Microfluidic Biochips.” In Proceedings of the 2018 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3168826
• Czajka, Łukasz. 2020a. “A New Coinductive Confluence Proof for Infinitary Lambda Calculus.” Logical Methods in Computer Science Volume 16, Issue 1: 4757. https://doi.org/10.23638/lmcs-16(1:31)2020
• Czajka, Łukasz. 2020b. “An Operational Interpretation of Coinductive Types.” Logical Methods in Computer Science Volume 16, Issue 1: 4758. https://doi.org/10.23638/lmcs-16(1:11)2020
• Dagnino, Francesco. 2020. “Coaxioms: Flexible Coinductive Definitions by Inference Systems.” Logical Methods in Computer Science Volume 15, Issue 1: 4745. https://doi.org/10.23638/lmcs-15(1:26)2019
• Dagnino, Francesco. 2021. “Foundations of Regular Coinduction.” Logical Methods in Computer Science Volume 17, Issue 4: 6553. https://doi.org/10.46298/lmcs-17(4:2)2021
• Daiß, Gregor, Patrick Diehl, Hartmut Kaiser, and Dirk Pflüger. 2023. “Stellar Mergers with HPX-Kokkos and SYCL: Methods of Using an Asynchronous Many-Task Runtime System with SYCL.” In International Workshop on OpenCL. ACM. https://doi.org/10.1145/3585341.3585354
• Dakkak, Abdul, Tom Wickham-Jones, and Wen-mei Hwu. 2020. “The Design and Implementation of the Wolfram Language Compiler.” In Proceedings of the 18th ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3368826.3377913
• Dams, Dennis, Rob Gerth, and Orna Grumberg. 1997. “Abstract Interpretation of Reactive Systems.” ACM Transactions on Programming Languages and Systems 19 (2): 253–91. https://doi.org/10.1145/244795.244800
• Dange, Sumit, Prajwal Mundre, and Prerna Jaipurkar. 2023. “Implementation on a User Authentication Scheme Using Block Chain-Enabled Fog Nodes.” International Journal of Research Publication and Reviews 4 (4): 4765–71. https://doi.org/10.55248/gengpi.234.4.38226
• Danvy, Olivier, and Andrzej Filinski. 1990. “Abstracting Control.” In Proceedings of the 1990 ACM conference on LISP and functional programming. ACM. https://doi.org/10.1145/91556.91622
• Davenport, Douglas J. 1995. Object-Oriented Visual Programming Language. Phase 1. Defense Technical Information Center. https://doi.org/10.21236/ada300020
• De, Abhishek, Luc Pellissier, and Alexis Saurin. 2021. “Canonical Proof-Objects for Coinductive Programming: Infinets with Infinitely Many Cuts.” In 23rd International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3479394.3479402
• De Bosschere, Koen, and Paul Tarau. 1994. “High Performance Continuation Passing Style Prolog-to-C Mapping.” In Proceedings of the 1994 ACM symposium on Applied computing - SAC ‘94. ACM Press. https://doi.org/10.1145/326619.326786
• de Moura, Ana Lúcia, and Roberto Ierusalimschy. 2009. “Revisiting Coroutines.” ACM Transactions on Programming Languages and Systems 31 (2): 1–31. https://doi.org/10.1145/1462166.1462167
• de Niz, Dionisio. 2007. Diagrams and Languages for Model-Based Software Engineering of Embedded Systems: UML and AADL. Defense Technical Information Center. https://doi.org/10.21236/ada633428
• De Paula, Gabriel Coutinho, and Roberto Ierusalimschy. 2022. “A Foreign Function Interface for Pallene.” In Proceedings of the XXVI Brazilian Symposium on Programming Languages. ACM. https://doi.org/10.1145/3561320.3561321
• “The Deasibility and Properties of Dividing Virtual Machine Resources Using the Virtual Machine Cluster as the Unit in Cloud Computing.” 2015. KSII Transactions on Internet and Information Systems 9 (7). https://doi.org/10.3837/tiis.2015.07.018
• Debenham, Helen, and Shane Westlake. 2014. “Pre-Stack Depth Migration for Improved Imaging under Seafloor Canyons: 2D Case Study of Browse Basin, AustraliaFN1.” Exploration Geophysics 45 (3): 216–22. https://doi.org/10.1071/eg12085
• Dejtrakulwong, Piyapa, Gary Mavko, and Tapan Mukerji. 2013. “Sensitivity Analysis and Cascaded Interpretation Scheme for Subtle Seismic Signatures in Thin Shaly-Sand Reservoirs.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/segam2013-0385.1
• del Vado Vírseda, Rafael. 2021. “Learning Compiler Design: From the Implementation to Theory.” In Proceedings of the 26th ACM Conference on Innovation and Technology in Computer Science Education V. 2. ACM. https://doi.org/10.1145/3456565.3460041
• Delaët, Alain, Sandrine Blazy, and Denis Merigoux. 2025. “Abstract Machines and Small-Step Semantics: A Winning Ticket for Proof Automation?” In Proceedings of the 27th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3756907.3756926
• Delgado-Pérez, Pedro, and Sergio Segura. 2019. “Study of Trivial Compiler Equivalence on C++ Object-Oriented Mutation Operators.” In Proceedings of the 34th ACM/SIGAPP Symposium on Applied Computing. ACM. https://doi.org/10.1145/3297280.3297499
• Denney, Ewen, and Bernd Fischer. 2005. “Formal Safety Certification of Aerospace Software.” In Infotech@Aerospace, Arlington, VA, September 26-29, 2005. https://ntrs.nasa.gov/citations/20050241794
• Denney, Ewen, and Bernd Fischer. 2009. “Generating Code Review Documentation for Auto-Generated Mission-Critical Software.” In IEEE International Conference on Space Mission Challenges for Information Technology (SMC-IT) 2009. https://ntrs.nasa.gov/citations/20100023347
• Deransart, P. 1979. “Proof by Semantic Attributes of a LISP Compiler.” Computer Journal 22 (3): 240–45. https://doi.org/10.1093/comjnl/22.3.240
• Di Lavore, Elena, Giovanni de Felice, and Mario Román. 2025. “Coinductive Streams in Monoidal Categories.” Logical Methods in Computer Science Volume 21, Issue 3: 10759. https://doi.org/10.46298/lmcs-21(3:18)2025
• Dickerson, Mitchel, Anand Srinivasan, and Michael Franz. 2026. “Practical Python FPGA Acceleration with Fast Just-In-Time Compilation and Configuration.” ACM Transactions on Architecture and Code Optimization 23 (1): 1–25. https://doi.org/10.1145/3797265
• Dico, Dicopran sisco, and Tata Sutabri. 2025. “Virtual Desktop Infrastructure Sebagai Pendukung Perkuliahan Dengan Algoritma Virtual Machine.” BETRIK 16 (01): 74–85. https://doi.org/10.36050/8y461v31
• Ding, Chen, Dong Chen, Fangzhou Liu, Benjamin Reber, and Wesley Smith. 2022. “CARL: Compiler Assigned Reference Leasing.” ACM Transactions on Architecture and Code Optimization 19 (1): 1–28. https://doi.org/10.1145/3498730
• Dinikeev, A. M. 2025. “Type System for a Statically Typed Concatenative Programming Language with First Class Function Support.” Information-measuring and Control Systems: 15–25. https://doi.org/10.18127/j20700814-202505-02
• Dissegna, Stefano, Francesco Logozzo, and Francesco Ranzato. 2016. “An Abstract Interpretation-Based Model of Tracing Just-in-Time Compilation.” ACM Transactions on Programming Languages and Systems 38 (2): 1–50. https://doi.org/10.1145/2853131
• Dobravec, Tomaž. 2018. “Java Bytecode Instruction Usage Counting with Algator.” Acta Electrotechnica et Informatica 18 (4): 17–25. https://doi.org/10.15546/aeei-2018-0028
• Dold, Axel, Friedrich von Henke, and Wolfgang Goerigk. 2003. “A Completely Verified Realistic Bootstrap Compiler.” International Journal of Foundations of Computer Science 14 (04): 659–80. https://doi.org/10.1142/s0129054103001947
• Domagała, Łukasz, Duco van Amstel, Fabrice Rastello, and P. Sadayappan. 2016. “Register Allocation and Promotion through Combined Instruction Scheduling and Loop Unrolling.” In Proceedings of the 25th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/2892208.2892219
• Dong, Biao. 2013. “Design and Implementation of Compiler Subsystem for Object Oriented Publish/Subscribe Systems.” Applied Mechanics and Materials 462-463: 1036–39. https://doi.org/10.4028/www.scientific.net/amm.462-463.1036
• Dong, Yukun. 2018. “A Sound Abstract Memory Model for Static Analysis of C Programs.” International Journal of Computational Science and Engineering 16 (3): 255. https://doi.org/10.1504/ijcse.2018.091782
• Dong, Yuan, Sheng-Yuan Wang, Li-Wei Zhang, Yun-Min Zhu, and Ping Yang. 2011. “Logic System for Bytecode Program Modular Certification.” Journal of Software 21 (12): 3056–67. https://doi.org/10.3724/sp.j.1001.2010.03709
• Donohoe, Patrick. 1987. A Survey of Real-Time Performance Benchmarks for the Ada Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada200608
• Doronin, Oleg. 2019. “Problem Research and Development of a Tool for Checking Application Binary Interface Compatibility of Virtual Method Tables.” In SGEM International Multidisciplinary Scientific GeoConference EXPO Proceedings, vol. 19. STEF92 Technology. https://doi.org/10.5593/sgem2019/2.1/s07.070
• Downen, Paul, and Zena M. Ariola. 2014. “Delimited Control and Computational Effects.” Journal of Functional Programming 24 (1): 1–55. https://doi.org/10.1017/s0956796813000312
• Downen, Paul, and Zena M. Ariola. 2025. “A Contextual Formalization of Structural Coinduction.” Journal of Functional Programming 35: e14. https://doi.org/10.1017/s0956796825100026
• Du, Hongjia. 2026. “Performance Verification of BFS for Unweighted Maze Solving: A Comparative Analysis with DFS and a* via Ocaml Implementation.” Mathematical Modeling and Algorithm Application 9 (1): 230–36. https://doi.org/10.54097/b1m57229
• Dubach, Christophe, John Cavazos, Björn Franke, Grigori Fursin, Michael F. P. O’Boyle, and Olivier Temam. 2007. “Fast Compiler Optimisation Evaluation Using Code-Feature Based Performance Prediction.” In Proceedings of the 4th international conference on Computing frontiers. ACM. https://doi.org/10.1145/1242531.1242553
• Duhoux, Benoît, Kim Mens, and Bruno Dumas. 2019. “Implementation of a Feature-Based Context-Oriented Programming Language.” In Proceedings of the Workshop on Context-oriented Programming - COP ‘19. ACM Press. https://doi.org/10.1145/3340671.3343357
• Dybvig, R. Kent, Simon Peyton Jones, and Amr Sabry. 2007. “A Monadic Framework for Delimited Continuations.” Journal of Functional Programming 17 (6): 687–730. https://doi.org/10.1017/s0956796807006259
• Eachempati, Deepak, Hyoung Joon Jun, and Barbara Chapman. 2010. “An Open-Source Compiler and Runtime Implementation for Coarray Fortran.” In Proceedings of the Fourth Conference on Partitioned Global Address Space Programming Model. ACM. https://doi.org/10.1145/2020373.2020386
• Ecma International. 2023. C# Language Specification. ECMA-334, 7th edition. Ecma International. https://www.ecma-international.org/publications-and-standards/standards/ecma-334/
• Ecma International, TC39. n.d. ECMAScript® 2027 Language Specification. ECMA-262. Ecma International. https://tc39.es/ecma262/
• “Efficient Implementation of Class Based Decomposition Schemes for Naive Bayes Classifier.” 2015. International Journal of Science and Research (IJSR) 4 (11): 237–40. https://doi.org/10.21275/v4i11.nov151091
• Efthymiou, Stavros, Marco Lazzarin, Andrea Pasquale, and Stefano Carrazza. 2022. “Quantum Simulation with Just-in-Time Compilation.” Quantum 6: 814. https://doi.org/10.22331/q-2022-09-22-814
• Egreteau, A., and P. Thierry. 2005. “Attenuating the Effects of Pre-Stack Depth Migration for AVA Analysis.” In 67th EAGE Conference & Exhibition. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.1.p023
• Eisl, Josef, Matthias Grimmer, Doug Simon, Thomas Würthinger, and Hanspeter Mössenböck. 2016. “Trace-Based Register Allocation in a JIT Compiler.” In Proceedings of the 13th International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools. ACM. https://doi.org/10.1145/2972206.2972211
• Eisl, Josef, David Leopoldseder, and Hanspeter Mössenböck. 2018. “Parallel Trace Register Allocation.” In Proceedings of the 15th International Conference on Managed Languages & Runtimes - ManLang ‘18. ACM Press. https://doi.org/10.1145/3237009.3237010
• Electronic Systems Div Hanscom Afb Ma. 1970. User’s Manual Jovial Compiler Validation System. Defense Technical Information Center. https://doi.org/10.21236/ad0711370
• Elkhouly, Reem, Mohammad Alshboul, Akihiro Hayashi, Yan Solihin, and Keiji Kimura. 2019. “Compiler-Support for Critical Data Persistence in NVM.” ACM Transactions on Architecture and Code Optimization 16 (4): 1–25. https://doi.org/10.1145/3371236
• Elof Frank. 1995. “Constrained Register Allocation in Bus Architectures.” In 32nd Design Automation Conference. ACM. https://doi.org/10.1109/dac.1995.250085
• Emerson, Guy. 2020. “Autoencoding Pixies: Amortised Variational Inference with Graph Convolutions for Functional Distributional Semantics.” In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics. Association for Computational Linguistics. https://doi.org/10.18653/v1/2020.acl-main.367
• Endo, Fernando A., Arthur Perais, and André Seznec. 2017. “On the Interactions between Value Prediction and Compiler Optimizations in the Context of EOLE.” ACM Transactions on Architecture and Code Optimization 14 (2): 1–24. https://doi.org/10.1145/3090634
• Ermedahl, Andreas, Friedhelm Stappert, and Jakob Engblom. 2003. “Clustered Calculation of Worst-Case Execution Times.” In Proceedings of the international conference on Compilers, architectures and synthesis for embedded systems - CASES ‘03. ACM Press. https://doi.org/10.1145/951718.951720
• Evans, R. V., G. S. Lockington, and T. N. Reid. 1978. “A Compiler Compiler and Methodology for Problem Oriented Language Compiler Implementors.” Computer Journal 21 (2): 117–21. https://doi.org/10.1093/comjnl/21.2.117
• Ewing, Gregory. 2009. “Syntax for Delegating to a Subgenerator.” Python Enhancement Proposals. Accessed October 24, 2026. https://peps.python.org/pep-0380/
• Facchinetti, Leandro, Zachary Palmer, and Scott Smith. 2019. “Higher-Order Demand-Driven Program Analysis.” ACM Transactions on Programming Languages and Systems 41 (3): 1–53. https://doi.org/10.1145/3310340
• Falis, Edward. 1982. “Design and Implementation in Ada of a Runtime Task Supervisor.” In Proceedings of the AdaTEC Conference on Ada. ACM. https://doi.org/10.1145/3304133.3304135
• Falk, Heiko. 2009. “WCET-Aware Register Allocation Based on Graph Coloring.” In Proceedings of the 46th Annual Design Automation Conference. ACM. https://doi.org/10.1145/1629911.1630100
• Fan, Yun-Zhuo, Yu-Xia Wu, and Dan-Bo Zhang. 2025. “Adaptive Random Compiler for Hamiltonian Simulation.” Physical Review A 112 (6): 062431. https://doi.org/10.1103/4nmq-twj8
• Fayzrakhmanov, Timur Rasimovich. 2022. “Introducing Programming Language Metrics.” Proceedings of the Institute for System Programming of the RAS 34 (6): 67–84. https://doi.org/10.15514/ispras-2022-34(6)-5
• Feitosa, Samuel da Silva, and Rodrigo Geraldo Ribeiro. 2024. “Differential Testing Using Random Well-Typed Haskell Programs.” In Anais do XXVIII Simpósio Brasileiro de Linguagens de Programação (SBLP 2024). Sociedade Brasileira de Computação. https://doi.org/10.5753/sblp.2024.3462
• Feldman, Jerome A. 1966. “A Formal Semantics for Computer Languages and Its Application in a Compiler-Compiler.” Communications of the ACM 9 (1): 3–9. https://doi.org/10.1145/365153.365156
• Feret, Jéro^me, Theodore E. Simos, and George Maroulis. 2007. “Reachability Analysis of Biological Signalling Pathways by Abstract Interpretation.” In AIP Conference Proceedings, vol. 963. AIP. https://doi.org/10.1063/1.2836158
• “A Fibrational Method of Indexed Coinductive Data Types.” 2020. Tehnicki vjesnik - Technical Gazette 27 (2). https://doi.org/10.17559/tv-20191130092745
• Finkelstein, M. 1968. “A Compiler Optimization Technique.” Computer Journal 11 (1): 22–25. https://doi.org/10.1093/comjnl/11.1.22
• Fisher, D. A. 1976. A Common Programming Language for the Department of Defense–Background and Technical Requirements. Defense Technical Information Center. https://doi.org/10.21236/ada028297
• Fonseca, Pedro, Kaiyuan Zhang, Xi Wang, and Arvind Krishnamurthy. 2017. “An Empirical Study on the Correctness of Formally Verified Distributed Systems.” In Proceedings of the Twelfth European Conference on Computer Systems. ACM. https://doi.org/10.1145/3064176.3064183
• Formal Methods Specification and Analysis Guidebook for the Verification of Software and Computer Systems: A Practitioner’s Companion: Volume 2. 1995a. NASA-GB-001-97/VOL2. National Aeronautics and Space Administration. https://ntrs.nasa.gov/citations/19980227975
• Formal Methods Specification and Verification Guidebook for Software and Computer Systems: Planning and Technology Insertion: Volume 1. 1995b. NASA-GB-002-95/VOL1. National Aeronautics and Space Administration. https://ntrs.nasa.gov/citations/19980228002
• Forster, Yannick, Ohad Kammar, Sam Lindley, and Matija Pretnar. 2019. “On the Expressive Power of User-Defined Effects: Effect Handlers, Monadic Reflection, Delimited Control.” Journal of Functional Programming 29: e15. https://doi.org/10.1017/s0956796819000121
• Freitas da Luz, Samuel L., and João C. Ribeiro Cruz. 2003. “The CRS Stack as a Tool for Pre-Stack Depth Migration.” In 8th International Congress of the Brazilian Geophysical Society. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.168.arq_809
• Frenkel, Jens, Günter Kunze, Peter Fritzson, Martin Sjölund, Adrian Pop, and Willi Braun. 2011. “Towards a Modular and Accessible Modelica Compiler Backend.” In Linköping Electronic Conference Proceedings, vol. 63. Linköping University Electronic Press. https://doi.org/10.3384/ecp11063232
• Freund, Stephen N., and John C. Mitchell. 1999. “A Type System for Object Initialization in the Java Bytecode Language.” ACM Transactions on Programming Languages and Systems 21 (6): 1196–1250. https://doi.org/10.1145/330643.330646
• Fruehwirth, Thom. 2025. “Runtime Repeated Recursion Unfolding in CHR: A Just-In-Time Online Program Optimization Strategy That Can Achieve Super-Linear Speedup.” Fundamenta Informaticae Volume 194, Issue 3: 11547. https://doi.org/10.46298/fi.11547
• Gal, Andreas, Christian W. Probst, and Michael Franz. 2008. “Java Bytecode Verification via Static Single Assignment Form.” ACM Transactions on Programming Languages and Systems 30 (4): 1–21. https://doi.org/10.1145/1377492.1377496
• Gallaher, L. J. 1982. Investigate Capability of Ada Higher Order Programming Language for Developing Machine Independent Software. Defense Technical Information Center. https://doi.org/10.21236/ada116070
• Ganzinger, Harald, Knut Ripken, and Reinhard Wilhelm. 1976. “MUG1: An Incremental Compiler-Compiler.” In Proceedings of the annual conference on - ACM 76. ACM Press. https://doi.org/10.1145/800191.805629
• Gao, Hong-bo, Qing-bao Li, Wei Wang, Xiao-dong Xie, and Yu Zhu. 2014. “A Method of Binary Code Variable Interval Analysis Based on Abstract Interpretation.” Journal of Electronics & Information Technology 35 (8): 1927–32. https://doi.org/10.3724/sp.j.1146.2012.01341
• Gao, Lei, and Ce Shi. 2005. “An Improved Approach of Register Allocation via Graph Coloring.” In SPIE Proceedings, vol. 5683, edited by Subramania Sudharsanan, V. Michael Bove Jr., Sethuraman Panchanathan. SPIE. https://doi.org/10.1117/12.586295
• Garcia, Ronald, Andrew Lumsdaine, and Amr Sabry. 2010. “Lazy Evaluation and Delimited Control.” Logical Methods in Computer Science Volume 6, Issue 3: 1013. https://doi.org/10.2168/lmcs-6(3:1)2010
• Gaudet, Matthew, and Mark Stoodley. 2016. “Rebuilding an Airliner in Flight: A Retrospective on Refactoring IBM Testarossa Production Compiler for Eclipse OMR.” In Proceedings of the 8th International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/2998415.2998419
• Georgakoudis, Giorgis, Konstantinos Parasyris, and David Beckingsale. 2025. “Proteus: Portable Runtime Optimization of GPU Kernel Execution with Just-in-Time Compilation.” In Proceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3696443.3708939
• Georgescu, Călin, Mitchell Olsthoorn, Pouria Derakhshanfar, Marat Akhin, and Annibale Panichella. 2024. “Evolutionary Generative Fuzzing for Differential Testing of the Kotlin Compiler.” In Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3663529.3663864
• Georgiou, Kyriakos, Zbigniew Chamski, Andres Amaya Garcia, David May, and Kerstin Eder. 2020. “Lost in Translation: Exposing Hidden Compiler Optimization Opportunities.” Computer Journal 65 (3): 718–35. https://doi.org/10.1093/comjnl/bxaa103
• Gerasimov, A. Yu. 2018. “Directed Dynamic Symbolic Execution for Static Analysis Warnings Confirmation.” Programming and Computer Software 44 (5): 316–23. https://doi.org/10.1134/s036176881805002x
• Ghica, Dan R., and Khulood Alyahya. 2017. “On the Learnability of Programming Language Semantics.” Electronic Proceedings in Theoretical Computer Science 261: 57–75. https://doi.org/10.4204/eptcs.261.7
• Ghuzdewan, Toriq Arif. 2025. “Development of a Python-Based Program for Pareto Analysis in Construction Project Cost Management.” G-Tech: Jurnal Teknologi Terapan 9 (3): 1447–56. https://doi.org/10.70609/g-tech.v9i3.7379
• Gibbons, Jeremy. 2021. “Continuation-Passing Style, Defunctionalization, Accumulations, and Associativity.” Art, Science, and Engineering of Programming 6 (2): 7. https://doi.org/10.22152/programming-journal.org/2022/6/7
• Gifford, David K., Pierre Jouvelot, Mark A. Sheldon, and James W. O’Toole. 1992. Report on the FX-91 Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada256798
• Ginsbach, Philip, Lewis Crawford, and Michael F. P. O’Boyle. 2018. “CAnDL: A Domain Specific Language for Compiler Analysis.” In Proceedings of the 27th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3178372.3179515
• Giorgi, J. F., and D. Le Métayer. 1990. “Continuation-Based Parallel Implementation of Functional Programming Languages.” In Proceedings of the 1990 ACM conference on LISP and functional programming. ACM. https://doi.org/10.1145/91556.91648
• Girault, Alain. 2025. “Toward a Formally Verified Compiler for a Synchronous, Functional, Data-Flow Programming Language.” Communications of the ACM 69 (1): 92–92. https://doi.org/10.1145/3768311
• Goldberg, Allen. 1998. “A Specification of Java Loading and Bytecode Verification.” In Proceedings of the 5th ACM conference on Computer and communications security. ACM. https://doi.org/10.1145/288090.288104
• Gómez-Déniz, Emilo, Nancy Dávila-Cárdenes, and Ma Dolores García-Artiles. 2016. “Random Tests Combining Mathematica Package and Latex Compiler.” International Journal of Software Engineering & Applications 7 (4): 01–10. https://doi.org/10.5121/ijsea.2016.7401
• Goncharov, Sergey, Lutz Schröder, Christoph Rauch, and Julian Jakob. 2018. “Unguarded Recursion on Coinductive Resumptions.” Logical Methods in Computer Science Volume 14, Issue 3: 4773. https://doi.org/10.23638/lmcs-14(3:10)2018
• Goodenough, John B., Clement L. McGowan, and John R. Kelly. 1976. Evaluation of ALGOL 68, JOVIAL J3B, PASCAL, SIMULA 67, and TACPOL vs. TINMAN Requirements for a Common High Order Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada033893
• Gordon, Stuart, and Sven-Bodo Scholz. 2015. “Dynamic Adaptation of Functional Runtime Systems through External Control.” In Proceedings of the 27th Symposium on the Implementation and Application of Functional Programming Languages. ACM. https://doi.org/10.1145/2897336.2897347
• Gore, Ankita, Vanshika Bajaj, Preeti Yadav, Vaishnavi Chouhan, Madhuri Tayal, and M. Sasi Kumar. 2023. “Sentence Generator for English Language Using Formal Semantics.” International Journal of Next-Generation Computing. https://doi.org/10.47164/ijngc.v14i1.1090
• Gorodetskiy, A. D. 2019. “Nextgen: Programming Language with Programmable Semantics.” In A collection of conference papers. Omsk Scientific-Research Institute of Instrument Engineering. https://doi.org/10.33286/978-5-6041917-2-9.286-287
• Gourdin, Léo. 2023. “Lazy Code Transformations in a Formally Verified Compiler.” In Proceedings of the 18th ACM International Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems. ACM. https://doi.org/10.1145/3605158.3605848
• Grabmayer, Clemens. 2023. “A Coinductive Reformulation of Milner’s Proof System for Regular Expressions Modulo Bisimilarity.” Logical Methods in Computer Science Volume 19, Issue 2: 9244. https://doi.org/10.46298/lmcs-19(2:17)2023
• Graham, Marc. 1995. Information Technology. Programming Language. the SQL Ada Module Description Language (SAMeDL). Defense Technical Information Center. https://doi.org/10.21236/ada302319
• Granli, J. R. 1993. “Imaging Salt with Pre-Stack Depth Migration.” In 55th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201411447
• Grechanik, Mark. 2012. “Random Benchmark Application Generation for Evaluating Program Analysis and Testing Tools.” ACM SIGSOFT Software Engineering Notes 37 (6): 6–7. https://doi.org/10.1145/2382756.2382758
• Green, Pd, and Ar Wood. 2024. “Reasoning about the Acoustic Realisation of Semivowels Using an Intermediate Representation: The ‘Speech Sketch’.” In Autumn Conference 1984. Institute of Acoustics. https://doi.org/10.25144/22696
• “Green Supply Chain Management and Competitive Advantage: Evidence of Just-in-Time Management on Firm Performance SMEs in Indonesia.” 2023. Quality - Access to Success 24 (195). https://doi.org/10.47750/qas/24.195.06
• Groenewegen, Danny M., Elmer van Chastelet, and Eelco Visser. 2020. “Evolution of the WebDSL Runtime: Reliability Engineering of the WebDSL Web Programming Language.” In Conference Companion of the 4th International Conference on Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3397537.3397553
• Grolaux, Donatien, Thanh-Diane Nguyen, and Jean Vanderdonckt. 2026. “Async/await Is an Effective Paradigm for Event Management of User Interfaces.” In Companion Proceedings of the 18th ACM SIGCHI Symposium on Engineering Interactive Computing Systems. ACM. https://doi.org/10.1145/3807968.3810928
• Groß, Samuel, Simon Koch, Lukas Bernhard, Thorsten Holz, and Martin Johns. 2023. “FUZZILLI: Fuzzing for JavaScript JIT Compiler Vulnerabilities.” In Proceedings 2023 Network and Distributed System Security Symposium. Internet Society. https://doi.org/10.14722/ndss.2023.24290
• Grover, V. 1985. Guidelines for a Minimal Ada Runtime Environment. Defense Technical Information Center. https://doi.org/10.21236/ada160451
• Gruner, Bernd, Clemens-Alexander Brust, and Andreas Zeller. 2025a. “Finding Information Leaks with Information Flow Fuzzing.” ACM Transactions on Software Engineering and Methodology 34 (6): 1–18. https://doi.org/10.1145/3711902
• Gruner, Bernd, Clemens-Alexander Brust, and Andreas Zeller. 2025b. “Finding Information Leaks with Information Flow Fuzzing—RCR Report.” ACM Transactions on Software Engineering and Methodology 34 (6): 1–4. https://doi.org/10.1145/3711905
• Gu, Qiuhan. 2023. “LLM-Based Code Generation Method for Golang Compiler Testing.” In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3611643.3617850
• Guan, Xueting, and Christoph Treude. 2024. “Enhancing Source Code Representations for Deep Learning with Static Analysis.” In Proceedings of the 32nd IEEE/ACM International Conference on Program Comprehension. ACM. https://doi.org/10.1145/3643916.3644396
• Guarna, Vincent A., Jr. 1987. VPC: A Proposal for a Vector Parallel C Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada190885
• Guerrini, Stefano, and Andrea Masini. 2009. “Proofs, Tests and Continuation Passing Style.” ACM Transactions on Computational Logic 10 (2): 1–34. https://doi.org/10.1145/1462179.1462184
• Gupta, Shail A. 1990. An Incremental Type Inference System for the Programming Language Id. Defense Technical Information Center. https://doi.org/10.21236/ada230085
• Gupta, Nitish, and Mike Lewis. 2018. “Neural Compositional Denotational Semantics for Question Answering.” In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics. https://doi.org/10.18653/v1/d18-1239
• Haase, Oliver. 2016. “Abstract Interpretation of Java Bytecode for Immutability Analysis.” Journal of Computer Science 12 (7): 314–22. https://doi.org/10.3844/jcssp.2016.314.322
• Haj-Yihia, Jawad, Yosi Ben Asher, Efraim Rotem, Ahmad Yasin, and Ran Ginosar. 2015. “Compiler-Directed Power Management for Superscalars.” ACM Transactions on Architecture and Code Optimization 11 (4): 1–21. https://doi.org/10.1145/2685393
• Hamana, Makoto. 2022. “Modular Termination for Second-Order Computation Rules and Application to Algebraic Effect Handlers.” Logical Methods in Computer Science Volume 18, Issue 2: 6600. https://doi.org/10.46298/lmcs-18(2:18)2022
• Hamid, Rahimah Abdul, and Teruaki Ito. 2017. “Image Segmentation to Design Semi-Optimized Curve for B-Code Generation.” Proceedings of Design & Systems Conference 2017.27 (0): 2502. https://doi.org/10.1299/jsmedsd.2017.27.2502
• Hammond, Jeff, Lisandro Dalcin, Erik Schnetter, et al. 2023. “MPI Application Binary Interface Standardization.” In Proceedings of the 30th European MPI Users’ Group Meeting. ACM. https://doi.org/10.1145/3615318.3615319
• Han, Dong Yeon, Seung Min Yoo, and Ho Kyun Park. 2026. “Design and Implementation of Boss AI for 2D Action Games Using Finite State Machines and Coroutine Chaining.” Asia-pacific Journal of Convergent Research Interchange 12 (5): 31–44. https://doi.org/10.47116/apjcri.2026.05.03
• Hanitzsch, C., E. Robein, and P. Sexton. 2001. “Pre-Stack Depth Migration for Time-to-Depth Conversion: The Ultimate Tool?” In 63rd EAGE Conference & Exhibition. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.15.iv-4
• Hanley, James A., and Abby Lippman-Hand. 1983. “If Nothing Goes Wrong, Is Everything All Right?: Interpreting Zero Numerators.” JAMA 249 (13): 1743. https://doi.org/10.1001/jama.1983.03330370053031
• Hanzich, M., M. Araya-Polo, J. M. Cela, and F. Ortigosa. 2009. “Subsalt Imaging through Pre-Stack Depth Migration: A Case Study from the North Red Sea.” In Proceedings. EAGE Publications BV. https://doi.org/10.3997/2214-4609.20145760
• Hardy, Damien, and Isabelle Puaut. 2013. “Static Probabilistic Worst Case Execution Time Estimation for Architectures with Faulty Instruction Caches.” In Proceedings of the 21st International conference on Real-Time Networks and Systems. ACM. https://doi.org/10.1145/2516821.2516842
• Harmon, Marion G. 1988. “An Ada Implementation of Marsaglia’s Universal Random Number Generator.” ACM SIGAda Ada Letters VIII (2): 110–12. https://doi.org/10.1145/45380.45386
• Harper, Robert, and Frank Pfenning. 1992. A Module System for a Programming Language Based on the LF Logical Framework. Defense Technical Information Center. https://doi.org/10.21236/ada256731
• Harrison, George C. 1989. Research, Development, Training and Education Using the Ada Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada210760
• Harrison, Michael, Susan Graham, and Kenneth Kennedy. 1976. “Theoretical Results in Compiler Design and Implementation (Tutorial Session).” In Proceedings of the annual conference on - ACM 76. ACM Press. https://doi.org/10.1145/800191.805518
• Hart, Ruth M., and Marilyn S. McClanahan. 1981. JOVIAL (J73) Compiler Validator. Defense Technical Information Center. https://doi.org/10.21236/ada102386
• Hartley, Tim, Foivos S. Zakkak, Andy Nisbet, Christos Kotselidis, and Mikel Luján. 2022. “Just-In-Time Compilation on ARM—a Closer Look at Call-Site Code Consistency.” ACM Transactions on Architecture and Code Optimization 19 (4): 1–23. https://doi.org/10.1145/3546568
• Haspert, J. Kent, and Anthony Beauregard. 1998. The Commercialization of a Rapid Prototyping Development Tool for Real-Time Embedded Software Intensive, Process, and Resource Management Systems. Defense Technical Information Center. https://doi.org/10.21236/ada358469
• Hataba, Muhammad, Ahmed El-Mahdy, and Kazunori Ueda. 2019. “Generation of Efficient Obfuscated Code through Just-in-Time Compilation.” IEICE Transactions on Information and Systems E102.D (3): 645–49. https://doi.org/10.1587/transinf.2018edl8180
• Hausladen, Jürgen, Florian Gerstmayer, Thomas Jerabek, and Martin Horauer. 2017. “Integration of Static Worst-Case Execution Time and Stack Usage Analysis for Embedded Systems Software in a Cloud-Based Development Environment.” In Volume 9: 13th ASME/IEEE International Conference on Mechatronic and Embedded Systems and Applications. American Society of Mechanical Engineers. https://doi.org/10.1115/detc2017-67402
• Havelund, Klaus, Mike Lowry, SeungJoon Park, et al. 2000. “Formal Analysis of the Remote Agent before and after Flight.” In Lfm2000: Fifth NASA Langley Formal Methods Workshop. https://ntrs.nasa.gov/citations/20000055731
• Hazimeh, Ahmad, Adrian Herrera, and Mathias Payer. 2021. “Magma: A Ground-Truth Fuzzing Benchmark.” ACM SIGMETRICS Performance Evaluation Review 49 (1): 81–82. https://doi.org/10.1145/3543516.3456276
• He, Yifeng, Luning Yang, Christopher Gonzalo, and Hao Chen. 2025. “Evaluating Program Semantics Reasoning with Type Inference in System $F$.” In Advances in Neural Information Processing Systems 38. Neural Information Processing Systems Foundation, Inc. (NeurIPS). https://doi.org/10.52202/085713-0123
• He, Wenju, Maosu Zhao, Yuxin Zou, and Feng Zou. 2023b. “Profile Guided Optimization Transfer-Learning for OpenCL/SYCL Kernel Compilation and Runtime.” In International Workshop on OpenCL. ACM. https://doi.org/10.1145/3585341.3585359
• Heim, Bettina. 2018. “Compiler and Language Design for Quantum Computing (Keynote).” In Proceedings of the 27th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3178372.3183636
• Heimbigner, Dennis. 2006. A Tamper-Resistant Programming Language System. Defense Technical Information Center. https://doi.org/10.21236/ada449363
• Hensley, Dalton, and Heba Elgazzar. 2025. “Design and Implementation of the Morehead-Azalea Compiler (Mac).” Computer Science & Engineering: An International Journal: 315–28. https://doi.org/10.5121/cseij.2025.15133
• Herring, Charles, Biju Kalathil, and Joseph Teo. 1993. Research in Presistent Simulation: Development of the Persistent ModSim Object-Oriented Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada268568
• Heuring, Vincent P., William M. Waite, and Gerhard Fischer. 1990. Automatic Compiler Construction. Defense Technical Information Center. https://doi.org/10.21236/ada218777
• Hillerström, Daniel, and Sam Lindley. 2016. “Liberating Effects with Rows and Handlers.” In Proceedings of the 1st International Workshop on Type-Driven Development. ACM. https://doi.org/10.1145/2976022.2976033
• HillerstrÖM, Daniel, Sam Lindley, and Robert Atkey. 2020. “Effect Handlers via Generalised Continuations.” Journal of Functional Programming 30: e5. https://doi.org/10.1017/s0956796820000040
• HillerstrÖM, Daniel, Sam Lindley, and John Longley. 2024. “Asymptotic Speedup via Effect Handlers.” Journal of Functional Programming 34: e5. https://doi.org/10.1017/s0956796824000030
• Hinkley, D., R. Ho, and S. Lee. 1994. “Velocity Model Building for 3D Pre-Stack Depth Migration: A Case Study.” In EAEG/SEG Summer Workshop - Construction of 3-D Macro Velocity-Depth Models. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201407588
• Hird, Geoffrey R. 1991. “Formal Specification and Verification of Ada Software.” In AIAA Computing in Aerospace Conference, Baltimore, MD, October 21-24, 1991. https://ntrs.nasa.gov/citations/19920034961
• Hmid, Soukaina N., Jose G. F. Coutinho, and Wayne Luk. 2016. “A Transfer-Aware Runtime System for Heterogeneous Asynchronous Parallel Execution.” ACM SIGARCH Computer Architecture News 43 (4): 40–45. https://doi.org/10.1145/2927964.2927972
• Hollingshaus, Wade, and Will Daddario. 2015. “Performance Philosophy: Arrived Just in Time?” Theatre Topics 25 (1): 51–56. https://doi.org/10.1353/tt.2015.0002
• Holmen, John, Damodar Sahasrabudhe, and Martin Berzins. 2021. “A Heterogeneous MPI+PPL Task Scheduling Approach for Asynchronous Many-Task Runtime Systems.” In Practice and Experience in Advanced Research Computing. ACM. https://doi.org/10.1145/3437359.3465581
• Hook, Audrey A. 1987. Export Control of the Ada (Trade Name) Compiler Validation Capability (ACVC). Defense Technical Information Center. https://doi.org/10.21236/ada197503
• Hook, Audrey A., and Stephen Heilbrunner. 1989. Ada Compiler Validation Procedures. Defense Technical Information Center. https://doi.org/10.21236/ada224222
• Hook, Audrey A., and R. D. Lehman. 1992. Ada Compiler Validation Support: Fiscal Year 1992,. Defense Technical Information Center. https://doi.org/10.21236/ada307189
• Horký, Vojtěch, Jaroslav Kotrč, Peter Libič, and Petr Tůma. 2016. “Analysis of Overhead in Dynamic Java Performance Monitoring.” In Proceedings of the 7th ACM/SPEC on International Conference on Performance Engineering. ACM. https://doi.org/10.1145/2851553.2851569
• Horwat, Waldemar. 1988. A Concurrent Smalltalk Compiler for the Message-Driven Processor. Defense Technical Information Center. https://doi.org/10.21236/ada202182
• Hoskins, Rose. 1988. “The Design and Implementation of a Karel Compiler and Interpreter.” ACM SIGAda Ada Letters VIII (4): 83–96. https://doi.org/10.1145/62162.62166
• Howe, R. G. 1984. A Study of the Feasibility of Duplicating JAMPS Applications Software in the Ada Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada140884
• Hu, Wen, and Yanli Zhao. 2014. “Analysis on Process Code Schedule of Android Dalvik Virtual Machine.” International Journal of Hybrid Information Technology 7 (3): 401–12. https://doi.org/10.14257/ijhit.2014.7.3.38
• Huang, Chenyu, Huaien Gao, Yongfeng Zhong, and Shuting Cai. 2022. “A High-Performance Bidirectional Compiler for Conversion between SystemC and Verilog.” In Proceedings of the 6th International Conference on High Performance Compilation, Computing and Communications. ACM. https://doi.org/10.1145/3546000.3546019
• Huang, F. Y., C. B. Jay, and D. B. Skillicorn. 2006. “Adaptiveness in Well-Typed Java Bytecode Verification.” In Proceedings of the 2006 conference of the Center for Advanced Studies on Collaborative research - CASCON ‘06. ACM Press. https://doi.org/10.1145/1188966.1188992
• Huangfu, Yijie, and Wei Zhang. 2018. “Estimating the Worst-Case Execution Time of the Shared Data Cache in Integrated CPU-GPU Architectures.” Journal of Computing Science and Engineering 12 (4): 139–48. https://doi.org/10.5626/jcse.2018.12.4.139
• Hunt, James J., Isabel Tonin, and Fridtjof B. Siebert. 2008. “Using Global Data Flow Analysis on Bytecode to Aid Worst Case Execution Time Analysis for Real-Time Java Programs.” In Proceedings of the 6th international workshop on Java technologies for real-time and embedded systems. ACM. https://doi.org/10.1145/1434790.1434806
• Hyvernat, Pierre. 2025a. “The Size-Change Principle for Mixed Inductive and Coinductive Types.” Logical Methods in Computer Science Volume 21, Issue 3: 13902. https://doi.org/10.46298/lmcs-21(3:20)2025
• Hyvernat, Pierre. 2025b. “Totality for Mixed Inductive and Coinductive Types.” Logical Methods in Computer Science Volume 21, Issue 3: 5121. https://doi.org/10.46298/lmcs-21(3:19)2025
• IEEE and The Open Group. 2004. Makecontext, Swapcontext: Manipulate User Contexts. IEEE Std 1003.1, 2004 Edition. The Open Group. https://pubs.opengroup.org/onlinepubs/9699919799/functions/makecontext.html
• Ierusalimschy, Roberto, Luiz Henrique de Figueiredo, and Waldemar Celes. n.d. “Lua 5.4 Reference Manual.” Lua.org, PUC-Rio. Accessed October 24, 2026. https://www.lua.org/manual/5.4/manual.html
• Ikemori, Kazuki, Youyou Cong, and Hidehiko Masuhara. 2023. “Typed Equivalence of Labeled Effect Handlers and Labeled Delimited Control Operators.” In International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3610612.3610616
• Ilik, Danko. 2013b. “Type Directed Partial Evaluation for Level-1 Shift and Reset.” Electronic Proceedings in Theoretical Computer Science 127: 86–100. https://doi.org/10.4204/eptcs.127.6
• Ilik, Danko. 2014. “Proofs in Continuation-Passing Style: Normalization of Gödel’s System T Extended with Sums and Delimited Control Operators: Distilled Tutorial.” In Proceedings of the 16th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/2643135.2643161
• “Incorporating near-Surface Velocity Anomalies in Pre-Stack Depth Migration Models.” 2015. ASEG Extended Abstracts 2015 (1): 1–1. https://doi.org/10.1071/aseg2015ab071
• Information Management INC San Francisco CA. 1970. User’s Manual Cobol Compiler Validation System. Defense Technical Information Center. https://doi.org/10.21236/ad0711369
• Ishiura, Nagisa. 2016. “Compiler Fuzzing.” IEICE ESS Fundamentals Review 9 (3): 188–96. https://doi.org/10.1587/essfr.9.3_188
• Iskra, Kamil, and Torsten Hoefler. 2015. “Operating Systems and Runtime Environments on Supercomputers.” International Journal of High Performance Computing Applications 29 (1): 3–4. https://doi.org/10.1177/1094342014560666
• Islam, Syful, Dong Wang, Raula Gaikovina Kula, Takashi Ishio, and Kenichi Matsumoto. 2022. “An Exploration of Npm Package Co-Usage Examples from Stack Overflow: A Case Study.” IEICE Transactions on Information and Systems E105.D (1): 11–18. https://doi.org/10.1587/transinf.2021mpp0003
• Ivey, Jared S., and George F. Riley. 2016. “Analysis of Programming Language Overhead in DCE.” In Proceedings of the Workshop on ns-3 - WNS3 ‘16. ACM Press. https://doi.org/10.1145/2915371.2915383
• Izawa, Yusuke, Hidehiko Masuhara, Carl Friedrich Bolz-Tereick, and Youyou Cong. 2022. “Threaded Code Generation with a Meta-Tracing JIT Compiler.” Journal of Object Technology 21 (2): 2:1. https://doi.org/10.5381/jot.2022.21.2.a1
• Jaafar, Hamza, and Guilhem Jaber. 2025. “Operational Game Semantics for Generative Algebraic Effects and Handlers.” In Proceedings of the 27th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3756907.3756924
• Jackson, Adrian. 2026. “I/O Optimisation at the Compiler Level: IOOpt.” In Proceedings of the 35th International Symposium on High-Performance Parallel and Distributed Computing. ACM. https://doi.org/10.1145/3806645.3816125
• Jadhav, Veena Janardhan, Prakash R. Devale, Nischal Puri, and Priya Parkhi. 2026. “Analysis of Compiler-Level Static and Dynamic Features for Automated Bug Prediction Using Transformer Models.” Automation and Remote Control 87 (2): 198–215. https://doi.org/10.1134/s0005117925601058
• Jagnik, Nilesh. 2023. “Structured Concurrency in Java.” Journal of Mathematical & Computer Applications 2 (4): 1. https://doi.org/10.47363/jmca/2023(2)e127
• Jana, Angshuman. 2023. “Sensitive Information Leakage Analysis of Database Code by Abstract Interpretation.” International Journal of Security and Networks 1 (1): 1. https://doi.org/10.1504/ijsn.2023.10054893
• Janetschek, Matthias, and Radu Prodan. 2017. “A Compiler Transformation-Based Approach to Scientific Workflow Enactment.” In Proceedings of the 12th Workshop on Workflows in Support of Large-Scale Science. ACM. https://doi.org/10.1145/3150994.3150999
• Jeannot, J. P. 1994. “Robust Kirchhoff Pre-Stack Depth Imaging with Semi-Gridded Rays.” In 56th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201410049
• Jeannot, J. P., and I. Berranger. 1994. “Ray-Mapped Focusing: A Migration Velocity Analysis for Kirchoff Pre-Stack Depth Imaging.” In 56th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201409835
• Jefferson, David K., L. A. Johnson, and Donald J. Peifer. 1994b. Ada Compiler Validation Summary Report: Certificate Number 940902S1.11377 UNISYS Corporation. IntegrAda for Windows NT, Version 1.0. Intel Deskside Server with Intel 80486DX266 => Intel Deskside Server with Intel 80486DX266,. Defense Technical Information Center. https://doi.org/10.21236/ada288571
• Jefferson, David K., L. A. Johnson, and Donald J. Reifer. 1994a. Ada Compiler Validation Summary Report: Certificate Number 940902S1.11376. UNISYS Corporation IntegrAda for Windows NT, Version 1.0. Intel Deskside Server for Intel Pentium 60 MHz =>. Intel Deskside Server with Intel Pentium 60 MHz,. Defense Technical Information Center. https://doi.org/10.21236/ada288572
• Jeong, Sooyong, Sungdeok Cha, and Woo Jin Lee. 2021. “Usage Log-Based Testing of Embedded Software and Identification of Dependencies among Environmental Components.” IEICE Transactions on Information and Systems E104.D (11): 2011–14. https://doi.org/10.1587/transinf.2021edl8042
• Jervis, E. W. 1963. Mobile. a Mobidic Cobol Compiler. Defense Technical Information Center. https://doi.org/10.21236/ad0411444
• Jesus, Ricardo, and Michèle Weiland. 2024. “Evaluating and Optimising Compiler Code Generation for NVIDIA Grace.” In Proceedings of the 53rd International Conference on Parallel Processing. ACM. https://doi.org/10.1145/3673038.3673104
• Ji, Zhuoran, and Cho-Li Wang. 2022. “Optimizing Aggregate Computation of Graph Neural Networks with on-GPU Interpreter-Style Programming.” In Proceedings of the International Conference on Parallel Architectures and Compilation Techniques. ACM. https://doi.org/10.1145/3559009.3569690
• Ji, M.-L., J. Wang, S. Li, and Z.-C. Qi. 2007. “Automated Worst-Case Execution Time Analysis Based on Program Modes.” Computer Journal 52 (5): 530–44. https://doi.org/10.1093/comjnl/bxm058
• Jiang, Long Long, and Dai Ping Li. 2014. “Using Contour Marking Bytecode Verification Algorithm on the Java Card.” Applied Mechanics and Materials 556-562: 4120–23. https://doi.org/10.4028/www.scientific.net/amm.556-562.4120
• Jiang, Wen Rong, and Ji Hong Yan. 2010. “Implementation of Static Web-Pages Generator Using JavaScript.” Applied Mechanics and Materials 39: 588–91. https://doi.org/10.4028/www.scientific.net/amm.39.588
• Jiang, Lizheng, Xin Zheng, and Jiantao Zhao. 2015. “Implementation and Comparison of the Way That Office Document Is Converted to PDF Documents in the Java Runtime Environment.” International Journal of Future Computer and Communication 4 (6): 431–34. https://doi.org/10.18178/ijfcc.2015.4.6.431
• Johnson, Steven C. 1978. “Tools for Automatic Compiler Generation (Panel Discussion).” In Proceedings of the 1978 annual conference on - ACM 78. ACM Press. https://doi.org/10.1145/800127.804153
• Jones, Neil D. 1980. “Compiler Generation from Denotational Semantics.” DAIMI Report Series 9 (113). https://doi.org/10.7146/dpb.v9i113.6531
• Jones, Neil D., and Henning Christiansen. 1981. “Control Flow Treatment in a Simple: Semantics-Directed Compiler Generator.” DAIMI Report Series 10 (137). https://doi.org/10.7146/dpb.v10i137.7411
• Jui-Ming Chang. 1995. “Register Allocation and Binding for Low Power.” In 32nd Design Automation Conference. ACM. https://doi.org/10.1109/dac.1995.250019
• Jung, Tae Hwan. 2021. “CommitBERT: Commit Message Generation Using Pre-Trained Programming Language Model.” In Proceedings of the 1st Workshop on Natural Language Processing for Programming (NLP4Prog 2021). Association for Computational Linguistics. https://doi.org/10.18653/v1/2021.nlp4prog-1.3
• Jung, Ralf. 2024. “Miri: Practical Undefined Behavior Detection for Rust (Keynote).” In Proceedings of the 19th ACM International Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems. ACM. https://doi.org/10.1145/3679005.3695733
• Jyh-Charn Liu and Hung-Ju Lee. 1994. “Deterministic Upperbounds of the Worst-Case Execution Times of Cached Programs.” In Proceedings Real-Time Systems Symposium REAL-94. IEEE Comput. Soc. Press. https://doi.org/10.1109/real.1994.342717
• Kaestner, Daniel, Gernot Gebhard, Christian Huembert, Markus Pister, Simon Wegener, and Christian Ferdinand. 2025. “Determining Worst-Case Execution Time Bounds for Multi-Core Processors.” In SAE Technical Paper Series, vol. 1. SAE International. https://doi.org/10.4271/2025-01-0155
• Kalhitashvili D.SH. 2024. “Implementation concept of the IoT platform using C++ programming language.” Automation. Modern Techologies: 297–302. https://doi.org/10.36652/0869-4931-2024-78-7-297-302
• Kammar, Ohad, and Matija Pretnar. 2017. “No Value Restriction Is Needed for Algebraic Effects and Handlers.” Journal of Functional Programming 27: e7. https://doi.org/10.1017/s0956796816000320
• Kanatov, Alexey Valer’evich, and Eugene Zouev. 2022. “Unified Type System for the Modern General-Purpose Programing Language.” Proceedings of the Institute for System Programming of the RAS 34 (3): 13–30. https://doi.org/10.15514/ispras-2022-34(3)-2
• Kang, Seokhyeon, Moohyun Song, Taeyoon Kim, et al. 2025. “HybridServe: Adaptive WebAssembly-Container Runtime Selection for Edge Serverless Computing.” In Proceedings of the 11th International Workshop on Serverless Computing. ACM. https://doi.org/10.1145/3774899.3775011
• Kargén, Ulf, and Nahid Shahmehri. 2018. “Speeding up Bug Finding Using Focused Fuzzing.” In Proceedings of the 13th International Conference on Availability, Reliability and Security. ACM. https://doi.org/10.1145/3230833.3230867
• Karpovich, Vladimir Dmitrievich, and Ilya Borisovich Gosudarev. 2025. “WebAssembly Performance in the Node.js Environment.” Программные системы и вычислительные методы, no. 2: 12–34. https://doi.org/10.7256/2454-0714.2025.2.74049
• Karsten, Martin, and Saman Barghi. 2020. “User-Level Threading: Have Your Cake and Eat It Too.” ACM SIGMETRICS Performance Evaluation Review 48 (1): 89–90. https://doi.org/10.1145/3410048.3410100
• Kasampalis, Theodoros, Daejun Park, Zhengyao Lin, Vikram S. Adve, and Grigore Roşu. 2021. “Language-Parametric Compiler Validation with Application to LLVM.” In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. ACM. https://doi.org/10.1145/3445814.3446751
• Keaton, David, and Robert C. Seacord. 2014. Performance of Compiler-Assisted Memory Safety Checking. Defense Technical Information Center. https://doi.org/10.21236/ada610094
• Kelly, R. 1963. “Advanced Mystic- a Compiler for Management Control of Computer Programming.” In Space Flight Testing Conference. AIAA 1963-102. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.1963-102
• Kelly, John C. 1997. Formal Methods Specification and Analysis Guidebook for the Verification of Software and Computer Systems Volume II: A Practitioner’s Companion. Jet Propulsion Laboratory. https://ntrs.nasa.gov/citations/20060035409
• Khaldi, Dounia, Pierre Jouvelot, François Irigoin, Corinne Ancourt, and Barbara Chapman. 2015. “LLVM Parallel Intermediate Representation: Design and Evaluation Using OpenSHMEM Communications.” In Proceedings of the Second Workshop on the LLVM Compiler Infrastructure in HPC. ACM. https://doi.org/10.1145/2833157.2833158
• Kiam Tan, Yong, Magnus O. Myreen, Ramana Kumar, Anthony Fox, Scott Owens, and Michael Norrish. 2019. “The Verified CakeML Compiler Backend.” Journal of Functional Programming 29: e2. https://doi.org/10.1017/s0956796818000229
• Kim, Hyeon Gyu. 2015. “Exploiting Window Query Semantics in Scalable Data Stream Processing.” International Journal of Control and Automation 8 (11): 13–20. https://doi.org/10.14257/ijca.2015.8.11.02
• Kim, Je-Min, Seon-Tae Kim, Joon-Seok Park, and Weon-Hee Yoo. 2012. “Generating Verification Conditions from BIRS Code Using Basic Paths for Java Bytecode Verification.” Journal of the Korea Society of Computer and Information 17 (8): 61–69. https://doi.org/10.9708/jksci.2012.17.8.061
• Kim, JaeHyun, and YangSun Lee. 2017. “A Study on the Light-Weight Virtual Machine Code for IoT Virtual Machine.” International Journal of Control and Automation 10 (12): 221–28. https://doi.org/10.14257/ijca.2017.10.12.20
• Kim, Jaehyun, and Yangsun Lee. 2018. “A Study on the Code Generator for a Virtual Machine Code Based JavaScript Compiler.” International Journal of Advanced Science and Technology 119: 123–34. https://doi.org/10.14257/ijast.2018.119.11
• Kim, Ju O., and Deokwoo Lee. 2026. “Amortised Neural Acoustic Tomography: Domain-Specific Encoder Design and Topology-Dependent Eikonal Analysis.” Measurement Science and Technology 37 (31): 316003. https://doi.org/10.1088/1361-6501/ae8c6d
• Kim, Seulbae, Meng Xu, Sanidhya Kashyap, Jungyeon Yoon, Wen Xu, and Taesoo Kim. 2020b. “Finding Bugs in File Systems with an Extensible Fuzzing Framework.” ACM Transactions on Storage 16 (2): 1–35. https://doi.org/10.1145/3391202
• Kingsley, C. 1987. “The Implementation of a State Machine Compiler.” In 24th ACM/IEEE conference proceedings on Design automation conference - DAC ‘87. ACM Press. https://doi.org/10.1145/37888.37978
• Kirichenko, P. G., and I. V. Tarasov. 2017. “Development of Design Flow for Multiported Register Files, Which Includes a Cell Library and a Compiler for SOI 0.25-μm Process.” Russian Microelectronics 46 (1): 66–73. https://doi.org/10.1134/s1063739717010048
• Kishorbhai, Tank Hardik, and Maulika Patel. 2026. “Online Code Compiler: A Modern Web Based Programming Platform.” International Journal of Research Publication and Reviews 7 (4): 3311–13. https://doi.org/10.55248/gengpi.07.0426.b910
• Kistel, Thomas, and Ralf Vandenhouten. 2013. “A metamodel-based ASN.1 editor and compiler for the implementation of communication protocols.” Wissenschaftliche Beiträge / Technische Hochschule Wildau. https://doi.org/10.15771/0949-8214_2013_1_11
• Klein, Gerwin. 2005. “Verified Java Bytecode Verification (Verified Java Bytecode Verification).” it - Information Technology 47 (2): 107–10. https://doi.org/10.1524/itit.47.2.107.62257
• Klimis, Vasileios. 2026. “Compilomorphic Fuzzing: Turning a Compiler against Itself.” In Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3803437.3805569
• Knoblock, Todd B., and Jakob Rehof. 2001. “Type Elaboration and Subtype Completion for Java Bytecode.” ACM Transactions on Programming Languages and Systems 23 (2): 243–72. https://doi.org/10.1145/383043.383045
• Kobusińska, Anna, and Grzegorz Wilczynski. 2022. “Blocked-Based Solidity — A Service for Graphically Creating the Smart Contracts in Solidity Programming Language.” In Proceedings of the Annual Hawaii International Conference on System Sciences. Hawaii International Conference on System Sciences. https://doi.org/10.24251/hicss.2022.887
• Komendantskaya, Ekaterina, and Yue Li. 2018. “Towards Coinductive Theory Exploration in Horn Clause Logic: Position Paper.” Electronic Proceedings in Theoretical Computer Science 278: 27–33. https://doi.org/10.4204/eptcs.278.5
• Komolov, Sirojiddin, Nursultan Askarbekuly, and Manuel Mazzara. 2020. “An Empirical Study of Multi-Threading Paradigms Reactive Programming vs Continuation-Passing Style.” In 2020 the 3rd International Conference on Computing and Big Data. ACM. https://doi.org/10.1145/3418688.3418695
• Kong, Liang Liang, and Lin Chen. 2013. “A Worst-Case Execution Time Analysis Approach Based on AOE Networks.” Advanced Materials Research 791-793: 1726–29. https://doi.org/10.4028/www.scientific.net/amr.791-793.1726
• Kong, Liangliang, and Jianhui Jiang. 2012. “A Worst-Case Execution Time Analysis Approach Based on Independent Paths for ARM Programs.” Wuhan University Journal of Natural Sciences 17 (5): 391–99. https://doi.org/10.1007/s11859-012-0860-1
• Kong, Liang Liang, Lin Xiang Shi, and Lin Chen. 2014. “An Overview of Worst-Case Execution Time Estimation for Embedded Programs.” Applied Mechanics and Materials 651-653: 624–29. https://doi.org/10.4028/www.scientific.net/amm.651-653.624
• Kossatchev, A. S., and M. A. Posypkin. 2005. “Survey of Compiler Testing Methods.” Programming and Computer Software 31 (1): 10–19. https://doi.org/10.1007/s11086-005-0008-6
• Kozen, Dexter, and Alexandra Silva. 2016. “Practical Coinduction.” Mathematical Structures in Computer Science 27 (7): 1132–52. https://doi.org/10.1017/s0960129515000493
• Krause, Philipp Klaus. 2015. “Bytewise Register Allocation.” In Proceedings of the 18th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/2764967.2764971
• Krishnamoorthy, Vasanth. 2025. “Webassembly: Revolutionizing Web Performance and Expanding Frontiers of Browser-Based Applications.” International Journal of Information Technology and Management Information Systems 16 (1): 827–43. https://doi.org/10.34218/ijitmis_16_01_059
• Kristensen, Bent Bruun, Birger Møller-Pedersen, Ole Lehrmann Madsen, and Kristen Nygaard. 1987. “Coroutine Sequencing in BETA.” DAIMI Report Series 16 (235). https://doi.org/10.7146/dpb.v16i235.7591
• Kroening, Daniel, Daniel Poetzl, Peter Schrammel, and Björn Wachter. 2016. “Sound Static Deadlock Analysis for C/Pthreads.” In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering. ACM. https://doi.org/10.1145/2970276.2970309
• Kuperberg, Denis, Laureline Pinault, and Damien Pous. 2021. “Coinductive Algorithms for Büchi Automata.” Fundamenta Informaticae 180 (4): 351–73. https://doi.org/10.3233/fi-2021-2046
• Kupke, Clemens, and Jurriaan Rot. 2021. “Expressive Logics for Coinductive Predicates.” Logical Methods in Computer Science Volume 17, Issue 4: 6593. https://doi.org/10.46298/lmcs-17(4:19)2021
• Kuroda, Masahiro, and Shoji Yuen. 2026. “A Concurrent Extension of Reversible Imperative Programming Language with Runtime.” Journal of Information Processing 34 (0): 444–68. https://doi.org/10.2197/ipsjjip.34.444
• Kusano, Markus, and Chao Wang. 2017. “Thread-Modular Static Analysis for Relaxed Memory Models.” In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering. ACM. https://doi.org/10.1145/3106237.3106243
• Kusmenko, Evgeny, Bernhard Rumpe, Sascha Schneiders, and Michael von Wenckstern. 2018. “Highly-Optimizing and Multi-Target Compiler for Embedded System Models: C++ Compiler Toolchain for the Component and Connector Language EmbeddedMontiArc.” In Proceedings of the 21th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems. ACM. https://doi.org/10.1145/3239372.3239388
• Kwon, Jung-Hoon, and Jong-Min Bae. 2016. “Development of a Code Generation Support System in Integrated Development Environment of an Educational Compiler.” Journal of the Korea Society of Computer and Information 21 (11): 159–66. https://doi.org/10.9708/jksci.2016.21.11.159
• Kwon, Seungwan, Jaeseong Kwon, Wooseok Kang, Juneyoung Lee, and Kihong Heo. 2024. “Translation Validation for JIT Compiler in the V8 JavaScript Engine.” In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. ACM. https://doi.org/10.1145/3597503.3639189
• Kyrtatas, Nikolaos, Daniele G. Spampinato, and Markus Püschel. 2015. “A Basic Linear Algebra Compiler for Embedded Processors.” In Design, Automation & Test in Europe Conference & Exhibition (DATE), 2015. IEEE Conference Publications. https://doi.org/10.7873/date.2015.0182
• Laliotis, T. A. 1973. “Implementation Aspects of the Symbol Hardware Compiler.” ACM SIGARCH Computer Architecture News 2 (4): 111–15. https://doi.org/10.1145/633642.803976
• Lambert, Matthew A., and B. David Saunders. 2017. “Compiler Auto-Vectorization of Matrix Multiplication Modulo Small Primes.” In Proceedings of the International Workshop on Parallel Symbolic Computation. ACM. https://doi.org/10.1145/3115936.3115943
• Landa, E., and V. Sorin. 1993. “Fast Pre-Stack Depth Migration by CRP Stacking.” In 55th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201411670
• Lane, James E., and Peter W. Poorman. 1991. “Preserving Software Investment Using New Fortran Compiler Technology.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/1.1888920
• Lange, R. G., H. Cheeseman, E. W. Davis, and R. W. Lott. 1977. Specification for a STARAN Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada040468
• Larkins, D. Brian, and William M. Jones. 2011. “Targeting FPGA-Based Processors for an Implementation-Driven Compiler Construction Course.” In Proceedings of the 49th Annual Southeast Regional Conference. ACM. https://doi.org/10.1145/2016039.2016056
• Le Charlier, Baudouin, and Pascal Van Hentenryck. 1994. “Experimental Evaluation of a Generic Abstract Interpretation Algorithm for PROLOG.” ACM Transactions on Programming Languages and Systems 16 (1): 35–101. https://doi.org/10.1145/174625.174627
• League, Christopher A. 2002. A Type-Preserving Compiler Infrastructure. Defense Technical Information Center. https://doi.org/10.21236/ada436496
• Leavitt, Thomas, and Kermit Terrell. 1991a. Ada Compiler Evaluation Capability. Defense Technical Information Center. https://doi.org/10.21236/ada236716
• Leavitt, Thomas, and Kermit Terrell. 1991b. ADA Compiler Evaluation Capability User’s Guide, Release 2.0. Defense Technical Information Center. https://doi.org/10.21236/ada236321
• Leavitt, Thomas, and Kermit Terrell. 1991c. Ada Compiler Evaluation Capability. Release 2.0. Defense Technical Information Center. https://doi.org/10.21236/ada238259
• Lee, Jong-In, Ho-Jung Bang, Tai-Hyo Kim, and Sung-Deok Cha. 2009. “Visualization and Formalization of User Constraints for Tight Estimation of Worst-Case Execution Time.” IEICE Transactions on Information and Systems E92-D (1): 24–31. https://doi.org/10.1587/transinf.e92.d.24
• Lehman, R. D. 1992. Ada Compiler Validation Support: Fiscal Year 1991. Defense Technical Information Center. https://doi.org/10.21236/ada249950
• Lehman, R. D., Audrey A. Hook, and James Wolfe. 1988. Sources of Compiler Capability Information in Validation Summary Reports. Defense Technical Information Center. https://doi.org/10.21236/ada197645
• Lei, Hanwen, Ding Li, and Yao Guo. 2025. “Furina: A Light-Weight WebAssembly Runtime for ICS.” In Proceedings of the 2025 Workshop on Re-design Industrial Control Systems with Security. ACM. https://doi.org/10.1145/3733823.3764514
• Lemaistre, L., C. Hanitzsch, and A. Lehec. 2001. “Automatic and Continuous Image Gather Analysis after Pre-Stack Depth Migration.” In 63rd EAGE Conference & Exhibition. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.15.p068
• Leopoldseder, David, Lukas Stadler, Thomas Würthinger, Josef Eisl, Doug Simon, and Hanspeter Mössenböck. 2018b. “Dominance-Based Duplication Simulation (DBDS): Code Duplication to Enable Compiler Optimizations.” In Proceedings of the 2018 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3168811
• Leroy, Xavier. 2009a. “Formal Verification of a Realistic Compiler.” Communications of the ACM 52 (7): 107–15. https://doi.org/10.1145/1538788.1538814
• Leuschel, Michael. 2004. “A Framework for the Integration of Partial Evaluation and Abstract Interpretation of Logic Programs.” ACM Transactions on Programming Languages and Systems 26 (3): 413–63. https://doi.org/10.1145/982158.982159
• Leverett, Bruce W., Roderic G. Cattell, Steven O. Hobbs, Joseph M. Newcomer, and Andrew H. Reiner. 1979. An Overview of the Production Quality Compiler-Compiler Project. Defense Technical Information Center. https://doi.org/10.21236/ada955949
• Li, Meng-Jun. 2008. “Program Verification Techniques Based on the Abstract Interpretation Theory.” renshenyubanlu 30 (1). https://doi.org/10.3724/sp.j.1145.2008.0001
• Li, Tianchi. 2019. “Haskell Compiler Testing Automation Based on Equivalence-Modulo-Inputs Method.” In Proceedings of the 2019 International Conference on Modeling, Simulation and Big Data Analysis (MSBDA 2019). Atlantis Press. https://doi.org/10.2991/msbda-19.2019.25
• Li, Hao, Chengchen Hu, Peng Zhang, and Lei Xie. 2016. “Modular SDN Compiler Design with Intermediate Representation.” In Proceedings of the 2016 ACM SIGCOMM Conference. ACM. https://doi.org/10.1145/2934872.2959061
• Li, Xiaoting, Xiao Liu, Lingwei Chen, Rupesh Prajapati, and Dinghao Wu. 2022a. “ALPHAPROG: Reinforcement Generation of Valid Programs for Compiler Fuzzing.” Proceedings of the AAAI Conference on Artificial Intelligence 36 (11): 12559–65. https://doi.org/10.1609/aaai.v36i11.21527
• Li, Zongjie, Pingchuan Ma, Huaijin Wang, et al. 2022b. “Unleashing the Power of Compiler Intermediate Representation to Enhance Neural Program Embeddings.” In Proceedings of the 44th International Conference on Software Engineering. ACM. https://doi.org/10.1145/3510003.3510217
• Li, Juhua, Kazunori Sakamoto, Hironori Washizaki, and Yoshiaki Fukazawa. 2017. “Promotion of Educational Effectiveness by Translation-Based Programming Language Learning Using Java and Swift.” In Proceedings of the Annual Hawaii International Conference on System Sciences. Hawaii International Conference on System Sciences. https://doi.org/10.24251/hicss.2017.016
• Li, Shaohua, and Zhendong Su. 2023. “Finding Unstable Code via Compiler-Driven Differential Testing.” In Proceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3. ACM. https://doi.org/10.1145/3582016.3582053
• Li, Hongfu, Qian Tao, Song Yu, et al. 2024a. “GastCoCo: Graph Storage and Coroutine-Based Prefetch Co-Design for Dynamic Graph Processing.” Proceedings of the VLDB Endowment 17 (13): 4827–39. https://doi.org/10.14778/3704965.3704986
• Li, Qingan, Mengying Zhao, Jingtong Hu, Yongpan Liu, Yanxiang He, and Chun Jason Xue. 2015. “Compiler Directed Automatic Stack Trimming for Efficient Non-Volatile Processors.” In Proceedings of the 52nd Annual Design Automation Conference. ACM. https://doi.org/10.1145/2744769.2744809
• Lidman, Jacob, and Josef Svenningsson. 2017. “Bridging Static and Dynamic Program Analysis Using Fuzzy Logic.” Electronic Proceedings in Theoretical Computer Science 250: 111–26. https://doi.org/10.4204/eptcs.250.7
• Lindholm, Tim, Frank Yellin, Gilad Bracha, Alex Buckley, and Daniel Smith. 2023. “The Java® Virtual Machine Specification: Java SE 21 Edition.” Oracle. Accessed October 24, 2026. https://docs.oracle.com/javase/specs/jvms/se21/html/index.html
• Liu, Xuehua, Liping Ding, Yanfeng Li, Guangxuan Chen, and Jin Du. 2018. “Research of Register Pressure Aware Loop Unrolling Optimizations for Compiler.” MATEC Web of Conferences 228: 03008. https://doi.org/10.1051/matecconf/201822803008
• Liu, Dongbo, and Yongjian Li. 2018. “A Novel Virtual Machine Scheduling Policy Based on Performance Prediction Model.” International Journal of Networking and Virtual Organisations 18 (4): 279. https://doi.org/10.1504/ijnvo.2018.093649
• Liu, Xiaojian, Hao Lv, and Shuo Liu. 2021a. “Design and Implementation of Multi-Core Parallel Compiler Based on OpenMP.” Journal of Physics: Conference Series 1802 (3): 032137. https://doi.org/10.1088/1742-6596/1802/3/032137
• Liu, Lingjun, Feiran (Alex) Qin, Owolabi Legunsen, and Marcelo d’Amorim. 2026. “Learning Compiler Fuzzing Mutators from Historical Bugs.” In Proceedings of the 23rd International Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/3793302.3793374
• Liu, Mugeng, Haiyang Shen, Yixuan Zhang, Hong Mei, and Yun Ma. 2025b. “WebAssembly for Container Runtime: Are We There Yet?” ACM Transactions on Software Engineering and Methodology 34 (6): 1–22. https://doi.org/10.1145/3712197
• LLVM Project. n.d.-a. “Coroutines in LLVM.” LLVM Documentation. Accessed October 24, 2026. https://llvm.org/docs/Coroutines.html
• LLVM Project. n.d.-b. “LLVM Language Reference Manual.” LLVM Documentation. Accessed October 24, 2026. https://llvm.org/docs/LangRef.html
• LLVM Project. n.d.-c. “Stack Maps and Patch Points in LLVM.” LLVM Documentation. Accessed October 24, 2026. https://llvm.org/docs/StackMaps.html
• Lo, Daniel, and G. Edward Suh. 2012. “Worst-Case Execution Time Analysis for Parallel Run-Time Monitoring.” In Proceedings of the 49th Annual Design Automation Conference. ACM. https://doi.org/10.1145/2228360.2228435
• Lopoukhine, Alexandre, Federico Ficarelli, Christos Vasiladiotis, et al. 2025. “A Multi-Level Compiler Backend for Accelerated Micro-Kernels Targeting RISC-V ISA Extensions.” In Proceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3696443.3708952
• Loveless, Tyson, Jason Ott, and Philip Brisk. 2020. “A Performance-Optimizing Compiler for Cyber-Physical Digital Microfluidic Biochips.” In Proceedings of the 18th ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3368826.3377925
• Loy, D. Gareth. 1981. “Notes on the Implementation of MUSBOX: A Compiler for the Systems Concepts Digital Synthesizer.” Computer Music Journal 5 (1): 34. https://doi.org/10.2307/3679693
• Lozano, Roberto Castañeda, Mats Carlsson, Gabriel Hjort Blindell, and Christian Schulte. 2016. “Register Allocation and Instruction Scheduling in Unison.” In Proceedings of the 25th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/2892208.2892237
• Lu, Kuang-Chen, Ben Greenman, Carl Meyer, Dino Viehland, Aniket Panse, and Shriram Krishnamurthi. 2022. “Gradual Soundness: Lessons from Static Python.” Art, Science, and Engineering of Programming 7 (1): 2. https://doi.org/10.22152/programming-journal.org/2023/7/2
• Lu, Yue, Thomas Nolte, Iain Bate, and Liliana Cucu-Grosjean. 2011a. “A New Way about Using Statistical Analysis of Worst-Case Execution Times.” ACM SIGBED Review 8 (3): 11–14. https://doi.org/10.1145/2038617.2038619
• Ly, Hung C., Erik Birgersson, and Michael Vynnycky. 2009. “Reduced Model for a PEMFC Stack: Automated Code Generation and Verification.” ECS Meeting Abstracts MA2009-02 (10): 794–794. https://doi.org/10.1149/ma2009-02/10/794
• Lyamin, A. V. 2018. “Method of Formal Program Verification for Post Machine Virtual Laboratory.” Informatsionno-upravliaiushchie sistemy (Information and Control Systems) 2 (93): 104–14. https://doi.org/10.15217/issn1684-8853.2018.2.104
• Lynn, Donald S. 1978. Interactive Compiler Proving Using Hoare Proof Rules. Defense Technical Information Center. https://doi.org/10.21236/ada052911
• Maccabe, Arthur B. 2017. “Operating and Runtime Systems Challenges for HPC Systems.” In Proceedings of the 7th International Workshop on Runtime and Operating Systems for Supercomputers ROSS 2017. ACM. https://doi.org/10.1145/3095770.3095771
• MacMillen, Don. 2001. Nimble Compiler Environment for Agile Hardware. Volume 1. Defense Technical Information Center. https://doi.org/10.21236/ada405143
• Madsen, Magnus, Ramin Zarifi, and Ondřej Lhoták. 2018. “Tail Call Elimination and Data Representation for Functional Languages on the Java Virtual Machine.” In Proceedings of the 27th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3178372.3179499
• Magdalenić, Ivan, Danijel Radošević, and Dragutin Kermek. 2011. “Implementation Model of Source Code Generator.” Journal of Communications Software and Systems 7 (2): 71. https://doi.org/10.24138/jcomss.v7i2.180
• Magesty, Rafael Araujo, and João Eduardo A. Montandon. 2026. “PromiseAwait: A Dataset of JavaScript Migrations from Promises to Async/Await.” In Proceedings of the 2026 IEEE/ACM Third International Conference on AI Foundation Models and Software Engineering. ACM. https://doi.org/10.1145/3793655.3793714
• Mahajan, Sonal, Negarsadat Abolhassani, and Mukul R. Prasad. 2020. “Recommending Stack Overflow Posts for Fixing Runtime Exceptions Using Failure Scenario Matching.” In Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3368089.3409764
• Maity, Satanu, and Manojit Ghose. 2026. “SAGE: A Compiler-Assisted Reinforcement Learning-Based Offloading Approach under near-Memory Processing Paradigm.” ACM Transactions on Architecture and Code Optimization 23 (1): 1–23. https://doi.org/10.1145/3778361
• Mäkelä, Jari-Matti, Martti Forsell, and Ville Leppänen. 2016. “Compiler Assisted Dynamic Allocation of Finite Hardware Acceleration Resources for Parallel Tasks.” In Proceedings of the 17th International Conference on Computer Systems and Technologies 2016. ACM. https://doi.org/10.1145/2983468.2983494
• Makki Mohialden, Yasmin, Nadia Mahmood Hussien, Esraa Jaffar Baker, and Kapil Joshi. 2023. “A Comparative Analysis of Python Code-Line Bug-Finding Methods.” Scientific Research Journal of Engineering and Computer Sciences 3 (2): 1–6. https://doi.org/10.47310/srjecs.2023.v03i02.006
• Malcolm, Michael A. 1971. PL360(Revised). a Programming Language for the IBM360. Defense Technical Information Center. https://doi.org/10.21236/ad0727115
• Mane Ritesh Pratap and Alpona Das. 2023. “Designing a Random Password Generator Using Python Programming Language.” International Journal of Scientific Research in Science, Engineering and Technology: 450–54. https://doi.org/10.32628/ijsrset23103138
• Manjunath, T. C. 2010. “Colored Steganography Implementation Scheme of Images Using Transform Technique.” International Journal of Computer Applications 12 (6): 28–33. https://doi.org/10.5120/1682-2166
• Mann, C. J. H. 2003. “The Compiler Design Handbook – Optimisation and Machine Code Generation.” Kybernetes 32 (9/10). https://doi.org/10.1108/k.2003.06732iae.004
• Manna, Zohar. 1988. TABLOG: The Deductive Tableau Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada202490
• Marcelino, Cynthia, Noah Krennmair, Thomas Werner Pusztai, and Stefan Nastic. 2025. “Lumos: Performance Characterization of WebAssembly as a Serverless Runtime in the Edge-Cloud Continuum.” In Proceedings of the 15th International Conference on the Internet of Things. ACM. https://doi.org/10.1145/3770501.3770515
• Marcelino, Cynthia, and Stefan Nastic. 2023. “CWASI: A WebAssembly Runtime Shim for Inter-Function Communication in the Serverless Edge-Cloud Continuum.” In Proceedings of the Eighth ACM/IEEE Symposium on Edge Computing. ACM. https://doi.org/10.1145/3583740.3626611
• Marriott, Kim, Harald Søndergaard, and Neil D. Jones. 1994. “Denotational Abstract Interpretation of Logic Programs.” ACM Transactions on Programming Languages and Systems 16 (3): 607–48. https://doi.org/10.1145/177492.177650
• Márton, Gábor, and Zoltán Porkoláb. 2017. “Unit Testing in C++ with Compiler Instrumentation and Friends.” Acta Cybernetica 23 (2): 659–86. https://doi.org/10.14232/actacyb.23.2.2017.14
• Matsikoudis, Eleftherios, and Christos Stergiou. 2014. First Draft of the Act Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada603562
• Matteo R. Donelli. 2025. “Compiler-Assisted Optimization Using Neural Code Embeddings for Heterogeneous Architectures.” Journal of Multidisciplinary Knowledge 5 (2): 165–70. https://doi.org/10.36676/jmk.v5.i2.93
• Melnyk, Anatoliy, and Nazar Kozak. 2019. “Easy Universal Translator as an Alternative Compiler-Compiler.” Advances in Cyber-Physical Systems 4 (2): 105–9. https://doi.org/10.23939/acps2019.02.105
• Merazga, Ammar, Djamel Rahem, Fateh Moulahcene, Djemai Kebbal, Rostom Khelaf, and Imad Benacer. 2025. “Worst-Case Execution Time Analysis of a Real-Time System Based on Arduino in CAN Network.” Engineering, Technology & Applied Science Research 15 (3): 23467–78. https://doi.org/10.48084/etasr.10990
• Meybodi, Mohammad Z. 2015. “The Links between Just-in-Time Practices and Alignment of Benchmarking Performance Measures.” TQM Journal 27 (1): 108–21. https://doi.org/10.1108/tqm-08-2013-0098
• Midtgaard, Jan. 2025. “Property-Based Testing of OCaml 5’s Runtime System: Fun and Segfaults with Interpreters and State Transition Functions.” In Proceedings of the Workshop Dedicated to Olivier Danvy on the Occasion of His 64th Birthday. ACM. https://doi.org/10.1145/3759427.3760378
• Midzic, Noa, and Matija Novak. 2025. “Performance Comparison of WebAssembly and Phaser in Procedural Maze Generation.” Eurasia Proceedings of Science Technology Engineering and Mathematics 34: 172–81. https://doi.org/10.55549/epstem.1753850
• Mihelic, Jurij, William Steingartner, and Valerie Novitzká. 2021. “A Denotational Semantics of a Concatenative/compositional Programming Language.” Acta Polytechnica Hungarica 18 (4): 231–50. https://doi.org/10.12700/aph.18.4.2021.4.13
• Minato, Yuta, Takeshi Masumoto, and Hiroshi Koide. 2025. “Implementation and Evaluation of a System Call Moving Target Defense Applied Multiple Times at Runtime for Binary Injections.” International Journal of Networking and Computing 15 (2): 118–37. https://doi.org/10.15803/ijnc.15.2_118
• Miné, Antoine. 2017. “Tutorial on Static Inference of Numeric Invariants by Abstract Interpretation.” Foundations and Trends® in Programming Languages 4 (3–4): 120–372. https://doi.org/10.1561/2500000034
• Mitra, Tulika, and Tony Givargis. 2009. “Session Details: Microfluidics, Worst-Case Execution Time, and Cache Optimization.” In Proceedings of the 2009 international conference on Compilers, architecture, and synthesis for embedded systems. ACM. https://doi.org/10.1145/3252479
• Mizikovskiy, Igor’. 2024. “Methodology of Management Cost Accounting and Calculation of the Cost of Not Amortised Organizational and Technological Equipment for the Production of Industrial Enterprise Products.” Economy under Guard 1 (1): 131–41. https://doi.org/10.36511/2588-0071-2024-1-131-141
• Mohan, Sibin. 2008. “Worst-Case Execution Time Analysis of Security Policies for Deeply Embedded Real-Time Systems.” ACM SIGBED Review 5 (1): 1–2. https://doi.org/10.1145/1366283.1366291
• Mohnen, Markus. 1997. “A Compiler Correctness Proof for the Static Link Technique by Means of Evolving Algebras.” Fundamenta Informaticae 29 (3): 257–303. https://doi.org/10.3233/fi-1997-29303
• Moliavko, Oleksandr, Taras Drozdovskyi, Vitalii Petrychenko, and Oleg Kopysov. 2019. “uJVM: Lightweight Java Virtual Machine for Embedded Systems.” Journal of Open Source Software 4 (36): 1338. https://doi.org/10.21105/joss.01338
• MolinaFraticelli, Jose Carlos. 2012. Auto Code Generation for Simulink-Based Attitude Determination Control System. M12-1759. National Aeronautics and Space Administration. https://ntrs.nasa.gov/citations/20120014979
• Mondal, Amit Kumar, Mohammad Masudur Rahman, and Chanchal K. Roy. 2016. “Embedded Emotion-Based Classification of Stack Overflow Questions towards the Question Quality Prediction.” In International Conferences on Software Engineering and Knowledge Engineering, vol. 2016. KSI Research Inc. and Knowledge Systems Institute Graduate School. https://doi.org/10.18293/seke2016-146
• Mondshein, L. F. 1967. Vital Compiler System: Reference Manual. Defense Technical Information Center. https://doi.org/10.21236/ad0649140
• Moore, S. A. 1968. “Data Processing with the Compiler Compiler.” ITNOW 11 (4): 153–55. https://doi.org/10.1093/combul/11.4.153
• Moret, Philippe, Walter Binder, and Éric Tanter. 2011. “Polymorphic Bytecode Instrumentation.” In Proceedings of the tenth international conference on Aspect-oriented software development. ACM. https://doi.org/10.1145/1960275.1960292
• Morford, Mark. 1999. “A Case Study: Using 3D Pre-Stack Depth Migration to Improve the Sub-Salt Image in Marbella, Mexico, Gulf of Mexico.” In 6th International Congress of the Brazilian Geophysical Society. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.215.sbgf421
• Morford, Mark. 2000. “A Case Study: Using 3d Pre-Stack Depth Migration to Image Sub-Salt Sediments and Fault Zones in Marbella, Mexico.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/1.1815563
• Morford, Mark. 2001. “Analysis of the Effects of Varying the Anti: Alias Filter in Kirchoff Pre- Stack Depth Migration.” In 7th International Congress of the Brazilian Geophysical Society. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.217.256
• Moskalenko, Oleksandr. 2025. “Application of WebAssembly for High-Performance Client-Side Media Content Analysis.” American Journal of Engineering and Technology 7 (10): 139–45. https://doi.org/10.37547/tajet/volume07issue10-17
• Mössenböck, Η. 1984. “Ein Einfacher Compiler-Compiler Für Mikrocomputer / Α Simple Compiler-Compiler for Microcomputer.” itit 26 (1–6): 186–94. https://doi.org/10.1524/itit.1984.26.16.186
• Mukherjee, Rijoy, Archisman Ghosh, and Rajat Subhra Chakraborty. 2024. “HLS-IRT: Hardware Trojan Insertion through Modification of Intermediate Representation during High-Level Synthesis.” ACM Transactions on Design Automation of Electronic Systems 29 (5): 1–23. https://doi.org/10.1145/3663477
• Muller, Robert, and Yuli Zhou. 1992. “Abstract Interpretation in Weak Powerdomains.” In Proceedings of the 1992 ACM conference on LISP and functional programming. ACM. https://doi.org/10.1145/141471.141520
• Muts, Kateryna, and Heiko Falk. 2020. “Compiler-Based WCET Prediction Performing Function Specialization.” In Proceedings of the 23th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/3378678.3391879
• Na, Yeoul, Seon Wook Kim, and Youngsun Han. 2016. “JavaScript Parallelizing Compiler for Exploiting Parallelism from Data-Parallel HTML5 Applications.” ACM Transactions on Architecture and Code Optimization 12 (4): 1–25. https://doi.org/10.1145/2846098
• Nagata, Fusaomi, Shingo Sakata, Ryoma Abe, Keigo Watanabe, and Maki K. Habib. 2024. “Evaluation of Interoperability of CNN Models between MATLAB and Python Environments Using ONNX Runtime Model.” AI, Computer Science and Robotics Technology 3. https://doi.org/10.5772/acrt.20240043
• Naish, Lee. 2015. “Sharing Analysis in the Pawns Compiler.” PeerJ Computer Science 1: e22. https://doi.org/10.7717/peerj-cs.22
• Nakata, Yuki, and Katsuya Matsubara. 2025. “Self-Hosted WebAssembly Runtime for Runtime-Neutral Checkpoint/Restore in Edge-Cloud Continuum.” In Proceedings of the 3rd International Workshop on Middleware for the Computing Continuum. ACM. https://doi.org/10.1145/3774898.3778040
• Nakata, Keiko, and Tarmo Uustalu. 2015. “A Hoare Logic for the Coinductive Trace-Based Big-Step Semantics of While.” Logical Methods in Computer Science Volume 11, Issue 1: 692. https://doi.org/10.2168/lmcs-11(1:1)2015
• Namakonov, E. S., and A. V. Podkopaev. 2019. “Compilation of OCaml Memory Model into Power.” Proceedings of the Institute for System Programming of the RAS 31 (5): 63–78. https://doi.org/10.15514/ispras-2019-31(5)-4
• National Bureau of Standards Gaithersburg MD. 1988a. Ada Compiler Validation Summary Report: Certificate Number: 880708S1. 09151, SoftTech, Inc., Ada 86, Version 3.21 VAX 11/780-11/785 Host and Intel IAPX 80386R Target. Defense Technical Information Center. https://doi.org/10.21236/ada209138
• National Bureau of Standards Gaithersburg MD. 1988b. Ada Compiler Validation Summary Report: Certificate Number: 880719S1. 09154, Naval Underwater Systems Command, ADAUYK43 (ALS/N Ada/L), Version 1.0, VAX 11/785 Host and AN/UYK-43 Target. Defense Technical Information Center. https://doi.org/10.21236/ada208498
• National Bureau of Standards Gaithersburg MD. 1988c. Ada Compiler Validation Summary Report: Compiler Name: ADE/32 Revision 3.00. Certificate Number: 880527S1.09113. Host: MV/20000 under AOS/VS, Revision 7.56. Target: ROLM HAWK/32 under AOS/VS, Revision 7.56. Defense Technical Information Center. https://doi.org/10.21236/ada204904
• National Bureau of Standards Gaithersburg MD. 1989. Ada Compiler Validation Summary Report: Certificate Number: 880624S1. 09132, Control Data Corporation CYBER 180 Ada Compiler, Version 1.1 HOST and TARGET COMPUTER: CYBER 180-930-31. Defense Technical Information Center. https://doi.org/10.21236/ada208475
• Naveen, M. 2026. “No-Code Backend Orchestrator with Drag and Drop Architecture and AI-Assisted Contextual Code Generation.” International Journal for Research in Applied Science and Engineering Technology 14 (4): 4236–40. https://doi.org/10.22214/ijraset.2026.79963
• Nayvelt, Lev, and Lorie K. Bear. 2008. “Case Study: Anisotropic Pre-Stack Depth Migration on the Louisiana Shelf.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/1.3064099
• Nedoria, Aleksei Evgenevitch. 2023. “Programming Language for Teaching Compilation and Transformation Technologies.” Proceedings of the Institute for System Programming of the RAS 35 (6): 95–102. https://doi.org/10.15514/ispras-2023-35(6)-5
• “Network-Aware Virtual Machine Placement in the Cloud.” 2016. International Journal of Science and Research (IJSR) 5 (1): 114–17. https://doi.org/10.21275/v5i1.nov152580
• Newey, Marcolm C. 1975. Formal Sematics of LISP with Applications to Program Correctness. Defense Technical Information Center. https://doi.org/10.21236/ada005413
• Ngo, Van-Chan, Jean-Pierre Talpin, Thierry Gautier, Loïc Besnard, and Paul Le Guernic. 2015. “Modular Translation Validation of a Full-Sized Synchronous Compiler Using off-the-Shelf Verification Tools.” In Proceedings of the 18th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/2764967.2775291
• Nguyen, Thien, and Alexander J. McCaskey. 2022. “Extending Python for Quantum-Classical Computing via Quantum Just-in-Time Compilation.” ACM Transactions on Quantum Computing 3 (4): 1–25. https://doi.org/10.1145/3544496
• Nielsen, Jens. 1997. Compiler Support for Message Passing Systems. Defense Technical Information Center. https://doi.org/10.21236/ada328290
• Nielsen, Jens. 1998. Compiler Support for Message Passing Systems. Defense Technical Information Center. https://doi.org/10.21236/ada336718
• Niephaus, Fabio, Tim Felgentreff, Tobias Pape, Robert Hirschfeld, and Marcel Taeumel. 2018. “Live Multi-Language Development and Runtime Environments.” Art, Science, and Engineering of Programming 2 (3): 8. https://doi.org/10.22152/programming-journal.org/2018/2/8
• Nikhil, C. K. 2022. “Video Calling with Build-In Compiler.” International Journal for Research in Applied Science and Engineering Technology 10 (6): 1064–69. https://doi.org/10.22214/ijraset.2022.43930
• Nikhil Sripathi Rao. 2024. “WebAssembly: Revolutionizing Web User Interface Development through Performance and Cross-Language Integration.” International Journal of Scientific Research in Computer Science, Engineering and Information Technology 10 (6): 1973–81. https://doi.org/10.32628/cseit241061235
• Nishizaki, Shin-Ya. 2017a. “Linear Lambda Calculus with Non-Linear First-Class Continuations.” In Proceedings of the 6th International Conference on Software and Computer Applications. ACM. https://doi.org/10.1145/3056662.3056693
• Nishizaki, Shin-ya. 2019. “ML Polymorphism of Linear Lambda Calculus with First-Class Continuations.” In Proceedings of the 2019 8th International Conference on Software and Computer Applications. ACM. https://doi.org/10.1145/3316615.3316668
• Niu, Changan, Chuanyi Li, Vincent Ng, David Lo, and Bin Luo. 2024. “FAIR: Flow Type-Aware Pre-Training of Compiler Intermediate Representations.” In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. ACM. https://doi.org/10.1145/3597503.3608136
• “Noci-Compiler: A Theoretical Architecture for the Semantic Translation of Nociceptive Signals into a Digital Pain Alphabet.” 2026. International Journal of Progressive Research in Engineering Management and Science. https://doi.org/10.58257/ijprems51382
• Nougrahiya, Aman, and V. Krishna Nandivada. 2024. “Homeostasis: Design and Implementation of a Self-Stabilizing Compiler.” ACM Transactions on Programming Languages and Systems 46 (2): 1–58. https://doi.org/10.1145/3649308
• NTUU “, Y. S. Sulema, KPI”, V. V. Glinskii, and NTUU “KPI”. 2020. “Semantics and Pragmatics of Programming Language ASAMPL.” Problems in Programming, no. 1: 074–083. https://doi.org/10.15407/pp2020.01.074
• Oates, N. K., P. Harinder, and C. Willacy. 1998. “The Application of Pre-Stack Depth Migration Using Topographic Analysis to Aid in The.” In SPE India Oil and Gas Conference and Exhibition. SPE. https://doi.org/10.2118/39499-ms
• Odaira, Rei, Takuya Nakaike, Tatsushi Inagaki, Hideaki Komatsu, and Toshio Nakatani. 2010. “Coloring-Based Coalescing for Graph Coloring Register Allocation.” In Proceedings of the 8th annual IEEE/ACM international symposium on Code generation and optimization. ACM. https://doi.org/10.1145/1772954.1772978
• Odegard, Ryan, Zoran Milenkovic, Joel Henry, and Michael Buttacoli. 2014. “Model-Based GN and C Simulation and Flight Software Development for Orion Missions beyond LEO.” In 2014 IEEE Aerospace Conference, Big Sky, Montana, March 1-8, 2014. https://ntrs.nasa.gov/citations/20140003581
• Oehlert, Dominic, Arno Luppold, and Heiko Falk. 2018. “Mitigating Data Cache Aging through Compiler-Driven Memory Allocation.” In Proceedings of the 21st International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/3207719.3207731
• Oh, Selim, and Seulbae Kim. 2026. “Detecting Compiler-Introduced Security Bugs via IR Mutation and Coverage-Guided Fuzzing.” In Proceedings of the 19th European Workshop on Systems Security. ACM. https://doi.org/10.1145/3803525.3804981
• Oh, Hyeong-Seok, Ji Hwan Yeo, and Soo-Mook Moon. 2015. “Bytecode-to-C Ahead-of-Time Compilation for Android Dalvik Virtual Machine.” In Design, Automation & Test in Europe Conference & Exhibition (DATE), 2015. IEEE Conference Publications. https://doi.org/10.7873/date.2015.0927
• “Online Platform Learning the Java Programming Language: Development, Implementation and Efficiency.” 2024. Connectivity 172 (6). https://doi.org/10.31673/2412-9070.2024.063151
• Orlov, D. A. 2017. “Program Source Code Static Analysis for Memory Access Error Detection Using Backwards Execution.” Programmnaya Ingeneria 8 (7): 291–99. https://doi.org/10.17587/prin.8.291-299
• Orr, James K., and Johnnie A. Henderson. 2000. “Space Shuttle Software Development and Certification.” National Aeronautics and Space Administration, October 12. https://ntrs.nasa.gov/citations/20100033619
• Ortiz, Ariel. 2022. “Using WebAssembly to Teach Code Generation in a Compiler Design Course.” In Proceedings of the 53rd ACM Technical Symposium on Computer Science Education V. 2. ACM. https://doi.org/10.1145/3478432.3499119
• Osborne, Ianna, Jim Pivarski, Ioana Ifrim, Angus Hollands, and Henry Schreiner. 2024. “Awkward Just-In-Time (JIT) Compilation: A Developer’s Experience.” EPJ Web of Conferences 295: 06003. https://doi.org/10.1051/epjconf/202429506003
• Othman, Achraf, and Oussama El Ghoul. 2022. “BuHamad: The First Qatari Virtual Interpreter for Qatari Sign Language.” Nafath 7 (20). https://doi.org/10.54455/mcn.20.01
• Pai T, Vaikunta, A. Jayanthila Devi, and P. S. Aithal. 2020. “A Systematic Literature Review of Lexical Analyzer Implementation Techniques in Compiler Design.” International Journal of Applied Engineering and Management Letters: 285–301. https://doi.org/10.47992/ijaeml.2581.7000.0087
• Painter, James A. 1970. “Effectiveness of an Optimizing Compiler for Arithmetic Expressions.” In Proceedings of a symposium on Compiler optimization -. ACM Press. https://doi.org/10.1145/800028.808487
• Palsberg, Jens. 1992. “Provably Correct Compiler Generation.” DAIMI Report Series 21 (422). https://doi.org/10.7146/dpb.v21i422.6736
• Palsberg, Jens, and Michael I. Schwartzbach. 1992. “Binding Time Analysis: Abstract Interpretation vs. Type Inference.” DAIMI Report Series 21 (393). https://doi.org/10.7146/dpb.v21i393.6628
• Pan, Jingwen, James Cheney, and Amir Shaikhha. 2026. “A Backend-Agnostic Compiler for Approximate Query Processing with Probabilistic Tensor Algebra.” Proceedings of the ACM on Management of Data 4 (3): 1–25. https://doi.org/10.1145/3802003
• Pankhurst, R. J. 1968. “GULP—A Compiler-Compiler for Verbal and Graphic Languages.” In Proceedings of the 1968 23rd ACM national conference on -. ACM Press. https://doi.org/10.1145/800186.810605
• Paradis, Carlos, Ivan Perez, and Misty Davies. 2025. “Towards Streamlining Auditing for Compliance with Requirements in Open-Source Software at NASA.” In 2025 AIAA DATC/IEEE 44th Digital Avionics Systems Conference (DASC). https://ntrs.nasa.gov/citations/20250006564
• Paraman, Padma Priya Dharishini, and Prakriya V. Ramana Murthy. 2023. “Analysis of Benchmark Program Results of Worst Case Execution Time for Multithreaded Programs.” Indonesian Journal of Electrical Engineering and Computer Science 29 (2): 990. https://doi.org/10.11591/ijeecs.v29.i2.pp990-1005
• Parashar, Harsh, Sandeep Kumawat, Harsh Kumar Shah, Ishan Dubey, Praveen Singh Tomar, and Mahima Parihar. 2026. “A Comparative Architectural and Performance Analysis of WebAssembly and JavaScript for Computationally Intensive Web Applications.” International Journal of Drug Delivery Technology 16 (54s). https://doi.org/10.25258/ijddt.16.54s.58
• Park, Hyeon-Hui, Myeong-Su Choi, Seung-Min Yang, Yong-Hoon Choi, and Hyung-Taek Lim. 2005. “Implementation of Worst Case Execution Time Analysis Tool for Embedded Software Based on XScale Processor.” KIPS Transactions:PartA 12A (5): 365–74. https://doi.org/10.3745/kipsta.2005.12a.5.365
• Park, Daejun, Yi Zhang, Manasvi Saxena, Philip Daian, and Grigore Roşu. 2018. “A Formal Verification Tool for Ethereum VM Bytecode.” In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3236024.3264591
• Pasareanu, Corina S., Johann M. Schumann, Peter C. Mehlitz, et al. 2009. “Model Based Analysis and Test Generation for Flight Software.” In Space Mission Challenges for Information Technology (SMC-IT) Conference, Pasadena, CA, July 19-23, 2009. https://ntrs.nasa.gov/citations/20090036803
• Pasupuleti, Murali Krishna. 2025. “AI-Guided Quantum Compiler Design Using Superalgebraic Symmetries.” International Journal of Academic and Industrial Research Innovations(IJAIRI): 23–35. https://doi.org/10.62311/nesx/rp0225
• Patel, Radha, Willow Ahrens, and Saman Amarasinghe. 2025. “SySTeC: A Symmetric Sparse Tensor Compiler.” In Proceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3696443.3708919
• Pattinson, Dirk, and Lutz Schröder. 2016. “Program Equivalence Is Coinductive.” In Proceedings of the 31st Annual ACM/IEEE Symposium on Logic in Computer Science. ACM. https://doi.org/10.1145/2933575.2934506
• Paul, Johns, Bingsheng He, Shengliang Lu, and Chiew Tong Lau. 2020. “Improving Execution Efficiency of Just-in-Time Compilation Based Query Processing on GPUs.” Proceedings of the VLDB Endowment 14 (2): 202–14. https://doi.org/10.14778/3425879.3425890
• Pavlovskiy, O. M., and I. M. Platov. 2025. “Research on Code Generation of C/C++ Compiler for High-Performance Computing in Microprocessor Systems.” Scientific notes of Taurida National V.I. Vernadsky University. Series: Technical Sciences 2 (2): 175–82. https://doi.org/10.32782/2663-5941/2025.2.2/24
• Pałka, Michał H., Koen Claessen, Alejandro Russo, and John Hughes. 2011. “Testing an Optimising Compiler by Generating Random Lambda Terms.” In Proceedings of the 6th International Workshop on Automation of Software Test. ACM. https://doi.org/10.1145/1982595.1982615
• Peng, Jinzhan, Gansha Wu, and Guei-Yuan Lueh. 2004. “Code Sharing among States for Stack-Caching Interpreter.” In Proceedings of the 2004 workshop on Interpreters, virtual machines and emulators. ACM. https://doi.org/10.1145/1059579.1059584
• Peterson, Brad, Alan Humphrey, John Schmidt, and Martin Berzins. 2017. “Addressing Global Data Dependencies in Heterogeneous Asynchronous Runtime Systems on GPUs.” In Proceedings of the Third International Workshop on Extreme Scale Programming Models and Middleware. ACM. https://doi.org/10.1145/3152041.3152082
• Petkovski, Maki, and Keith Bradey. 2001. “The Success of Pre-Stack Depth Migration over the Anama Structure in the Papuan Foreland Basin, PNG: A Case History.” ASEG Extended Abstracts 2001 (1): 1–4. https://doi.org/10.1071/aseg2001ab108
• Pham, Cao Nguyen, and Martin Odersky. 2024. “Stack-Copying Delimited Continuations for Scala Native.” In Proceedings of the 19th ACM International Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems. ACM. https://doi.org/10.1145/3679005.3685979
• Pieters, Ruben P., and Tom Schrijvers. 2020. “Faster Coroutine Pipelines: A Reconstruction.” Journal of Functional Programming 30: e22. https://doi.org/10.1017/s0956796820000192
• Pieters, Ruben P., Tom Schrijvers, and Exequiel Rivas. 2017. “Handlers for Non-Monadic Computations.” In Proceedings of the 29th Symposium on the Implementation and Application of Functional Programming Languages. ACM. https://doi.org/10.1145/3205368.3205372
• Pike, Lee, Nis Wegmann, Sebastian Niller, and Alwyn Goodloe. 2012. “Experience Report: A Do-It-Yourself High-Assurance Compiler.” In International Conference on Functional Programming, Copenhagen, Denmark, September 9-15, 2012. https://ntrs.nasa.gov/citations/20120014570
• Pla, Edward. 2004. Weapon System Software Technology Support (WSSTS). Delivery Order 0008: Real-Time Java for Embedded Systems (RTJES). Defense Technical Information Center. https://doi.org/10.21236/ada425710
• Plangger, Richard, and Andreas Krall. 2016. “Vectorization in PyPy’s Tracing Just-In-Time Compiler.” In Proceedings of the 19th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/2906363.2906384
• Plasterie, Pierre, and Dmitri Chagalov. 2006. “Wave Equation versus Kirchhoff Pre-Stack Depth Migration Algorithms ? An Australian Case Study.” ASEG Extended Abstracts 2006 (1): 1–7. https://doi.org/10.1071/aseg2006ab137
• Plishka, Richard M., and Agustin Ifarraguerri. 1993. Evaluation of Alsys 037 Ada Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada266972
• Ploensin, Teerit, Krerk Piromsopa, and Norraphat Srimanobhas. 2021. “Code Transformation Impact on Compiler-Based Optimization: A Case Study in the CMSSW.” Journal of Physics: Conference Series 1936 (1): 012023. https://doi.org/10.1088/1742-6596/1936/1/012023
• Plotkin, Gordon D., and Matija Pretnar. 2013. “Handling Algebraic Effects.” Logical Methods in Computer Science Volume 9, Issue 4: 705. https://doi.org/10.2168/lmcs-9(4:23)2013
• Poonguzhali, Boo., and R. Vinodha. 2014. “Implementation of Anti-Reset Windup Scheme in Pi Controller for Spherical Tank Process.” International Journal of Modelling and Simulation 34 (3). https://doi.org/10.2316/journal.205.2014.3.205-5983
• Posenau, Mary-Anne K. 1993. Unstructured Grid Generation Techniques and Software. NASA-CP-10119. National Aeronautics and Space Administration. https://ntrs.nasa.gov/citations/19940017877
• Pous, Damien. 2015. “Coinductive Techniques, from Automata to Coalgebra.” In Proceedings of the Programming Languages Mentoring Workshop. ACM. https://doi.org/10.1145/2792434.2792440
• Pous, Damien. 2016. “Coinduction All the Way Up.” In Proceedings of the 31st Annual ACM/IEEE Symposium on Logic in Computer Science. ACM. https://doi.org/10.1145/2933575.2934564
• Power, John. 2006. “The Universal Algebra of Computational Effects: Lawvere Theories and Monads.” In Electronic Workshops in Computing. BCS Learning & Development. https://doi.org/10.14236/ewic/msfp2006.2
• Pratt, Vaughan R. 1997. Second Calculus of Binary Relations as a Concurrent Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada329349
• Pretnar, Matija. 2014. “Inferring Algebraic Effects.” Logical Methods in Computer Science Volume 10, Issue 3: 1004. https://doi.org/10.2168/lmcs-10(3:21)2014
• Prokopec, Aleksandar, and Fengyun Liu. 2018. “On the Soundness of Coroutines with Snapshots.” Preprint, Leibniz international proceedings in informatics. https://doi.org/10.4230/lipics.ecoop.2018.3
• Proy, Julien, Karine Heydemann, Alexandre Berzati, and Albert Cohen. 2017. “Compiler-Assisted Loop Hardening against Fault Attacks.” ACM Transactions on Architecture and Code Optimization 14 (4): 1–25. https://doi.org/10.1145/3141234
• Puchol, Carlos, Douglas A. Stuart, and Aloysius K. Mok. 1998. “An Operational Semantics and Compiler for Real-Time Specifications1.” Integrated Computer-Aided Engineering 5 (3): 187–206. https://doi.org/10.3233/ica-1998-5301
• Punnoose, Ratish. 2020. “Ensuring Completeness of Formal Verification with Gap Free Verification.” In Proposed for presentation at the Osmosis for DoD held October 13-14, 2020 in Virtual Event, United States.. US DOE. https://doi.org/10.2172/1825972
• Pyzik, Mateusz. 2023. “Call-By-Name Is Just Call-By-Value with Delimited Control.” Electronic Notes in Theoretical Informatics and Computer Science Volume 1 - Proceedings of…: 10502. https://doi.org/10.46298/entics.10502
• Qassir, Samar Amil. 2025. “MyDSL: Front-End Compiler Design for a User-Friendly Language Supporting Hybrid Meta-Heuristics.” TEM Journal: 2036–49. https://doi.org/10.18421/tem143-11
• Qian, Zhenyu. 2000. “Standard Fixpoint Iteration for Java Bytecode Verification.” ACM Transactions on Programming Languages and Systems 22 (4): 638–72. https://doi.org/10.1145/363911.363915
• Qian, Peng, Xinlei Ying, Jiashui Wang, et al. 2025. “FreeWavm: Enhanced WebAssembly Runtime Fuzzing Guided by Parse Tree Mutation and Snapshot.” Proceedings of the ACM on Software Engineering 2 (ISSTA): 159–81. https://doi.org/10.1145/3728877
• Qin, Xiao, Chunwei Xia, and Zheng Wang. 2026. “Augmenting LLM Code Translation with Compiler Analysis for C to Triton Kernel Generation.” In Proceedings of the 40th ACM International Conference on Supercomputing - Workshops. ACM. https://doi.org/10.1145/3774895.3812200
• “Quantum Software Engineering: Algorithm Design, Error Mitigation, and Compiler Optimization for Fault-Tolerant Quantum Computing.” 2025. International Journal of Computer Applications Technology and Research. https://doi.org/10.7753/ijcatr1404.1003
• Queiroz Junior, Nilton Luiz, Anderson Faustino da Silva, and Luis Gustavo Araujo Rodriguez. 2020. “Finding Effective Compiler Optimization Sequences: A Hybrid Approach.” Computing and Informatics 39 (6): 1117–47. https://doi.org/10.31577/cai_2020_6_1117
• Quiring, Benjamin, John Reppy, and Olin Shivers. 2021. “3CPS: The Design of an Environment-Focussed Intermediate Representation.” In 33rd Symposium on Implementation and Application of Functional Languages. ACM. https://doi.org/10.1145/3544885.3544889
• Radošević, Danijel, and Ivan Magdalenić. 2014. “Python Implementation of Source Code Generator Based on Dynamic Frames.” Preprint, . https://doi.org/10.2139/ssrn.2505704
• Rajathi, M., and Ramaswami Murugesh. 2021. “Comparative Study of Binary Classification Algorithms to Analyze the Students Performance on Virtual Machine.” International Journal of Science and Research (IJSR) 10 (4): 300–304. https://doi.org/10.21275/sr21329124355
• Raju Cherukuri, Bangar. 2024. “Building Scalable Web Applications: Best Practices for Backend Architecture.” International Journal of Science and Research (IJSR) 13 (10): 126–39. https://doi.org/10.21275/es24928085711
• Ramdani, Muhammad Asnur, Tifanny Nabarian, and Reza Maulana. 2025. “Pengembangan Backend Aplikasi Geoproperty Dengan Golang Di PT. Nerdvana Solusi Teknologi.” DBESTI: Journal of Digital Business and Technology Innovation 2 (1): 85–95. https://doi.org/10.54914/dbesti.v2i1.1636
• Ranganathan, Jaishree, Sagar Sharma, and Angelina A. Tzacheva. 2020. “Hybrid Scalable Action Rule: Rule Based and Object Based.” In Proceedings of the 2020 4th International Conference on Compute and Data Analysis. ACM. https://doi.org/10.1145/3388142.3388143
• Ranjan, Rishi, Ian Paterson, and Matthew Hicks. 2025. “ClosureX: Compiler Support for Correct Persistent Fuzzing.” In Proceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 1. ACM. https://doi.org/10.1145/3669940.3707281
• Rath, Felix, Daniel Schemmel, and Klaus Wehrle. 2018. “Interoperability-Guided Testing of QUIC Implementations Using Symbolic Execution.” In Proceedings of the Workshop on the Evolution, Performance, and Interoperability of QUIC. ACM. https://doi.org/10.1145/3284850.3284853
• Ravanbakhsh, Hadi, and Sriram Sankaranarayanan. 2014. “Infinite Horizon Safety Controller Synthesis through Disjunctive Polyhedral Abstract Interpretation.” In Proceedings of the 14th International Conference on Embedded Software. ACM. https://doi.org/10.1145/2656045.2656060
• Ravedutti Lucio Machado, Rafael, Jan Eitzinger, and Harald Köstler. 2025. “P4IRS: An Intermediate Representation and Compiler for Parallel and Performance-Portable Particle Simulations.” International Journal of High Performance Computing Applications 40 (5): 621–42. https://doi.org/10.1177/10943420251405928
• Refaie, Abbas Al, and Asem Thyabat. 2015. “Effect of Just-in-Time Selling Strategy on Firms’ Performance in Jordan.” International Journal of Business Performance Management 16 (1): 1. https://doi.org/10.1504/ijbpm.2015.066020
• Regehr, John, Alastair Reid, and Kirk Webb. 2005. “Eliminating Stack Overflow by Abstract Interpretation.” ACM Transactions on Embedded Computing Systems 4 (4): 751–78. https://doi.org/10.1145/1113830.1113833
• Reinhardt, Anastasia, Tianyi Zhang, Mihir Mathur, and Miryung Kim. 2018. “Augmenting Stack Overflow with API Usage Patterns Mined from GitHub.” In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3236024.3264585
• Reis, Luís, João Bispo, and João M. P. Cardoso. 2017. “Compiler Techniques for Efficient MATLAB to OpenCL Code Generation.” In Proceedings of the 5th International Workshop on OpenCL. ACM. https://doi.org/10.1145/3078155.3078186
• Reiss, Stephen P. 1983. “Generation of Compiler Symbol Processing Mechanisms from Specifications.” ACM Transactions on Programming Languages and Systems 5 (2): 127–63. https://doi.org/10.1145/69624.69625
• Reitz, Mia, and Jonas Posner. 2025. “Stackless vs. Stackful Coroutines: A Comparative Study for RDMA-Based Asynchronous Many-Task (AMT) Runtimes.” In Proceedings of the SC ‘25 Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis. ACM. https://doi.org/10.1145/3731599.3767502
• Ren, Zhilei, Huijiang Liu, Shikai Guo, Yi Guo, Xiaochen Li, and He Jiang. 2026. “SpiceFuzz: LLM-Based Fuzzing for Spice Circuit Simulator Tools Bug Detection.” ACM Transactions on Design Automation of Electronic Systems 31 (6): 1–22. https://doi.org/10.1145/3797154
• Reshef, M., and M. Roth. 2003. “Anisotropy Corrections after Pre-Stack Depth Migration.” In 65th EAGE Conference & Exhibition. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609-pdb.6.e16
• Ricardo, Gabriel Guimarães dos Santos, Natanael dos Santos Junior, Flavio Figueiredo, and Fernando Magno Quintão Pereira. 2025. “On the Practicality of LLM-Based Compiler Fuzzing.” In Anais do XXIX Simpósio Brasileiro de Linguagens de Programação (SBLP 2025). Sociedade Brasileira de Computação. https://doi.org/10.5753/sblp.2025.12264
• Ritchie, Walt, Mihai Popovici, and Moritz Fleidner. 2005. “Challenges and Opportunities in Pre-Stack Depth Imaging of Legacy Seismic Data: An Overthrust Belt Case Study.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/1.2142225
• Roberts, R. 1995. “3D Post Stack Depth Migration in the UK Southern North Sea: A Case Study.” In Proceedings. EAGE Publications BV. https://doi.org/10.3997/2214-4609.201409442
• Robinson, G. C., J. P. Tung, H. J. Tieman, and G. R. Savage. 1994. “Prospect Definition by Pre-Stack Depth Migration of a Grid of Seismic Lines: A Case History.” In 56th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201409800
• Rodriguez Ferrandez, Ivan, Alvaro Jover Alvarez, Matina Maria Trompouki, Leonidas Kosmidis, and Francisco J. Cazorla. 2023. “Worst Case Execution Time and Power Estimation of Multicore and GPU Software: A Pedestrian Detection Use Case.” ACM SIGAda Ada Letters 43 (1): 111–17. https://doi.org/10.1145/3631483.3631502
• Rogers, Patrick. 1993. Ada Embedded Computer Software Support (AECSS). Defense Technical Information Center. https://doi.org/10.21236/ada291202
• Rokotyanskaya, Violyetta Valeryevna, and Vadim Sergeevich Abramov. 2023. “Studying WebAssembly and Comparison of Its Performance with JavaScript.” Vestnik of Astrakhan State Technical University. Series: Management, computer science and informatics 2023 (2): 93–100. https://doi.org/10.24143/2072-9502-2023-2-93-100
• Romano, Alan, and Weihang Wang. 2023. “When Function Inlining Meets WebAssembly: Counterintuitive Impacts on Runtime Performance.” In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3611643.3616311
• Rompf, Tiark, and Nada Amin. 2019. “A SQL to C Compiler in 500 Lines of Code.” Journal of Functional Programming 29: e9. https://doi.org/10.1017/s0956796819000054
• Rong, Hongbo. 2009. “Tree Register Allocation.” In Proceedings of the 42nd Annual IEEE/ACM International Symposium on Microarchitecture. ACM. https://doi.org/10.1145/1669112.1669123
• Rosing, Matthew, Robert B. Schnabel, and Robert P. Weaver. 1990. The DINO Parallel Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada459435
• Rowland, Zachary S., and Saverio Perugini. 2025. “The Formal Semantics and Implementation of a Domain-Specific Language for Mixed-Initiative Dialogs.” Art, Science, and Engineering of Programming 10 (1): 7. https://doi.org/10.22152/programming-journal.org/2025/10/7
• Royuela, Sara, Roger Ferrer, Diego Caballero, and Xavier Martorell. 2015. “Compiler Analysis for OpenMP Tasks Correctness.” In Proceedings of the 12th ACM International Conference on Computing Frontiers. ACM. https://doi.org/10.1145/2742854.2742882
• Ruggedized Minicomputer Hardware and Software Topics, 1981: Proceedings of the 4th ROLM MIL-SPEC Computer User’s Group Conference. 1981. NASA-CP-2206. National Aeronautics and Space Administration. https://ntrs.nasa.gov/citations/19820006956
• Rui Li, Bingzhou Ma, and Renfa Li. 2013. “Bounding the Worst-Case Execution Time for the Fixed-Priority Preemptive Systems Based on the Preemption Points.” INTERNATIONAL JOURNAL ON Advances in Information Sciences and Service Sciences 5 (10): 947–55. https://doi.org/10.4156/aiss.vol5.issue10.111
• Rushby, John. 2002. Formally Verified Hardware Encapsulation Mechanism for Security, Integrity, and Safety. Defense Technical Information Center. https://doi.org/10.21236/ada403303
• “The Rust Reference.” n.d. The Rust Project. Accessed October 24, 2026. https://doc.rust-lang.org/reference/
• Sadasue, Tamon, and Tsuyoshi Isshiki. 2023. “LLVM-C2RTL: C/C++ Based System Level RTL Design Framework Using LLVM Compiler Infrastructure.” IPSJ Transactions on System and LSI Design Methodology 16 (0): 12–26. https://doi.org/10.2197/ipsjtsldm.16.12
• Sadat, Anwar. 2005. “A Compiler Driven Simulation Technique for the Analysis of Digital Logic Circuit.” Journal of Applied Sciences 5 (8): 1466–69. https://doi.org/10.3923/jas.2005.1466.1469
• Safin M.A. Sadyikov R.D. 2023. “Development of a mobile robot control system in the Python programming language using Raspberry Pi.” Automation. Modern Techologies: 567–70. https://doi.org/10.36652/0869-4931-2023-77-12-567-570
• Sahkhar, Lizia, Bunil Kumar Balabantaray, and Satyendra Singh Yadav. 2022. “Efficient Cloudlet Allocation to Virtual Machine to Impact Cloud System Performance.” International Journal of Information System Modeling and Design 13 (6): 1–21. https://doi.org/10.4018/ijismd.297630
• Saieva, Anthony, and Gail Kaiser. 2020. “Binary Quilting to Generate Patched Executables without Compilation.” In Proceedings of the 2020 ACM Workshop on Forming an Ecosystem Around Software Transformation. ACM. https://doi.org/10.1145/3411502.3418424
• Salama, Ramiz, Ahmed Qazi, and Mohamed Elsayed. 2018. “Online Programming Language—Learning Management System.” Global Journal of Information Technology: Emerging Technologies 8 (3): 114–23. https://doi.org/10.18844/gjit.v8i3.4051
• Salánki, Dániel, and Kornél Sarvajcz. 2019. “Development of a Gait Recognition System in NI LabVIEW Programming Language.” Műszaki Tudományos Közlemények 11 (1): 167–70. https://doi.org/10.33894/mtk-2019.11.37
• Saleh, Amr Hany, and Tom Schrijvers. 2016. “Efficient Algebraic Effect Handlers for Prolog.” Theory and Practice of Logic Programming 16 (5–6): 884–98. https://doi.org/10.1017/s147106841600034x
• Sambasivam, Balachandher, Maheswari Subramanian, Deb Chatterjee, Mallikarjuna Gouda, Sosutha Sethuramapandian, and Yogender Singh Saroha. 2021. “Writing P4 Compiler Backend for Packet Processing Engines.” In Proceedings of the Symposium on Architectures for Networking and Communications Systems. ACM. https://doi.org/10.1145/3493425.3502769
• Samet, Hanan. 1976. “Compiler Testing via Symbolic Interpretation.” In Proceedings of the annual conference on - ACM 76. ACM Press. https://doi.org/10.1145/800191.805648
• Samet, Hanan. 1977. “A Normal Form for Compiler Testing.” ACM SIGART Bulletin, no. 64: 155–62. https://doi.org/10.1145/872736.806945
• Samet, Hanan. 1980. “A Coroutine Approach to Parsing.” ACM Transactions on Programming Languages and Systems 2 (3): 290–306. https://doi.org/10.1145/357103.357106
• Samuel Blessed Nayagam, P. V., and A. Shajin Nargunam. 2018. “Secure Data Verification and Virtual Machine Monitoring.” International Journal of Engineering and Technology 7 (4.36): 574–79. https://doi.org/10.14419/ijet.v7i4.36.24140
• Sanada, Takahiro. 2023. “Category-Graded Algebraic Theories and Effect Handlers.” Electronic Notes in Theoretical Informatics and Computer Science Volume 1 - Proceedings of…: 10491. https://doi.org/10.46298/entics.10491
• Sanada, Takahiro. 2024. “Algebraic Effects and Handlers for Arrows.” Journal of Functional Programming 34: e8. https://doi.org/10.1017/s0956796824000066
• Santo, Jose Espirito, Ralph Matthes, and Luis Pinto. 2009. “Continuation-Passing Style and Strong Normalisation for Intuitionistic Sequent Calculi.” Logical Methods in Computer Science Volume 5, Issue 2: 1149. https://doi.org/10.2168/lmcs-5(2:11)2009
• Santone, Antonella. 2011. “Clone Detection through Process Algebras and Java Bytecode.” In Proceedings of the 5th International Workshop on Software Clones. ACM. https://doi.org/10.1145/1985404.1985422
• Santos, Fernando Fernandes Dos, Luigi Carro, Flavio Vella, and Paolo Rech. 2024. “Assessing the Impact of Compiler Optimizations on GPUs Reliability.” ACM Transactions on Architecture and Code Optimization 21 (2): 1–22. https://doi.org/10.1145/3638249
• Sanusi, Bashir, Emmanuel Ogunshile, Mehmet Aydin, and Stephen Olabiyisi. 2024. “Assuring Correctness, Testing, and Verification of X-Compiler by Integrating Communicating Stream X-Machine.” In Proceedings of the 2024 6th International Conference on Software Engineering and Development. ACM. https://doi.org/10.1145/3686614.3686622
• Saraf, Prateek, and Rajnish Dashora. 2013. “An Optimal Code Heuristic Approach for Compiler Optimization Using Graph Coloring Technique.” International Journal of Computer Applications 79 (1): 37–40. https://doi.org/10.5120/13708-1461
• Sato, Masahiko. 2021. “Proof Assistant and Type Theory.” Kagaku tetsugaku 53 (2): 3–23. https://doi.org/10.4216/jpssj.53.2_3
• Satya Teja Muddada. 2025. “Serverless 2.0: Unlocking Performance and Portability with WebAssembly.” International Journal of Computational and Experimental Science and Engineering 11 (4). https://doi.org/10.22399/ijcesen.4130
• Schemenauer, Neil, Tim Peters, and Magnus Lie Hetland. 2001. “Simple Generators.” Python Enhancement Proposals. Accessed October 24, 2026. https://peps.python.org/pep-0255/
• Schiewe, Micah. 2022. “Bridging the Gap between Source Code and High-Level Concepts in Static Code Analysis: Student Research Abstract.” In Proceedings of the 37th ACM/SIGAPP Symposium on Applied Computing. ACM. https://doi.org/10.1145/3477314.3508371
• Schkufza, Eric, Michael Wei, and Christopher J. Rossbach. 2019. “Just-In-Time Compilation for Verilog: A New Technique for Improving the FPGA Programming Experience.” In Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems. ACM. https://doi.org/10.1145/3297858.3304010
• Schlichtkrull, Anders, Rene Rydhof Hansen, and Flemming Nielson. 2024. “Isabelle-Verified Correctness of Datalog Programs for Program Analysis.” In Proceedings of the 39th ACM/SIGAPP Symposium on Applied Computing. ACM. https://doi.org/10.1145/3605098.3636091
• Schmidt, David. 2000. “Abstract Interpretation and Program Modelling.” ACM SIGSOFT Software Engineering Notes 25 (1): 81–82. https://doi.org/10.1145/340855.341017
• Schmidt-Schauß, Manfred, and David Sabel. 2015. “Improvements in a Functional Core Language with Call-by-Need Operational Semantics.” In Proceedings of the 17th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/2790449.2790512
• Schöpp, Ulrich. 2017. “Defunctionalisation as Modular Closure Conversion.” In Proceedings of the 19th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3131851.3131868
• Schuele, Tobias, and Klaus Schneider. 2004. “Abstraction of Assembler Programs for Symbolic Worst Case Execution Time Analysis.” In Proceedings of the 41st annual Design Automation Conference. ACM. https://doi.org/10.1145/996566.996602
• Schwaab, Christopher, and Jeremy G. Siek. 2013. “Modular Type-Safety Proofs in Agda.” In Proceedings of the 7th workshop on Programming languages meets program verification. ACM. https://doi.org/10.1145/2428116.2428120
• Schwarcz, Florian, Felix Berlakovich, Gergö Barany, and Hanspeter Mössenböck. 2024. “LOOL: Low-Overhead, Optimization-Log-Guided Compiler Fuzzing (Registered Report).” In Proceedings of the 3rd ACM International Fuzzing Workshop. ACM. https://doi.org/10.1145/3678722.3685533
• Scott, Michael L. 1986. The Interface between Distributed Operating System and High-Level Programming Language. Revision. Defense Technical Information Center. https://doi.org/10.21236/ada179522
• Sculthorpe, Neil, Paolo Torrini, and Peter D. Mosses. 2016. “A Modular Structural Operational Semantics for Delimited Continuations.” Electronic Proceedings in Theoretical Computer Science 212: 63–80. https://doi.org/10.4204/eptcs.212.5
• Selivanov, Yury. 2015. “Coroutines with Async and Await Syntax.” Python Enhancement Proposals. Accessed October 24, 2026. https://peps.python.org/pep-0492/
• Sen, Vikram, Donald E. Wagner, John T. Etgen, et al. 2000. “Velocity Analysis Using Pre-Stack Depth Migration and 3D Tomogrphy: A Case Study over Steeply Dipping Salt.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/1.1816168
• Senior Software Engineer at Uvik, Hollywood, FL, USA and Kokalko Mykola. 2024. “Using Asynchronous Programming in Python to Improve Application Performance.” American Journal of Engineering and Technology 06 (12): 51–58. https://doi.org/10.37547/tajet/volume06issue12-06
• Seo, Yongjin, and Hyeon Soo Kim. 2016a. “Measuring Method of Worst-Case Execution Time by Analyzing Relation between Source Code and Executable Code.” Journal of Internet Computing and Services 17 (4): 51–60. https://doi.org/10.7472/jksii.2016.17.4.51
• Seo, Sunae, Hongseok Yang, Kwangkeun Yi, and Taisook Han. 2007. “Goal-Directed Weakening of Abstract Interpretation Results.” ACM Transactions on Programming Languages and Systems 29 (6): 39. https://doi.org/10.1145/1286821.1286830
• Serafin, Nathan, Souradip Ghosh, Harsh Desai, Nathan Beckmann, and Brandon Lucia. 2023. “Pipestitch: An Energy-Minimal Dataflow Architecture with Lightweight Threads.” In 56th Annual IEEE/ACM International Symposium on Microarchitecture. ACM. https://doi.org/10.1145/3613424.3614283
• Serrano, Manuel. 2022. “On JavaScript Ahead-of-Time Compilation Performance (Keynote).” In Proceedings of the 19th International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3546918.3560825
• Seshia, Sanjit A., and Alexander Rakhlin. 2009. Quantitative Analysis of Embedded Software Using Game-Theoretic Learning. Defense Technical Information Center. https://doi.org/10.21236/ada538736
• Shahrokhi, Hesam, Callum Groeger, Yizhuo Yang, and Amir Shaikhha. 2023. “Efficient Query Processing in Python Using Compilation.” In Companion of the 2023 International Conference on Management of Data. ACM. https://doi.org/10.1145/3555041.3589735
• Sharma, Ritu. 2025. “Green Threads: Human Connection with Nature in Richard Powers’ the Overstory.” Journal Global Values XVI (SI): 149–54. https://doi.org/10.31995/jgv.2025.v16isi.024
• Sharma, Divyanjali, and Subodh Sharma. 2024. “Parameterized Static Analysis for Weak Memory Models.” In Proceedings of the 17th Innovations in Software Engineering Conference. ACM. https://doi.org/10.1145/3641399.3641443
• Sharma, Mayank, Pingshi Yu, and Alastair F. Donaldson. 2023. “RustSmith: Random Differential Compiler Testing for Rust.” In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3597926.3604919
• Sharp, Oliver. 1990. Pythia: A Parallel Compiler for Delirium. Defense Technical Information Center. https://doi.org/10.21236/ada632217
• Sharrad, Joanna, Olaf Chitil, and Meng Wang. 2018. “Delta Debugging Type Errors with a Blackbox Compiler.” In Proceedings of the 30th Symposium on Implementation and Application of Functional Languages. ACM. https://doi.org/10.1145/3310232.3310243
• Sharygin, E. Y., and R. A. Buchatskiy. 2017. “Survey of Just-in-Time Query Compilation Methods.” Proceedings of the Institute for System Programming of the RAS 29 (3): 179–224. https://doi.org/10.15514/ispras-2017-29(3)-11
• Shcherbakov, Ye. V., and M. Ye. Shcherbakova. 2024. “Comparative Analysis of Coroutine Functionality in Modern Programming Languages.” Scientific news of Dahl university. https://doi.org/10.33216/2222-3428-2024-27-5
• Shen, Feng. 2017. “Android Security via Static Program Analysis.” In Proceedings of the 2017 Workshop on MobiSys 2017 Ph.D. Forum. ACM. https://doi.org/10.1145/3086467.3086469
• Sherman, Elena. 2018. “Redesigning Soot’s Data-Flow Analysis Framework for Abstract Interpretation.” In Companion Proceedings for the ISSTA/ECOOP 2018 Workshops. ACM. https://doi.org/10.1145/3236454.3236506
• Shi, Yunhe, Kevin Casey, M. Anton Ertl, and David Gregg. 2008. “Virtual Machine Showdown: Stack versus Registers.” ACM Transactions on Architecture and Code Optimization 4 (4): 1–36. https://doi.org/10.1145/1328195.1328197
• Shin, Kang G., Shige Wang, Zonghua Gu, Sharath Kodase, and Jeong-Chang Kim. 2004. AIRES: Automatic Integration of Reusable Embedded Software, Methodologies, Toolkit, and Experiments. Defense Technical Information Center. https://doi.org/10.21236/ada425188
• Shirai, Tatsuya, Olivier Nourry, Yutaro Kashiwa, Kenji Fujiwara, and Hajimu Iida. 2026. “Does Programming Language Matter? An Empirical Study of Fuzzing Bug Detection.” In Proceedings of the 23rd International Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/3793302.3793358
• Shukla, S., M. Nanjundappa, M. Anderson, B. Jose, M. Kracht, and J. Ouy. 2014. A Formal Approach to the Provably Correct Synthesis of Mission Critical Embedded Software for Multi Core Embedded Platforms. Defense Technical Information Center. https://doi.org/10.21236/ada602193
• Siambaton, Muhammad Zulfansyuri, Zainal Azis, and Tua Halomoan Harahap. 2024. “Implementation Draft Programming Oriented Objects in Parking System Application Using Language Programming Java.” Tsabit Journal of Computer Science 1 (1): 1–7. https://doi.org/10.56211/tsabit24
• Sinharoy, Balaram. 1988. EPL: Equational Programming Language Parsing and Dimension Propagation. Defense Technical Information Center. https://doi.org/10.21236/ada200722
• SLIIT City Uni, Dineth Mallawarachchi, Yasas Jayaweera, and SLIIT City Uni. 2025. “Implementation of Wyltl: An Imperative Language with a Dual Interpreter – Compiler Architecture.” In Proceedings of the Annual Research Conference of SCU. SLIIT City Uni. https://doi.org/10.54389/cwbl6597
• Snavely, Allan. 2011. Test and Evaluation of Architecture-Aware Compiler Environment. Defense Technical Information Center. https://doi.org/10.21236/ada563246
• Snyder, Alan. 1975. A Portable Compiler for the Language C. Defense Technical Information Center. https://doi.org/10.21236/ada010218
• “Socket System in Php Programming Language.” 2021. Nedelya nauki Sankt-Peterburgskogo gosudarstvennogo morskogo tekhnicheskogo universiteta 1 (1). https://doi.org/10.52899/978-5-88303-612-4_281
• Sokhatskyi, Maksym, and Pavlo Maslianko. 2018. “The Systems Engineering of Consistent Pure Language with Effect Type System for Certified Applications and Higher Languages.” In AIP Conference Proceedings, vol. 1982. Author(s). https://doi.org/10.1063/1.5045439
• Soluian, O., and L. Lіushenko. 2025. “Research of WebAssembly Usage for High-Performance Code Development in Web Applications.” System technologies 3 (158): 188–200. https://doi.org/10.34185/1562-9945-3-158-2025-19
• Son, Yunsik, and YangSun Lee. 2016. “A Study on the Interpreter for the Light-Weighted Virtual Machine on IoT Environments.” International Journal of Web Science and Engineeringfor Smart Devices 3 (2): 19–24. https://doi.org/10.21742/ijwsesd.2016.3.2.04
• Son, Yunsik, Seman Oh, and Yangsun Lee. 2014. “A Reversing Technique for Symbol Table Verification on Compiler Constructions.” In Advanced Science and Technology Letters. Science & Engineering Research Support soCiety. https://doi.org/10.14257/astl.2014.60.10
• Son, Yunsik, Seman Oh, and YangSun Lee. 2017. “Design and Implementation of the RSIL to LLVM IR Translator for Verification of the Intermediate Code on IoT Virtual Machine.” International Journal of Control and Automation 10 (10): 123–34. https://doi.org/10.14257/ijca.2017.10.10.11
• Song, Lihua, and Haitao Wang. 2021. “Monadic Programming Featured Teaching Innovation of Compilation Experiments: SONG Et Al.: Monadic Programming Featured Compilation Experiments.” In 2021 3rd International Conference on Modern Educational Technology. ACM. https://doi.org/10.1145/3468978.3468984
• Sorensen, Tyler, Aninda Manocha, Esin Tureci, Marcelo Orenes-Vera, Juan L. Aragón, and Margaret Martonosi. 2020. “A Simulator and Compiler Framework for Agile Hardware-Software Co-Design Evaluation and Exploration.” In Proceedings of the 39th International Conference on Computer-Aided Design. ACM. https://doi.org/10.1145/3400302.3415751
• Spampinato, Daniele G., and Markus Püschel. 2016. “A Basic Linear Algebra Compiler for Structured Matrices.” In Proceedings of the 2016 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/2854038.2854060
• Stata, Raymie, and Martin Abadi. 1999. “A Type System for Java Bytecode Subroutines.” ACM Transactions on Programming Languages and Systems 21 (1): 90–137. https://doi.org/10.1145/314602.314606
• Stepanov, Daniil, and Vladimir Itsykson. 2022. “Backend Bug Finder — A Platform for Effective Compiler Fuzzing.” Information and Control Systems, no. 6: 31–40. https://doi.org/10.31799/1684-8853-2022-6-31-40
• Stepanov, Oleksandr, and Halyna Klym. 2025. “A Quantitative Analysis of Webassembly Integration: Architectural Patterns, Tooling, and Performance Evaluation.” Electronics and Information Technologies 32: 837. https://doi.org/10.30970/eli.32.10
• Stiévenart, Quentin, David W. Binkley, and Coen De Roover. 2022. “Static Stack-Preserving Intra-Procedural Slicing of Webassembly Binaries.” In Proceedings of the 44th International Conference on Software Engineering. ACM. https://doi.org/10.1145/3510003.3510070
• Stolyarov, Vladislav Romanovich. 2023. “Static Analyzer Implementation Model for the Solidty Programming Language.” Recent Scientific Investigation 40. https://doi.org/10.32743/usaconf.2023.1.40.350415
• Stoonkisto, Peter, and Jaspal Subhlok. 1997. Coordinating Foreign Modules with a Parallelizing Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada327279
• Strauch, Tobias. 2023. “MRPHS: A Verilog RTL to C++ Model Compiler Using Intermediate Representations for Object-Oriented Model-Driven Prototyping.” In Proceedings of the 34th International Workshop on Rapid System Prototyping. ACM. https://doi.org/10.1145/3625223.3649276
• Subramanyan, Bala. 2025. “Cwamr: Reimagining a Capabilitybased Webassembly Runtime via Cheri-Based Compartmentalization.” In Computer Science and Information Technology Trends 2025. Academy & Industry Research Collaboration. https://doi.org/10.5121/csit.2025.151407
• Sudha, V., M. Archana, D. H. Chaithra, G. M. Chethana, and S. Kavya. 2019. “A Weighted Ensemble of Automatic Algorithms for Virtual Machine Performance Prediction in Cloud.” International Journal of Current Engineering and Scientific Research 6 (6): 198–203. https://doi.org/10.21276/ijcesr.2019.6.6.34
• Suhendra, Agus, and Adam Mukharil Bachtiar. 2016. “Migration Code Pada Backend Crimezone Dari PHP Ke Scala.” Jurnal Sistem Informasi 12 (2): 75. https://doi.org/10.21609/jsi.v12i2.489
• Sukha, Jim. 2015. “A Compiler-Runtime Application Binary Interface for Pipe-While Loops.” In Proceedings of the 27th ACM symposium on Parallelism in Algorithms and Architectures. ACM. https://doi.org/10.1145/2755573.2755610
• SulĂ­r, Matúš, and Jaroslav Poruban. 2017. “Exposing Runtime Information through Source Code Annotations.” Acta Electrotechnica et Informatica 17 (1): 3–9. https://doi.org/10.15546/aeei-2017-0001
• Sun, Chengnian, Vu Le, Qirun Zhang, and Zhendong Su. 2016b. “Toward Understanding Compiler Bugs in GCC and LLVM.” In Proceedings of the 25th International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/2931037.2931074
• Sun, Aoyuan, Yue Tu, Yuhao Gu, Chunyu Chen, Jiangsu Du, and Xianwei Zhang. 2025a. “Archs: A WebAssembly Runtime for Cross-Host Heterogeneous Computing in Serverless.” In Proceedings of the 2025 9th International Conference on High Performance Compilation, Computing and Communications. ACM. https://doi.org/10.1145/3774949.3774968
• Suo, Chenyao, Junjie Chen, Shuang Liu, Jiajun Jiang, Yingquan Zhao, and Jianrong Wang. 2024. “Fuzzing MLIR Compiler Infrastructure via Operation Dependency Analysis.” In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3650212.3680360
• “Supplemental Material for a Just-in-Time Adaptive Intervention to Enhance Physical Activity in the SMARTFAMILY2.0 Trial.” 2022. Sport, Exercise, and Performance Psychology. https://doi.org/10.1037/spy0000311.supp
• Surakka, Kimmo, Tommi Mikkonen, Hannu-Matti Järvinen, Timo Vuorela, and Jukka Vanhala. 2005. “Towards Compiler Backend Optimization for Low Energy Consumption at Instruction Level.” Proceedings of the Estonian Academy of Sciences. Engineering 11 (4): 347–57. https://doi.org/10.3176/eng.2005.4.07
• Surati, Rajeev. 1993. A Parallelizing Compiler Based on Partial Evaluation. Defense Technical Information Center. https://doi.org/10.21236/ada270838
• Swierstra, S. Doaitse, Marcos Viera, and Atze Dijkstra. 2016. “A Lazy Language Needs a Lazy Type System: Introducing Polymorphic Contexts.” In Proceedings of the 28th Symposium on the Implementation and Application of Functional Programming Languages. ACM. https://doi.org/10.1145/3064899.3064906
• “Syntax-Directed Semantics in Programming Language Design.” 2026. Iconic Research and Engineering Journals 9 (10). https://doi.org/10.64388/irev9i10-1716556
• Szydełko, Łukasz. 2018. “Bonds Balance Sheet Valuation in Amortised Cost – Chosen Aspects.” Prace Naukowe Uniwersytetu Ekonomicznego we Wrocławiu, no. 503: 464–72. https://doi.org/10.15611/pn.2018.503.41
• Tadepalli, Sharma, Zhiming Li, and Chen-Bin Su. 2003. “3D Pre-Stack Depth Imaging and Well Ties: A Case History of Depth Imaging in Gulf of Mexico.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/1.1817654
• Ţălu, Mircea. 2025. “A Comparative Study of WebAssembly Runtimes: Performance Metrics, Integration Challenges, Application Domains, and Security Features.” Archives of Advanced Engineering Science 4 (3): 275–87. https://doi.org/10.47852/bonviewaaes52024965
• Tan, Yong Kiam, Scott Owens, and Ramana Kumar. 2015. “A Verified Type System for CakeML.” In Proceedings of the 27th Symposium on the Implementation and Application of Functional Programming Languages. ACM. https://doi.org/10.1145/2897336.2897344
• Tarau, Paul. 2011. “The BinProlog Experience: Architecture and Implementation Choices for Continuation Passing Prolog and First-Class Logic Engines.” Theory and Practice of Logic Programming 12 (1–2): 97–126. https://doi.org/10.1017/s1471068411000433
• Tarjan, Robert Endre. 1985. “Amortized Computational Complexity.” SIAM Journal on Algebraic Discrete Methods 6 (2): 306–18. https://doi.org/10.1137/0606031
• Tavares, André L. C., Quentin Colombet, Mariza A. S. Bigonha, Christophe Guillon, Fernando M. Q. Pereira, and Fabrice Rastello. 2011. “Decoupled Graph-Coloring Register Allocation with Hierarchical Aliasing.” In Proceedings of the 14th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/1988932.1988934
• Tejaswini, A., S. Vindhya, V. Sharanraj, K. S. Raveendra, and Vasanth Kumar. 2024. “Design of Mechatronics Based Virtual Telepresence for Robotic System Using Raspberry Python Interpreter.” Interantional Journal of Scientific Research in Engineering and Management 08 (09): 1–6. https://doi.org/10.55041/ijsrem37614
• Terao, Taku. 2018. “Lazy Abstraction for Higher-Order Program Verification.” In Proceedings of the 20th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3236950.3236969
• Thangamani, Arun, Tiago Trevisan Jost, Vincent Loechner, Stéphane Genaud, and Bérenger Bramas. 2023. “Lifting Code Generation of Cardiac Physiology Simulation to Novel Compiler Technology.” In Proceedings of the 21st ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3579990.3580008
• TheDan64. n.d. “Inkwell(s): It’s a New Kind of Wrapper for Exposing LLVM (Safely).” GitHub. Accessed October 24, 2026. https://github.com/TheDan64/inkwell
• Thielecke, Hayo. 2012. “Functional Semantics of Parsing Actions, and Left Recursion Elimination as Continuation Passing.” In Proceedings of the 14th symposium on Principles and practice of declarative programming. ACM. https://doi.org/10.1145/2370776.2370789
• Thorpe, Jamie, Laura P. Swiler, Seth Hanson, et al. 2022a. “Verification of Cyber Emulation Experiments through Virtual Machine and Host Metrics.” In Proceedings of the 15th Workshop on Cyber Security Experimentation and Test. ACM. https://doi.org/10.1145/3546096.3546115
• Thorpe, Jamie, Laura Swiler, Seth Hanson, et al. 2022b. “WiP: Verification of Cyber Emulation Experiments through Virtual Machine and Host Metrics.” In Proposed for presentation at the Cyber-Physical Systems Virtual Organization Hot Topics in the Science of Security (HoTSoS) held April 5-7, 2022 in , United States. US DOE. https://doi.org/10.2172/2002078
• Tian, Xinmin, Hideki Saito, Ernesto Su, et al. 2017. “LLVM Compiler Implementation for Explicit Parallelization and SIMD Vectorization.” In Proceedings of the Fourth Workshop on the LLVM Compiler Infrastructure in HPC. ACM. https://doi.org/10.1145/3148173.3148191
• Tinnerholm, John, Martin Sjölund, and Adrian Pop. 2019. “Towards Introducing Just-in-Time Compilation in a Modelica Compiler.” In Proceedings of the 9th International Workshop on Equation-based Object-oriented Modeling Languages and Tools. ACM. https://doi.org/10.1145/3365984.3365990
• Titzer, Ben. 2025. “WebAssembly: How Low Can a Bytecode Go?: New Performance and Capabilities.” Queue 23 (3): 31–47. https://doi.org/10.1145/3746172
• Todoran, Eneia Nicolae, and Nikolaos Papaspyrou. 2017. “Concurrency Semantics in Continuation-Passing Style.” Fundamenta Informaticae 153 (1–2): 125–46. https://doi.org/10.3233/fi-2017-1534
• Tokumori, Junya, Satoshi Ono, Takashi Koba, Shinichi Kitayama, and Shigeru Nakayama. 2007. “Development of Metadata Generation Support System Using Compiler Compiler.” Joho Chishiki Gakkaishi 17 (1): 41–50. https://doi.org/10.2964/jsik.17.41
• Tolpin, David, Jan-Willem van de Meent, Hongseok Yang, and Frank Wood. 2016. “Design and Implementation of Probabilistic Programming Language Anglican.” In Proceedings of the 28th Symposium on the Implementation and Application of Functional Programming Languages. ACM. https://doi.org/10.1145/3064899.3064910
• Tran, Duong Dinh, Thet Wai Mon, and Kazuhiro Ogata. 2023. “Transport Layer Security 1.0 Handshake Protocol Formal Verification Case Study: How to Use a Proof Script Generator for Existing Large Proof Scores.” PeerJ Computer Science 9: e1284. https://doi.org/10.7717/peerj-cs.1284
• Trout, Robert G. 1967. “A Compiler—Compiler System.” In Proceedings of the 1967 22nd national conference on -. ACM Press. https://doi.org/10.1145/800196.806002
• Tuck, Russ. 1988. An Optimally Portable SIMD (Single-Instruction Multiple-Data) Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada201089
• Turcotte, Alexi, and Jan Vitek. 2019. “Towards a Type System for R.” In Proceedings of the 14th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems. ACM. https://doi.org/10.1145/3340670.3342426
• “The Utilization of Cloud Computing as Virtual Machine.” 2017. International Journal of Recent Trends in Engineering and Research 3 (7): 396–99. https://doi.org/10.23883/ijrter.2017.3371.mfrag
• van der Hoeven, Joris, and Grégoire Lecerf. 2021. “Amortized Bivariate Multi-Point Evaluation.” In Proceedings of the 2021 International Symposium on Symbolic and Algebraic Computation. ACM. https://doi.org/10.1145/3452143.3465531
• van Rossum, Guido, and Phillip J. Eby. 2005. “Coroutines via Enhanced Generators.” Python Enhancement Proposals. Accessed October 24, 2026. https://peps.python.org/pep-0342/
• van Tonder, Rijnard, and Claire Le Goues. 2020. “Tailoring Programs for Static Analysis via Program Transformation.” In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering. ACM. https://doi.org/10.1145/3377811.3380343
• Vandenbroucke, Alexander, and Tom Schrijvers. 2023. “Disjunctive Delimited Control.” Theory and Practice of Logic Programming 24 (1): 110–31. https://doi.org/10.1017/s1471068423000029
• Vasilyev, A. A., and V. S. Mutilin. 2020. “Predicate Extension of Symbolic Memory Graphs for the Analysis of Memory Safety Correctness.” Programming and Computer Software 46 (8): 747–54. https://doi.org/10.1134/s0361768820080071
• Vegdahl, Steven R., and Uwe F. Pleban. 1989. “The Runtime Environment for Scheme, a Scheme Implementation on the 88000.” ACM SIGARCH Computer Architecture News 17 (2): 172–82. https://doi.org/10.1145/68182.68199
• Veit, Adrienn, and Elvira Böcskei. 2024. “IFRS 9 Classification Aspects – Measurement of Sustainability-Linked Loans at Amortised Cost or Fair Value.” Pénzügyi Szemle = Public Finance Quarterly 70 (4). https://doi.org/10.35551/pfq_2024_4_4
• Venkanna, Mood, and Rameshwar Rao. 2018. “Static Worst-Case Execution Time Optimization Using DPSO for ASIP Architecture.” Ingeniería Solidaria 14 (25): 1–11. https://doi.org/10.16925/.v14i0.2230
• Venkanna, Mood, Rameshwar Rao, and P. Chandra Sekhar. 2018. “PSO Based Optimization of Worst-Case Execution Time for ASIP Application.” International Journal of Engineering & Technology 7 (3.3): 252. https://doi.org/10.14419/ijet.v7i2.33.14162
• Venkata Padma Kumar Vemuri. 2021. “WebAssembly for High-Performance Web Applications: A Study on Execution Speed and Efficiency.” International Journal on Science and Technology 12 (2): 2812. https://doi.org/10.71097/ijsat.v12.i2.2812
• Venkatesan, S. 2025. “Towards Autonomous Code Optimization: A Reinforcement Learning Framework for Compiler Design.” International Journal of Applied Mathematics 38 (11s): 1790–1813. https://doi.org/10.12732/ijam.v38i11s.1286
• Verma, Amit, and Nikita Bakshi. 2015. “Chronological Advancement in Compiler Design: A Review.” Research in Computing Science 103 (1): 99–109. https://doi.org/10.13053/rcs-103-1-9
• “Virtual Machine Consolidation Using Load Balancing Algorithm in Cloud Data Center.” 2017. International Journal of Science and Research (IJSR) 6 (1): 2098–2102. https://doi.org/10.21275/22121601
• Vista Research Corp Tucson AZ. 1994a. Ada Compiler Validation Summary Report: Certificate Number: 940223W1. 11338 Green Hills Software, Inc. Green Hills Optimizing Ada Compiler, 1.8.7 SPARCstation 10 under SunOS, Release 4.1.3. Defense Technical Information Center. https://doi.org/10.21236/ada278081
• Vista Research Corp Tucson AZ. 1994b. Ada Compiler Validation Summary Report: Certificate Number: 940305W1. 11335 TLD Systems, Ltd. TLD Comanche VAX/1960 Ada Compiler System, Version 4.1.1 VAX Cluster under VMS 5.5 => Tronix JIAWG Execution Vehicle (i960MX) under TLD Real Time Executive, Version 4.1.1. Defense Technical Information Center. https://doi.org/10.21236/ada278080
• von Behren, Rob, Jeremy Condit, Feng Zhou, George C. Necula, and Eric Brewer. 2003. “Capriccio: Scalable Threads for Internet Services.” In Proceedings of the nineteenth ACM symposium on Operating systems principles. ACM. https://doi.org/10.1145/945445.945471
• Vos, Jelle, Mauro Conti, and Zekeriya Erkin. 2023. “Oraqle: A Depth-Aware Secure Computation Compiler.” In Proceedings of the 12th Workshop on Encrypted Computing & Applied Homomorphic Cryptography. ACM. https://doi.org/10.1145/3689945.3694808
• Vraný, Jan, and Boris Shingarov. 2024. “Tinyrossa: A Compiler Framework for Vertical, Verified Construction of Smalltalk VMs.” In Companion Proceedings of the 8th International Conference on the Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3660829.3660838
• Wagle, Bibek, Mohammad Alaul Haque Monil, Kevin Huck, Allen D. Malony, Adrian Serio, and Hartmut Kaiser. 2019. “Runtime Adaptive Task Inlining on Asynchronous Multitasking Runtime Systems.” In Proceedings of the 48th International Conference on Parallel Processing. ACM. https://doi.org/10.1145/3337821.3337915
• Wagstaff, Kiri L., Edward Benowitz, D. J. Byrne, Ken Peters, and Garth Watney. 2008. “Automatic Code Generation for Instrument Flight Software.” In 9th International Symposium on Artificial Intelligence, Robotics, and Automation in Space. https://ntrs.nasa.gov/citations/20090031888
• Wahyudi, Erfan, and Agus Miswanto. 2020. “Virtual Machine Forensic Analysis & Recovery (Vmfar) Sebagai Framework Untuk Analisis Bukti Digital Pada Virtual Machine.” EXPLORE 10 (2). https://doi.org/10.35200/explore.v9i2.225
• Waites, William, Göksel Mısırlı, Matteo Cavaliere, Vincent Danos, and Anil Wipat. 2018. “A Genetic Circuit Compiler: Generating Combinatorial Genetic Circuits with Web Semantics and Inference.” ACS Synthetic Biology 7 (12): 2812–23. https://doi.org/10.1021/acssynbio.8b00201
• Wambua, Anthony. 2025. “Topics, Trends, and Sentiments in Software Testing: An Analysis of Developers’ Engagement on Stack Overflow.” International Journal of Computer and Information Technology(2279-0764) 14 (3). https://doi.org/10.24203/dfjd8332
• Wang, Xinyuan, and hejiao Huang. 2022b. “Sgpm: A Coroutine Scheduling Model for Wound-Wait Concurrency Control.” Preprint, . https://doi.org/10.2139/ssrn.4022101
• Wang, Zichen, Jingyi Wang, Fu Song, Kun Wang, Hongyi Pu, and Peng Cheng. 2024. “K-RAPID: A Formal Executable Semantics of the RAPID Robot Programming Language.” In Proceedings of the 10th ACM Cyber-Physical System Security Workshop. ACM. https://doi.org/10.1145/3626205.3659149
• Wang, Yanzhao, and Fei Xie. 2024. “Enhancing Translation Validation of Compiler Transformations with Large Language Models.” International Journal of Software Engineering and Knowledge Engineering 35 (01): 45–57. https://doi.org/10.1142/s0218194024500475
• Wang, Bo, Yingfei Xiong, Yangqingwei Shi, Lu Zhang, and Dan Hao. 2017. “Faster Mutation Analysis via Equivalence Modulo States.” In Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3092703.3092714
• Wang, Yuan Da, and Tian Qi Yang. 2014. “Applied Technology in Front-End Implementation of Tiger Compiler Using Hacs Language.” Advanced Materials Research 952: 325–29. https://doi.org/10.4028/www.scientific.net/amr.952.325
• Watanabe, Yutaka, Jinpil Lee, Kentaro Sano, Taisuke Boku, and Mitsuhisa Sato. 2020. “Design and Preliminary Evaluation of OpenACC Compiler for FPGA with OpenCL and Stream Processing DSL.” In Proceedings of the International Conference on High Performance Computing in Asia-Pacific Region Workshops. ACM. https://doi.org/10.1145/3373271.3373274
• Watt, Conrad. 2025. “Concurrency in WebAssembly: Experiments in the Web and Beyond.” Queue 23 (3): 65–85. https://doi.org/10.1145/3747201.3746173
• WebAssembly Community Group. n.d. “Stack-Switching Proposal for WebAssembly.” GitHub. Accessed October 24, 2026. https://github.com/WebAssembly/stack-switching
• Weber, Dorian, and Joachim Fischer. 2020. “Process-Based Simulation with Stackless Coroutines.” In Proceedings of the 12th System Analysis and Modelling Conference. ACM. https://doi.org/10.1145/3419804.3421450
• Welch, Daniel, Blair Durkee, Mike Kabbani, and Murali Sitaraman. 2017. “Formalization IDEs Integrated with a Verifying Compiler.” In Proceedings of the 12th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems. ACM. https://doi.org/10.1145/3098572.3098580
• Wenes, G., S. Kremer, and J. Shiu. 1994. “A Practical Implementation of a 3D Pre-Stack Depth Migration Algorithm.” In 56th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201409898
• Western, P. G., and G. Ball. 1991. “3D Pre-Stack Depth Migration in the Gulf of Sueza. a Case History.” In 53rd EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201410925
• Whiteside, Wilfred, Alex Yeh, and Bin Wang. 2012. “Directional Imaging Stack (DIS) for Shot Based Pre-Stack Depth Migrations.” In International Meeting for Applied Geoscience & Energy, vol. 1. Society of Exploration Geophysicists. https://doi.org/10.1190/segam2012-1184.1
• Wilhelm, Reinhard, Jakob Engblom, Andreas Ermedahl, et al. 2008. “The Worst-Case Execution-Time Problem—Overview of Methods and Survey of Tools.” ACM Transactions on Embedded Computing Systems 7 (3): 1–53. https://doi.org/10.1145/1347375.1347389
• Wilson, Steven P. 1989a. Ada Compiler Validation Capability (ACVC) Version 1.11 (Field-Test Release). ANSI. Defense Technical Information Center. https://doi.org/10.21236/ada212548
• Wilson, Steven P. 1989b. Ada Compiler Validation Capability (ACVC) Version 1.11 (Field-Test Release). ANSI, BACKUP, TAR. Defense Technical Information Center. https://doi.org/10.21236/ada212550
• Wilson, Steven P. 1989c. Ada Compiler Validation Capability (ACVC) Version 1.11 (Field-Test Release). BACKUP. Defense Technical Information Center. https://doi.org/10.21236/ada212551
• Wilson, Steven P. 1989d. Ada Compiler Validation Capability (ACVC) Version 1.11 (Field-Test Release). TAR. Defense Technical Information Center. https://doi.org/10.21236/ada212437
• Wilson, Steven P. 1990a. Ada/Ed Compiler, Version 1.10 (UNIX). Defense Technical Information Center. https://doi.org/10.21236/ada218688
• Wilson, Steven P. 1990b. Ada/Ed Compiler, Version 1.10(VAX). Defense Technical Information Center. https://doi.org/10.21236/ada218687
• Wimmer, Christian, Vojin Jovanovic, Erik Eckstein, and Thomas Würthinger. 2017. “One Compiler: Deoptimization to Optimized Code.” In Proceedings of the 26th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3033019.3033025
• Windsor, Matt, Alastair F. Donaldson, and John Wickerson. 2021. “C4: The C Compiler Concurrency Checker.” In Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3460319.3469079
• “Worst Case Execution Time Calculation of Parallel Embedded Real-Time Software.” 2016. In Proceedings of 2016 the 6th International Workshop on Computer Science and Engineering. WCSE. https://doi.org/10.18178/wcse.2016.06.002
• Wu, Peng. 2023. “PyTorch 2.0: The Journey to Bringing Compiler Technologies to the Core of PyTorch (Keynote).” In Proceedings of the 21st ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3579990.3583093
• Wu, Yu-Xia, Yun-Zhuo Fan, and Dan-Bo Zhang. 2026b. “Fluctuation-Guided Adaptive Random Compiler for Hamiltonian Simulation.” Physical Review Applied 25 (5): 054034. https://doi.org/10.1103/52wr-1hys
• Wu, Xiao, Junzhou He, Liyan Huang, Cai Fu, and Weihang Wang. 2025b. “WBSan: WebAssembly Bug Detection for Sanitization and Binary-Only Fuzzing.” In Proceedings of the ACM on Web Conference 2025. ACM. https://doi.org/10.1145/3696410.3714622
• Wu, Xiaojie, Qiming Sun, and Yuanheng Wang. 2026a. “Designing Quantum Chemistry Algorithms with Just-in-Time Compilation.” Journal of Chemical Physics 164 (19): 194102. https://doi.org/10.1063/5.0314659
• Wu, Jianping, Fukang Yin, and Jinhui Yang. 2017. “Two Schemes to Improve the Implementation of the Aggregation Based Algebraic Multigrid Preconditioner.” In Proceedings of the 2017 International Conference on Applied Mathematics, Modeling and Simulation (AMMS 2017). Atlantis Press. https://doi.org/10.2991/amms-17.2017.7
• Wu, Lan, and Wei Zhang. 2012. “A Model Checking Based Approach to Bounding Worst-Case Execution Time for Multicore Processors.” ACM Transactions on Embedded Computing Systems 11 (S2): 1–19. https://doi.org/10.1145/2331147.2331166
• Wu, Lan, and Wei Zhang. 2018. “Cache-Aware SPM Allocation to Reduce Worst-Case Execution Time for Hybrid SPM-Caches.” Journal of Circuits, Systems and Computers 27 (05): 1850080. https://doi.org/10.1142/s0218126618500809
• Wu, Jingwen, Jiajing Zheng, Zhenyu Yang, and Zhongxing Yu. 2025a. “Compiler Optimization Testing Based on Optimization-Guided Equivalence Transformations.” In Proceedings of the 33rd ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3696630.3728528
• x86-psABIs. 2019. “x86-64 psABI.” GitLab. Accessed October 24, 2026. https://gitlab.com/x86-psABIs/x86-64-ABI
• Xia, Songtao, and Benedetto L. DiVito. 2005. “Software Certification for Temporal Properties with Affordable Tool Qualification.” In Workshop on Software Certificate Management, Long Beach, CA, November 8-11, 2005. https://ntrs.nasa.gov/citations/20050240928
• Xiao, Sheng, Yong Chen, Jing He, and Xi Yang. 2023. “Read-Write Dependency Aware Register Allocation.” Computer Systems Science and Engineering 46 (3): 3527–40. https://doi.org/10.32604/csse.2023.027081
• Xie, Yuanmin, Zhenyang Xu, Yongqiang Tian, Min Zhou, Xintong Zhou, and Chengnian Sun. 2025. “Kitten: A Simple Yet Effective Baseline for Evaluating LLM-Based Compiler Testing Techniques.” In Proceedings of the 34th ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3713081.3731731
• Xue, Yuankun, and Paul Bogdan. 2016. “Scalable and Realistic Benchmark Synthesis for Efficient NoC Performance Evaluation: A Complex Network Analysis Approach.” In Proceedings of the Eleventh IEEE/ACM/IFIP International Conference on Hardware/Software Codesign and System Synthesis. ACM. https://doi.org/10.1145/2968456.2968471
• Yan, Jun, and Wei Zhang. 2008. “Analyzing the Worst-Case Execution Time for Instruction Caches with Prefetching.” ACM Transactions on Embedded Computing Systems 8 (1): 1–19. https://doi.org/10.1145/1457246.1457253
• Yaneva, Vanya, Ajitha Rajan, and Christophe Dubach. 2017. “Compiler-Assisted Test Acceleration on GPUs for Embedded Software.” In Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3092703.3092720
• Yang, Zheng. 2018. “Formal Process Virtual Machine for Smart Contracts Verification.” International Journal of Performability Engineering. https://doi.org/10.23940/ijpe.18.08.p9.17261734
• Ye, Guixin, Tianmin Hu, Zhanyong Tang, et al. 2023. “A Generative and Mutational Approach for Synthesizing Bug-Exposing Test Cases to Guide Compiler Fuzzing.” In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3611643.3616332
• Yesua, I. Nyoman, Puger Rahardjo, and Pesta Parulian Maurid Edwar. 2019. “Keamanan Penggunaan Propofol Auto-Coinduction Dibandingkan Dengan Midazolam Coinduction Berdasarkan Perubahan Hemodinamik Pada Induksi Anestesi Pasien Yang Dilakukan General Anestesi.” JAI (Jurnal Anestesiologi Indonesia) 11 (1): 1. https://doi.org/10.14710/jai.v11i1.22039
• Yi, Soyul, and Youngjun Lee. 2018. “An Educational System Design to Support Learning Transfer from Block-Based Programming Language to Text-Based Programming Language.” International Journal on Advanced Science, Engineering and Information Technology 8 (4–2): 1571–76. https://doi.org/10.18517/ijaseit.8.4-2.5735
• Yin, Hanwen, Yun Pan, and Han Jiang. 2020. “The Implementation of Simple Smart Contract Language and Its Compiler Based on Ethereum Platform.” In Proceedings of the 2020 International Conference on Computer Communication and Information Systems. ACM. https://doi.org/10.1145/3418994.3419010
• Yoo, Ju Kyung, and Jong-Bae Kim. 2017. “Coroutine Based Algorithms for Reducing Memory Overhead in Virtual Reality.” Asia-pacific Journal of Multimedia services convergent with Art, Humanities, and Sociology 7 (9): 327–36. https://doi.org/10.14257/ajmahs.2017.09.79
• Yu, Dan. 2008. “Design and Implementation of NC Code Compiler Based on ANTLR.” Journal of Computer Applications 28 (2): 522–24. https://doi.org/10.3724/sp.j.1087.2008.00522
• Yu, Pingshi. 2023. “Reasoning about MLIR Semantics through Effects and Handlers.” In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3597926.3605239
• Yu, Weihai, and Abul Ahsan Md. Mahmudul Haque. 2011. “Decentralised Web-Services Orchestration with Continuation-Passing Messaging.” International Journal of Web and Grid Services 7 (3): 304. https://doi.org/10.1504/ijwgs.2011.043532
• Yu, Weihai, and Jie Yang. 2007. “Continuation-Passing Enactment of Distributed Recoverable Workflows.” In Proceedings of the 2007 ACM symposium on Applied computing. ACM. https://doi.org/10.1145/1244002.1244114
• Zaitsev, Dmitry Anatoly, and Kyril Dmitry Guliaiev. 2011. “Stack E6 and Its Implementation within Linux Kernel.” Journal of Software Engineering and Applications 04 (06): 379–87. https://doi.org/10.4236/jsea.2011.46043
• Zaytsev, Vadim. 2020. “Modelling of Language Syntax and Semantics: The Case of the Assembler Compiler.” Journal of Object Technology 19 (2): 5:1. https://doi.org/10.5381/jot.2020.19.2.a5
• Zelenova, S. A. 2025. “Static Memory Layout for Real-Time Operating Systems.” Programming and Computer Software 51 (6): 453–62. https://doi.org/10.1134/s036176882570032x
• Zelkowitz, Marvin V. 1975. “Third Generation Compiler Design.” In Proceedings of the 1975 annual conference on - ACM 75. ACM Press. https://doi.org/10.1145/800181.810332
• Zeng, Yishun, Yue Wu, and Chao Zhang. 2026. “TypeNFuzz: Dynamic Type-Aware Object Dependence Graph-Guided Fuzzing for JavaScript Library Bug Discovery.” ACM Transactions on Software Engineering and Methodology 35 (6): 1–22. https://doi.org/10.1145/3765760
• Zhang, Yu. 2018. “Compiler Practice System Integrated with Real Open Source Compiler: (Abstract Only).” In Proceedings of the 49th ACM Technical Symposium on Computer Science Education. ACM. https://doi.org/10.1145/3159450.3162242
• Zhang, Yixuan, Shangtong Cao, Haoyu Wang, et al. 2023a. “Characterizing and Detecting WebAssembly Runtime Bugs.” ACM Transactions on Software Engineering and Methodology 33 (2): 1–29. https://doi.org/10.1145/3624743
• Zhang, R., and Z. Deng. 2018. “A Depth Variant Seismic Wavelets Extraction Method for Inversion of Post-Stack Depth Domain Seismic Data.” In Proceedings. EAGE Publications BV. https://doi.org/10.3997/2214-4609.201800728
• Zhang, Tianxu, and Fanchen Meng. 2020. “Design and Implementation of Multi-Core DSP Parallel Compiler Based on Otsu Method.” In 2020 4th International Conference on Advances in Image Processing. ACM. https://doi.org/10.1145/3441250.3441261
• Zhang, Hongjun, Junbiao Ping, Feng Yang, Qi He, and Hongtao Chen. 2011. “A Case Study of Pre-Stack Depth Migration Application over a Salt Dome Area.” In All Days. IPTC. https://doi.org/10.2523/iptc-14474-ms
• Zhang, Hongbin, Mingjie Xing, Yanjun Wu, and Chen Zhao. 2023b. “Compiler Technologies in Deep Learning Co-Design: A Survey.” Intelligent Computing 2: 0040. https://doi.org/10.34133/icomputing.0040
• Zhang, Denghui, and Guocai Yin. 2021. “A Virtual Machine Placement Strategy Based on Virtual Machine Selection and Integration.” Journal on Internet of Things 3 (4): 149–57. https://doi.org/10.32604/jiot.2021.016936
• Zhang, Shuoming, Jiacheng Zhao, Chunwei Xia, Zheng Wang, Yunji Chen, and Huimin Cui. 2024. “Introducing Compiler Semantics into Large Language Models as Programming Language Translators: A Case Study of C to x86 Assembly.” In Findings of the Association for Computational Linguistics: EMNLP 2024. Association for Computational Linguistics. https://doi.org/10.18653/v1/2024.findings-emnlp.55
• Zhao, Ziming, Tingting Li, and Jianwei Yin. 2026. “QuaMap: A Multi-Backend Benchmark Dataset for Quantum Circuit Mapping and Learning-Based Compiler Evaluation.” In Proceedings of the 32nd ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.1. ACM. https://doi.org/10.1145/3770854.3785697
• Zhao, Wenxuan, Ruiying Zeng, and Yangfan Zhou. 2024c. “Wapplique: Testing WebAssembly Runtime via Execution Context-Aware Bytecode Mutation.” In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3650212.3680340
• Zhao, Li Xian, Li Zhang, and Jing Jiang. 2021a. “Hot Question Prediction in Stack Overflow.” IET Software 15 (1): 90–106. https://doi.org/10.1049/sfw2.12013
• Zhong, Hao. 2022. “Enriching Compiler Testing with Real Program from Bug Report.” In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering. ACM. https://doi.org/10.1145/3551349.3556894
• Zhong, Ming, Fang Lyu, Lulin Wang, et al. 2024. “ComBack: A Versatile Dataset for Enhancing Compiler Backend Development Efficiency.” In Advances in Neural Information Processing Systems 37. Neural Information Processing Systems Foundation, Inc. (NeurIPS). https://doi.org/10.52202/079017-3567
• Zhong, Ming, Lei Qiu, Lulin Wang, Hongna Geng, Xin Sun, and Fang Lv. 2026c. “Towards Fully Automated Compiler Backend Generation with Multi-Agent Systems: How Far Are We?” In Proceedings of the 40th ACM International Conference on Supercomputing - Workshops. ACM. https://doi.org/10.1145/3774895.3812193
• Zhong, Ming, Xin Sun, Fang Lv, et al. 2026a. “BePilot: An AI Programming Assistant for Compiler Backend Development.” ACM Transactions on Software Engineering and Methodology 35 (6): 1–45. https://doi.org/10.1145/3764585
• Zhou, Neng-Fa. 1996. “Parameter Passing and Control Stack Management in Prolog Implementation Revisited.” ACM Transactions on Programming Languages and Systems 18 (6): 752–79. https://doi.org/10.1145/236114.236120
• Zhou, Wei, Xincong Jiang, and Chuan Qin. 2024. “C-CORE: Clustering by Code Representation to Prioritize Test Cases in Compiler Testing.” Computer Modeling in Engineering & Sciences 139 (2): 2069–93. https://doi.org/10.32604/cmes.2023.043248
• Zhou, Qiang, Yakun Li, Xingliang Zou, Albert M. K. Cheng, and Yu Jiang. 2016. “Worst Case Response Time and Schedulability Analysis for Real-Time Software Transactional Memory-Lazy Conflict Detection (STM-LCD).” ACM SIGBED Review 13 (2): 14–19. https://doi.org/10.1145/2930957.2930959
• Zhou, Yawei, Junmin Wu, Yi Zhang, Yan Yin, and Shaodi Li. 2020. “Design and Implementation of Coroutine Scheduling System on SW26010.” In Proceedings of the 2020 5th International Conference on Big Data and Computing. ACM. https://doi.org/10.1145/3404687.3404700
• Zhou, Hao, and Jingling Xue. 2016. “A Compiler Approach for Exploiting Partial SIMD Parallelism.” ACM Transactions on Architecture and Code Optimization 13 (1): 1–26. https://doi.org/10.1145/2886101
• Zhu, Kelin, Yu Wang, Linzhang Wang, and Xuandong Li. 2025. “Emerging Compiler Testing Based on Test Case Reuse.” In Proceedings of the 16th International Conference on Internetware. ACM. https://doi.org/10.1145/3755881.3755917
• Zou, Changwei, Xudong Wang, Yaoqing Gao, and Jingling Xue. 2022. “Buddy Stacks: Protecting Return Addresses with Efficient Thread-Local Storage and Runtime Re-Randomization.” ACM Transactions on Software Engineering and Methodology 31 (2): 1–37. https://doi.org/10.1145/3494516
• Zubarev, Aleksei. 2017. “Type Analysis for the Predicate Programming Language.” System Informatics, no. 9. https://doi.org/10.31144/si.2307-6410.2017.n9.p1-22
• Zwanziger, Colin. 2019. “Dependently-Typed Montague Semantics in the Proof Assistant Agda-Flat.” In Proceedings of the 16th Meeting on the Mathematics of Language. Association for Computational Linguistics. https://doi.org/10.18653/v1/w19-5704
• Телегин, В.А. 2023. “AHEAD-OF-TIME and JUST-IN-TIME technologies.” Vestnik of Russian New University. Series «Complex systems: models, analysis, management», no. 4: 171–75. https://doi.org/10.18137/rnu.v9187.23.04.p.171
• Толстікова, О. В., І. С. Мирошниченко, and А. Б. Коцюр. 2016. “Efficiency Asynchronous Application Programming Language Python.” Problems of Informatization and Management 1 (53). https://doi.org/10.18372/2073-4751.1.10367