Keleusma Research Spike: What It Costs to Compile a Data Structure Whose Shape Is Already Decided

The largest remaining item in a compiler backend was estimated at a quarter’s work. Measured, it is pointer arithmetic over compile-time constants, and two of the three representation forms it was supposed to need account for two operations in the entire corpus.

The item is aggregate data types, meaning structs, tuples, arrays and enumerations. It blocks 34.5 percent of the corpus, more than every other unimplemented feature combined, and it had never been scoped because everyone knew it was large.

Everyone was reasoning from the wrong artefact. Aggregates are large in a compiler that must decide their layout. This compiler decided it already, in an earlier pass, and bakes the answer into the instruction stream. What reaches the backend is not a type system. It is a byte offset and a scalar kind.

The measurement that establishes this took twenty minutes to write and two and a half seconds to run. It reports that of 331 aggregate operations in the corpus, 300 are a constant offset and a typed load, 2 need anything resembling a value representation, and 0 use the general mechanism the instruction set still carries.

This article reports that, and reports why the author’s own recommendation to run it deserves more scepticism than the result.

What this is a case study of

The setting is compiler backend scoping and the project is Keleusma, whose backend is described in the first, second and third articles of this series. No compiler background is required.

The general shape is estimating the cost of a feature from its name rather than from its instances. “Aggregate data types” names something with a large literature, a hard general case, and a well-known set of representation decisions. None of that is evidence about the work in front of you, and the gap between the category and the instance is where the estimate went wrong.

The transferable question is what remains once a decision has already been made upstream. The answer is often mechanical, and the mechanical residue is easy to mistake for the original problem because it wears the same name.

What You Need to Know to Read This

No compiler background is required, and this section is what makes that claim true. Six ideas carry the whole article.

A program is written once and exists in several forms. The form a person writes, an intermediate form that is easy for machines to handle, and the final form the processor actually executes. The part of the compiler that produces that last form is called the backend, and it is the part being scoped here.

Bytecode is the intermediate form. It is a simple, regular list of instructions that no physical processor runs directly. It is easy to reason about, which is why this project proves things about it.

An aggregate is several values bundled into one. A point holding an x and a y. A record holding a name, an age and an address. Every language has them, and how to represent them in memory is one of the classic hard problems in compiler design, because the compiler must decide where each field sits, how much space it takes and how it is found again.

The hard part is deciding the layout, and this compiler decided it early. Three stages before the backend, a pass works out that the x sits at byte 0 and the y at byte 8, and writes those numbers directly into the instructions. By the time the backend sees the program, the question is not how to lay out a record. It is how to add 8 to an address.

There are two ways to hold an aggregate, and only one of them is expensive. The flat form is a plain run of bytes with the fields at known positions. The boxed form carries extra bookkeeping alongside the data so that the shape can be discovered while the program runs. Boxing is what makes aggregates costly, and the measurement below is largely about how often it is actually needed.

The last thing worth knowing is where the bytes live. This language allocates from an arena, which is a fixed-size region whose total is known before the program starts. Taking memory from it is a matter of moving a marker along, and because the region is fixed and the total is proven in advance, memory taken from the arena is already accounted for.

The Setting

Keleusma compiles to bytecode for a virtual machine and, since recently, lowers that bytecode to native code through LLVM. An aggregate in the source language becomes, in the bytecode, a sequence of instructions that construct and read it.

The version of the language current here made a decision two releases ago called the flat-byte representation. An aggregate is not a tree of tagged values. It is a contiguous run of bytes, and every field access is a byte offset into that run, resolved by the compiler.

That decision is why this article exists, and its consequence had never been traced to the backend.

Notation

Let $\mathcal{A}$ denote the aggregate operations in a corpus. Each carries a compiler-baked operand drawn from three forms,

\[\mathcal{A} = \mathcal{A}_{\mathsf{Flat}} \;\sqcup\; \mathcal{A}_{\mathsf{Nested}} \;\sqcup\; \mathcal{A}_{\mathsf{Boxed}}, \tag{1}\]

which differ in what a backend must supply.

$\mathsf{Flat}$ carries a pair $(\mathrm{off}, \kappa)$: a byte offset and a scalar kind. Reading it is

\[\mathrm{load}_{\kappa}\bigl(\mathrm{base} + \mathrm{off}\bigr), \tag{2}\]

with $\mathrm{off}$ a compile-time constant. This is an address computation and a typed load, being a getelementptr with constant indices followed by a load, and it is the same operation the backend already performs for the program’s data segment.

$\mathsf{Nested}$ carries $(\mathrm{off}, \mathrm{size}, \mathrm{variant})$ and extracts a byte range, re-wrapping it as an aggregate. This is the form that requires an aggregate to exist as a value, which is the representation question a backend with a uniform machine-word stack cannot dodge.

$\mathsf{Boxed}$ is the pre-flat form: a metadata table, a heap body, positional indices. It is the general mechanism, and it is the one whose cost dominates every estimate of this work.

Write $C(\cdot)$ for implementation cost. The estimate everyone carried was

\[C(\mathcal{A}) \approx C(\mathcal{A}_{\mathsf{Boxed}}), \tag{3}\]

because the boxed form is what “implementing aggregates” means in the general case. The question this article answers is whether that term has any instances.

The distinction the article turns on is which index set the sum runs over. An estimate anchored on the category prices every form the instruction set defines,

\[C_{\mathrm{est}} \;=\; \sum_{f \in \mathcal{F}} C(f), \tag{4}\]

while the work actually required prices only the forms the corpus contains,

\[C_{\mathrm{act}} \;=\; \sum_{f \in \mathcal{F}} \mathbf{1}\bigl[\lvert \mathcal{A}_f \rvert > 0\bigr] \cdot C(f). \tag{5}\]

The two differ by exactly the terms with no instances,

\[C_{\mathrm{est}} - C_{\mathrm{act}} \;=\; \sum_{f \,:\, \lvert \mathcal{A}_f \rvert = 0} C(f), \tag{6}\]

and nothing in the feature’s name distinguishes them. That is the whole error, stated before the measurement that exposes it. The measurement is an evaluation of that sum, and the article’s result is that the term which dominated the estimate falls inside it.

The failure mode this identity describes has a literature, since pricing $\mathcal{F}$ when the work is indexed by the corpus is anchoring on the category. Jørgensen 2004b reviews expert estimation of software effort and finds systematic optimism together with strong anchoring on framing, and Jørgensen and Grimstad 2011 show irrelevant information shifting estimates directly. The contribution here is not the observation that estimates anchor. It is that in this case the anchor is visible in the index set, so the error can be removed by counting instead of by debiasing.

The Measurement

The instrument compiles every program in the shipped example corpus and the self-hosted compiler’s own sources, walks every instruction, and classifies each aggregate operation by its baked form.

Operation	Count	Share
`NewComposite::Flat`	239	72.2%
`GetTupleField::Flat`	41	12.4%
`IsEnum`	29	8.8%
`GetIndex::Flat`	14	4.2%
`GetEnumField::Flat`	4	1.2%
`GetField::Flat`	2	0.6%
`GetTupleField::FlatNested`	2	0.6%
Total	331

Aggregated by form:

\[\lvert \mathcal{A}_{\mathsf{Flat}} \rvert = 300, \qquad \lvert \mathcal{A}_{\mathsf{Nested}} \rvert = 2, \qquad \lvert \mathcal{A}_{\mathsf{Boxed}} \rvert = 0. \tag{7}\]

Those three counts total 302 and not 331, which is worth explaining instead of leaving a reader to subtract. The 29 discriminant tests carry no form tag at all, since testing which variant an enumeration holds is a comparison rather than an access, and the operation names no layout. They are counted in the work below and simply have no representation to be classified by.

The boxed form has no instances. The general mechanism, the one that carries the metadata table and the heap body and the whole weight of the estimate, is not used by any program this compiler is for. Taken with the two nested occurrences, the two forms other than flat account for 2 of the 302 operations that carry a form at all, which is the claim the opening makes and this is where it is checkable.

The constructed bodies are small:

\[\mathrm{byte\_size} \in [8, 64], \quad \text{median } 24, \qquad \mathrm{count} \in [1, 5], \quad \text{median } 3. \tag{8}\]

An aggregate in this corpus is three values in twenty-four bytes.

What Remains, Enumerated

With the boxed term empty, the work is:

Construction, 239 instances. Reserve $\mathrm{byte_size}$ bytes in the arena and write the popped values at their baked offsets,

\[\mathrm{body}\bigl[\mathrm{off}_i,\; \mathrm{off}_i + w_i\bigr) \;\leftarrow\; v_i, \qquad i = 1 \ldots \mathrm{count}, \tag{9}\]

then yield a reference to the body.

The bodies go in the arena, not on the machine stack, and that is the whole of the memory story. The language’s model is a fixed-size arena with countable bytes, and the interpreter already allocates composite bodies there. A backend that put them on the machine stack instead would be departing from the memory model rather than implementing it, and would forfeit a bound that already exists, since the byte_size operand is documented as the allocation the worst-case-memory pass sums. Arena allocation is a bump pointer against a region whose size is proven before the program runs.

The machine stack is still involved, since scalars and addresses live in registers and spill, and local allocations that do arise belong in the entry block per LLVM’s frontend guidance, so the promotion pass can lift them. But the aggregate bodies themselves are not a frame question.

Since bodies are at most 64 bytes and constructed from at most five values, an aggregate is a bump allocation and a run of stores.

Flat access, 61 instances across four opcodes. An address computation and a typed load. The backend already does exactly this for the program’s data segment, where a slot resolves to a base pointer plus a constant offset, and that path is implemented and tested.

Discriminant tests, 29 instances. A variant is identified by a number stored at the front of the body, so the test loads that word and compares it against a constant the compiler already knows,

\[\bigl[\mathrm{load}_{\mathrm{word}}(\mathrm{base}) = k\bigr], \qquad k \text{ fixed at compile time}, \tag{10}\]

which is an integer comparison and names no layout, which is why these 29 carry no form tag.

Nested access, 2 instances. The only form needing an aggregate as a first-class value. Because the representation is contiguous, a child body is a sub-range of its parent,

\[\mathrm{addr}(\mathrm{child}) \;=\; \mathrm{addr}(\mathrm{parent}) + \mathrm{off}, \qquad \mathrm{len}(\mathrm{child}) = \mathrm{size}, \tag{11}\]

so no copy is required and the operation is an address computation as well. Contiguity, chosen upstream for unrelated reasons, is what makes the one genuinely hard form cheap.

Boxed anything, 0 instances. Refused, at no cost to coverage. The claim being made is universal,

\[\Phi_{\mathsf{Boxed}} \;\equiv\; \forall a \in \mathcal{A} : \mathrm{form}(a) \ne \mathsf{Boxed}, \tag{12}\]

so a single counterexample refutes it and no quantity of confirming instances would have been needed to state it. That is the same quantifier structure the second article identified, arriving here with the opposite sign, since there an existential defeated a proposed unification while here a universal licenses a refusal.

\[C(\mathcal{A}) \;=\; C(\text{arena bump}) + C(\text{constant-offset store}) + C(\text{constant-offset load}) + C(\text{integer compare}), \tag{13}\]

every term of which the backend already implements for other opcodes.

And the memory term is already bounded, which is the part most likely to be got wrong. An earlier version of this article priced aggregate construction as machine-stack growth and warned that it could enlarge the native machine frame the previous article measures. That was an error of design and not of arithmetic, and it is left visible here because it is the more instructive mistake.

Bodies belong in the arena. Writing $M$ for the arena requirement, the construction term is

\[\Delta M \;=\; \sum_{a \in \mathcal{A}^{\mathrm{new}}} \mathrm{byte\_size}(a), \tag{14}\]

which is exactly the quantity the worst-case-memory pass already sums, because byte_size is the operand it was given for that purpose. So the memory cost of aggregate lowering is not a new bound to establish. It is an existing bound the native artefact inherits by allocating where the interpreter allocates.

The general point is worth more than the correction. A backend is free to choose a representation, and choosing one the language’s memory model does not describe converts a bounded quantity into an unbounded one at no benefit. The stack looked cheaper because it is closer to hand.

The Estimate Was Wrong Because It Named A Category

Aggregates are genuinely expensive in a compiler that decides their layout. Field ordering, padding, alignment, tag placement, niche optimisation, the interaction with generics and with a garbage collector: that is real work and it fills textbooks.

None of it is in front of this backend, because a pass three stages earlier already did it and wrote the answers into the instruction operands. What arrives is the residue, being constants, in fields, in an instruction stream.

The failure mode is worth naming precisely. The estimate was anchored to the hardest thing the name denotes, and the name is accurate. Nothing about the phrase “implement aggregate data types” is misleading. It simply does not describe the work, and only counting the instances reveals that.

Threats to Validity

A corpus of one project. The zero for the boxed form is a fact about programs written so far. The instruction set still carries that form, so a program could use it, and the estimate would then be wrong in the expensive direction. Refusing it is safe and assuming it will never appear is not, and the difference matters for what gets built rather than for what gets counted.

Cost is estimated, not measured. Every term above is claimed to be cheap because the backend implements something structurally identical elsewhere. That is an argument from similarity and it has failed in this series before, when a string constant was judged cheap by the same reasoning and turned out to require an entire representation decision.

Estimating by analogy is a studied method and its record is mixed, which is the right prior to hold here. Shepperd and Schofield 1997 set out the technique and report it outperforming algorithmic models on their datasets, while Walkerden and Jeffery 1999 find human-selected analogies doing better than the automated ones and neither dominating. The method is respectable and it is not a measurement, and the present article uses the weaker human form of it.

Two instances is not zero. The nested form has two occurrences, and a design that handles 300 cases and refuses 2 delivers

\[\frac{\lvert \mathcal{A}_{\mathsf{Flat}} \rvert}{\lvert \mathcal{A}_{\mathsf{Flat}} \rvert + \lvert \mathcal{A}_{\mathsf{Nested}} \rvert} \;=\; \frac{300}{302} \;=\; 0.993, \tag{15}\]

which is less than the headline and not by much. Whether those two sit in modules that are otherwise unblocked is not established here.

The author scoped work he would then perform. This is the sharpest threat and it was flagged before the measurement was taken, since a result reading “cheaper than feared” from a party who benefits from it starting sooner deserves more scepticism than one reading “expensive”. The association between an investigator’s interest and a favourable result is measured and not merely suspected, and Bekelman et al. 2003 give the systematic review for biomedical research, where the effect is large and consistent. The domain is not this one and the mechanism is not domain-specific. The mitigation offered is that the central number is a zero, which is harder to produce by motivated reasoning than a favourable ratio, and that the instrument reports counts a reader can reproduce.

Pattern Extraction

Estimate from instances, not from the category. A feature’s name inherits the difficulty of its hardest form. The work in front of you is whatever your inputs actually contain, and the two are related only by coincidence.

An upstream decision converts a design problem into a mechanical one, and the mechanical residue keeps the original name. That is why the estimate survived, because everyone kept calling it the same thing after it stopped being the same work.

A dead general mechanism is worth finding before it is worth building. The boxed form is fully specified, implemented in the interpreter, and used by nothing. Counting it cost twenty minutes and removed the dominant term from the estimate.

Scepticism should scale with who benefits from the answer. A scoping result that shortens the scoper’s own work is the configuration in which optimism is least detectable. Preferring a zero to a ratio is one defence, since a zero is refutable by a single counterexample and a ratio absorbs error quietly.

The Contemporary Literature

Data representation is a classical compiler subject and its difficulty lives upstream of code generation. The standard treatment in Appel 1997 places layout, tagging and access-path resolution in the middle end, which is exactly why a backend that receives resolved offsets inherits so little of it.

The representation problem is a type-system problem, which is why it is not here

The literature that makes aggregates expensive is about deciding representation in the presence of polymorphism, where a function compiled once must handle values whose layout differs per instantiation. Peyton Jones and Salkild 1989 give the tagless machine that makes uniform representation cheap, Leroy 1992 introduces the coercion-based unboxing analysis, Ohori 1995 gives the polymorphic record calculus together with a compilation method that resolves field access to an index computation, which is the closest antecedent to what this backend receives already resolved, Henglein and Jørgensen 1994 characterise optimal boxing placement; Harper and Morrisett 1995 compile polymorphism by passing types at run time, Shao and Appel 1995 and Tarditi et al. 1996 build type-directed compilers around the idea, and Shao 1997 reconciles the approaches. Morrisett et al. 1999 carry types all the way to assembly.

Every one of these is expensive because the layout is not known when the code is compiled. Keleusma monomorphises before bytecode, so every aggregate operation in the corpus refers to exactly one concrete layout, and the entire literature above answers a question this backend is never asked. That is the precise sense in which the estimate measured somebody else’s problem.

108 further contemporary records carry this vocabulary. The field is large and it is upstream of everything this article measures, which is the point the section makes.

Object layout is expensive for reasons this language does not have

The object-oriented layout literature concerns inheritance, dynamic dispatch and separate compilation. Pugh and Weddell 1990 give bidirectional record layout for multiple inheritance, Sweeney and Gil 1999 pursue space and time efficiency in the same setting, and Driesen and Hölzle 1996 measure what virtual dispatch costs.

Keleusma has no inheritance, no subtyping and no separate compilation of dependencies, so none of these costs arise. The finding is not that this literature is wrong. It is that a backend inherits only the costs its language’s design admits, and enumerating those is cheaper than assuming all of them.

Dispatch and object layout account for 11 contemporary records.

Layout is also a performance lever, and the design forecloses it

A parallel literature treats layout as something to optimise and not merely to fix. Chilimbi et al. 1999a define cache-conscious structures, Chilimbi et al. 1999b lay them out accordingly, and Lattner and Adve 2005a pool-allocate by data structure for locality.

None of this is in scope, and it is worth saying why, because a reader could reasonably ask whether the baked-offset design forecloses it. It does, because the offsets are in the instruction stream, so a backend cannot reorder fields without invalidating them. That is a real cost of the design, paid in exchange for the cheapness this article reports.

Unboxing and flattening are the transformations that produce this situation on purpose. Leroy 1992 gives the unboxed-representation analysis for polymorphic languages, Peyton Jones and Launchbury 1991 introduce unboxed values into a lazy functional compiler, and Shao 1997 treats flexible representation analysis. All three are about removing indirection before the backend sees it, and the flat-byte representation this project adopted is the same move made at the bytecode boundary.

The boxed form being dead is an instance of a general finding about specified-but-unused mechanism. Richards et al. 2010 analyse the dynamic behaviour of deployed JavaScript and find programs exercising a narrow subset of what the language permits, with the assumptions behind common optimisations holding far less often than expected. The direction of that finding is the opposite of this one and the method is the same, being to count what the corpus does rather than what the specification allows.

The method has a name and a literature. Dyer et al. 2014 mine billions of syntax-tree nodes to compare actual against potential usage of Java language features, which is this article’s question stated generally. Parnin et al. 2012 track generics adoption and find it slower and narrower than the feature’s prominence suggests, and Callaú et al. 2011 measure how much of a dynamic language’s dynamism is used in practice, finding far less than the language permits.

The consistent result is that specified capability over-predicts exercised capability, which is exactly the gap between $C_{\mathrm{est}}$ and $C_{\mathrm{act}}$ above. The present measurement is a small instance of a well-replicated finding, and its only novelty is that the gap was sitting inside a backlog estimate rather than inside a language feature.

183 contemporary records treat layout as a performance decision, more than the representation and dispatch clusters combined, and every one of them presumes a compiler free to choose the layout.

Most bytecodes do NOT bake offsets, which is why this result is unusual

The comparison that explains the finding is with other bytecode formats. The Java Virtual Machine resolves a field access through a symbolic constant-pool reference: getfield names a class, a field and a descriptor, and the offset is computed at run time on first use. The Common Language Infrastructure does the same through a metadata token. In both, layout is deliberately not fixed by the format, which buys version tolerance across independently compiled assemblies and obliges every implementation to resolve, cache and specialise.

The WebAssembly garbage-collection proposal takes the middle position, declaring struct and array types in the module so that field indices are static while the physical layout stays the engine’s choice. That position follows from the format’s stated design goals, which Haas et al. 2017 set out as hardware independence together with fast validation, and a format that fixed byte offsets would forfeit the first to obtain something the engine can supply anyway.

Keleusma sits at the far end, with the byte offset in the instruction. That forecloses independent recompilation of a dependency, which is a real cost paid elsewhere in the design, and it is exactly why the backend inherits arithmetic rather than resolution. The finding of this article is a consequence of that trade, not a discovery about aggregates in general.

The same trade appears outside compilers whenever access must be cheap. FlatBuffers and Cap’n Proto compute field offsets when the schema is compiled so that reading a message is pointer arithmetic with no parse step, and the Apache Arrow columnar format fixes buffer layout in the specification for the same reason. Each accepts a rigid layout to make access mechanical, which is the trade this compiler made and then did not trace to its own backend for two releases.

Bytecode formats and their machines account for a further 316 records.

The layout rules the backend does not have to invent

Where layout is not predetermined, it is the ABI’s problem, and the relevant documents are substantial: System V AMD64 classifies aggregates recursively to decide register versus memory passing, AAPCS64 defines homogeneous aggregate rules, and the Itanium C++ ABI specifies object layout including base-class packing. A language may also expose the decision to the programmer, as the Rust Reference does with its representation attributes.

None of that reaches this backend, because aggregates here never cross a foreign boundary as aggregates , since they are bytes in a region and the boundary sees a pointer. That immunity is worth stating because it ends the moment the foreign-linkage work begins, where an exported entry point taking a struct by value would face every one of these rules at once.

Refusing, and not approximating, is the position the verification tradition requires. Necula 1997 formalises proof-carrying code and Leroy 2009 establishes verified compilation; under either stance a backend that guessed at an unimplemented form would emit code whose semantics were never established. Refusal is the correct behaviour and it also lets a zero-instance form be skipped for free.

On estimation itself, the software-engineering literature has documented the anchoring failure this article instantiates. Jørgensen 2004b reviews expert estimation of software development effort and finds systematic optimism together with strong anchoring on framing, Jørgensen and Grimstad 2011 show irrelevant and misleading information shifting estimates directly, and Jørgensen and Shepperd 2007 survey the cost-estimation field as a whole. The underlying mechanism is Tversky and Kahneman 1974, whose anchoring-and-adjustment account predicts that an initial value dominates a final estimate even when the anchor is uninformative.

The present case is anchoring on a category name, the cheapest possible frame and the one least likely to be recognised as a frame at all. It is also the rare case where the anchor is removable by counting, since the category decomposes into forms and the forms can be tallied. That is the practical contribution: not a better estimate, but an instrument that dissolves the anchor instead of adjusting from it.

What the survey shows. The literature explains why the estimate was wrong and does not contain the measurement that corrects it, because the measurement is specific to one corpus and one instruction set. The transferable part is the method rather than the number. Classify the instances by the form that decides implementation cost, and count.

A further 174 records treat formats that precompute layout for the same reason.

The backend literature this work actually sits in

The sections above are the literatures the argument engages. This is the one the work belongs to, being code generation and the machinery that turns an intermediate form into instructions. It is the largest cluster in the survey at 650 records.

Where the bytes go, which the arena decides

Allocation and reclamation account for 183 records. They belong here because the article’s memory result turns entirely on which region a constructed body lands in, and the arena discipline is why that answer is already bounded.

Types and verification, which is the series this article sits in

A further 434 records treat type systems, semantics and verified compilation. The connection is that a representation decision is a type-system decision, taken upstream, and the rest of this series is about what survives being compiled.

Counting a corpus, which is the method rather than the subject

184 contemporary records measure what programs actually contain. The instrument in this article is an instance of that tradition, and its result is a count rather than an argument.

Estimation and the biases that inflate it

Estimation, anchoring and the conditions under which a judgement is worth less than it appears account for 575 records. This is the article’s other half, since the finding is about an estimate before it is about aggregates.

The surrounding literature

70 admitted records share the article’s vocabulary without addressing its question. They are listed and not discarded, because the selection that produced them is reported in full, and a survey presenting only the records that support its thesis has selected twice while reporting one selection.

The historical layer

The clusters above are drawn from work published in 2015 or later. The older records are listed here in one place instead of being distributed above, because for this subject the pre-2015 work is the foundation the contemporary work cites, and the hand-selected references that carry the argument are almost all of it. There are 3,166 of them.

What the survey shows

The upstream decision is what makes this article’s result unusual, and the survey is how that is established. Every layout literature above presumes a compiler that decides layout. The representation work decides it in the presence of polymorphism, the locality work decides it for cache behaviour, the object-oriented work decides it under inheritance, and the bytecode formats deliberately refuse to decide it so that independently compiled parts stay compatible. Not one of them describes a format that fixes byte offsets in the instruction stream, which is the configuration this backend receives.

The survey therefore supports a narrow claim and refuses a broad one. The narrow claim is that the cheap residue measured here follows from a design decision taken upstream and is not a general fact about aggregates. The broad claim, that aggregates are cheap to compile, is contradicted by every cluster above.

The scale should be read for what it is. The survey lists 6,032 references, of which 31 were selected because a step of the argument depends on them and were read, and 6,001 were harvested by query across ten clusters and were not. The harvested majority establishes coverage and not agreement.

The Source Base

The instrument is a test in the detached native_codegen package. It compiles every .kel source in the example corpus and the self-hosted compiler’s stages, discards any that fail to compile, walks every chunk’s instruction sequence and classifies each aggregate operation by the variant of its baked operand. It reports rather than asserts, because the distribution is a fact about the corpus and not about the code.

How the harvested survey was assembled

The 31 hand-selected research references were chosen because a step of the argument depends on them, and each was read. The 6,001 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 several thousand citations otherwise implies a reading it does not represent. What the harvested list supports is a claim about coverage, since the queries were fixed before any record was 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.

The harvest issued 78 keyword queries against the Crossref registry across ten topic clusters, in seven rounds separating journal articles, conference proceedings, book chapters and defence technical reports, and separating work published through 2014 from work published since. Requesting all three publication types from the start is a lesson the previous article paid for, since Springer deposits its Lecture Notes in Computer Science volumes as book chapters and a journals-only harvest misses a large part of this field entirely. The harvest retrieved 45,989 records and the anchor test discarded 39,632 of them.

This subject is unusually badly placed for keyword harvesting, and its own vocabulary is the reason. Aggregate is a concrete-materials term and an economics term before it is a compiler term. Layout is integrated-circuit layout and facility layout. Alignment is sequence alignment in bioinformatics. Offset is the carbon offset, boxing is a sport and arena is a stadium. None of those words is used as an anchor here without a computing qualifier, and the accumulated homonym store the repository keeps supplied the families earlier sweeps had already paid for.

The count that survives is smaller again. Of the 6,357 records the anchor test admitted, 313 were duplicates holding the same title and year under two identifiers, 13 carried a contraction or a doubled word in a verbatim title that this corpus cannot reproduce in link text, and 23 duplicated a work already cited by hand. 6,008 therefore reach the reference list, five of which a later audit removed, three being dictionary entries, one a chapter title identical to its book title, and one an identifier that does not resolve at all, and two later audits against the accumulated homonym store, leaving 6,001.

Epistemic State

Measured, and reproducible from the instrument. The corpus contains 331 aggregate operations, being 239 NewComposite::Flat, 41 GetTupleField::Flat, 29 IsEnum, 14 GetIndex::Flat, 4 GetEnumField::Flat, 2 GetField::Flat and 2 GetTupleField::FlatNested. By form that is 300 flat, 2 nested and 0 boxed. Constructed bodies range from 8 to 64 bytes with a median of 24, from 1 to 5 values with a median of 3. Aggregates block 34.5 percent of the corpus at the module level, established in the first article of this series.

Derived, and checkable from the definitions. That a flat access is an address computation and a typed load, since its operand is a compile-time byte offset and a scalar kind. That a nested access needs no copy, since the representation is contiguous and a child body is a sub-range of its parent. That the backend already implements the same address-plus-constant-offset access for the data segment.

Verified, and the defect rate is now a series-level observation rather than an incident. All 26 research identifiers were resolved against the registry. Seven needed correction before publication, a rate of 26.9 percent as first drafted. Two carried the ACM placeholder prefix 10.5555, which never resolves, and they were dropped and not replaced with invented identifiers, one substituted by a work making the same point that is registered. One cited the wrong journal volume. Four resolved to different papers in the same proceedings, differing from the correct identifier by one or two digits in the article suffix.

That last class is the dangerous one and it now dominates. A neighbouring identifier in the same volume resolves cleanly, returns a plausible compiler paper, and is wrong. It cannot be caught by checking that a link works, only by comparing the resolved title against the cited one, which is what the project’s verification script exists to do.

Across the three articles in this series the rates are 0 of 35, 4 of 27 and 7 of 26, and the trend tracks the age and proceedings-density of the bibliography rather than anything about care taken. Searching the registry by title is the only reliable method, and every correction here was obtained that way.

Corrected during writing, and left visible. This article first priced aggregate construction as machine-stack growth, bounded it at 15,296 bytes, and warned that it could enlarge the native machine frame. The figure it compared that bound against has since been retracted by the previous article, whose frame measurements were taken on code the optimiser had never seen. The design was wrong, not the arithmetic. The language’s memory model is a fixed-size arena with countable bytes, the interpreter allocates composite bodies there, and byte_size is documented as the allocation the worst-case-memory pass sums. Arena-allocated bodies therefore carry an existing bound instead of creating a new unbounded quantity. A backend that reached for the machine stack because it was nearer would have converted a bounded quantity into an unbounded one for no benefit.

Harvested rather than read. 6,001 of the 6,032 research references were retrieved by keyword query and are listed on the strength of their titles, authors, years and venues as the registry holds them. Nothing in the argument rests on any one of them, and the cluster sizes are the only quantitative use made of them. The residual contamination rate is not zero, since each sample read during assembly found families the previous one had missed.

Assumed, and marked as such. That structural similarity to implemented operations implies comparable cost. This inference has failed in this series before, when a string constant was judged cheap on the same grounds and proved to require a whole representation decision.

What this article does not establish. The cost in time of any of the terms. Where an aggregate body lives when it outlives its constructing call, which is an arena question the previous article’s findings make more delicate rather than less. Whether the two nested instances sit in otherwise-unblocked modules. Whether a future program uses the boxed form.

The strongest claim the evidence supports is that the dominant term of the standing estimate has zero instances in this corpus and can be refused at no cost to coverage. The weakest link is the cost inference, which rests on similarity rather than measurement, and a reader should treat the conclusion as a redirection of expectations and not as a schedule.

Out of Scope

The design of the aggregate lowering, which this article scopes and does not specify. Where bodies live across calls and suspensions. The size of the native machine frame, which the previous article measures and which aggregate lowering does not change once bodies are arena-allocated. Garbage collection, which this language does not have. The layout decisions themselves, which happen three passes earlier and are not the backend’s to make.

Conclusion

An item was carried as the largest remaining piece of work because its name denotes something large. The name is accurate and the work is not, and the distance between them was a twenty-minute measurement nobody had taken.

The dominant term is empty. What remains is address arithmetic over compile-time constants, discriminant comparison, and an arena bump for bodies that are three values in twenty-four bytes on average, against a region whose size the compiler already proves.

The generalisation is not that aggregates are cheap. It is that a decision made upstream leaves a residue that keeps the original name, and an estimate anchored on the name measures the problem somebody else already solved.

Equations

This section collects the 15 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 15, 4 are established and 11 are bespoke. Counts are numbers of aggregate operations in the measured corpus, sizes and offsets are in bytes, and implementation cost is an unquantified effort with no unit, so the cost equations state which terms are present rather than how large they are.

Equation 1, Bespoke Partition of Aggregate Operations by Form. The article partitions the aggregate operations of a corpus into three disjoint sets by the form of the operand the compiler bakes into each instruction.

\[\mathcal{A} = \mathcal{A}_{\mathsf{Flat}} \;\sqcup\; \mathcal{A}_{\mathsf{Nested}} \;\sqcup\; \mathcal{A}_{\mathsf{Boxed}}, \tag{1}\]

Equation 2, Typed Load at a Constant Offset. A field is read by adding a compile-time byte offset to a base address and loading a scalar of the stated kind from the result.

\[\mathrm{load}_{\kappa}\bigl(\mathrm{base} + \mathrm{off}\bigr), \tag{2}\]

Equation 3, Bespoke Category-Anchored Estimate. The estimate the article examines assumes that the cost of implementing aggregates is dominated by the cost of the general boxed form.

\[C(\mathcal{A}) \approx C(\mathcal{A}_{\mathsf{Boxed}}), \tag{3}\]

Equation 4, Bespoke Estimated Cost over the Instruction Set. The estimated cost sums the implementation cost of every operand form that the instruction set defines, whether or not any program uses it.

\[C_{\mathrm{est}} \;=\; \sum_{f \in \mathcal{F}} C(f), \tag{4}\]

Equation 5, Bespoke Actual Cost over the Corpus. The actual cost sums the implementation cost only of the operand forms that have at least one instance in the corpus.

\[C_{\mathrm{act}} \;=\; \sum_{f \in \mathcal{F}} \mathbf{1}\bigl[\lvert \mathcal{A}_f \rvert > 0\bigr] \cdot C(f). \tag{5}\]

Equation 6, Bespoke Excess of the Estimate over the Actual Cost. Subtracting Equation 5 from Equation 4 leaves exactly the costs of the forms with no instances, which the article identifies as the trace of anchoring on the category. Jørgensen 2004b

\[C_{\mathrm{est}} - C_{\mathrm{act}} \;=\; \sum_{f \,:\, \lvert \mathcal{A}_f \rvert = 0} C(f), \tag{6}\]

Equation 7, Bespoke Measured Counts by Form. The measurement evaluates the partition of Equation 1 over the corpus and finds three hundred flat operations, two nested operations and no boxed operation.

\[\lvert \mathcal{A}_{\mathsf{Flat}} \rvert = 300, \qquad \lvert \mathcal{A}_{\mathsf{Nested}} \rvert = 2, \qquad \lvert \mathcal{A}_{\mathsf{Boxed}} \rvert = 0. \tag{7}\]

Equation 8, Bespoke Measured Sizes of Constructed Aggregates. The measured bodies range from eight to sixty-four bytes with a median of twenty-four, and hold between one and five values with a median of three.

\[\mathrm{byte\_size} \in [8, 64], \quad \text{median } 24, \qquad \mathrm{count} \in [1, 5], \quad \text{median } 3. \tag{8}\]

Equation 9, Construction by Stores at Byte Offsets. An aggregate in a contiguous layout is built by writing each value into the byte range that begins at its offset and spans its width.

\[\mathrm{body}\bigl[\mathrm{off}_i,\; \mathrm{off}_i + w_i\bigr) \;\leftarrow\; v_i, \qquad i = 1 \ldots \mathrm{count}, \tag{9}\]

Equation 10, Discriminant Test of a Tagged Variant. A variant is identified by loading the word at the front of the body and comparing it with a tag value fixed at compile time.

\[\bigl[\mathrm{load}_{\mathrm{word}}(\mathrm{base}) = k\bigr], \qquad k \text{ fixed at compile time}, \tag{10}\]

Equation 11, Address of a Nested Sub-Aggregate. In a contiguous layout a child body is the sub-range of its parent that starts at the child’s offset and has the child’s size, so no copy is needed.

\[\mathrm{addr}(\mathrm{child}) \;=\; \mathrm{addr}(\mathrm{parent}) + \mathrm{off}, \qquad \mathrm{len}(\mathrm{child}) = \mathrm{size}, \tag{11}\]

Equation 12, Bespoke Universal Claim That No Operation Is Boxed. The article states as a universal claim that no aggregate operation in the corpus uses the boxed form, which a single counterexample would refute. second

\[\Phi_{\mathsf{Boxed}} \;\equiv\; \forall a \in \mathcal{A} : \mathrm{form}(a) \ne \mathsf{Boxed}, \tag{12}\]

Equation 13, Bespoke Decomposition of the Remaining Cost. With the boxed term empty, the cost of aggregates is assembled from an arena bump allocation, constant-offset stores and loads, and an integer comparison, each of which the backend already implements.

\[C(\mathcal{A}) \;=\; C(\text{arena bump}) + C(\text{constant-offset store}) + C(\text{constant-offset load}) + C(\text{integer compare}), \tag{13}\]

Equation 14, Bespoke Arena Requirement of Aggregate Construction. Placing aggregate bodies in the arena makes their memory cost the sum of the byte sizes of all constructions, which is the quantity the worst-case memory pass already sums.

\[\Delta M \;=\; \sum_{a \in \mathcal{A}^{\mathrm{new}}} \mathrm{byte\_size}(a), \tag{14}\]

Equation 15, Bespoke Coverage of a Design That Refuses Nested Access. The counts of Equation 7 give the fraction of form-carrying operations that a design handling only the flat form would cover.

\[\frac{\lvert \mathcal{A}_{\mathsf{Flat}} \rvert}{\lvert \mathcal{A}_{\mathsf{Flat}} \rvert + \lvert \mathcal{A}_{\mathsf{Nested}} \rvert} \;=\; \frac{300}{302} \;=\; 0.993, \tag{15}\]

Notation

$\mathcal{A}$, the set of aggregate operations in a corpus
$\mathcal{A}_{\mathsf{Flat}}$, the operations whose operand is a byte offset and a scalar kind
$\mathcal{A}_{\mathsf{Nested}}$, the operations that extract a byte range and re-wrap it as an aggregate
$\mathcal{A}_{\mathsf{Boxed}}$, the operations that use the general form with a metadata table and a heap body
$\mathrm{off}$, a byte offset fixed at compile time, with $\mathrm{off}_i$ the offset of the $i$-th value
$\kappa$, the scalar kind of a typed load
$\mathrm{base}$, the address at which an aggregate body begins
$C(f)$, the implementation cost of operand form $f$, with $C(\cdot)$ the cost of whatever it is applied to
$\mathcal{F}$, the set of operand forms the instruction set defines
$\mathcal{A}_f$, the operations in the corpus that use form $f$
$C_{\mathrm{est}}$, the estimated cost priced over every form the instruction set defines
$C_{\mathrm{act}}$, the actual cost priced over the forms the corpus contains
$\mathbf{1}$, the indicator that equals one when its condition holds and zero otherwise
$\mathrm{byte_size}$, the number of bytes an aggregate body occupies, the operand the memory pass sums
$w_i$, the width in bytes of the $i$-th value $v_i$ written into a body
$k$, the tag value that identifies a variant
$\mathrm{size}$, the length in bytes of a nested child body
$\Phi_{\mathsf{Boxed}}$, the claim that no operation in the corpus uses the boxed form
$\Delta M$, the arena requirement added by aggregate construction
$\mathcal{A}^{\mathrm{new}}$, the construction operations among the aggregate operations

References

Primary Sources, Peer-Reviewed

“154 Predictable Parallel Real-Time Code Generation.” 1994. Control Engineering Practice 2 (4): 720. https://doi.org/10.1016/0967-0661(94)90169-4
“194 Predictable Parallel Real-Time Code Generation.” 1993. Control Engineering Practice 1 (3): 571. https://doi.org/10.1016/0967-0661(93)92086-j
“6. Further Remarks of Garbage Collection.” 1976. In An Optimized Translation Process and Its Application to ALGOL 68. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-07545-3_26
Abadir, Magdy S., Kenneth L. Albin, John Havlicek, Narayanan Krishnamurthy, and Andrew K. Martin. 2003. “Formal Verification Successes at Motorola.” Formal Methods in System Design 22 (2): 117–23. https://doi.org/10.1023/a:1022917321255
Abate, Carmine, Roberto Blanco, Ştefan Ciobâcă, et al. 2021. “An Extended Account of Trace-Relating Compiler Correctness and Secure Compilation.” ACM Transactions on Programming Languages and Systems 43 (4): 1–48. https://doi.org/10.1145/3460860
Abdelhadi, Ameer M. S., and Guy G. F. Lemieux. 2016. “A Multi-Ported Memory Compiler Utilizing True Dual-Port BRAMs.” In 2016 IEEE 24th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm.2016.45
AbdelRahman, Samir E., and Amr M. AbdelLatif. 2010. “DisBlue+: A Distributed Annotation-Based C# Compiler.” Egyptian Informatics Journal 11 (1): 1–10. https://doi.org/10.1016/j.eij.2010.06.001
Abdulhalik, Enes, Mehmet Emin Baytekin, Gizem Sungu Terci, Alp Arslan Bayrakci, and Alihan Turan. 2026. “A Modular Graph Coloring Abstraction for Register Allocation in LLVM: Design and Evaluation.” In 2026 8th International Congress on Human-Computer Interaction, Optimization and Robotic Applications (ICHORA). IEEE. https://doi.org/10.1109/ichora69329.2026.11537233
Abdullahi, Saleh E., and Graem A. Ringwood. 1998. “Garbage Collecting the Internet: A Survey of Distributed Garbage Collection.” ACM Computing Surveys 30 (3): 330–73. https://doi.org/10.1145/292469.292471
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
Abhaay, S., Mg Shashank, Bs Shreyas, and Subramaniam Kalambur. 2021. “Effect of Garbage Collection on Streaming Big Data Workloads.” In 2021 2nd Global Conference for Advancement in Technology (GCAT). IEEE. https://doi.org/10.1109/gcat52182.2021.9587808
Abi-Antoun, Marwan, and Jonathan Aldrich. 2006. “A Static Analysis for Extracting Runtime Views from Annotated Object-Oriented Code.” In Companion to the 21st ACM SIGPLAN symposium on Object-oriented programming systems, languages, and applications. ACM. https://doi.org/10.1145/1176617.1176699
Abi-Antoun, Marwan, Sumukhi Chandrashekar, Radu Vanciu, and Andrew Giang. 2014. “Are Object Graphs Extracted Using Abstract Interpretation Significantly Different from the Code?” In 2014 IEEE 14th International Working Conference on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2014.42
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
Abishega, R., S. Saranya, M. Devayani, C. P. Subiksha, and G. Sudha. 2021. “WITHDRAWN: Driverless Vehicle for Garbage Collection.” Materials Today: Proceedings. https://doi.org/10.1016/j.matpr.2021.01.044
Abnane, Ibtissam, Mohamed Hosni, Ali Idri, and Alain Abran. 2019. “Analogy Software Effort Estimation Using Ensemble KNN Imputation.” In 2019 45th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2019.00044
Abnane, Ibtissam, Ali Idri, and Alain Abran. 2023b. “Optimized Fuzzy Clustering-Based k-Nearest Neighbors Imputation for Mixed Missing Data in Software Development Effort Estimation.” Journal of Software: Evolution and Process 36 (4): e2529. https://doi.org/10.1002/smr.2529
Abnane, Ibtissam, Ali Idri, Imane Chlioui, and Alain Abran. 2023a. “Evaluating Ensemble Imputation in Software Effort Estimation.” Empirical Software Engineering 28 (2): 56. https://doi.org/10.1007/s10664-022-10260-0
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
Absar, Javed, Praveen Raghavan, Andy Lambrechts, Min Li, Murali Jayapala, and Francky Catthoor. 2008. “Locality Optimization in a Compiler for Wireless Applications.” Design Automation for Embedded Systems 13 (1–2): 53–72. https://doi.org/10.1007/s10617-008-9019-x
Abuosba, Khalil. 2015. “Formalizing Big Data Processing Lifecycles: Acquisition, Serialization, Aggregation, Analysis, Mining, Knowledge Representation, and Information Dissemination.” In 2015 International Conference and Workshop on Computing and Communication (IEMCON). IEEE. https://doi.org/10.1109/iemcon.2015.7344533
Acay, Coşku, Rolph Recto, Joshua Gancher, Andrew C. Myers, and Elaine Shi. 2021. “Viaduct: An Extensible, Optimizing Compiler for Secure Distributed Programs.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454074
Accomazzo, E., M. Ancona, R. Bobbio, C. Cagnassi, and L. Paolin. 1990. “Integrating Intermediate Code Optimization with Retargetable Code Generation.” Microprocessing and Microprogramming 30 (1–5): 475–81. https://doi.org/10.1016/0165-6074(90)90285-h
Achour, Safaa, and Mohammed Benattou. 2016. “Test Case Generation for Java Bytecode Programs Annotated with BML Specifications.” In 2016 5th International Conference on Multimedia Computing and Systems (ICMCS). IEEE. https://doi.org/10.1109/icmcs.2016.7905597
Achour, Safaa, and Mohammzed Benattou. 2018a. “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
Achour, Safaa, and Mohammed Benattou. 2018b. “Vulnerabilities Constraint Based Analysis Approach for Java Bytecode Programs.” In 2018 6th International Conference on Multimedia Computing and Systems (ICMCS). IEEE. https://doi.org/10.1109/icmcs.2018.8525962
Adali, O. Ege, N. Alpay Karagoz, Zeynep Gurel, Touseef Tahir, and Cigdem Gencel. 2017. “Software Test Effort Estimation: State of the Art in Turkish Software Industry.” In 2017 43rd Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2017.72
Adams, Norman, David Kranz, Richard Kelsey, Jonathan Rees, Paul Hudak, and James Philbin. 1986. “ORBIT: An Optimizing Compiler for Scheme.” In Proceedings of the 1986 SIGPLAN symposium on Compiler construction. ACM. https://doi.org/10.1145/12276.13333
Adjé, Assalé, Stéphane Gaubert, and Eric Goubault. 2014. “Computing the Smallest Fixed Point of Order-Preserving Nonexpansive Mappings Arising in Positive Stochastic Games and Static Analysis of Programs.” Journal of Mathematical Analysis and Applications 410 (1): 227–40. https://doi.org/10.1016/j.jmaa.2013.07.076
“Adjusting Analogy Software Effort Estimation Based on Fuzzy Logic.” 2008. In Proceedings of the Third International Conference on Software and Data Technologies Special Session on Applications in Banking and Finance. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0001876601270132
Adl-Tabatabai, Ali-Reza, Thomas Gross, and Guei-Yuan Lueh. 1996. “Code Reuse in an Optimizing Compiler.” In Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. ACM. https://doi.org/10.1145/236337.236342
Adler, Philipp, and Wolfram Amme. 2009. “Type-Separated Bytecode – Its Construction and Evaluation.” In Runtime Verification. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-04694-0_3
Ae, Jin, and Youpyo Hong. 2022. “Efficient Garbage Collection Algorithm for Low Latency SSD.” Electronics 11 (7): 1084. https://doi.org/10.3390/electronics11071084
Afsari, Kereshmeh, Charles M. Eastman, and Daniel Castro-Lacouture. 2017. “JavaScript Object Notation (JSON) Data Serialization for IFC Schema in Web-Based BIM Data Exchange.” Automation in Construction 77: 24–51. https://doi.org/10.1016/j.autcon.2017.01.011
Aftandilian, Edward, Raluca Sauciuc, Siddharth Priya, and Sundaresan Krishnan. 2012. “Building Useful Program Analysis Tools Using an Extensible Java Compiler.” In 2012 IEEE 12th International Working Conference on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2012.28
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
Agesen, Ole. 1994. “Constraint-Based Type Inference and Parametric Polymorphism.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-58485-4_34
Agesen, Ole. 1999. “Space and Time-Efficient Hashing of Garbage-Collected Objects.” Theory and Practice of Object Systems 5 (2): 119–24. https://doi.org/10.1002/(sici)1096-9942(1999)5:2<119::aid-tapo5>3.3.co;2-h
Agrawal, Priya, and Shraddha Kumar. 2016. “Early Phase Software Effort Estimation Model.” In 2016 Symposium on Colossal Data Analysis and Networking (CDAN). IEEE. https://doi.org/10.1109/cdan.2016.7570914
Agrawal, Kunal, Jordyn Maglalang, and Jeremy T. Fineman. 2014a. “Cache-Conscious Scheduling of Streaming Pipelines on Parallel Machines with Private Caches.” In 2014 21st International Conference on High Performance Computing (HiPC). IEEE. https://doi.org/10.1109/hipc.2014.7116893
Ahmad, Farah B., and Laheeb M. Ibrahim. 2022a. “Software Development Effort Estimation Techniques Using Long Short Term Memory.” In 2022 International Conference on Computer Science and Software Engineering (CSASE). IEEE. https://doi.org/10.1109/csase51777.2022.9759751
Ahmad, Farah B., and Laheeb M. Ibrahim. 2022b. “Software Effort Estimation Based on Long Short Term Memory and Stacked Long Short Term Memory.” In 2022 8th International Conference on Contemporary Information Technology and Mathematics (ICCITM). IEEE. https://doi.org/10.1109/iccitm56309.2022.10031794
Ahmadi, Ali, Majid Daliri, Amir Kafshdar Goharshady, and Andreas Pavlogiannis. 2022. “Efficient Approximations for Cache-Conscious Data Placement.” In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3519939.3523436
Ahmed, Mansoor, Naeem Iqbal, Faraz Hussain, et al. 2022. “Blockchain-Based Software Effort Estimation: An Empirical Study.” IEEE Access 10: 120412–25. https://doi.org/10.1109/access.2022.3216840
Ahmed, Hameeza, and Muhammad Ali Ismail. 2021. “Toward a Novel Engine for Compiler Optimization Space Exploration of Big Data Workloads.” Software: Practice and Experience 52 (5): 1262–93. https://doi.org/10.1002/spe.3065
Ahn, Wonsun, Jiho Choi, Thomas Shull, María J. Garzarán, and Josep Torrellas. 2014. “Improving JavaScript Performance by Deconstructing the Type System.” In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2594291.2594332
Ahn, Seyeon, Donghyuk Im, Donggon You, and Youpyo Hong. 2024. “High-Performance Garbage Collection Scheme with Low Data Transfer Overhead for NoC-Based SSDC.” Electronics 13 (23): 4838. https://doi.org/10.3390/electronics13234838
Ahn, Byungmin, and Taewhan Kim. 2018. “Memory Access Driven Memory Layout and Block Replacement Techniques for Compressed Deep Neural Networks.” In 2018 31st IEEE International System-on-Chip Conference (SOCC). IEEE. https://doi.org/10.1109/socc.2018.8618552
Aiken, Alex, and Brian Murphy. 1991. “Static Type Inference in a Dynamically Typed Language.” In Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘91. ACM Press. https://doi.org/10.1145/99583.99621
Akbar, Fawwaz Ali, Siti Rochimah, and Adhatus Solichah Ahmadiyah. 2026. “Evaluating the Effect of Artefact Representation on LLM-Based RESTful API Code Generation.” In 2026 IEEE International Conference on Industry 4.0, Artificial Intelligence, and Communications Technology (IAICT). IEEE. https://doi.org/10.1109/iaict71158.2026.11620682
Åkesson, Johan, Torbjörn Ekman, and Görel Hedin. 2010. “Implementation of a Modelica Compiler Using JastAdd Attribute Grammars.” Science of Computer Programming 75 (1–2): 21–38. https://doi.org/10.1016/j.scico.2009.07.003
Al Shoaibi, Deema Adeeb, and Mohamed Wiem Mkaouer. 2023. “Understanding Software Performance Challenges an Empirical Study on Stack Overflow.” In 2023 International Conference on Code Quality (ICCQ). IEEE. https://doi.org/10.1109/iccq57276.2023.10114662
Al-Barak, Mashel, and Rami Bahsoon. 2016. “Database Design Debts through Examining Schema Evolution.” In 2016 IEEE 8th International Workshop on Managing Technical Debt (MTD). IEEE. https://doi.org/10.1109/mtd.2016.9
Al-Thubaity, Abdulmohsen, Marwa Khan, Manal Al-Mazrua, and Maram Al-Mousa. 2013. “New Language Resources for Arabic: Corpus Containing More than Two Million Words and a Corpus Processing Tool.” In 2013 International Conference on Asian Language Processing. IEEE. https://doi.org/10.1109/ialp.2013.21
Alardawi, Ahmed S., and Agil M. Agil. 2015. “Novice Comprehension of Object-Oriented OO Programs: An Empirical Study.” In 2015 World Congress on Information Technology and Computer Applications (WCITCA). IEEE. https://doi.org/10.1109/wcitca.2015.7367057
Alaswad, Feisal, Eswaran Poovammal, and Batoul Aljaddouh. 2026b. “Toward LLM-Aware Software Effort Estimation: A Conceptual Framework.” Frontiers in Artificial Intelligence 9: 1772418. https://doi.org/10.3389/frai.2026.1772418
Alaswad, Feisal, E. Poovammal, Kadiyala Ramana, G. Surya Narayana, Arfat Ahmad Khan, and Muhammad Faheem. 2026a. “Hybrid Intelligence Effort for Software Effort Estimation in LLM Assisted Development.” Discover Computing 29 (1): 424. https://doi.org/10.1007/s10791-026-10331-6
Alatawi, Mohammed Naif. 2024. “Forecasting the Software Engineering Model’s Effort Estimation Using Constructive Cost Estimation Models.” Iran Journal of Computer Science 7 (4): 735–54. https://doi.org/10.1007/s42044-024-00194-9
Alawairdhi, Mohammed. 2015. “Static Analysis Based Business Logic Modelling from Legacy System Code: Business Process Model Notation (BPMN) Extraction Using Abstract Syntax Tree (AST).” In 2015 International Symposium on Networks, Computers and Communications (ISNCC). IEEE. https://doi.org/10.1109/isncc.2015.7238572
Albert, Elvira, Richard Bubel, Samir Genaim, Reiner Hähnle, Germán Puebla, and Guillermo Román-Díez. 2015. “A Formal Verification Framework for Static Analysis: As Well as Its Instantiation to the Resource Analyzer COSTA and Formal Verification Tool KeY.” Software & Systems Modeling 15 (4): 987–1012. https://doi.org/10.1007/s10270-015-0476-y
Albert, Elvira, Maria Garcia de la Banda, Alejandro Hernández-Cerezo, Alexey Ignatiev, Albert Rubio, and Peter J. Stuckey. 2024. “SuperStack: Superoptimization of Stack-Bytecode via Greedy, Constraint-Based, and SAT Techniques.” Proceedings of the ACM on Programming Languages 8 (PLDI): 1437–62. https://doi.org/10.1145/3656435
Albert, Elvira, Samir Genaim, and Enrique Martin-Martin. 2026. “Towards Formally Verified Smart Contracts Compilation.” In Formal Methods. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-26220-2_13
Albert, Elvira, Miguel Gómez-Zamalloa, Laurent Hubert, and Germán Puebla. 2006. “Verification of Java Bytecode Using Analysis and Transformation of Logic Programs.” In Practical Aspects of Declarative Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-69611-7_8
Albert, Elvira, Pablo Gordillo, Benjamin Livshits, Albert Rubio, and Ilya Sergey. 2018. “EthIR: A Framework for High-Level Analysis of Ethereum Bytecode.” In Automated Technology for Verification and Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-01090-4_30
Aldrich, Jonathan, Craig Chambers, Emin Gun Sirer, and Susan Eggers. 1999. “Static Analyses for Eliminating Unnecessary Synchronization from Java Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48294-6_2
Alenizy, Kholood Salem, and Faisal A. Al-Homoud. 2024a. “Correction: Discourse Marker Usage in Argumentative Essays by Saudi Learners of English as Foreign Language: A Quantitative Corpus-Based Study.” Corpus Pragmatics 9 (1): 17–17. https://doi.org/10.1007/s41701-024-00179-w
Alenizy, Kholood Salem, and Faisal A. Al-Homoud. 2024b. “Discourse Marker Usage in Argumentative Essays by Saudi Learners of English as Foreign Language: A Quantitative Corpus-Based Study.” Corpus Pragmatics 9 (1): 1–16. https://doi.org/10.1007/s41701-024-00176-z
Alhajj, Reda, and Faruk Polat. 2003. “Rule-Based Schema Evolution in Object-Oriented Databases.” Knowledge-Based Systems 16 (1): 47–57. https://doi.org/10.1016/s0950-7051(02)00051-5
Alhamed, Mohammed, and Tim Storer. 2022. “Evaluation of Context-Aware Language Models and Experts for Effort Estimation of Software Maintenance Issues.” In 2022 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE. https://doi.org/10.1109/icsme55016.2022.00020
Ali, Khayri A. M. 1998. “A Simple Generational Real-Time Garbage Collection Scheme.” New Generation Computing 16 (2): 201–21. https://doi.org/10.1007/bf03037316
Ali, Asad, and Carmine Gravino. 2019. “Using Bio-Inspired Features Selection Algorithms in Software Effort Estimation: A Systematic Literature Review.” In 2019 45th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2019.00043
Ali, Nasir, Yann-Gael Gueneuc, and Giuliano Antoniol. 2013. “Trustrace: Mining Software Repositories to Improve the Accuracy of Requirement Traceability Links.” IEEE Transactions on Software Engineering 39 (5): 725–41. https://doi.org/10.1109/tse.2012.71
Ali, Syed Sarmad, Jian Ren, and Ji Wu. 2024. “Framework to Improve Software Effort Estimation Accuracy Using Novel Ensemble Rule.” Journal of King Saud University - Computer and Information Sciences 36 (9): 102189. https://doi.org/10.1016/j.jksuci.2024.102189
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
Allamigeon, Xavier, Wenceslas Godard, and Charles Hymans. 2006. “Static Analysis of String Manipulations in Critical Embedded C Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/11823230_4
Allamigeon, Xavier, and Charles Hymans. 2007. “Static Analysis by Abstract Interpretation: Application to the Detection of Heap Overflows.” Journal in Computer Virology 4 (1): 5–23. https://doi.org/10.1007/s11416-007-0063-z
Allen, Gregory E., Paul E. Zucknick, and Brian L. Evans. 2006. “Zero-Copy Queues for Native Signal Processing Using the Virtual Memory System.” In 2006 Fortieth Asilomar Conference on Signals, Systems and Computers. IEEE. https://doi.org/10.1109/acssc.2006.354943
Alli, S., and C. Bailey. 2004. “Compiler-Directed Dynamic Memory Disambiguation for Loop Structures.” In Euromicro Symposium on Digital System Design, 2004. DSD 2004.. IEEE. https://doi.org/10.1109/dsd.2004.1333268
Alouini, Ilies. 1995. “Concurrent Garbage Collection for Concurrent Rewriting.” In Rewriting Techniques and Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-59200-8_53
Alpernas, Kalev, Roman Manevich, Aurojit Panda, et al. 2018. “Abstract Interpretation of Stateful Networks.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-99725-4_8
Alsaadi, Bashaer, and Kawther Saeedi. 2024. “Ensemble Effort Estimation for Novice Agile Teams.” Information and Software Technology 170: 107447. https://doi.org/10.1016/j.infsof.2024.107447
Alshaikh, Ahmed, Robert H. Blick, and Christian Heyn. 2024. “GaAs Cone-Shell Quantum Dots in a Lateral Electric Field: Exciton Stark-Shift, Lifetime, and Fine-Structure Splitting.” Nanomaterials 14 (14): 1174. https://doi.org/10.3390/nano14141174
Alt, Martin, Uwe Aßmann, and Hans Someren. 1994. “Cosy Compiler Phase Embedding with the CoSy Compiler Model.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57877-3_19
Alt, Martin, Christian Ferdinand, Florian Martin, and Reinhard Wilhelm. 1996. “Cache Behavior Prediction by Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61739-6_33
Altunel, Haluk, Tugba Erdogan, and Ayca Kolukısa. 2026. “Rethinking Correctness and Efficiency in AI-Assisted Code Generation.” 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/0014971000004015
Alves, Luis M., Andre Sousa, Pedro Ribeiro, and Ricardo J. Machado. 2013. “An Empirical Study on the Estimation of Software Development Effort with Use Case Points.” In 2013 IEEE Frontiers in Education Conference (FIE). IEEE. https://doi.org/10.1109/fie.2013.6684796
Amadio, Roberto M., Solange Coupet-Grimal, Silvano Dal Zilio, and Line Jakubiec. 2004. “A Functional Scenario for Bytecode Verification of Resource Bounds.” In Computer Science Logic. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30124-0_22
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
Amasaki, Sousuke. 2012. “A Study on the Use of COSMIC BFCs for Effort Estimation.” In 2012 Fourth International Workshop on Empirical Software Engineering in Practice. IEEE. https://doi.org/10.1109/iwesep.2012.11
Amasaki, Sousuke. 2019. “Exploring Preference of Chronological and Relevancy Filtering in Effort Estimation.” In Product-Focused Software Process Improvement. Springer International Publishing. https://doi.org/10.1007/978-3-030-35333-9_18
Amasaki, Sousuke, and Chris Lokan. 2013. “The Evaluation of Weighted Moving Windows for Software Effort Estimation.” In Product-Focused Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-39259-7_18
Amasaki, Sousuke, and Chris Lokan. 2014a. “The Effect of Moving Windows on Software Effort Estimation: Comparative Study with CART.” In 2014 6th International Workshop on Empirical Software Engineering in Practice. IEEE. https://doi.org/10.1109/iwesep.2014.10
Amasaki, Sousuke, and Chris Lokan. 2014b. “The Effects of Gradual Weighting on Duration-Based Moving Windows for Software Effort Estimation.” In Product-Focused Software Process Improvement. Springer International Publishing. https://doi.org/10.1007/978-3-319-13835-0_5
Amasaki, S., and C. Lokan. 2014c. “On the Effectiveness of Weighted Moving Windows: Experiment on Linear Regression Based Software Effort Estimation.” Journal of Software: Evolution and Process 27 (7): 488–507. https://doi.org/10.1002/smr.1672
Amasaki, Sousuke, and Chris Lokan. 2016a. “On Applicability of Fixed-Size Moving Windows for ANN-Based Effort Estimation.” In 2016 Joint Conference of the International Workshop on Software Measurement and the International Conference on Software Process and Product Measurement (IWSM-MENSURA). IEEE. https://doi.org/10.1109/iwsm-mensura.2016.041
Amasaki, Sousuke, and Chris Lokan. 2017a. “An Evaluation of Selection Methods for Time-Aware Effort Estimation.” In 2017 24th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2017.105
Amasaki, Sousuke, and Chris Lokan. 2017b. “A Virtual Study of Moving Windows for Software Effort Estimation Using Finnish Datasets.” In Product-Focused Software Process Improvement. Springer International Publishing. https://doi.org/10.1007/978-3-319-69926-4_6
Amasaki, Sousuke, Yohei Takahara, and Tomoyuki Yokogawa. 2011. “Performance Evaluation of Windowing Approach on Effort Estimation by Analogy.” In 2011 Joint Conference of the 21st International Workshop on Software Measurement and the 6th International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm-mensura.2011.29
Amasaki, Sousuke, and Tomoyuki Yokogawa. 2012. “A Study on Predictive Performance of Regression-Based Effort Estimation Models Using Base Functional Components.” In Product-Focused Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-31063-8_27
Amasaki, Sousuke, and Tomoyuki Yokogawa. 2013. “The Effects of Variable Selection Methods on Linear Regression-Based Effort Estimation Models.” In 2013 Joint Conference of the 23rd International Workshop on Software Measurement and the 8th International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm-mensura.2013.24
Amato, Gianluca, and Giorgio Levi. 2000. “Abstract Interpretation Based Semantics of Sequent Calculi.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-45099-3_3
Amazal, Fatima Azzahra, Ali Idri, and Alain Abran. 2014a. “Improving Fuzzy Analogy Based Software Development Effort Estimation.” In 2014 21st Asia-Pacific Software Engineering Conference. IEEE. https://doi.org/10.1109/apsec.2014.46
Amazal, Fatima Azzahra, Ali Idri, and Alain Abran. 2019. “Analysis of Cluster Center Initialization of 2FA-Kprototypes Analogy-Based Software Effort Estimation.” Journal of Software: Evolution and Process 31 (12): e2180. https://doi.org/10.1002/smr.2180
Ambrosch, Wolfgang, M. Anton Ertl, Felix Beer, and Andreas Krall. 1994. “Dependence-Conscious Global Register Allocation.” In Programming Languages and System Architectures. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57840-4_28
Amiri, Amir Reza, Kavitha Kanesalingam, Suzie Cro, and Adrian T. H. Casey. 2014. “Does Source of Funding and Conflict of Interest Influence the Outcome and Quality of Spinal Research?” Spine Journal 14 (2): 308–14. https://doi.org/10.1016/j.spinee.2013.10.047
Amiri, Puya, Arsene Perard-Gayot, Richard Membarth, Philipp Slusallek, Roland Leiba, and Sebastian Hack. 2021. “FLOWER: A Comprehensive Dataflow Compiler for High-Level Synthesis.” In 2021 International Conference on Field-Programmable Technology (ICFPT). IEEE. https://doi.org/10.1109/icfpt52863.2021.9609930
Amy, Matthew, Martin Roetteler, and Krysta M. Svore. 2017. “Verified Compilation of Space-Efficient Reversible Circuits.” In Computer Aided Verification. Springer International Publishing. https://doi.org/10.1007/978-3-319-63390-9_1
An, Siwei. 2026. “Urban Mobile Charging Vehicle Scheduling via Bi- Level Coupled Optimization: Spatio-Temporal Demand Prediction, MCLP Pre-Deployment, and VRPTW-Based Dynamic Dispatch.” In 2026 7th International Conference on Big Data & Artificial Intelligence & Software Engineering (ICBASE). IEEE. https://doi.org/10.1109/icbase70763.2026.11619391
Anagnostopoulou, Afroditi, Maria Boile, Evangelia Papargyri, and Maria Poulou. 2017. “An Advanced Solution Approach for Energy Efficient Garbage Collection Service.” Transportation Research Procedia 24: 362–69. https://doi.org/10.1016/j.trpro.2017.05.099
Ancona, Davide, Andrea Corradi, Giovanni Lagorio, and Ferruccio Damiani. 2011. “Abstract Compilation of Object-Oriented Languages into Coinductive CLP(X): Can Type Inference Meet Verification?” In Formal Verification of Object-Oriented Software. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-18070-5_3
Ancona, Davide, Ferruccio Damiani, Sophia Drossopoulou, and Elena Zucca. 2005. “Polymorphic Bytecode: Compositional Compilation for Java-like Languages.” ACM SIGPLAN Notices 40 (1): 26–37. https://doi.org/10.1145/1047659.1040308
Andersson, Christian. 2003. “Register Allocation by Optimal Graph Coloring.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36579-6_3
Andrade, Henrique, Suresh Aryangat, Tahsin Kurc, Joel Saltz, and Alan Sussman. 2004. “Efficient Execution of Multi-Query Data Analysis Batches Using Compiler Optimization Strategies.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24644-2_33
Andrade, Diego, Basilio B. Fraguela, and Ramón Doallo. 2012. “Static Analysis of the Worst-Case Memory Performance for Irregular Codes with Indirections.” ACM Transactions on Architecture and Code Optimization 9 (3): 1–32. https://doi.org/10.1145/2355585.2355593
Andrade-Valbuena, Nelson A., and Manuel Alonso-Dos Santos. 2026. “Perceived Cognitive Effort and Judgment under Uncertainty: A Cognitive Perspective on Opportunity Evaluation.” Journal of Psychology: 1–31. https://doi.org/10.1080/00223980.2026.2701855
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
Angelis, L., and I. Stamelos. 2002. “Reply to Comments by M. Jorgensen, on the Paper: ‘A Simulation Tool for Efficient Analogy Based Cost Estimation’ by L. Angelis and I. Stamelos, Published in Empirical Software Engineering, 5, 35–68 (2000).” Empirical Software Engineering 7 (4): 377–81. https://doi.org/10.1023/a:1020527423831
Angelo, Monika Di, and Gernot Salzer. 2024. “Bytecode Skeletons for Sample Selection in the Analysis of Blockchain Programs.” In 2024 IEEE International Conference on Blockchain and Cryptocurrency (ICBC). IEEE. https://doi.org/10.1109/icbc59979.2024.10634441
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
Anirudh, S., and C. R. Kavitha. 2024. “Enhancing GCC Compiler Optimization through Natural Language Processing-Driven Automation.” In 2024 5th International Conference on Data Intelligence and Cognitive Informatics (ICDICI). IEEE. https://doi.org/10.1109/icdici62993.2024.10810996
Ansari, Ali, Pejman Lotfi-Kamran, and Hamid Sarbazi-Azad. 2019. “Code Layout Optimization for near-Ideal Instruction Cache.” IEEE Computer Architecture Letters 18 (2): 124–27. https://doi.org/10.1109/lca.2019.2924429
Ansel, Jason, Petr Marchenko, Úlfar Erlingsson, et al. 2011. “Language-Independent Sandboxing of Just-in-Time Compilation and Self-Modifying Code.” ACM SIGPLAN Notices 46 (6): 355–66. https://doi.org/10.1145/1993316.1993540
Ansel, Jason, Petr Marchenko, Úlfar Erlingsson, et al. 2012. “Language-Independent Sandboxing of Just-in-Time Compilation and Self-Modifying Code.” ACM SIGPLAN Notices 47 (6): 355. https://doi.org/10.1145/2345156.1993540
Antao, Samuel F., Alexey Bataev, Arpith C. Jacob, et al. 2016. “Offloading Support for OpenMP in Clang and LLVM.” In 2016 Third Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc.2016.006
Ao, Qi, Longbing Zhang, Shuai Chen, Jie Fu, and Bin Liao. 2015. “A Fault-Tolerant Java Virtual Machine Using Fast Rejuvenation for Soft-Error-Prone Systems.” In 2015 IEEE 17th International Conference on High Performance Computing and Communications, 2015 IEEE 7th International Symposium on Cyberspace Safety and Security, and 2015 IEEE 12th International Conference on Embedded Software and Systems. IEEE. https://doi.org/10.1109/hpcc-css-icess.2015.31
Apandi, Nurfarihah, and Nursuriati Jamil. 2016. “An Analysis of Malay Language Emotional Speech Corpus for Emotion Recognition System.” In 2016 IEEE Industrial Electronics and Applications Conference (IEACon). IEEE. https://doi.org/10.1109/ieacon.2016.8067383
Apel, Joachim, and Uwe Klaus. 1993. “Data Representation and in-Built Compilation in the Computer Algebra Program FELIX.” In Design and Implementation of Symbolic Computation Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57272-4_34
Appel, Andrew W. 1987. “Garbage Collection Can Be Faster than Stack Allocation.” Information Processing Letters 25 (4): 275–79. https://doi.org/10.1016/0020-0190(87)90175-x
Appel, Andrew W., and Aage Bendiksen. 1989. “Vectorized Garbage Collection.” Journal of Supercomputing 3 (3): 151–60. https://doi.org/10.1007/bf00127826
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
“An Approach for Schema Evolution in Odmg Databases.” 2004. In Proceedings of the 4th International Workshop on Pattern Recognition in Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002617901360141
“Approval Gained for COBOL Compiler.” 1986. Data Processing 28 (7): 339. https://doi.org/10.1016/0011-684x(86)90135-8
Apt, Krzysztof R. 1984. “A Static Analysis of CSP Programs.” In Logics of Programs. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-12896-4_351
Aratovskyi, Oleksandr, and Vira Liubchenko. 2025. “Constructing a Github-Based Dataset for Machine Learning Driven Software Effort Estimation.” In 2025 IEEE 13th International Conference on Intelligent Data Acquisition and Advanced Computing Systems: Technology and Applications (IDAACS). IEEE. https://doi.org/10.1109/idaacs68557.2025.11322078
Arceri, Vincenzo, Isabella Mastroeni, and Sunyi Xu. 2020. “Static Analysis for ECMAScript String Manipulation Programs.” Applied Sciences 10 (10): 3525. https://doi.org/10.3390/app10103525
Arfa, Sirine, Bernhard Vogginger, Chen Liu, Johannes Partzsch, Mark Schöne, and Christian Mayr. 2025. “Efficient Deployment of Spiking Neural Networks on SpiNNaker2 for DVS Gesture Recognition Using Neuromorphic Intermediate Representation.” In 2025 Neuro Inspired Computational Elements (NICE). IEEE. https://doi.org/10.1109/nice65350.2025.11065119
Ariav, Gad. 1991. “Temporally Oriented Data Definitions: Managing Schema Evolution in Temporally Oriented Databases.” Data & Knowledge Engineering 6 (6): 451–67. https://doi.org/10.1016/0169-023x(91)90023-q
Aridor, Yariv, Michael Factor, and Avi Teperman. 2001. “A Distributed Implementation of a Virtual Machine for Java.” Concurrency and Computation: Practice and Experience 13 (3): 221–44. https://doi.org/10.1002/cpe.565
Arman, Ala, Emiliano Di Reto, Massimo Mecella, and Giuseppe Santucci. 2023. “An Approach for Software Development Effort Estimation Using ChatGPT.” In 2023 IEEE International Conference on Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE). IEEE. https://doi.org/10.1109/wetice57085.2023.10477777
Armbruster, Austin, Jason Baker, Antonio Cunei, et al. 2007. “A Real-Time Java Virtual Machine with Applications in Avionics.” ACM Transactions on Embedded Computing Systems 7 (1): 1–49. https://doi.org/10.1145/1324969.1324974
Armejach, Adria, Adrian Cristal, and Osman S. Unsal. 2015. “Tidy Cache: Improving Data Placement in Die-Stacked DRAM Caches.” In 2015 27th International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD). IEEE. https://doi.org/10.1109/sbac-pad.2015.23
Armstrong, Joe, and Robert Virding. 1995. “One Pass Real-Time Generational Mark-Sweep Garbage Collection.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_31
Arnborg, Stefan. 1974. “Optimal Memory Management in a System with Garbage Collection.” BIT 14 (4): 375–81. https://doi.org/10.1007/bf01932534
Arzt, Steven. 2021. “Sustainable Solving: Reducing the Memory Footprint of IFDS-Based Data Flow Analyses Using Intelligent Garbage Collection.” In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse43902.2021.00102
Asati, Rahul, Amitabha Sanyal, Amey Karkare, and Alan Mycroft. 2014. “Liveness-Based Garbage Collection.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-54807-9_5
Ashajyothi, Sirapu, and P. Chandrashekar Reddy. 2023. “Survey: Garbage Collection and Segmentation System Using Mask-RCNN Based Deep Learning Algorithms.” In 2023 14th International Conference on Computing Communication and Networking Technologies (ICCCNT). IEEE. https://doi.org/10.1109/icccnt56998.2023.10306973
Ashcraft, Matthew B., Alexander Lemon, David A. Penry, and Quinn Snell. 2017. “Compiler Optimization of Accelerator Data Transfers.” International Journal of Parallel Programming 47 (1): 39–58. https://doi.org/10.1007/s10766-017-0549-3
Askarpour, Mehrnoosh, Dino Mandrioli, Matteo Rossi, and Federico Vicentini. 2016. “SAFER-HRC: Safety Analysis through Formal vERification in Human-Robot Collaboration.” In Computer Safety, Reliability, and Security. Springer International Publishing. https://doi.org/10.1007/978-3-319-45477-1_22
Askitis, Nikolas, and Justin Zobel. 2005. “Cache-Conscious Collision Resolution in String Hash Tables.” In String Processing and Information Retrieval. Springer Berlin Heidelberg. https://doi.org/10.1007/11575832_11
Aslam, Faisal, Luminous Fennell, Christian Schindelhauer, et al. 2010. “Optimized Java Binary and Virtual Machine for Tiny Motes.” In Distributed Computing in Sensor Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-13651-1_2
Aslanyan, Hayk, Zhora Gevorgyan, Ruslan Mkoyan, Hovhannes Movsisyan, Vardan Sahakyan, and Sevak Sargsyan. 2022. “Static Analysis Methods for Memory Leak Detection: A Survey.” In 2022 Ivannikov Memorial Workshop (IVMEM). IEEE. https://doi.org/10.1109/ivmem57067.2022.9983955
Aspinall, David, Robert Atkey, Kenneth MacKenzie, and Donald Sannella. 2010. “Symbolic and Analytic Techniques for Resource Analysis of Java Bytecode.” In Trustworthly Global Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-15640-3_1
Assefa, Yibeltal, Fekerte Berhanu, Asnakech Tilahun, and Esubalew Alemneh. 2022. “Software Effort Estimation Using Machine Learning Algorithm.” In 2022 International Conference on Information and Communication Technology for Development for Africa (ICT4DA). IEEE. https://doi.org/10.1109/ict4da56482.2022.9971209
“ASSESSING EFFORT PREDICTION MODELS FOR CORRECTIVE SOFTWARE MAINTENANCE: An Empirical Study.” 2004. In Proceedings of the 4th International Workshop on Pattern Recognition in Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002595603830390
Assolini, Nicola, Alessandra Di Pierro, and Isabella Mastroeni. 2025a. “A Static Analysis of Entanglement.” In Verification, Model Checking, and Abstract Interpretation. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-82703-7_3
Assolini, Nicola, Alessandra Di Pierro, and Isabella Mastroeni. 2025b. “Static Analysis of Quantum Programs.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-74776-2_1
Asztalos, Márk, László Lengyel, and Tihamér Levendovszky. 2010. “Towards Automated, Formal Verification of Model Transformations.” In 2010 Third International Conference on Software Testing, Verification and Validation. IEEE. https://doi.org/10.1109/icst.2010.42
Ataie, Ismail, and Weikuan Yu. 2022. “SVAGC: Garbage Collection with a Scalable Virtual Address Swapping Technique.” In 2022 IEEE International Conference on Cluster Computing (CLUSTER). IEEE. https://doi.org/10.1109/cluster51413.2022.00047
Athale, Mihir, and Vishal Vaddina. 2025. “Knowledge Graph Based Repository-Level Code Generation.” In 2025 IEEE/ACM International Workshop on Large Language Models for Code (LLM4Code). IEEE. https://doi.org/10.1109/llm4code66737.2025.00026
Atif, Maimoon, and Fahad A. Al-Sulaiman. 2015. “Development of a Mathematical Model for Optimizing a Heliostat Field Layout Using Differential Evolution Method.” International Journal of Energy Research 39 (9): 1241–55. https://doi.org/10.1002/er.3325
Auer, M., and S. Biffl. 2004. “Increasing the Accuracy and Reliability of Analogy-Based Cost Estimation with Extensive Project Feature Dimension Weighting.” In Proceedings. 2004 International Symposium on Empirical Software Engineering, 2004. ISESE ‘04.. IEEE. https://doi.org/10.1109/isese.2004.1334902
Auer, M., A. Trendowicz, B. Graser, E. Haunschmid, and S. Biffl. 2006. “Optimal Project Feature Weights in Analogy-Based Cost Estimation: Improvement and Limitations.” IEEE Transactions on Software Engineering 32 (2): 83–92. https://doi.org/10.1109/tse.2006.1599418
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
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
Awais, Muhammad, and Ali Afzal Malik. 2023. “A Comparative Analysis of Popular Software Effort Estimation Techniques.” In 2023 International Conference on IT and Industrial Technologies (ICIT). IEEE. https://doi.org/10.1109/icit59216.2023.10335868
Ayala, Claudia, Burak Turhan, Xavier Franch, and Natalia Juristo. 2022. “Use and Misuse of the Term “Experiment” in Mining Software Repositories Research.” IEEE Transactions on Software Engineering 48 (11): 4229–48. https://doi.org/10.1109/tse.2021.3113558
Ayari, Salma, Yousra Bendali Hlaoui, and Leila Ben Ayed. 2019. “A Grammar Based Approach to BPMN Model Semantic Preservation Using Refinement.” In 2019 IEEE 43rd Annual Computer Software and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac.2019.10264
Ayoade, Gbadebo, Erick Bauman, Latifur Khan, and Kevin Hamlen. 2019. “Smart Contract Defense through Bytecode Rewriting.” In 2019 IEEE International Conference on Blockchain (Blockchain). IEEE. https://doi.org/10.1109/blockchain.2019.00059
Aytekin, Mehmet Cem, Fatma Gizem Yılmaz, and Mustafa Umut Demirezen. 2026. “Automating Code Generation for a New Ecosystem: Establishing Baselines with Large Language Model Based Code Generation for ArkTS and HarmonyOS.” Automated Software Engineering 33 (2): 59. https://doi.org/10.1007/s10515-026-00599-9
Azeemi, N. 2006a. “Compiler Directed Battery-Aware Implementation of Mobile Applications.” In 2006 International Conference on Emerging Technologies. IEEE. https://doi.org/10.1109/icet.2006.335979
Azeemi, Naeem. 2006b. “Multicriteria Energy Efficient Source Code Compilation for Dependable Embedded Applications.” In 2006 Innovations in Information Technology. IEEE. https://doi.org/10.1109/innovations.2006.301963
Azevedo, Ana, Alex Nicolau, and Joe Hummel. 2000. “An Annotation-Aware Java Virtual Machine Implementation.” Concurrency: Practice and Experience 12 (6): 423–44. https://doi.org/10.1002/1096-9128(200005)12:6<423::aid-cpe483>3.0.co;2-l
Aziz, Rehan, Valeena Afzal, Zeeshan Ali Rana, and S. A. M. Gilani. 2024. “Improving Software Effort Estimation by Adjusting for Over-Commitment.” In 2024 International Conference on Frontiers of Information Technology (FIT). IEEE. https://doi.org/10.1109/fit63703.2024.10838423
Azzeh, Mohammad. 2011a. “Adjusted Case-Based Software Effort Estimation Using Bees Optimization Algorithm.” In Knowlege-Based and Intelligent Information and Engineering Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-23863-5_32
Azzeh, Mohammad. 2011b. “Model Tree Based Adaption Strategy for Software Effort Estimation by Analogy.” In 2011 IEEE 11th International Conference on Computer and Information Technology. IEEE. https://doi.org/10.1109/cit.2011.48
Azzeh, Mohammad. 2011c. “A Replicated Assessment and Comparison of Adaptation Techniques for Analogy-Based Effort Estimation.” Empirical Software Engineering 17 (1–2): 90–127. https://doi.org/10.1007/s10664-011-9176-6
Azzeh, Mohammad. 2023. “Software Effort Estimation Using Deep Learning and Fuzzy Modelling.” In 2023 28th International Conference on Automation and Computing (ICAC). IEEE. https://doi.org/10.1109/icac57885.2023.10275256
Azzeh, Mohammad, Peter I. Cowling, and Daniel Neagu. 2010. “Software Stage-Effort Estimation Based on Association Rule Mining and Fuzzy Set Theory.” In 2010 10th IEEE International Conference on Computer and Information Technology. IEEE. https://doi.org/10.1109/cit.2010.76
Azzeh, Mohammad, and Ali Bou Nassif. 2018. “Project Productivity Evaluation in Early Software Effort Estimation.” Journal of Software: Evolution and Process 30 (12): e2110. https://doi.org/10.1002/smr.2110
Azzeh, Mohammad, Ali Bou Nassif, and Leandro L. Minku. 2015. “An Empirical Evaluation of Ensemble Adjustment Methods for Analogy-Based Effort Estimation.” Journal of Systems and Software 103: 36–52. https://doi.org/10.1016/j.jss.2015.01.028
Azzeh, Mohammad, Daniel Neagu, and Peter I. Cowling. 2009a. “Fuzzy Grey Relational Analysis for Software Effort Estimation.” Empirical Software Engineering 15 (1): 60–90. https://doi.org/10.1007/s10664-009-9113-0
Azzeh, Mohammad, Daniel Neagu, and Peter I. Cowling. 2011. “Analogy-Based Software Effort Estimation Using Fuzzy Numbers.” Journal of Systems and Software 84 (2): 270–84. https://doi.org/10.1016/j.jss.2010.09.028
Ba, Haihe, Huaizhe Zhou, Jiangchun Ren, and Zhiying Wang. 2017. “Runtime Measurement Architecture for Bytecode Integrity in JVM-Based Cloud.” In 2017 IEEE 36th Symposium on Reliable Distributed Systems (SRDS). IEEE. https://doi.org/10.1109/srds.2017.39
Baecker, H. D. 1972. “Garbage Collection for Virtual Memory Computer Systems.” Communications of the ACM 15 (11): 981–86. https://doi.org/10.1145/355606.361886
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. 2024a. “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
Bahig, Ghada, and Amr El-Kadi. 2017. “Formal Verification of Automotive Design in Compliance with ISO 26262 Design Verification Guidelines.” IEEE Access 5: 4505–16. https://doi.org/10.1109/access.2017.2683508
Baik, Seungsu, Taehwa Lee, and Jaehyuk Cha. 2024. “Data Placement through Clustering Sequential Writes and Isolating Cold Pages for Write Amplification Reduction in NAND Flash Memory.” IEEE Access 12: 142265–74. https://doi.org/10.1109/access.2024.3470812
Bajta, Manal El. 2015. “Analogy-Based Software Development Effort Estimation in Global Software Development.” In 2015 IEEE 10th International Conference on Global Software Engineering Workshops. IEEE. https://doi.org/10.1109/icgsew.2015.19
Bajwa, Sohaib Shahid, and Cigdem Gencel. 2009. “What Are the Significant Cost Drivers for COSMIC Functional Size Based Effort Estimation?” In Software Process and Product Measurement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-05415-0_5
Baker, Henry G. 1994. “Thermodynamics and Garbage Collection.” ACM SIGPLAN Notices 29 (4): 58–63. https://doi.org/10.1145/181761.181770
Baker, Simon, and Emilia Mendes. 2010. “Aggregating Expert-Driven Causal Maps for Web Effort Estimation.” In Advances in Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-17578-7_27
Bakhirkin, Alexey, and David Monniaux. 2017. “Combining Forward and Backward Abstract Interpretation of Horn Clauses.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-66706-5_2
Balaji, P., S. Bhagvat, H.-W. Jin, and D. K. Panda. 2006. “Asynchronous Zero-Copy Communication for Synchronous Sockets in the Sockets Direct Protocol (SDP) over InfiniBand.” In Proceedings 20th IEEE International Parallel & Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2006.1639560
Balaska, Vasiliki, Dimitris Folinas, Fotios K. Konstantinidis, and Antonios Gasteratos. 2022. “Smart Counting of Unboxed Stocks in the Warehouse 4.0 Ecosystem.” In 2022 IEEE International Conference on Imaging Systems and Techniques (IST). IEEE. https://doi.org/10.1109/ist55454.2022.9827758
Balasubramanian, Karthikeyan Kalyanasundaram, Mirco Di Salvo, Walter Rocchia, Sergio Decherchi, and Marco Crepaldi. 2024. “Designing RISC-V Instruction Set Extensions for Artificial Neural Networks: An LLVM Compiler-Driven Perspective.” IEEE Access 12: 55925–44. https://doi.org/10.1109/access.2024.3389673
Balat, Vincent, and Olivier Danvy. 1998. “Strong Normalization by Type-Directed Partial Evaluation and Run-Time Code Generation.” In Types in Compilation. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0055521
Baldan, Dante, and Gilberto Filé. 1997. “Abstract Interpretation for Improving WAM Code.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032754
Ball, Thomas, Peli de Halleux, and Michał Moskal. 2019. “Static TypeScript: An Implementation of a Static Compiler for the TypeScript Language.” In Proceedings of the 16th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3357390.3361032
Ballabriga, Clément, Julien Forget, Laure Gonnord, Giuseppe Lipari, and Jordy Ruiz. 2019. “Static Analysis of Binary Code with Memory Indirections Using Polyhedra.” In Verification, Model Checking, and Abstract Interpretation. Springer International Publishing. https://doi.org/10.1007/978-3-030-11245-5_6
Balman, Mehmet. 2012a. “Abstract: MemzNet: Memory-Mapped Zero-Copy Network Channel for Moving Large Datasets over 100Gbps Network.” In 2012 SC Companion: High Performance Computing, Networking Storage and Analysis. IEEE. https://doi.org/10.1109/sc.companion.2012.294
Balman, Mehmet. 2012b. “Poster: MemzNet: Memory-Mapped Zero-Copy Network Channel for Moving Large Datasets over 100Gbps Networks.” In 2012 SC Companion: High Performance Computing, Networking Storage and Analysis. IEEE. https://doi.org/10.1109/sc.companion.2012.295
Balogh, G. D., G. R. Mudalige, I. Z. Reguly, S. F. Antao, and C. Bertolli. 2018. “OP2-Clang: A Source-to-Source Translator Using Clang/LLVM LibTooling.” In 2018 IEEE/ACM 5th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc.2018.8639205
Balou, A. T., and A. N. Refenes. 1990. “Designing a Parallel Object-Oriented Compiler Target Language (TOOL).” Microprocessing and Microprogramming 30 (1–5): 457–65. https://doi.org/10.1016/0165-6074(90)90283-f
Banach, R. 1994. “Term Graph Rewriting and Garbage Collection Using Opfibrations.” Theoretical Computer Science 131 (1): 29–94. https://doi.org/10.1016/0304-3975(94)90090-6
Banerjee, Abhijeet, Sudipta Chattopadhyay, and Abhik Roychoudhury. 2013. “Static Analysis Driven Cache Performance Testing.” In 2013 IEEE 34th Real-Time Systems Symposium. IEEE. https://doi.org/10.1109/rtss.2013.39
Bangash, Abdul Ali, Kalvin Eng, Qasim Jamal, Karim Ali, and Abram Hindle. 2023. “Energy Consumption Estimation of API-Usage in Smartphone Apps via Static Analysis.” In 2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR). IEEE. https://doi.org/10.1109/msr59073.2023.00047
BaniMustafa, Ahmed. 2018. “Predicting Software Effort Estimation Using Machine Learning Techniques.” In 2018 8th International Conference on Computer Science and Information Technology (CSIT). IEEE. https://doi.org/10.1109/csit.2018.8486222
Bansal, Aman, Saksham Goel, Preey Shah, Amitabha Sanyal, and Prasanna Kumar. 2020. “Garbage Collection Using a Finite Liveness Domain.” In Proceedings of the 2020 ACM SIGPLAN International Symposium on Memory Management. ACM. https://doi.org/10.1145/3381898.3397208
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
Baqasah, Abdullah, and Eric Pardede. 2010. “Managing Schema Evolution in Hybrid XML-Relational Database Systems.” In 2010 IEEE 24th International Conference on Advanced Information Networking and Applications Workshops. IEEE. https://doi.org/10.1109/waina.2010.127
Barabash, Katherine, Yoav Ossia, and Erez Petrank. 2003. “Mostly Concurrent Garbage Collection Revisited.” ACM SIGPLAN Notices 38 (11): 255–68. https://doi.org/10.1145/949343.949328
Barabash, Katherine, and Erez Petrank. 2010. “Tracing Garbage Collection on Highly Parallel Platforms.” ACM SIGPLAN Notices 45 (8): 1–10. https://doi.org/10.1145/1837855.1806653
Baradaran, Sara, Liyan Huang, Mukund Raghothaman, and Weihang Wang. 2026b. “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
Baradaran, Sara, Amirmohammad Nazari, and Mukund Raghothaman. 2026a. “LLM-Integrated Declarative Program Analysis.” In Proceedings of the 15th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. ACM. https://doi.org/10.1145/3814987.3814993
Bardizbanyan, A., P. Gavin, D. Whalley, et al. 2013. “Improving Data Access Efficiency by Using a Tagless Access Buffer (TAB).” In Proceedings of the 2013 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2013.6495003
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
Barili, Fabio, and Mauro Rinaldi. 2018. “Benchmark to Avoid Judgment under Uncertainty in the Choice.” Journal of Thoracic and Cardiovascular Surgery 156 (4): 1391–92. https://doi.org/10.1016/j.jtcvs.2018.07.006
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
Barragán, L. A., and A. Roy. 1993. “An Empirical Study of Automatic Restructuring of Vision Programs for Simd Machines.” Microprocessing and Microprogramming 38 (1–5): 553–60. https://doi.org/10.1016/0165-6074(93)90195-q
Barragan, Luis Angel, and Armando Roy. 1993. “An Empirical Study of Vision Programs for Data Dependence Analysis.” In PARLE ‘93 Parallel Architectures and Languages Europe. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-56891-3_65
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
Barry, Evelyn J., Tridas Mukhopadhyay, and Sandra A. Slaughter. 2002. “Software Project Duration and Effort: An Empirical Study.” Information Technology and Management 3 (1–2): 113–36. https://doi.org/10.1023/a:1013168927238
Barth, Jeffrey M. 1977. “Shifting Garbage Collection Overhead to Compile Time.” Communications of the ACM 20 (7): 513–18. https://doi.org/10.1145/359636.359713
Barthe, Gilles, Sandrine Blazy, Benjamin Grégoire, et al. 2019. “Formal Verification of a Constant-Time Preserving C Compiler.” Proceedings of the ACM on Programming Languages 4 (POPL): 1–30. https://doi.org/10.1145/3371075
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
Barthe, Gilles, and Guillaume Dufay. 2004. “A Tool-Assisted Framework for Certified Bytecode Verification.” In Fundamental Approaches to Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24721-0_7
Bartlett, Joel F. 1988. “Compacting Garbage Collection with Ambiguous Roots.” ACM SIGPLAN Lisp Pointers 1 (6): 3–12. https://doi.org/10.1145/1317224.1317225
Bartolini, Sandro, Iacopo Casini, and Paolo Detti. 2014. “Solving Graph Partitioning Problems Arising in Tagless Cache Management.” In Combinatorial Optimization. Springer International Publishing. https://doi.org/10.1007/978-3-319-09174-7_5
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
Basch, Danko, Dorian Ivančić, and Nikica Hlupić. 2014. “Mark without much Sweep Algorithm for Garbage Collection.” Automatika 55 (4): 514–25. https://doi.org/10.7305/automatika.2014.11.857
Basgalupp, Márcio P., Rodrigo C. Barros, Ricardo Cerri, Ferrante Neri, Péricles B. C. Miranda, and Teresa Ludermir. 2025. “Grammar-Based Evolutionary Approaches for Software Effort Estimation.” In 2025 IEEE Congress on Evolutionary Computation (CEC). IEEE. https://doi.org/10.1109/cec65147.2025.11042977
Basile, Davide, Felicita Di Giandomenico, and Stefania Gnesi. 2017. “Enhancing Models Correctness through Formal Verification: A Case Study from the Railway Domain.” In Proceedings of the 5th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006291106790686
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
Basin, David, Stefan Friedrich, Joachim Posegga, and Harald Vogt. 1999. “Java Bytecode Verification by Model Checking: System Abstract.” In Computer Aided Verification. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48683-6_43
Baskeles, Bilge, Burak Turhan, and Ayse Bener. 2007. “Software Effort Estimation Using Machine Learning Methods.” In 2007 22nd international symposium on computer and information sciences. IEEE. https://doi.org/10.1109/iscis.2007.4456863
Basri, Sufyan, Nazri Kama, Haslina Md Sarkan, Saiful Adli, and Faizura Haneem. 2016a. “An Algorithmic-Based Change Effort Estimation Model for Software Development.” In 2016 23rd Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2016.034
Basso, Matteo, Eduardo Rosales, Filippo Schiavio, Andrea Rosà, and Walter Binder. 2022. “Accurate Fork-Join Profiling on the Java Virtual Machine.” In Euro-Par 2022: Parallel Processing. Springer International Publishing. https://doi.org/10.1007/978-3-031-12597-3_3
Basten, Dirk, and Werner Mellis. 2011. “A Current Assessment of Software Development Effort Estimation.” In 2011 International Symposium on Empirical Software Engineering and Measurement. IEEE. https://doi.org/10.1109/esem.2011.32
Basten, Dirk, and Ali Sunyaev. 2011. “Guidelines for Software Development Effort Estimation.” Computer 44 (10): 88–90. https://doi.org/10.1109/mc.2011.315
Basu, Nilanjana, Claudio Montanari, and Jakob Eriksson. 2021. “Frequent Background Polling on a Shared Thread, Using Light-Weight Compiler Interrupts.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454107
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, Steven J., and Mark Hempstead. 2013. “Register Allocation and VDD-Gating Algorithms for out-of-Order Architectures.” In 2013 IEEE 31st International Conference on Computer Design (ICCD). IEEE. https://doi.org/10.1109/iccd.2013.6657032
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, F. L. 1974. “Appendix: Historical Remarks on Compiler Construction.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-21549-4_22
Baumann, Joachim. 2000. “Chapter 5. Distributed Garbage Collection.” In Mobile Agents: Control Algorithms. Springer Berlin Heidelberg. https://doi.org/10.1007/10704127_5
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
Baxter, James, and Ana Cavalcanti. 2017. “Algebraic Compilation of Safety-Critical Java Bytecode.” In Integrated Formal Methods. Springer International Publishing. https://doi.org/10.1007/978-3-319-66845-1_11
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
Becker, Joseph, and Deanna Kuhn. 1984. “Judgements under Uncertainty: Heuristics and Biases.” New Ideas in Psychology 2 (2): 201–10. https://doi.org/10.1016/0732-118x(84)90024-2
Becker, Andrew, Scott Sirowy, and Frank Vahid. 2011. “Just-in-Time Compilation for FPGA Processor Cores.” In 2011 Electronic System Level Synthesis Conference (ESLsyn). IEEE. https://doi.org/10.1109/eslsyn.2011.5952282
Beenker, F., R. Dekker, R. Stans, and M. Van der Star. 1990. “Implementing Macro Test in Silicon Compiler Design.” IEEE Design & Test of Computers 7 (2): 41–51. https://doi.org/10.1109/54.53044
Beg, Mirza, and Peter van Beek. 2010. “A Graph Theoretic Approach to Cache-Conscious Placement of Data for Direct Mapped Caches.” ACM SIGPLAN Notices 45 (8): 113–20. https://doi.org/10.1145/1837855.1806670
Behravan Rad, A. 2018. “Static Analysis of Non-Uniform 2D Functionally Graded Auxetic-Porous Circular Plates Interacting with the Gradient Elastic Foundations Involving Friction Force.” Aerospace Science and Technology 76: 315–39. https://doi.org/10.1016/j.ast.2018.01.036
Belefqih, Saad, Mohammed Barchane, Ahmed Zellou, Karim Doumi, and Elhabib Benlahmar. 2025. “Reinforcement Learning for Dynamic RDF Schema Evolution in NoSQL Databases.” In 2025 International Conference on Intelligent Systems: Theories and Applications (SITA). IEEE. https://doi.org/10.1109/sita67914.2025.11273715
Bell, Oren, Chris Gill, and Xuan Zhang. 2023. “Hardware Acceleration with Zero-Copy Memory Management for Heterogeneous Computing.” In 2023 IEEE 29th International Conference on Embedded and Real-Time Computing Systems and Applications (RTCSA). IEEE. https://doi.org/10.1109/rtcsa58653.2023.00013
Bellahsene, Zohra. 1996. “View Mechanism for Schema Evolution in Object-Oriented DBMS.” In Advances in Databases. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61442-7_2
Bellahsene, Zohra. 2002. “Schema Evolution in Data Warehouses.” Knowledge and Information Systems 4 (3): 283–304. https://doi.org/10.1007/s101150200008
Bellè, Gianna, and Eugenio Moggi. 1997. “Typed Intermediate Languages for Shape Analysis.” In Typed Lambda Calculi and Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-62688-3_26
Belz, Julie A. 2004. “Learner Corpus Analysis and the Development of Foreign Language Proficiency.” System 32 (4): 577–91. https://doi.org/10.1016/j.system.2004.09.013
Benaissa, Nazim, David Bonvoisin, Abderrahmane Feliachi, and Julien Ordioni. 2016. “The PERF Approach for Formal Verification.” In Reliability, Safety, and Security of Railway Systems. Modelling, Analysis, Verification, and Certification. Springer International Publishing. https://doi.org/10.1007/978-3-319-33951-1_15
Benala, Tirimula Rao, and Rohitha Bandarupalli. 2016. “Least Square Support Vector Machine in Analogy-Based Software Development Effort Estimation.” In 2016 International Conference on Recent Advances and Innovations in Engineering (ICRAIE). IEEE. https://doi.org/10.1109/icraie.2016.7939524
Benala, Tirimula Rao, and Satchidananda Dehuri. 2022. “Tuning Functional Link Artificial Neural Network for Software Development Effort Estimation.” In Innovations in Intelligent Computing and Communication. Springer International Publishing. https://doi.org/10.1007/978-3-031-23233-6_5
Benala, Tirimula Rao, and Rajib Mall. 2018. “DABE: Differential Evolution in Analogy-Based Software Development Effort Estimation.” Swarm and Evolutionary Computation 38: 158–72. https://doi.org/10.1016/j.swevo.2017.07.009
Benander, Alan, Barbara Benander, and Janche Sang. 2004. “Factors Related to the Difficulty of Learning to Program in Java—an Empirical Study of Non-Novice Programmers.” Information and Software Technology 46 (2): 99–107. https://doi.org/10.1016/s0950-5849(03)00112-5
Benediktsson, Oddur, and Darren Dalcher. 2004b. “Project Effort Estimation: Or, When Size Makes a Difference.” In Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30181-3_16
Bennour, I. E., and E. M. Aboulhamid. 1996. “Register Allocation Using Circular FIFOs.” In 1996 IEEE International Symposium on Circuits and Systems (ISCAS). IEEE. https://doi.org/10.1109/iscas.1996.542085
Benton, Bruce. 2009. “Model-Based Time and Cost Estimation in a Software Testing Environment.” In 2009 Sixth International Conference on Information Technology: New Generations. IEEE. https://doi.org/10.1109/itng.2009.98
Benton, Nick, and Chung-Kil Hur. 2009. “Biorthogonality, Step-Indexing and Compiler Correctness.” ACM SIGPLAN Notices 44 (9): 97–108. https://doi.org/10.1145/1631687.1596567
Benz, Florian, Andreas Hildebrandt, and Sebastian Hack. 2012. “A Dynamic Program Analysis to Find Floating-Point Accuracy Problems.” In Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2254064.2254118
Berekovic, Mladen, Helge Kloos, and Peter Pirsch. 1999. “Hardware Realization of a Java Virtual Machine for High Performance Multimedia Applications.” Journal of VLSI signal processing systems for signal, image and video technology 22 (1): 31–43. https://doi.org/10.1023/a:1008169702146
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
Bergami, Giacomo. 2024. “Streamlining Temporal Formal Verification over Columnar Databases.” Information 15 (1): 34. https://doi.org/10.3390/info15010034
Beringer, Lennart, Gordon Stewart, Robert Dockins, and Andrew W. Appel. 2014. “Verified Compilation for Shared-Memory C.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-54833-8_7
Bernardeschi, Cinzia, and Nicoletta De Francesco. 2002. “Combining Abstract Interpretation and Model Checking for Analysing Security Properties of Java Bytecode.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-47813-2_1
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
Bernardeschi, Cinzia, Nicoletta De Francesco, and Luca Martini. 2003. “Efficient Bytecode Verification Using Immediate Postdominators in Control Flow Graphs.” In On The Move to Meaningful Internet Systems 2003: OTM 2003 Workshops. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39962-9_49
Bernardeschi, Cinzia, Alessandro Fantechi, Stefania Gnesi, Salvatore Larosa, Giorgio Mongardi, and Dario Romano. 1998. “A Formal Verification Environment for Railway Signaling System Design.” Formal Methods in System Design 12 (2): 139–61. https://doi.org/10.1023/a:1008645826258
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
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
Berstis, V. 1989. “The V Compiler: Automatic Hardware Design.” IEEE Design & Test of Computers 6 (2): 8–17. https://doi.org/10.1109/54.19131
Bertelsen, Peter. 2000. “Dynamic Semantics of Java Bytecode.” Future Generation Computer Systems 16 (7): 841–50. https://doi.org/10.1016/s0167-739x(99)00094-1
Berthelot, Guillaume, Arnault Ioualalen, and Matthieu Martel. 2025. “Accelerating the Static Analysis of Neural Networks by Batch Representation of Abstract Values.” In Proceedings of the 11th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming. ACM. https://doi.org/10.1145/3736112.3736142
Bertisen, Jasper, and Graham A. Davis. 2008. “Bias and Error in Mine Project Capital Cost Estimation.” Engineering Economist 53 (2): 118–39. https://doi.org/10.1080/00137910802058533
Bertolli, Carlo, Samuel F. Antao, Alexandre E. Eichenberger, et al. 2014. “Coordinating GPU Threads for OpenMP 4.0 in LLVM.” In 2014 LLVM Compiler Infrastructure in HPC. IEEE. https://doi.org/10.1109/llvm-hpc.2014.10
Bertot, Yves, Benjamin Grégoire, and Xavier Leroy. 2006. “A Structured Approach to Proving Compiler Optimizations Based on Dataflow Analysis.” In Types for Proofs and Programs. Springer Berlin Heidelberg. https://doi.org/10.1007/11617990_5
Bertrane, Julien. 2005. “Static Analysis by Abstract Interpretation of the Quasi-Synchronous Composition of Synchronous Programs.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30579-8_7
Besson, Frédéric, David Cachera, Thomas Jensen, and David Pichardie. 2009. “Certified Static Analysis by Abstract Interpretation.” In Foundations of Security Analysis and Design V. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-03829-7_8
Besson, Frédéric, Thomas Jensen, and Julien Lepiller. 2018. “Modular Software Fault Isolation as Abstract Interpretation.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-99725-4_12
Bevan, Di. 1987. “Distributed Garbage Collection Using Reference Counting.” In PARLE Parallel Architectures and Languages Europe. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-17945-3_10
Bevan, David I. 1989. “An Efficient Reference Counting Solution to the Distributed Garbage Collection Problem.” Parallel Computing 9 (2): 179–92. https://doi.org/10.1016/0167-8191(89)90127-0
Beyerle, Marc, Joachim Franz, and Wilhelm G. Spruth. 2005. “Persistent Reusable Java Virtual Machine unter z/OS und Linux.” Informatik - Forschung und Entwicklung 20 (1–2): 102–11. https://doi.org/10.1007/s00450-005-0195-7
Bhardwaj, Meher, Hrishikesh Ethari, and Dennis Singh Moirangthem. 2025. “EzSQL: An SQL Intermediate Representation for Improving SQL-to-Text Generation.” Expert Systems with Applications 289: 128293. https://doi.org/10.1016/j.eswa.2025.128293
Bhasker, J. 1988. “Implementation of an Optimizing Compiler for VHDL.” ACM SIGPLAN Notices 23 (1): 92–108. https://doi.org/10.1145/44304.44313
Bhatt, Akanksha, Aayush Shrivastava, Manjaree Pandit, and Hari Mohan Dubey. 2014. “Cost and Profit Optimization of Integrated Wind-Thermal System by Dynamic Dispatch Using Swarm Intelligence.” In International Conference on Recent Advances and Innovations in Engineering (ICRAIE-2014). IEEE. https://doi.org/10.1109/icraie.2014.6909312
Bhosale, Akshay, Parinaz Barakhshan, Miguel Romero Rosas, and Rudolf Eigenmann. 2022. “Automatic and Interactive Program Parallelization Using the Cetus Source to Source Compiler Infrastructure v2.0.” Electronics 11 (5): 809. https://doi.org/10.3390/electronics11050809
Bian, Haocheng, and Chaoyuan Cui. 2026. “Memory-Efficient Inference for Neural Architecture Search Networks via Joint Optimization of Scheduling and Memory Layout.” In 2026 9th International Conference on Advanced Algorithms and Control Engineering (ICAACE). IEEE. https://doi.org/10.1109/icaace69793.2026.11509135
Bian, Yixiang, Hongzi Zhu, and Ziyang Lou. 2023. “Online Large-Scale Garbage Collection Scheduling: A Divide-and-Conquer Approach.” In 2022 IEEE 28th International Conference on Parallel and Distributed Systems (ICPADS). IEEE. https://doi.org/10.1109/icpads56603.2022.00058
Bik, Aart J. C., and Harry A. G. Wijshoff. 1994. “On Automatic Data Structure Selection and Code Generation for Sparse Computations.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57659-2_4
Binder, Walter. 2005. “A Portable and Customizable Profiling Framework for Java Based on Bytecode Instruction Counting.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/11575467_13
Binder, Walter, Jarle Hulaas, and Andrea Camesi. 2006. “Continuous Bytecode Instruction Counting for CPU Consumption Estimation.” In Third International Conference on the Quantitative Evaluation of Systems - (QEST’06). IEEE. https://doi.org/10.1109/qest.2006.12
Binder, Walter, Jarle Hulaas, and Philippe Moret. 2007b. “Reengineering Standard Java Runtime Systems through Dynamic Bytecode Instrumentation.” In Seventh IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2007). IEEE. https://doi.org/10.1109/scam.2007.4362901
Bingsheng He, Qiong Luo, and Byron Choi. 2006. “Cache-Conscious Automata for XML Filtering.” IEEE Transactions on Knowledge and Data Engineering 18 (12): 1629–44. https://doi.org/10.1109/tkde.2006.184
Binkley, David, Nicolas Gold, and Mark Harman. 2007. “An Empirical Study of Static Program Slice Size.” ACM Transactions on Software Engineering and Methodology 16 (2): 8. https://doi.org/10.1145/1217295.1217297
Binna, Robert, Dominic Pacher, Thomas Meindl, and Günther Specht. 2015. “The DCB-Tree: A Space-Efficient Delta Coded Cache Conscious B-Tree.” In In Memory Data Management and Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-13960-9_10
Bird, Peter L. 1982. “An Implementation of a Code Generator Specification Language for Table Driven Code Generators.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806979
Bird, R. S. 1987. “A Formal Development of an Efficient Supercombinator Compiler.” Science of Computer Programming 8 (2): 113–37. https://doi.org/10.1016/0167-6423(87)90017-7
Biri, Nicolas. 2022. “Dependent Tagless Final.” In Proceedings of the 2022 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3498886.3502201
Birka, Adrian, and Michael D. Ernst. 2004. “A Practical Type System and Language for Reference Immutability.” In Proceedings of the 19th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. ACM. https://doi.org/10.1145/1028976.1028980
Birkedal, Lars, and Rasmus Ejlers Mogelberg. 2013. “Intensional Type Theory with Guarded Recursive Types Qua Fixed Points on Universes.” In 2013 28th Annual ACM/IEEE Symposium on Logic in Computer Science. IEEE. https://doi.org/10.1109/lics.2013.27
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
Bisio, Rossella, and Fabio Malabocchia. 1995. “Cost Estimation of Software Projects through Case Base Reasoning.” In Case-Based Reasoning Research and Development. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60598-3_2
Bistarelli, Stefano, Marco Fiore, Ivan Mercanti, and Marina Mongiello. 2025. “Usage of Large Language Model for Code Generation Tasks: A Review.” SN Computer Science 6 (6): 673. https://doi.org/10.1007/s42979-025-04241-5
Blackman, T., J. Fox, and C. Rosebrugh. 1985. “The Silc™ Silicon Compiler: Language and Features.” In 22nd ACM/IEEE Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1985.1585946
Blaschka, Markus, Carsten Sapia, and Gabriele Höfling. 1999. “On Schema Evolution in Multidimensional Databases.” In DataWarehousing and Knowledge Discovery. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48298-9_17
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
Blazy, Sandrine. 2024. “From Mechanized Semantics to Verified Compilation: The Clight Semantics of CompCert.” In Fundamental Approaches to Software Engineering. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-57259-3_1
Blazy, Sandrine, Zaynah Dargaye, and Xavier Leroy. 2006. “Formal Verification of a C Compiler Front-End.” In FM 2006: Formal Methods. Springer Berlin Heidelberg. https://doi.org/10.1007/11813040_31
Blazy, Sandrine, Vincent Laporte, André Maroneze, and David Pichardie. 2013. “Formal Verification of a C Value Analysis Based on Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-38856-9_18
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
Bluemke, Ilona, and Agnieszka Malanowska. 2021. “Software Testing Effort Estimation and Related Problems: A Systematic Literature Review.” ACM Computing Surveys 54 (3): 1–38. https://doi.org/10.1145/3442694
Bochenek, A., J. Protasiewicz, and W. Pedrycz. 2026. “RAGdeterm: Deterministic Retrieval-Augmented Generation for Code Generation.” SoftwareX 34: 102636. https://doi.org/10.1016/j.softx.2026.102636
Bock, Florian, Sebastian Siegl, and Reinhard German. 2016. “Mathematical Test Effort Estimation for Dependability Assessment of Sensor-Based Driver Assistance Systems.” In 2016 42th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2016.49
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
Bodei, Chiara, Pierpaolo Degano, and Corrado Priami. 1998. “Constructing Specific SOS Semantics for Concurrency via Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-49727-7_10
Bodei, Chiara, and Corrado Priami. 1997. “True Concurrency via Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032743
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
Boehm, H.-J. 1989. “Type Inference in the Presence of Type Abstraction.” In Proceedings of the ACM SIGPLAN 1989 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/73141.74835
Boehm, Hans-Juergen. 1993. “Space Efficient Conservative Garbage Collection.” ACM SIGPLAN Notices 28 (6): 197–206. https://doi.org/10.1145/173262.155109
Boehm, Hans-J. 1996. “Simple Garbage-Collector-Safety.” In Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/231379.231394
Boehm, Hans J. 2004. “Space Efficient Conservative Garbage Collection.” ACM SIGPLAN Notices 39 (4): 490–501. https://doi.org/10.1145/989393.989442
Boehm, Hans-Juergen, and Mark Weiser. 1988. “Garbage Collection in an Uncooperative Environment.” Software: Practice and Experience 18 (9): 807–20. https://doi.org/10.1002/spe.4380180902
Böhm, Igor, Tobias J. K. Edler von Koch, Stephen C. Kyle, Björn Franke, and Nigel Topham. 2011. “Generalized Just-in-Time Trace Compilation Using a Parallel Task Farm in a Dynamic Binary Translator.” ACM SIGPLAN Notices 46 (6): 74–85. https://doi.org/10.1145/1993316.1993508
Böhm, Igor, Tobias J. K. Edler von Koch, Stephen C. Kyle, Björn Franke, and Nigel Topham. 2012. “Generalized Just-in-Time Trace Compilation Using a Parallel Task Farm in a Dynamic Binary Translator.” ACM SIGPLAN Notices 47 (6): 74. https://doi.org/10.1145/2345156.1993508
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
Bohn, Meyer P., and Bradley A. Miller. 2025. “Digital Soil Mapping via Machine Learning of Agronomic Properties for the Full Soil Profile at within-Field Resolution.” Agronomy Journal 117 (5): e70144. https://doi.org/10.1002/agj2.70144
Böke, Ekin, and Simon Torka. 2026. ““Digital Camouflage”: The LLVM Challenge in LLM-Based Malware Detection.” Journal of Systems and Software 231: 112646. https://doi.org/10.1016/j.jss.2025.112646
Boldo, Sylvie, Jacques-Henri Jourdan, Xavier Leroy, and Guillaume Melquiond. 2014. “Verified Compilation of Floating-Point Computations.” Journal of Automated Reasoning 54 (2): 135–63. https://doi.org/10.1007/s10817-014-9317-x
Bonetta, Daniele, Júnior Löff, Matteo Basso, and Walter Binder. 2025. “HeapBuffers: Why Not Just Using a Binary Serialization Format for Your Managed Memory?” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 3483–3507. https://doi.org/10.1145/3763175
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
Bonnaventure, William, Ahmed Khanfir, Alexandre Bartel, Mike Papadakis, and Yves Le Traon. 2021. “Confuzzion: A Java Virtual Machine Fuzzer for Type Confusion Vulnerabilities.” In 2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS). IEEE. https://doi.org/10.1109/qrs54544.2021.00069
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
Börger, Egon, and Wolfram Schulte. 1998. “Defining the Java Virtual Machine as Platform for Provably Correct Java Compilation.” In Mathematical Foundations of Computer Science 1998. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0055755
Borkowski, Andrzej Szymon, Magdalena Kładź, and Mikołaj Michalak. 2026. “BIM Collaboration Format (BCF) as an Example of Reification and Serialization in Building Information Modeling (BIM) Practice.” Buildings 16 (9): 1669. https://doi.org/10.3390/buildings16091669
Borodin, Alexey. 2014. “Summary Based Static Analysis for Practical Search for Defects in C Programs and Libraries.” In 2014 IEEE Seventh International Conference on Software Testing, Verification and Validation Workshops. IEEE. https://doi.org/10.1109/icstw.2014.60
Borowiec, Jan. 1977. “Pragmatics in a Compiler Production System.” In Methods of Algorithmic Language Implementation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-08065-1_21
Borozan, L., B. Borozan, and D. Ševerdija. 2026. “Efficient Checkpointing via Object Serialization in C# Applications.” In 2026 49th MIPRO ICT and Electronics Convention (MIPRO). IEEE. https://doi.org/10.1109/mipro70003.2026.11591542
Borozdukhin, Andrei, Olga Dolinina, and Vitaly Pechenkin. 2016. “Approach to the Garbage Collection in the “Smart Clean City” Project.” In 2016 4th IEEE International Colloquium on Information Science and Technology (CiSt). IEEE. https://doi.org/10.1109/cist.2016.7805019
Borrione, Dominique, and Ashraf Salem. 1995. “Denotational Semantics of a Synchronous VHDL Subset.” Formal Methods in System Design 7 (1–2): 53–71. https://doi.org/10.1007/bf01383873
Börzel, Stefan, and Jörg Frochte. 2019. “Case Study on Model-Based Application of Machine Learning Using Small CAD Databases for Cost Estimation.” In Proceedings of the 11th International Joint Conference on Knowledge Discovery, Knowledge Engineering and Knowledge Management. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0007979802580265
Bosch, Jan. 1996. “Delegating Compiler Objects: An Object-Oriented Approach to Grafting Compilers.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61053-7_71
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
Botbol, Vincent, Emmanuel Chailloux, and Tristan Le Gall. 2017. “Static Analysis of Communicating Processes Using Symbolic Transducers.” In Verification, Model Checking, and Abstract Interpretation. Springer International Publishing. https://doi.org/10.1007/978-3-319-52234-0_5
Bouajjani, Ahmed, Javier Esparza, and Tayssir Touili. 2003. “A Generic Approach to the Static Analysis of Concurrent Programs with Procedures.” ACM SIGPLAN Notices 38 (1): 62–73. https://doi.org/10.1145/640128.604137
Bouakaz, Adnan, Isabelle Puaut, and Erven Rohou. 2011. “Predictable Binary Code Cache: A First Step towards Reconciling Predictability and Just-in-Time Compilation.” In 2011 17th IEEE Real-Time and Embedded Technology and Applications Symposium. IEEE. https://doi.org/10.1109/rtas.2011.29
Boujida, Fatima, Fatima Amazal, and Ali Idri. 2021. “Neural Networks Based Software Development Effort Estimation: A Systematic Mapping Study.” In Proceedings of the 16th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010603700002992
Boujida, Fatima Ezzahra, Fatima Azzahra Amazal, and Ali Idri. 2024. “Neural Networks-Based Software Development Effort Estimation: A Systematic Literature Review.” Journal of Software: Evolution and Process 37 (2): e2756. https://doi.org/10.1002/smr.2756
Boujida, Fatima Ezzahra, Fatima Azzahra Amazal, and Ali Idri. 2026. “Generative Adversarial Networks-Based Software Development Effort Estimation for Small Datasets.” Scientific African 31: e03156. https://doi.org/10.1016/j.sciaf.2025.e03156
Boulton, Alex, and Tom Cobb. 2017. “Corpus Use in Language Learning: A Meta-Analysis.” Language Learning 67 (2): 348–93. https://doi.org/10.1111/lang.12224
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, Basile Pesin, and Marc Pouzet. 2023. “Verified Compilation of Synchronous Dataflow with State Machines.” ACM Transactions on Embedded Computing Systems 22 (5s): 1–26. https://doi.org/10.1145/3608102
Boutonnet, Rémy, and Nicolas Halbwachs. 2019. “Disjunctive Relational Abstract Interpretation for Interprocedural Program Analysis.” In Verification, Model Checking, and Abstract Interpretation. Springer International Publishing. https://doi.org/10.1007/978-3-030-11245-5_7
Bradshaw, John L. 1987. “The Brain Code: Mechanisms of Information Transfer and the Role of the Corpus Callosum.” Neuropsychologia 25 (5): 849–50. https://doi.org/10.1016/0028-3932(87)90124-2
Brahmakshatriya, Ajay, and Saman Amarasinghe. 2021. “BuildIt: A Type-Based Multi-Stage Programming Framework for Code Generation in C++.” In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo51591.2021.9370333
Brahmakshatriya, Ajay, and Saman Amarasinghe. 2022. “GraphIt to CUDA Compiler in 2021 LOC: A Case for High-Performance DSL Implementation via Staging with BuilDSL.” In 2022 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo53902.2022.9741280
Brandner, Florian, Tommy Thorn, and Martin Schoeberl. 2009. “Embedded JIT Compilation with CACAO on YARI.” In 2009 IEEE International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing. IEEE. https://doi.org/10.1109/isorc.2009.20
Brandt, Steven R., Hari Krishnan, Costas Busch, and Gokarna Sharma. 2018. “Distributed Garbage Collection for General Graphs.” ACM SIGPLAN Notices 53 (5): 29–44. https://doi.org/10.1145/3299706.3210572
Brar, Pooja, and Deepak Nandal. 2022. “A Systematic Literature Review of Machine Learning Techniques for Software Effort Estimation Models.” In 2022 Fifth International Conference on Computational Intelligence and Communication Technologies (CCICT). IEEE. https://doi.org/10.1109/ccict56684.2022.00093
Brat, Guillaume, Jorge A. Navas, Nija Shi, and Arnaud Venet. 2014. “IKOS: A Framework for Static Analysis Based on Abstract Interpretation.” In Software Engineering and Formal Methods. Springer International Publishing. https://doi.org/10.1007/978-3-319-10431-7_20
Braun, T., I. Chrisment, C. Diot, F. Gagnon, and L. Gautier. 1996. “ALFred, a Protocol Compiler for the Automated Implementation of Distributed Applications.” In Proceedings of 5th IEEE International Symposium on High Performance Distributed Computing HPDC-96. IEEE. https://doi.org/10.1109/hpdc.1996.546216
Braz, Marcio, and Silvia Vergilio. 2006. “Software Effort Estimation Based on Use Cases.” In 30th Annual International Computer Software and Applications Conference (COMPSAC’06). IEEE. https://doi.org/10.1109/compsac.2006.77
“Breaker Pages: Session I: Formal Verification.” 2008. In 2008 6th ACM/IEEE International Conference on Formal Methods and Models for Co-Design. IEEE. https://doi.org/10.1109/memcod.2008.4547680
Breg, Fabian, and Constantine D. Polychronopoulos. 2003. “Java Virtual Machine Support for Object Serialization.” Concurrency and Computation: Practice and Experience 15 (3–5): 263–75. https://doi.org/10.1002/cpe.667
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
Brewster, Neil V., and Tarek S. Abdelrahman. 2001. “A Compiler Infrastructure for High-Performance Java⋆.” In High-Performance Computing and Networking. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48228-8_77
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
Briggs, Kim T., Baoguo Zhou, and Gerhard W. Dueck. 2016. “Cold Object Identification in the Java Virtual Machine.” Software: Practice and Experience 47 (1): 79–95. https://doi.org/10.1002/spe.2396
Britto, Ricardo, Vitor Freitas, Emilia Mendes, and Muhammad Usman. 2014b. “Effort Estimation in Global Software Development: A Systematic Literature Review.” In 2014 IEEE 9th International Conference on Global Software Engineering. IEEE. https://doi.org/10.1109/icgse.2014.11
Britto, Ricardo, Emilia Mendes, and Jurgen Borstler. 2015. “An Empirical Investigation on Effort Estimation in Agile Global Software Development.” In 2015 IEEE 10th International Conference on Global Software Engineering. IEEE. https://doi.org/10.1109/icgse.2015.10
Britto, Ricardo, Emilia Mendes, and Claes Wohlin. 2016. “A Specialized Global Software Engineering Taxonomy for Effort Estimation.” In 2016 IEEE 11th International Conference on Global Software Engineering (ICGSE). IEEE. https://doi.org/10.1109/icgse.2016.11
Britto, Ricardo, Muhammad Usman, and Emilia Mendes. 2014a. “Effort Estimation in Agile Global Software Development Context.” In Agile Methods. Large-Scale Development, Refactoring, Testing, and Estimation. Springer International Publishing. https://doi.org/10.1007/978-3-319-14358-3_15
Brockschmidt, Marc, Carsten Otto, Christian von Essen, and Jürgen Giesl. 2010. “Termination Graphs for Java Bytecode.” In Verification, Induction, Termination Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-17172-7_2
Brockschmidt, Marc, Thomas Ströder, Carsten Otto, and Jürgen Giesl. 2012. “Automated Detection of Non-Termination and NullPointerExceptions for Java Bytecode.” In Formal Verification of Object-Oriented Software. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-31762-0_9
Brooks, Rodney A., Richard P. Gabriel, and Guy L. Steele. 1982. “An Optimizing Compiler for Lexically Scoped LISP.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.807000
Brown, Nick. 2024. “Fully Integrating the Flang Fortran Compiler with Standard MLIR.” In SC24-W: Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/scw63240.2024.00133
Brunel, Julien, and Jacques Cazin. 2012. “Formal Verification of a Safety Argumentation and Application to a Complex UAV System.” In Computer Safety, Reliability, and Security. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-33675-1_27
Bruno, Rodrigo, and Paulo Ferreira. 2018. “A Study on Garbage Collection Algorithms for Big Data Environments.” ACM Computing Surveys 51 (1): 1–35. https://doi.org/10.1145/3156818
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
Brunthaler, Stefan. 2010b. “Inline Caching Meets Quickening.” In ECOOP 2010 – Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-14107-2_21
Brzeziński, Tomasz. 2002. “The Structure of Corings: Induction Functors, Maschke-Type Theorem, and Frobenius and Galois-Type Properties.” Algebras and Representation Theory 5 (4): 389–410. https://doi.org/10.1023/a:1020139620841
Bui, Thanh-Long, Hoa Khanh Dam, and Rashina Hoda. 2025. “An LLM-Based Multi-Agent Framework for Agile Effort Estimation.” In 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE. https://doi.org/10.1109/ase63991.2025.00090
Bulic, P., and V. Gustin. 2003. “Practical Dependence Analysis in a SIMD Vectorizing Compiler.” In Eleventh Euromicro Conference on Parallel, Distributed and Network-Based Processing, 2003. Proceedings.. IEEE. https://doi.org/10.1109/empdp.2003.1183564
Bulic, P., and V. Gustin. 2004. “Fast Dependence Analysis in a Multimedia Vectorizing Compiler.” In 12th Euromicro Conference on Parallel, Distributed and Network-Based Processing, 2004. Proceedings.. IEEE. https://doi.org/10.1109/empdp.2004.1271443
Burgess, Colin J., and Martin Lefley. 2001. “Can Genetic Programming Improve Software Effort Estimation? A Comparative Evaluation.” Information and Software Technology 43 (14): 863–73. https://doi.org/10.1016/s0950-5849(01)00192-6
Burlet, Gregory, and Abram Hindle. 2015. “An Empirical Study of End-User Programmers in the Computer Music Community.” In 2015 IEEE/ACM 12th Working Conference on Mining Software Repositories. IEEE. https://doi.org/10.1109/msr.2015.34
Burlyaev, Dmitry, and Pascal Fradet. 2015. “Formal Verification of Automatic Circuit Transformations for Fault-Tolerance.” In 2015 Formal Methods in Computer-Aided Design (FMCAD). IEEE. https://doi.org/10.1109/fmcad.2015.7542251
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
Burn, Geoffrey, and Daniel Métayer. 1993. “Proving the Correctness of Compiler Optimisations Based on Strictness Analysis.” In Progamming Language Implementation and Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57186-8_90
Burrows, Rachel, Fabiano C. Ferrari, Otavio A. L. Lemos, Alessandro Garcia, and Francois Taiani. 2010. “The Impact of Coupling on the Fault-Proneness of Aspect-Oriented Programs: An Empirical Study.” In 2010 IEEE 21st International Symposium on Software Reliability Engineering. IEEE. https://doi.org/10.1109/issre.2010.33
Buth, Bettina, Karl-Heinz Buth, Martin Fränzle, et al. 1992. “Provably Correct Compiler Development and Implementation.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-55984-1_14
Buyukkurt, Betul, and Walid A. Najj. 2008. “Compiler Generated Systolic Arrays for Wavefront Algorithm Acceleration on FPGAs.” In 2008 International Conference on Field Programmable Logic and Applications. IEEE. https://doi.org/10.1109/fpl.2008.4630032
Büzgülü, Yasin, Selim Akyokuş, and Salih Sarp. 2026. “LLM Based Code Generation and Code Integration with Multi-Agent Systems.” In 2026 34th Signal Processing and Communications Applications Conference (SIU). IEEE. https://doi.org/10.1109/siu71813.2026.11636409
Byun, Kyungjin, Bon-Tae Koo, and Nak-Woong Eum. 2008. “Cost-Effective Implementation of TETRA Codec Using the Primitive Functions of the Compiler.” In 2008 2nd International Conference on Signal Processing and Communication Systems. IEEE. https://doi.org/10.1109/icspcs.2008.4813690
Børte, Kristin, Sten R. Ludvigsen, and Anders I. Mørch. 2012. “The Role of Social Interaction in Software Effort Estimation: Unpacking the “Magic Step” between Reasoning and Decision-Making.” Information and Software Technology 54 (9): 985–96. https://doi.org/10.1016/j.infsof.2012.03.002
Cabral, José Thiago H. de A., Adriano L. I. Oliveira, and Fabio Q. B. da Silva. 2023. “Ensemble Effort Estimation: An Updated and Extended Systematic Literature Review.” Journal of Systems and Software 195: 111542. https://doi.org/10.1016/j.jss.2022.111542
Cai, Qingfeng, Jiao Chen, and Jianbo Lin. 2009b. “Institutional Investors, Equity Incentive and Executive Compensation: An Empirical Study Based on Conflict of Interest.” In 2009 International Conference on Computational Intelligence and Software Engineering. IEEE. https://doi.org/10.1109/cise.2009.5362717
Cai, Yixiang, Yubiao Pan, and Huizhen Zhang. 2026. “VGKV: Variable Granularity Garbage Collection with SSTable Management for KV Separation.” Future Generation Computer Systems 183: 108525. https://doi.org/10.1016/j.future.2026.108525
Cai, Hao, and Andy J. Wellings. 2003. “Towards a High Integrity Real-Time Java Virtual Machine.” In On The Move to Meaningful Internet Systems 2003: OTM 2003 Workshops. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39962-9_41
Calder, Brad, Chandra Krintz, Simmi John, and Todd Austin. 1998. “Cache-Conscious Data Placement.” ACM SIGPLAN Notices 33 (11): 139–49. https://doi.org/10.1145/291006.291036
“Call for Papers for the IEEE Transactions on Software Engineering Special Issue on Mining Software Repositories.” 2004. IEEE Transactions on Software Engineering 30 (10): 712–712. https://doi.org/10.1109/tse.2004.57
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
Callanan, S., R. Grosu, Xiaowan Huang, S. A. Smolka, and E. Zadok. 2006. “Compiler-Assisted Software Verification Using Plug-Ins.” In Proceedings 20th IEEE International Parallel & Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2006.1639579
Camacho, Thais, Lucas Alvarenga, Marcio Pereira, and Guido Araujo. 2026. “Using Task Graph Caching to Accelerate TVM Code Generation.” ACM Transactions on Architecture and Code Optimization 23 (2): 1–26. https://doi.org/10.1145/3810246
Campanelli, Giampiero. 2024. “Scientific Research, Sponsorship and Conflict of Interest: Unavoidable Pathway or the Only Way?” Hernia 28 (5): 1493–1493. https://doi.org/10.1007/s10029-024-03180-z
Campanoni, Simone, Martino Sykora, Giovanni Agosta, and Stefano Crespi Reghizzi. 2009. “Dynamic Look Ahead Compilation: A Technique to Hide JIT Compilation Latencies in Multicore Environment.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-00722-4_16
Campion, Marco, Mila Dalla Preda, and Roberto Giacobazzi. 2019. “Abstract Interpretation of Indexed Grammars.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-32304-2_7
Campos, Gabriel, and Frank Affonso. 2025. “DynaSchema: A Library to Support the Relational Data Schema Evolution for the Self-Adaptive Software Domain.” In Proceedings of the 27th International Conference on Enterprise Information Systems. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013349000003929
Campos, Leonardo, Alisson Marques da Silva, and Mirela Cazzolato. 2026. “Mutual Information Maximization for Data Enrichment and Enhancement of Predictive Models in Software Effort Estimation.” In Proceedings of the 28th International Conference on Enterprise Information Systems. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0014721200004018
Camurati, P., and P. Prinetto. 1988. “Formal Verification of Hardware Correctness: Introduction and Survey of Current Research.” Computer 21 (7): 8–19. https://doi.org/10.1109/2.65
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
Canedo, Arquimedes, and Jan H. Richter. 2014. “Architectural Design Space Exploration of Cyber-Physical Systems Using the Functional Modeling Compiler.” Procedia CIRP 21: 46–51. https://doi.org/10.1016/j.procir.2014.03.183
Canedo, Arquimedes, Jiang Wan, and Mohammad Abdullah Al Faruque. 2014. “Functional Modeling Compiler for System-Level Design of Automotive Cyber-Physical Systems.” In 2014 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE. https://doi.org/10.1109/iccad.2014.7001327
Cao, Shiyi, Salvatore Di Girolamo, and Torsten Hoefler. 2022. “Accelerating Data Serialization/Deserialization Protocols with in-Network Compute.” In 2022 IEEE/ACM International Workshop on Exascale MPI (ExaMPI). IEEE. https://doi.org/10.1109/exampi56604.2022.00008
Cao, Zhen, Yuan Dong, and Shengyuan Wang. 2011. “Compiler Backend Generation for Application Specific Instruction Set Processors.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-25318-8_12
Capilla, Rafael, Francisco Nava, and Carlos Carrillo. 2008. “Effort Estimation in Capturing Architectural Knowledge.” In 2008 23rd IEEE/ACM International Conference on Automated Software Engineering. IEEE. https://doi.org/10.1109/ase.2008.31
Capiluppi, Andrea, and Daniel Izquierdo-Cortázar. 2011. “Effort Estimation of FLOSS Projects: A Study of the Linux Kernel.” Empirical Software Engineering 18 (1): 60–88. https://doi.org/10.1007/s10664-011-9191-7
Carabaño, Jesús, Jan Westerholm, and Tapani Sarjakoski. 2017. “A Compiler Approach to Map Algebra: Automatic Parallelization, Locality Optimization, and GPU Acceleration of Raster Spatial Analysis.” GeoInformatica 22 (2): 211–35. https://doi.org/10.1007/s10707-017-0312-3
Carbon, Alexandre, Yves Lhuillier, and Henri-Pierre Charles. 2013. “Hardware Acceleration for Just-In-Time Compilation on Heterogeneous Embedded Systems.” In 2013 IEEE 24th International Conference on Application-Specific Systems, Architectures and Processors. IEEE. https://doi.org/10.1109/asap.2013.6567576
Carbon, Alexandre, Yves Lhuillier, and Henri-Pierre Charles. 2014. “Hardware Acceleration of Red-Black Tree Management and Application to Just-In-Time Compilation.” Journal of Signal Processing Systems 77 (1–2): 95–115. https://doi.org/10.1007/s11265-014-0902-3
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
Carr, Steve, Kathryn S. McKinley, and Chau-Wen Tseng. 1994. “Compiler Optimizations for Improving Data Locality.” ACM SIGPLAN Notices 29 (11): 252–62. https://doi.org/10.1145/195470.195557
Carrier, Camille. 1998. “Employee Creativity and Suggestion Programs: An Empirical Study.” Creativity and Innovation Management 7 (2): 62–72. https://doi.org/10.1111/1467-8691.00090
Carter, Larry, Jeanne Ferrante, and Vasanth Bala. 1994. “XDP: A Compiler Intermediate Language Extension for the Representation and Optimization of Data Movement.” International Journal of Parallel Programming 22 (5): 485–518. https://doi.org/10.1007/bf02577776
Carvalho, Halcyon. 2020. “Ensemble Regression Models for Software Development Effort Estimation: A Comparative Study.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.3641445
Cashman, Dylan, Shenyu Xu, Subhajit Das, et al. 2021. “CAVA: A Visual Analytics System for Exploratory Columnar Data Augmentation Using Knowledge Graphs.” IEEE Transactions on Visualization and Computer Graphics 27 (2): 1731–41. https://doi.org/10.1109/tvcg.2020.3030443
Catalao, Tiago, and Mario de Sousa. 2020. “IEC 61131-3 Front-End for the LLVM Compiler Family.” In 2020 25th IEEE International Conference on Emerging Technologies and Factory Automation (ETFA). IEEE. https://doi.org/10.1109/etfa46521.2020.9211921
Catta, Davide, Jean Leneutre, Antonina Mijatovic, Johanna Ulin, and Vadim Malvone. 2024. “A Formal Verification Approach to Handle Attack Graphs.” In Proceedings of the 16th International Conference on Agents and Artificial Intelligence. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0012310000003636
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
Causer, A. D. 1972. “The Implementation of an in-Core Compiler.” International Journal of Mathematical Education in Science and Technology 3 (3): 281–85. https://doi.org/10.1080/0020739700030310
Čeke, Denis, and Boris Milašinović. 2015. “Early Effort Estimation in Web Application Development.” Journal of Systems and Software 103: 219–37. https://doi.org/10.1016/j.jss.2015.02.006
Ceresnik, Peter, Branislav Mados, Anton Balaz, and Zuzana Bilanova. 2019. “SSVDAG*: Efficient Volume Data Representation Using Enhanced Symmetry-Aware Sparse Voxel Directed Acyclic Graph.” In 2019 IEEE 15th International Scientific Conference on Informatics. IEEE. https://doi.org/10.1109/informatics47936.2019.9119298
Cha, Chang-Il, Hyung-Jun Kim, Kyu-Jeong Hwang, Sang-Wook Kim, Sang-Yun Lee, and Hee-Sun Won. 2006. “Garbage Collection in an Embedded Java Virtual Machine.” In Knowledge-Based Intelligent Information and Engineering Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/11892960_54
Chai, Yi, Xueqin Lin, and Dai Wang. 2021b. “Industrial Structure Transformation and Layout Optimization of Beijing-Tianjin-Hebei Region under Carbon Emission Constraints.” Sustainability 13 (2): 643. https://doi.org/10.3390/su13020643
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
Chakraborty, Soham Sundar, and Rajeev Kumar. 2007. “Static Analysis Based Application Specific Dispatch Table Compaction.” In 15th International Conference on Advanced Computing and Communications (ADCOM 2007). IEEE. https://doi.org/10.1109/adcom.2007.117
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
Chambers, C., and D. Ungar. 1989. “Customization: Optimizing Compiler Technology for SELF, a Dynamically-Typed Object-Oriented Programming Language.” ACM SIGPLAN Notices 24 (7): 146–60. https://doi.org/10.1145/74818.74831
Chan, Sun C., Guang R. Gao, Barbara Chapman, Tony Linthicum, and Anshuman Dasgupta. 2008. “Open64 Compiler Infrastructure for Emerging Multicore/manycore Architecture All Symposium Tutorial.” In 2008 IEEE International Symposium on Parallel and Distributed Processing. IEEE. https://doi.org/10.1109/ipdps.2008.4536577
Chandra, Deepak, and Michael Franz. 2007. “Fine-Grained Information Flow Analysis and Enforcement in a Java Virtual Machine.” In Twenty-Third Annual Computer Security Applications Conference (ACSAC 2007). IEEE. https://doi.org/10.1109/acsac.2007.37
Chang, Hsung-Pin, Ray-I. Chang, Wei-Kuan Shih, and Ruei-Chuan Chang. 2004. “Real-Time Disk Scheduling with on-Disk Cache Conscious.” In Real-Time and Embedded Computing Systems and Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24686-2_6
Chang, Mason, Bernd Mathiske, Edwin Smith, et al. 2011. “The Impact of Optional Type Information on Jit Compilation of Dynamically Typed Languages.” ACM SIGPLAN Notices 47 (2): 13–24. https://doi.org/10.1145/2168696.2047853
Chang, Yang, and Andy Wellings. 2006. “Hard Real-Time Hybrid Garbage Collection with Low Memory Requirements.” In 2006 27th IEEE International Real-Time Systems Symposium (RTSS’06). IEEE. https://doi.org/10.1109/rtss.2006.25
Chang, Yang, and Andy Wellings. 2010. “Garbage Collection for Flexible Hard Real-Time Systems.” IEEE Transactions on Computers 59 (8): 1063–75. https://doi.org/10.1109/tc.2010.13
Chao, Guoqing, Jingyao Liu, Mingyu Wang, and Dianhui Chu. 2023. “Data Augmentation for Sentiment Classification with Semantic Preservation and Diversity.” Knowledge-Based Systems 280: 111038. https://doi.org/10.1016/j.knosys.2023.111038
Chapman, Barbara, Deepak Eachempati, and Oscar Hernandez. 2012. “Experiences Developing the OpenUH Compiler and Runtime Infrastructure.” International Journal of Parallel Programming 41 (6): 825–54. https://doi.org/10.1007/s10766-012-0230-9
Chapoutot, Alexandre, and Matthieu Martel. 2009. “Abstract Simulation: A Static Analysis of Simulink Models.” In 2009 International Conference on Embedded Software and Systems. IEEE. https://doi.org/10.1109/icess.2009.80
“Chapter 4: Linking the Management Structure to the Canal Network Layout.” 1992. Agricultural Water Management 22 (1–2): 65–77. https://doi.org/10.1016/0378-3774(92)90065-5
Charatonik, Witold, and Andreas Podelski. 1998. “Directional Type Inference for Logic Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-49727-7_17
Charlier, Baudouin, Olivier Degimbe, Laurent Michel, and Pascal Hentenryck. 1993. “Optimization Techniques for General Purpose Fixpoint Algorithms Practical Efficiency for the Abstract Interpretation of Prolog.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57264-3_26
Charmchi, Niloofar, Caroline Collange, and Andre Seznec. 2019. “Compressed Cache Layout Aware Prefetching.” In 2019 31st International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD). IEEE. https://doi.org/10.1109/sbac-pad.2019.00017
Charreteur, Florence, and Arnaud Gotlieb. 2010. “Constraint-Based Test Input Generation for Java Bytecode.” In 2010 IEEE 21st International Symposium on Software Reliability Engineering. IEEE. https://doi.org/10.1109/issre.2010.26
Charvat, Luka, Ales Smrcka, and Toma Vojnar. 2014. “Using Formal Verification of Parameterized Systems in RAW Hazard Analysis in Microprocessors.” In 2014 15th International Microprocessor Test and Verification Workshop. IEEE. https://doi.org/10.1109/mtv.2014.21
Chatterjee, Avimita, Subrata Das, and Swaroop Ghosh. 2025. “Q-Pandora Unboxed: Characterizing Resilience of Quantum Error Correction Codes under Biased Noise.” Applied Sciences 15 (8): 4555. https://doi.org/10.3390/app15084555
Chattopadhyay, Sudipta, and Abhik Roychoudhury. 2009. “Unified Cache Modeling for WCET Analysis and Layout Optimizations.” In 2009 30th IEEE Real-Time Systems Symposium. IEEE. https://doi.org/10.1109/rtss.2009.20
Chattopadhyay, Sneha, M. J. Tresina, and Shankar Narayan. 2012. “Worst Case Execution Time Analysis of Automotive Software.” Procedia Engineering 30: 983–88. https://doi.org/10.1016/j.proeng.2012.01.954
Chau, K. K., I.-F. Wang, and C. L. Eldridge. 1991. “VLSI Implementation of a 2-D DCT in a Compiler.” In [Proceedings] ICASSP 91: 1991 International Conference on Acoustics, Speech, and Signal Processing. IEEE. https://doi.org/10.1109/icassp.1991.150616
Chavan, Akshay, Pranathi Kunadi, Nidhi Wader, and Shirish Sane. 2021. “Proposing a Semantic Analysis Based Sanskrit Compiler by Mapping Sanskrit’s Linguistic Features with Compiler Phases.” In 2021 Second International Conference on Electronics and Sustainable Communication Systems (ICESC). IEEE. https://doi.org/10.1109/icesc51422.2021.9532969
Cheatham, Thomas, Haiming Gao, and Dan Stefanescu. 1994. “A Suite of Analysis Tools Based on a General Purpose Abstract Interpreter.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57877-3_13
Chelius, Guillaume, and Éric Fleury. 2000. “An IP Next Generation Compliant Java™ Virtual Machine.” In Parallel and Distributed Processing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45591-4_72
Chen, Juan. 2007. “A Typed Intermediate Language for Compiling Multiple Inheritance.” ACM SIGPLAN Notices 42 (1): 25–30. https://doi.org/10.1145/1190215.1190222
Chen, Xiao. 2009a. “An Improved Method of Zero-Copy Data Transmission in the High Speed Network Environment.” In 2009 International Conference on Multimedia Information Networking and Security. IEEE. https://doi.org/10.1109/mines.2009.53
Chen, Yi-Ting, Lauren Capelluto, Ryan Shaffer, and Jeffrey Heckey. 2025h. “Rule-Based Hardware-Configurable Static Analysis for Quantum Programs.” In 2025 IEEE International Conference on Quantum Computing and Engineering (QCE). IEEE. https://doi.org/10.1109/qce65121.2025.00087
Chen, Liqian, Taoqing Chen, Guangsheng Fan, and Banghu Yin. 2021b. “Static Analysis of Resource Usage Bounds for Imperative Programs.” In 2021 28th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec53868.2021.00077
Chen, Xiangping, Junqi Chen, Zhilu Lian, et al. 2025a. “An Alternative to Code Comment Generation? Generating Comment from Bytecode.” Information and Software Technology 179: 107623. https://doi.org/10.1016/j.infsof.2024.107623
Chen, Zhifei, Lin Chen, and Baowen Xu. 2014. “Hybrid Information Flow Analysis for Python Bytecode.” In 2014 11th Web Information System and Application Conference. IEEE. https://doi.org/10.1109/wisa.2014.26
Chen, Hanfeng, Wai-Mee Ching, and Laurie Hendren. 2017. “An ELI-to-C Compiler: Design, Implementation, and Performance.” In Proceedings of the 4th ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming. ACM. https://doi.org/10.1145/3091966.3091969
Chen, Yi-Chung, Micheal Floyd, Ryan Black, and M. Saleh Zein-Sabatto. 2020. “Compiler-Based Hardware Profiling for Software-Defined Architecture.” In 2020 SoutheastCon. IEEE. https://doi.org/10.1109/southeastcon44009.2020.9249733
Chen, Yang, Alex Groce, Chaoqiang Zhang, et al. 2013b. “Taming Compiler Fuzzers.” In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2491956.2462173
Chen, Tianyi, Xiaotong Guan, Shi Shuai, Cuiting Huang, and Michal Aibin. 2024. “Lite2: A Schemaless Zero-Copy Serialization Format.” Computers 13 (4): 89. https://doi.org/10.3390/computers13040089
Chen, Bochuan, Xiao Guo, Yuting Chen, Xiaofeng Yu, and Lei Bu. 2023a. “Constructing Exception Handling Chains for Testing Java Virtual Machine Implementations.” Journal of Software: Evolution and Process 36 (4): e2562. https://doi.org/10.1002/smr.2562
Chen, G., and M. Kandemir. 2005. “Improving Java Virtual Machine Reliability for Memory-Constrained Embedded Systems.” In Proceedings. 42nd Design Automation Conference, 2005.. IEEE. https://doi.org/10.1109/dac.2005.193900
Chen, Ching-Wen, and Chang-Jung Ku. 2011. “A Tagless Cache Design for Power Saving in Embedded Systems.” Journal of Supercomputing 62 (1): 174–98. https://doi.org/10.1007/s11227-011-0694-1
Chen, Guangyu, Feihui Li, Mahmut Kandemir, and Mary Jane Irwin. 2006. “Reducing NoC Energy Consumption through Compiler-Directed Channel Voltage Scaling.” In Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/1133981.1134004
Chen, Whai-En, Yi-Bing Lin, Tai-Hsiang Yen, Syuan-Ru Peng, and Yun-Wei Lin. 2022a. “DeviceTalk: A No-Code Low-Code IoT Device Code Generation.” Sensors 22 (13): 4942. https://doi.org/10.3390/s22134942
Chen, Jia-Lin, Dennis McLeod, and Daniel O’Leary. 1995. “Domain-Knowledge-Guided Schema Evolution for Accounting Database Systems.” Expert Systems with Applications 9 (4): 491–501. https://doi.org/10.1016/0957-4174(95)00019-4
Chen, Zuxi, Chuanjun Niu, Meng Mei, and Hongyang Zhang. 2025c. “Hierarchical Safety Analysis and Formal Verification for Safety-Critical Systems Using STAMP and Event-B.” Safety Science 184: 106744. https://doi.org/10.1016/j.ssci.2024.106744
Chen, Xianzhang, Edwin Hsing-Mean Sha, Qingfeng Zhuge, Chun Jason Xue, Weiwen Jiang, and Yuangang Wang. 2016. “Efficient Data Placement for Improving Data Access Performance on Domain-Wall Memory.” IEEE Transactions on Very Large Scale Integration (VLSI) Systems 24 (10): 3094–3104. https://doi.org/10.1109/tvlsi.2016.2537400
Chen, Yuanfang, Qingchuan Shi, and Xiaoming Li. 2018a. “CSSMT: Compiler Based Software Simultaneous Multithreading (SMT).” In 2018 26th Euromicro International Conference on Parallel, Distributed and Network-based Processing (PDP). IEEE. https://doi.org/10.1109/pdp2018.2018.00017
Chen, Xinguang, Fengdi Shu, and Ye Yang. 2011. “Software Effort Estimation Model Based on Use Case Specification.” In Proceedings of the 6th International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0003463302260231
Chen, Jian, and John Staples. 1993. “Defining Soft Sortedness by Abstract Interpretation.” In Mathematical Foundations of Computer Science 1993. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57182-5_28
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, Juan, and David Tarditi. 2005. “A Simple Typed Intermediate Language for Object-Oriented Languages.” ACM SIGPLAN Notices 40 (1): 38–49. https://doi.org/10.1145/1047659.1040309
Chen, Tse-Hsun, Stephen W. Thomas, and Ahmed E. Hassan. 2015. “A Survey on the Use of Topic Models When Mining Software Repositories.” Empirical Software Engineering 21 (5): 1843–1919. https://doi.org/10.1007/s10664-015-9402-8
Chen, Yuexi, Gauri Vaidya, Alison O’Connor, and Meghana Kshirsagar. 2026. “From Natural Language to Interpretable Code: Automated Code Generation for Healthcare with Large Language Models: A Comparative Analysis.” In Proceedings of the 18th International Conference on Agents and Artificial Intelligence. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0014717000004052
Chen, Xingrong, and Qianmei Yang. 2022. “Speed and Power Tradeoff Based on FinFET Structure, Voltage Changing and Circuit Layout.” In 2022 IEEE 5th International Conference on Automation, Electronics and Electrical Engineering (AUTEEE). IEEE. https://doi.org/10.1109/auteee56487.2022.9994548
Chen, Hechong, Fan Yang, Zhichun Yang, Chao Wang, Yu Chen, and Lingyan Sun. 2025f. “Research on Massive DER Dynamic Dispatch Information Model for Distribution Areas Based on IEC 61850 DER Dynamic Dispatch Information Model.” In 2025 5th International Conference on Electrical Engineering and Mechatronics Technology (ICEEMT). IEEE. https://doi.org/10.1109/iceemt66565.2025.11280858
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, Jinfu, Jiapeng Zhou, Wei Lin, et al. 2025d. “A Novel Vulnerability-Detection Method Based on the Semantic Features of Source Code and the LLVM Intermediate Representation.” Journal of Software: Evolution and Process 37 (5): e70026. https://doi.org/10.1002/smr.70026
Cheney, James, and Morten Dahl. 2008. “Resource Bound Analysis for Database Queries.” In Proceedings of the third ACM SIGPLAN workshop on Programming languages and analysis for security. ACM. https://doi.org/10.1145/1375696.1375706
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, 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
Cheng, Gang, and Zhang Yun-Zheng. 1992. “A “Functional + Logic” Programming Language in Interpretation-Compilation Implementation.” Lisp and Symbolic Computation 5 (3): 133–56. https://doi.org/10.1007/bf01807503
Chenou, Jules, Laurent Njilla, Aurelia William, and Tonya Fields. 2023. “FPGA Formal Verification: A Local Logic Correctness Approach.” In 2023 Congress in Computer Science, Computer Engineering, & Applied Computing (CSCE). IEEE. https://doi.org/10.1109/csce60160.2023.00364
Cheong, H., and A. V. Veidenbaum. 1990. “Compiler-Directed Cache Management in Multiprocessors.” Computer 23 (6): 39–47. https://doi.org/10.1109/2.55499
Cheptsov, Vitaly, and Alexey Khoroshilov. 2018. “Dynamic Analysis of ARINC 653 RTOS with LLVM.” In 2018 Ivannikov Ispras Open Conference (ISPRAS). IEEE. https://doi.org/10.1109/ispras.2018.00009
Cheshmi, Kazem, Guanzheng Xu, Saman A. Zonouz, and Maryam Mehri Dehnavi. 2016. “Axb: A Compiler for Sparse Direct Solvers.” In 2016 IEEE Conference on Electromagnetic Field Computation (CEFC). IEEE. https://doi.org/10.1109/cefc.2016.7816364
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
Chiang, Mei-Ling, and Yun-Chen Li. 2006. “LyraNET: A Zero-Copy TCP/IP Protocol Stack for Embedded Systems.” Real-Time Systems 34 (1): 5–18. https://doi.org/10.1007/s11241-006-6879-7
Chichereau, Brice, Stéphane Vialle, and Patrick Carribault. 2023. “Experimenting with Hybrid Quantum Optimization in HPC Software Stack for CPU Register Allocation.” In 2023 IEEE International Conference on Quantum Computing and Engineering (QCE). IEEE. https://doi.org/10.1109/qce57702.2023.10197
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
Chilimbi, Trishul M., Bob Davidson, and James R. Larus. 1999a. “Cache-Conscious Structure Definition.” In Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/301618.301635
Chilimbi, Trishul M., Mark D. Hill, and James R. Larus. 1999b. “Cache-Conscious Structure Layout.” In Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/301618.301633
Chilimbi, Trishul M., and James R. Larus. 1998. “Using Generational Garbage Collection to Implement Cache-Conscious Data Placement.” ACM SIGPLAN Notices 34 (3): 37–48. https://doi.org/10.1145/301589.286865
Chilimbi, Trishul M., and Ran Shaham. 2006. “Cache-Conscious Coallocation of Hot Data Streams.” ACM SIGPLAN Notices 41 (6): 252–62. https://doi.org/10.1145/1133255.1134011
Chirica, Laurian M., and David F. Martin. 1975. “An Approach to Compiler Correctness.” ACM SIGPLAN Notices 10 (6): 96–103. https://doi.org/10.1145/390016.808428
Chirica, Laurian M., and David F. Martin. 1986. “Toward Compiler Implementation Correctness Proofs.” ACM Transactions on Programming Languages and Systems 8 (2): 185–214. https://doi.org/10.1145/5397.30847
Chitre, Khushboo, Piyus Kedia, and Rahul Purandare. 2022. “The Road Not Taken: Exploring Alias Analysis Based Optimizations Missed by the Compiler.” Proceedings of the ACM on Programming Languages 6 (OOPSLA2): 786–810. https://doi.org/10.1145/3563316
Chiu, Nan-Hsing, and Sun-Jen Huang. 2007. “The Adjusted Analogy-Based Software Effort Estimation Based on Similarity Distances.” Journal of Systems and Software 80 (4): 628–40. https://doi.org/10.1016/j.jss.2006.06.006
Chiueh, Tzi-cker. 1991. “An Architectural Technique for Cache-Level Garbage Collection.” In Functional Programming Languages and Computer Architecture. Springer Berlin Heidelberg. https://doi.org/10.1007/3540543961_25
Chlipala, Adam. 2015. “An Optimizing Compiler for a Purely Functional Web-Application Language.” In Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming. ACM. https://doi.org/10.1145/2784731.2784741
Cho, Doosan, Sudeep Pasricha, Ilya Issenin, Nikil Dutt, Yunheung Paek, and SunJun Ko. 2008. “Compiler Driven Data Layout Optimization for Regular/irregular Array Access Patterns.” ACM SIGPLAN Notices 43 (7): 41–50. https://doi.org/10.1145/1379023.1375664
Choi, Wontae, Baris Aktemur, Kwangkeun Yi, and Makoto Tatsuta. 2011. “Static Analysis of Multi-Staged Programs via Unstaging Translation.” ACM SIGPLAN Notices 46 (1): 81–92. https://doi.org/10.1145/1925844.1926397
Choi, Junyoung, and Sagnik Bhattacharya. 2023. “Deep Learning-Based Real-Time Smartphone Pose Detection for Ultra-Wideband Tagless Gate.” In GLOBECOM 2023 - 2023 IEEE Global Communications Conference. IEEE. https://doi.org/10.1109/globecom54140.2023.10436971
Choi, Wontae, Satish Chandra, George Necula, and Koushik Sen. 2015. “SJS: A Type System for JavaScript with Fixed Object Layout.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-48288-9_11
Choi, Junyoung, Joohyun Lee, and Sagnik Bhattacharya. 2025. “Real-Time Pose Prediction and Dynamic Anchor Selection for Ultra-Wideband Tagless Gate.” IEEE Access 13: 23717–31. https://doi.org/10.1109/access.2025.3537976
Choi, Kwanghoon, Hyun-il Lim, and Taisook Han. 2001. “Compiling Lazy Functional Programs Based on the Spineless Tagless G-Machine for the Java Virtual Machine.” In Functional and Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44716-4_6
Choi, Lynn, Hock-Beng Lim, and Pen-Chung Yew. 1996. “Parallel Architectures: Techniques for Compiler-Directed Cache Coherence.” IEEE Parallel & Distributed Technology: Systems & Applications 4 (4): 23–34. https://doi.org/10.1109/m-pdt.1996.544438
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, L., and Pen-Chung Yew. 2000. “Compiler Analysis for Cache Coherence: Interprocedural Array Data-Flow Analysis and Its Impact on Cache Performance.” IEEE Transactions on Parallel and Distributed Systems 11 (9): 879–96. https://doi.org/10.1109/71.879772
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
Choi, Jung, and Sumit Sircar. 2006. “An Empirical Model of Software Size and Work-Effort Estimation for Business Application Software.” Journal of Computer Information Systems 47 (2): 66–75. https://doi.org/10.1080/08874417.2007.11645955
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
Choucha, Chams, Mohamed Ramdani, Mohamed Khalgui, and Laid Kahloul. 2020. “On Decomposing Formal Verification of CTL-Based Properties on IaaS Cloud Environment.” In Proceedings of the 15th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0009972605440551
Choudhari, Jitender, and Ugrasen Suman. 2012b. “Story Points Based Effort Estimation Model for Software Maintenance.” Procedia Technology 4: 761–65. https://doi.org/10.1016/j.protcy.2012.05.124
Chouikh, Asma, Khaled Khalfaoui, Elhillali Kerkouche, and Allaoua Chaoui. 2026. “Co-Evolution of UML Sequence Diagrams through an ATL Rule-Based Approach with Semantic Preservation in Maude.” Science of Computer Programming 253: 103478. https://doi.org/10.1016/j.scico.2026.103478
Chow, Frederick, and John Hennessy. 1984. “Register Allocation by Priority-Based Coloring.” In Proceedings of the 1984 SIGPLAN symposium on Compiler construction - SIGPLAN ‘84. ACM Press. https://doi.org/10.1145/502874.502896
Christakis, Maria, and Valentin Wüstholz. 2016. “Bounded Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-53413-7_6
Christopher, Thomas W. 1984. “Reference Count Garbage Collection.” Software: Practice and Experience 14 (6): 503–7. https://doi.org/10.1002/spe.4380140602
Chuanwen Lin, Naijie Gu, and Songsong Cai. 2013. “Cache Locking Optimization in Java Virtual Machine.” In IEEE Conference Anthology. IEEE. https://doi.org/10.1109/anthology.2013.6784761
Chuavalee, P., and L. N. Bhuyan. 1988. “VLSI Layout of Binary Tree Structures.” Integration 6 (1): 83–99. https://doi.org/10.1016/0167-9260(88)90019-3
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
Chun-Chieh Lin, Chuen-Liang Chen, and Ching-Hsu Tseng. 2007. “Source Code Arrangement of Embedded Java Virtual Machine for NAND Flash Memory.” In 2007 International Symposium on Communications and Information Technologies. IEEE. https://doi.org/10.1109/iscit.2007.4392003
Chung, Yi-Fan, Chun-Yu Lin, and Chung-Ta King. 2011. “ANEPROF: Energy Profiling for Android Java Virtual Machine and Applications.” In 2011 IEEE 17th International Conference on Parallel and Distributed Systems. IEEE. https://doi.org/10.1109/icpads.2011.28
Chung, Eric S., and Michael K. Papamichael. 2013. “ShrinkWrap: Compiler-Enabled Optimization and Customization of Soft Memory Interconnects.” In 2013 IEEE 21st Annual International Symposium on Field-Programmable Custom Computing Machines. IEEE. https://doi.org/10.1109/fccm.2013.56
Chy, Md Showkat Hossain, Muhammad Ashfakur Rahman Arju, Sri Manjusha Tella, and Tomas Cerny. 2023. “Comparative Evaluation of Java Virtual Machine-Based Message Queue Services: A Study on Kafka, Artemis, Pulsar, and RocketMQ.” Electronics 12 (23): 4792. https://doi.org/10.3390/electronics12234792
Cibir, Esra, and Tulin Ercelebi Ayyildiz. 2022. “An Empirical Study on Software Test Effort Estimation for Defense Projects.” IEEE Access 10: 48082–87. https://doi.org/10.1109/access.2022.3172326
Cimini, Matteo, Dale Miller, and Jeremy G. Siek. 2020. “Extrinsically Typed Operational Semantics for Functional Languages.” In Proceedings of the 13th ACM SIGPLAN International Conference on Software Language Engineering. ACM. https://doi.org/10.1145/3426425.3426936
Ciniselli, Matteo, Nathan Cooper, Luca Pascarella, Denys Poshyvanyk, Massimiliano Di Penta, and Gabriele Bavota. 2021. “An Empirical Study on the Usage of BERT Models for Code Completion.” In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR). IEEE. https://doi.org/10.1109/msr52588.2021.00024
Ciobanu, Madalina, Fausto Fasano, Fabio Martinelli, Francesco Mercaldo, and Antonella Santone. 2020. “Accidental Sensitive Data Leaks Prevention via Formal Verification.” In Proceedings of the 6th International Conference on Information Systems Security and Privacy. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0009380608250834
Ciocarlie, Horia, Marcela-Simona Atanasoae, and Mihai Ciocarlie. 2007. “Object Pascal Compiler for Rapid Development of Palm OS Applications.” In EUROCON 2007 - The International Conference on “Computer as a Tool”. IEEE. https://doi.org/10.1109/eurcon.2007.4400653
Clamen, Stewart M. 1994. “Schema Evolution and Integration.” Distributed and Parallel Databases 2 (1): 101–26. https://doi.org/10.1007/bf01263340
Clarke, Duncan, Hanêne Ben-Abdallah, Insup Lee, Hong -Liang Xie, and Oleg Sokolsky. 1996. “XVERSA: An Integrated Graphical and Textual Toolset for the Specification and Analysis of Resource-Bound Real-Time Systems.” In Computer Aided Verification. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61474-5_89
Clausen, Lars Ræder, Ulrik Pagh Schultz, Charles Consel, and Gilles Muller. 2000. “Java Bytecode Compression for Low-End Embedded Systems.” ACM Transactions on Programming Languages and Systems 22 (3): 471–89. https://doi.org/10.1145/353926.353933
Claypool, Kajal T., Elke A. Rundensteiner, and George T. Heineman. 2001. “Evolving the Software of a Schema Evolution System.” In Database Schema Evolution and Meta-Modeling. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48196-6_4
Clement, Valentin, and Jeffrey S. Vetter. 2021. “Flacc: Towards OpenACC Support for Fortran in the LLVM Ecosystem.” In 2021 IEEE/ACM 7th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvmhpc54804.2021.00007
Cleve, Anthony, Maxime Gobert, Loup Meurice, Jerome Maes, and Jens Weber. 2015. “Understanding Database Schema Evolution: A Case Study.” Science of Computer Programming 97: 113–21. https://doi.org/10.1016/j.scico.2013.11.025
Click, Cliff, and Michael Paleczny. 1995. “A Simple Graph-Based Intermediate Representation.” ACM SIGPLAN Notices 30 (3): 35–49. https://doi.org/10.1145/202530.202534
Cline, Carolyn, and Howard Jay Siegel. 1984. “A Comparison of Parallel Language Approaches to Data Representation and Data Transferral.” In 1984 IEEE First International Conference on Data Engineering. IEEE. https://doi.org/10.1109/icde.1984.7271255
Clinton, Michael, Rajinder Singh, Marty Tsai, Shayan Zhang, Bryan Sheffield, and Jonathan Chang. 2018. “A 5GHz 7nm L1 Cache Memory Compiler for High-Speed Computing and Mobile Applications.” In 2018 IEEE International Solid - State Circuits Conference - (ISSCC). IEEE. https://doi.org/10.1109/isscc.2018.8310253
“Code Generation and Optimization.” 2021. In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo51591.2021.9370328
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
Cohen, Jacques. 1981. “Garbage Collection of Linked Data Structures.” ACM Computing Surveys 13 (3): 341–67. https://doi.org/10.1145/356850.356854
Cohen, Jacques, and Laurent Trilling. 1967. “Remarks on »Garbage Collection« Using a Two-Level Storage.” BIT 7 (1): 22–30. https://doi.org/10.1007/bf01934123
Cohn, Neil. 2014. “The Architecture of Visual Narrative Comprehension: The Interaction of Narrative Structure and Page Layout in Understanding Comics.” Frontiers in Psychology 5. https://doi.org/10.3389/fpsyg.2014.00680
Colby, Christopher, Peter Lee, George C. Necula, Fred Blau, Mark Plesko, and Kenneth Cline. 2000. “A Certifying Compiler for Java.” In Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/349299.349315
Coleman, Stephanie, and Kathryn S. McKinley. 1995. “Tile Size Selection Using Cache Organization and Data Layout.” ACM SIGPLAN Notices 30 (6): 279–90. https://doi.org/10.1145/223428.207162
Collberg, Christian, Ginger Myles, and Michael Stepp. 2006. “An Empirical Study of Java Bytecode Programs.” Software: Practice and Experience 37 (6): 581–641. https://doi.org/10.1002/spe.776
Collopy, Fred. 2007. “Difficulty and Complexity as Factors in Software Effort Estimation.” International Journal of Forecasting 23 (3): 469–71. https://doi.org/10.1016/j.ijforecast.2007.05.011
Colnet, Dominique, and Benoît Sonntag. 2014. “Exploiting Array Manipulation Habits to Optimize Garbage Collection and Type Flow Analysis.” Software: Practice and Experience 45 (12): 1639–57. https://doi.org/10.1002/spe.2300
“The Compiler Proof.” 1981. In Compiler Specification and Verification. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-10886-6_4
“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
Conejo, Carlos. 2026. “Formal Verification of Functional Safety Supervisors for Autonomous Vehicles Using Behavior Tree Architectures.” In 2026 IEEE Intelligent Vehicles Symposium (IV). IEEE. https://doi.org/10.1109/iv66570.2026.11624044
Congying Li and Zhaofei Wang. 2011. “Structure Characteristics of Urban Public Bicycle Layout Network Based on Complex Networks.” In 2011 International Conference on Remote Sensing, Environment and Transportation Engineering. IEEE. https://doi.org/10.1109/rsete.2011.5965519
Contento, Lorenzo, Paul Stapor, Daniel Weindl, and Jan Hasenauer. 2023. “A More Expressive Spline Representation for SBML Models Improves Code Generation Performance in AMICI.” In Computational Methods in Systems Biology. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-42697-1_3
Contreras, Gilberto, and Margaret Martonosi. 2006. “Techniques for Real-System Characterization of Java Virtual Machine Energy and Power Behavior.” In 2006 IEEE International Symposium on Workload Characterization. IEEE. https://doi.org/10.1109/iiswc.2006.302727
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
Conway, Richard W., and Thomas R. Wilcox. 1973. “Design and Implementation of a Diagnostic Compiler for PL/I.” Communications of the ACM 16 (3): 169–79. https://doi.org/10.1145/361972.361992
Cooper, Keith D., Anshuman Dasgupta, and Jason Eckhardt. 2006. “Revisiting Graph Coloring Register Allocation: A Study of the Chaitin-Briggs and Callahan-Koblenz Algorithms.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-69330-7_1
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
Corazza, Anna, Sergio Di Martino, Filomena Ferrucci, Carmine Gravino, and Emilia Mendes. 2009. “Using Support Vector Regression for Web Development Effort Estimation.” In Software Process and Product Measurement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-05415-0_19
Corazza, Anna, Sergio Di Martino, Filomena Ferrucci, Carmine Gravino, and Federica Sarro. 2015. “From Function Points to COSMIC: A Transfer Learning Approach for Effort Estimation.” In Product-Focused Software Process Improvement. Springer International Publishing. https://doi.org/10.1007/978-3-319-26844-6_19
Cordeiro, Lucas, Pascal Kesseli, Daniel Kroening, Peter Schrammel, and Marek Trtik. 2018. “JBMC: A Bounded Model Checking Tool for Verifying Java Bytecode.” In Computer Aided Verification. Springer International Publishing. https://doi.org/10.1007/978-3-319-96145-3_10
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
“Correction to “BERT-Embedding-Based JSP Webshell Detection on Bytecode Level Using XGBoost”.” 2025. Security and Communication Networks 2025 (1): 9810902. https://doi.org/10.1155/sec/9810902
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
Cortesi, Agostino, Gilberto Filé, Roberto Giacobazzi, Catuscia Palamidessi, and Francesco Ranzato. 1995. “Complementation in Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60360-3_35
Cosmides, L. 1996. “Are Humans Good Intuitive Statisticians after All? Rethinking Some Conclusions from the Literature on Judgment under Uncertainty.” Cognition 58 (1): 1–73. https://doi.org/10.1016/0010-0277(95)00664-8
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
Cotroneo, Domenico, Salvatore Orlando, and Stefano Russo. 2007. “Characterizing Aging Phenomena of the Java Virtual Machine.” In 2007 26th IEEE International Symposium on Reliable Distributed Systems (SRDS 2007). IEEE. https://doi.org/10.1109/srds.2007.22
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
Couprie, Geoffroy. 2015. “Nom, a Byte Oriented, Streaming, Zero Copy, Parser Combinators Library in Rust.” In 2015 IEEE Security and Privacy Workshops. IEEE. https://doi.org/10.1109/spw.2015.31
Courbot, Alexandre, Gilles Grimaud, Jean-Jacques Vandewalle, and David Simplot-Ryl. 2005. “Application-Driven Customization of an Embedded Java Virtual Machine.” In Embedded and Ubiquitous Computing – EUC 2005 Workshops. Springer Berlin Heidelberg. https://doi.org/10.1007/11596042_9
Cousot, Patrick. 1996. “Program Analysis: The Abstract Interpretation Perspective.” ACM Computing Surveys 28 (4es): 165. https://doi.org/10.1145/242224.242433
Cousot, Patrick. 1997a. “Abstract Interpretation Based Static Analysis Parameterized by Semantics.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032759
Cousot, Patrick. 1997b. “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. 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, Radhia Cousot, and Laurent Mauborgne. 2012. “Theories, Solvers and Static Analysis by Abstract Interpretation.” Journal of the ACM 59 (6): 1–56. https://doi.org/10.1145/2395116.2395120
Cowan, Meghan, Deeksha Dangwal, Armin Alaghi, Caroline Trippel, Vincent T. Lee, and Brandon Reagen. 2021. “Porcupine: A Synthesizing Compiler for Vectorized Homomorphic Encryption.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454050
Cowan, D. D., and J. W. Graham. 1970. “Design Characteristics of the WATFOR Compiler.” ACM SIGPLAN Notices 5 (7): 25–36. https://doi.org/10.1145/390013.808481
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
Cox, Brad L. 1983. “The Object Oriented Pre-Compiler: Programming Smalltalk 80 Methods in C Language.” ACM SIGPLAN Notices 18 (1): 15–22. https://doi.org/10.1145/948093.948095
Crary, Karl, and Stephnie Weirich. 2000. “Resource Bound Certification.” In Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/325694.325716
Crawford, Lewis, and Michael O’Boyle. 2018. “A Cross-Platform Evaluation of Graphics Shader Compiler Optimization.” In 2018 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS). IEEE. https://doi.org/10.1109/ispass.2018.00035
Crisp, J. J., and J. S. Heeks. 1974. “P-N Code Generation Using S.A.W. Devices.” In 1974 Ultrasonics Symposium. IEEE. https://doi.org/10.1109/ultsym.1974.196362
Criswell, John. 2020. “Tutorial: LLVM for Security Practitioners.” In 2020 IEEE Secure Development (SecDev). IEEE. https://doi.org/10.1109/secdev45635.2020.00013
Criswell, John, Ethan Johnson, and Colin Pronovost. 2021. “Tutorial: LLVM for Security Practitioners.” In 2021 IEEE Secure Development Conference (SecDev). IEEE. https://doi.org/10.1109/secdev51306.2021.00016
Criswell, John, Ethan Johnson, and Colin Pronovost. 2022. “Tutorial: LLVM for Security Practitioners.” In 2022 IEEE Secure Development Conference (SecDev). IEEE. https://doi.org/10.1109/secdev53368.2022.00012
Cronquist, D. C., and L. McMurchie. 1996. “Emerald: An Architecture-Driven Tool Compiler for FPGAs.” In Fourth International ACM Symposium on Field-Programmable Gate Arrays. IEEE. https://doi.org/10.1109/fpga.1996.242542
Crosara, Marco, Luca Olivieri, Fausto Spoto, and Fabio Tagliaferro. 2021. “Re-Engineering ERC-20 Smart Contracts with Efficient Snapshots for the Java Virtual Machine.” In 2021 Third International Conference on Blockchain Computing and Applications (BCCA). IEEE. https://doi.org/10.1109/bcca53669.2021.9657047
Crowe, Malcolm, Clark Nicol, Michael Hughes, and David Mackay. 1985. “On Converting a Compiler into an Incremental Compiler.” ACM SIGPLAN Notices 20 (10): 14–22. https://doi.org/10.1145/382286.382376
Cuadrado-Gallego, Juan J., Pablo Rodríguez-Soria, and Borja Martín-Herrera. 2010. “Analogies and Differences between Machine Learning and Expert Based Software Project Effort Estimation.” In 2010 11th ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing. IEEE. https://doi.org/10.1109/snpd.2010.47
Cuenca, Javier, Luis P. Garcia, Domingo Gimenez, and Manuel Quesada. 2010. “Analysis of the Influence of the Compiler on Multicore Performance.” In 2010 18th Euromicro Conference on Parallel, Distributed and Network-based Processing. IEEE. https://doi.org/10.1109/pdp.2010.27
Cui, Baoquan, Rong Qu, Zhen Tang, and Jian Zhang. 2025b. “Static Analysis of Remote Procedure Call in Java Programs.” In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse55347.2025.00151
Cui, Xiang, Sheng Xu, Rui Jia, Longdi Li, Ze Hong, and Haotian Han. 2026. “An Efficient Clustered Register Allocation Algorithm for VLIW DSP Processors.” In 2026 6th International Symposium on Computer Technology and Information Science (ISCTIS). IEEE. https://doi.org/10.1109/isctis70043.2026.11572180
Cui, Huimin, Qing Yi, Jingling Xue, and Xiaobing Feng. 2013. “Layout-Oblivious Compiler Optimization for Matrix Computations.” ACM Transactions on Architecture and Code Optimization 9 (4): 1–20. https://doi.org/10.1145/2400682.2400694
Cumming, Daniel, Mark Utting, Franck Cassez, Naipeng Dong, Sadra Bayat Tork, and Marten Risius. 2024. “EVM-Vale: Formal Verification of EVM Bytecode Using Vale.” In Distributed Ledger Technology. Springer Nature Singapore. https://doi.org/10.1007/978-981-97-0006-6_3
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, Joao Carlos, Sergio Cruz, Marco Costa, Ana Rita Rodrigues, and Marco Vieira. 2011. “Implementing Software Effort Estimation in a Medium-Sized Company.” In 2011 IEEE 34th Software Engineering Workshop. IEEE. https://doi.org/10.1109/sew.2011.19
Curino, Carlo, Hyun Jin Moon, Alin Deutsch, and Carlo Zaniolo. 2012. “Automating the Database Schema Evolution Process.” VLDB Journal 22 (1): 73–98. https://doi.org/10.1007/s00778-012-0302-x
Curino, Carlo A., Hyun J. Moon, MyungWon Ham, and Carlo Zaniolo. 2009b. “The PRISM Workwench: Database Schema Evolution without Tears.” In 2009 IEEE 25th International Conference on Data Engineering. IEEE. https://doi.org/10.1109/icde.2009.46
Curtotti, Michael, and Eric McCreath. 2011a. “A Corpus of Australian Contract Language: Description, Profiling and Analysis.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.2304652
Curzer, Howard J., and Gary Santillanes. 2012. “Managing Conflict of Interest in Research: Some Suggestions for Investigators.” Accountability in Research 19 (3): 143–55. https://doi.org/10.1080/08989621.2012.678685
Cuzzocrea, Alfredo, Abderraouf Hafsaoui, and Carson K. Leung. 2023. “Machine-Learning-Based Multidimensional Big Data Analytics over Clouds via Multi-Columnar Big OLAP Data Cube Compression.” In 2023 IEEE International Conference on Big Data (BigData). IEEE. https://doi.org/10.1109/bigdata59044.2023.10386560
Cyca, Dan, and Laurence E. Turner. 2006a. “Bit-Serial Digital Filter Implementation Using a Custom C Compiler.” In APCCAS 2006 - 2006 IEEE Asia Pacific Conference on Circuits and Systems. IEEE. https://doi.org/10.1109/apccas.2006.342526
Cyca, Dan, and Laurence Turner. 2006b. “A C Compiler for Implementing FPGA Based Bit-Serial DSP Systems.” In 2006 IEEE International Conference on Field Programmable Technology. IEEE. https://doi.org/10.1109/fpt.2006.270334
Czajkowski, Grzegorz. 2000. “Application Isolation in the Java Virtual Machine.” ACM SIGPLAN Notices 35 (10): 354–66. https://doi.org/10.1145/354222.353195
Czibula, Istvan, Zsuzsanna Oneţ-Marian, and Robert-Francisc Vida. 2019. “Automatic Algorithmic Complexity Determination Using Dynamic Program Analysis.” In Proceedings of the 14th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0007831801860193
D’Antoni, Loris, and Margus Veanes. 2013. “Static Analysis of String Encoders and Decoders.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-35873-9_14
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
da Nova, José Niuton, Flávio de Barros Vidal, and Aleteia Araujo. 2025. “An Experiment on Serialization of DIS Messages Using Protocol Buffers.” In 2025 LI Latin American Computer Conference (CLEI). IEEE. https://doi.org/10.1109/clei67442.2025.11420498
da Silva, Anderson Faustino, and Vítor Santos Costa. 2006. “The Design and Implementation of the YAP Compiler: An Optimizing Compiler for Logic Programming Languages.” In Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/11799573_49
da Silva, Fabio Q. B., A. Cesar C. Franca, Tatiana B. Gouveia, Cleviton V. F. Monteiro, Elisa S. F. Cardozo, and Marcos Suassuna. 2011. “An Empirical Study on the Use of Team Building Criteria in Software Projects.” In 2011 International Symposium on Empirical Software Engineering and Measurement. IEEE. https://doi.org/10.1109/esem.2011.14
Dageförde, Jan C., and Herbert Kuchen. 2019. “A Compiler and Virtual Machine for Constraint-Logic Object-Oriented Programming with Muli.” Journal of Computer Languages 53: 63–78. https://doi.org/10.1016/j.cola.2019.05.001
Dagenais, Barthélémy, and Laurie Hendren. 2008. “Enabling Static Analysis for Partial Java Programs.” ACM SIGPLAN Notices 43 (10): 313–28. https://doi.org/10.1145/1449955.1449790
Dahlgren, Fredrik, Jonas Skeppstedt, and Per Stenström. 1998. “An Evaluation of Hardware-Based and Compiler-Controlled Optimizations of Snooping Cache Protocols.” Future Generation Computer Systems 13 (6): 469–87. https://doi.org/10.1016/s0167-739x(98)00002-8
Dain Samples, A. 1992. “Compiler Implementation of ADTs Using Profile Data.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-55984-1_9
Dal Zilio, Silvano, and Régis Gascon. 2005. “Resource Bound Certification for a Tail-Recursive Virtual Machine.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/11575467_17
Dalla Preda, Mila, Roberto Giacobazzi, Saumya Debray, Kevin Coogan, and Gregg M. Townsend. 2010. “Modelling Metamorphism by Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-15769-1_14
Damiani, Ferruccio, and Ina Schaefer. 2012. “Family-Based Analysis of Type Safety for Delta-Oriented Software Product Lines.” In Leveraging Applications of Formal Methods, Verification and Validation. Technologies for Mastering Change. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-34026-0_15
Daneva, Maya, Seanna Wettflower, and Sonia de Boer. 2008. “Uncertainty in ERP Effort Estimation: A Challenge or an Asset?” In Software Process and Product Measurement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-89403-2_18
Daneva, Maya, and Roel Wieringa. 2008. “Cost Estimation for Cross-Organizational ERP Projects: Research Perspectives.” Software Quality Journal 16 (3): 459–81. https://doi.org/10.1007/s11219-008-9045-8
Dang, Viet-Hung, and Truong-Thang Nguyen. 2026. “Seismic Reliability Analysis Framework Based on Robust Graph Data Representation and Efficient Selective State Space Model.” Structures 89: 112111. https://doi.org/10.1016/j.istruc.2026.112111
Dangeti, Tharun Kumar, Venkata Keerthy S., and Ramakrishna Upadrasta. 2018. “P4LLVM: An LLVM Based P4 Compiler.” In 2018 IEEE 26th International Conference on Network Protocols (ICNP). IEEE. https://doi.org/10.1109/icnp.2018.00059
Danh Nguyen-Cong and De Tran-Cao. 2013. “A Review of Effort Estimation Studies in Agile, Iterative and Incremental Software Development.” In The 2013 RIVF International Conference on Computing & Communication Technologies - Research, Innovation, and Vision for Future (RIVF). IEEE. https://doi.org/10.1109/rivf.2013.6719861
Dantas, Reno, Antonio Carvalho, Diego Marcilio, et al. 2018b. “Reconciling the past and the Present: An Empirical Study on the Application of Source Code Transformations to Automatically Rejuvenate Java Programs.” In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner.2018.8330247
Dantas, Bartira, David Déharbe, Stephenson Galvão, Anamaria Martins Moreira, and Valério Medeiros. 2009. “Verified Compilation and the B Method: A Proposal and a First Appraisal.” Electronic Notes in Theoretical Computer Science 240: 79–96. https://doi.org/10.1016/j.entcs.2009.05.046
Danvy, Olivier. 1991. “Semantics-Directed Compilation of Nonlinear Patterns.” Information Processing Letters 37 (6): 315–22. https://doi.org/10.1016/0020-0190(91)90148-b
Daoud, Houssem, and Michel Dagenais. 2020. “Multilevel Analysis of the Java Virtual Machine Based on Kernel and Userspace Traces.” Journal of Systems and Software 167: 110589. https://doi.org/10.1016/j.jss.2020.110589
Daradkeh, Tariq, Anjali Agarwal, Nishith Goely, and Marzia Zaman. 2018. “Real Time Metering of Cloud Resource Reading Accurate Data Source Using Optimal Message Serialization and Format.” In 2018 IEEE 11th International Conference on Cloud Computing (CLOUD). IEEE. https://doi.org/10.1109/cloud.2018.00067
Daraghmeh, Mustafa, Anjali Agarwal, and Yaser Jararweh. 2023. “Regression-Based Approach for Proactive Predictive Modeling of Efficient Cloud Cost Estimation.” In 2023 Tenth International Conference on Software Defined Systems (SDS). IEEE. https://doi.org/10.1109/sds59856.2023.10329194
Dardaillon, Mickaël, Stefanos Skalistis, Isabelle Puaut, and Steven Derrien. 2019. “Reconciling Compiler Optimizations and WCET Estimation Using Iterative Compilation.” In 2019 IEEE Real-Time Systems Symposium (RTSS). IEEE. https://doi.org/10.1109/rtss46320.2019.00022
Das, Manuvir. 1999. “Static Analysis of Large Programs (Invited Talk) (Abstract Only): Some Experiences.” ACM SIGPLAN Notices 34 (11): 1. https://doi.org/10.1145/328691.328692
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
Daudier, Dorian, Trinh Ngoc Quoc Bao, and Kazuhiro Ogata. 2018. “A Proof Score Approach to Formal Verification of an Imperative Programming Language Compiler.” In Structured Object-Oriented Formal Language and Method. Springer International Publishing. https://doi.org/10.1007/978-3-319-90104-6_13
Dave, Chirag, Hansang Bae, Seung-Jai Min, Seyong Lee, Rudolf Eigenmann, and Samuel Midkiff. 2009. “Cetus: A Source-to-Source Compiler Infrastructure for Multicores.” Computer 42 (12): 36–42. https://doi.org/10.1109/mc.2009.385
Dave, Vachik S., and Kamlesh Dutta. 2011b. “Neural Network Based Software Effort Estimation & Evaluation Criterion MMRE.” In 2011 2nd International Conference on Computer and Communication Technology (ICCCT-2011). IEEE. https://doi.org/10.1109/iccct.2011.6075192
Dave, Vachik S., and Kamlesh Dutta. 2012. “Neural Network Based Models for Software Effort Estimation: A Review.” Artificial Intelligence Review 42 (2): 295–307. https://doi.org/10.1007/s10462-012-9339-x
Dawson, Michael H. 2008. “Challenges in Implementing the Real-Time Specification for Java (RTSJ) in a Commercial Real-Time Java Virtual Machine.” In 2008 11th IEEE International Symposium on Object and Component-Oriented Real-Time Distributed Computing (ISORC). IEEE. https://doi.org/10.1109/isorc.2008.29
Dawson, Steven, C. R. Ramakrishnan, and David S. Warren. 1996. “Practical Program Analysis Using General Purpose Logic Programming Systems—a Case Study.” In Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/231379.231399
de A. Araújo, Ricardo, Adriano L. I. Oliveira, and Silvio Meira. 2017. “A Class of Hybrid Multilayer Perceptrons for Software Development Effort Estimation Problems.” Expert Systems with Applications 90: 1–12. https://doi.org/10.1016/j.eswa.2017.07.050
de A. Cabral, Jose Thiago H., and Adriano L. I. Oliveira. 2021. “Ensemble Effort Estimation Using Dynamic Selection.” Journal of Systems and Software 175: 110904. https://doi.org/10.1016/j.jss.2021.110904
de Almeida, Érika Regina Campos, Bruno Teixeira de Abreu, and Regina Moraes. 2009. “An Alternative Approach to Test Effort Estimation Based on Use Cases.” In 2009 International Conference on Software Testing Verification and Validation. IEEE. https://doi.org/10.1109/icst.2009.31
De Araújo, Vítor Bujés Ubatuba, Álvaro Freitas Moreira, and Rodrigo Machado. 2016. “Týr: A Dependent Type System for Spatial Memory Safety in LLVM.” Electronic Notes in Theoretical Computer Science 324: 3–13. https://doi.org/10.1016/j.entcs.2016.09.003
De Bortoli Fávero, Eliane Maria, Dalcimar Casanova, and Andrey Ricardo Pimentel. 2022. “SE 3 M: A Model for Software Effort Estimation Using Pre-Trained Embedding Models.” Information and Software Technology 147: 106886. https://doi.org/10.1016/j.infsof.2022.106886
De Carvalho, Halcyon Davys Pereira, Roberta Fagundes, and Wylliams Santos. 2021. “Extreme Learning Machine Applied to Software Development Effort Estimation.” IEEE Access 9: 92676–87. https://doi.org/10.1109/access.2021.3091313
de Dios, Javier, and Ricardo Peña. 2009. “A Certified Implementation on Top of the Java Virtual Machine.” In Formal Methods for Industrial Critical Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-04570-7_14
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 Jong, Michael, Arie van Deursen, and Anthony Cleve. 2017. “Zero-Downtime SQL Database Schema Evolution for Continuous Deployment.” In 2017 IEEE/ACM 39th International Conference on Software Engineering: Software Engineering in Practice Track (ICSE-SEIP). IEEE. https://doi.org/10.1109/icse-seip.2017.5
de Kruijf, M., and K. Sankaralingam. 2013. “Idempotent Code Generation: Implementation, Analysis, and Evaluation.” In Proceedings of the 2013 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2013.6495002
de Kruijf, Marc A., Karthikeyan Sankaralingam, and Somesh Jha. 2012. “Static Analysis and Compiler Design for Idempotent Processing.” In Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2254064.2254120
De Lucia, Andrea, Eugenio Pompella, and Silvio Stefanucci. 2005. “Assessing Effort Estimation Models for Corrective Maintenance through Empirical Studies.” Information and Software Technology 47 (1): 3–15. https://doi.org/10.1016/j.infsof.2004.05.002
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 Matos, Filipe B., Paulo Rego, and Fernando Trinta. 2021. “An Empirical Study about the Adoption of Multi-Language Technique in Computation Offloading in a Mobile Cloud Computing Scenario.” In Proceedings of the 11th International Conference on Cloud Computing and Services Science. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010437802070214
de Michiel, Marianne, Armelle Bonenfant, Hugues Casse, and Pascal Sainrat. 2008. “Static Loop Bound Analysis of C Programs Based on Flow Analysis and Abstract Interpretation.” In 2008 14th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications. IEEE. https://doi.org/10.1109/rtcsa.2008.53
De Stefano, Manuel. 2022. “An Empirical Study on the Current Adoption of Quantum Programming.” In 2022 IEEE/ACM 44th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). IEEE. https://doi.org/10.1109/icse-companion55297.2022.9793820
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
Deb, Ashoke. 1987. “Parallel Garbage Collection for Graph Machines.” In Graph Reduction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-18420-1_59
Debray, Saumya. 1997. “Resource-Bounded Partial Evaluation.” In Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation. ACM. https://doi.org/10.1145/258993.259017
Degenbaev, Ulan, Jochen Eisinger, Manfred Ernst, Ross McIlroy, and Hannes Payer. 2016. “Idle Time Garbage Collection Scheduling.” ACM SIGPLAN Notices 51 (6): 570–83. https://doi.org/10.1145/2980983.2908106
Dehdouh, Khaled, Fadila Bentayeb, Omar Boussaid, and Nadia Kabachi. 2014. “Columnar NoSQL CUBE: Agregation Operator for Columnar NoSQL Data Warehouse.” In 2014 IEEE International Conference on Systems, Man, and Cybernetics (SMC). IEEE. https://doi.org/10.1109/smc.2014.6974527
Dejaeger, Karel, Wouter Verbeke, David Martens, and Bart Baesens. 2012. “Data Mining Techniques for Software Effort Estimation: A Comparative Study.” IEEE Transactions on Software Engineering 38 (2): 375–97. https://doi.org/10.1109/tse.2011.55
del Bianco, Vieri, Luigi Lavazza, and Sandro Morasca. 2012. “A Proposal for Simplified Model-Based Cost Estimation Models.” In Product-Focused Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-31063-8_6
Delahaye, David, and Micaela Mayero. 2005. “Dealing with Algebraic Expressions over a Field in Coq Using Maple.” Journal of Symbolic Computation 39 (5): 569–92. https://doi.org/10.1016/j.jsc.2004.12.004
Delmas, David, and Antoine Miné. 2019. “Analysis of Software Patches Using Numerical Abstract Interpretation.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-32304-2_12
Delmas, David, Abdelraouf Ouadjaout, and Antoine Miné. 2021. “Static Analysis of Endian Portability by Abstract Interpretation.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-88806-0_5
Delplanque, Julien, Anne Etien, Nicolas Anquetil, and Olivier Auverlot. 2018. “Relational Database Schema Evolution: An Industrial Case Study.” In 2018 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE. https://doi.org/10.1109/icsme.2018.00073
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
Delzanno, Giorgio, Roberto Giacobazzi, and Francesco Ranzato. 2010. “Static Analysis, Abstract Interpretation and Verification in (Constraint Logic) Programming.” In A 25-Year Perspective on Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-14309-0_7
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
Demoen, Bart. 2002. “A Different Look at Garbage Collection for the WAM.” In Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45619-8_13
Demoen, Bart, and Konstantinos Sagonas. 1999. “Heap Garbage Collection in XSB: Practice and Experience.” In Practical Aspects of Declarative Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-46584-7_7
Deng, Chaoqiang, and Patrick Cousot. 2019. “Responsibility Analysis by Abstract Interpretation.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-32304-2_18
Deng, Chaoqiang, and Kedar S. Namjoshi. 2016. “Securing a Compiler Transformation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-53413-7_9
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
Denman, William, Behzad Akbarpour, Sofiene Tahar, Mohamed H. Zaki, and Lawrence C. Paulson. 2009. “Formal Verification of Analog Designs Using MetiTarski.” In 2009 Formal Methods in Computer-Aided Design. IEEE. https://doi.org/10.1109/fmcad.2009.5351136
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
“Deriving Models for Software Project Effort Estimation by Means of Genetic Programming.” 2009. In Proceedings of the International Conference on Knowledge Discovery and Information Retrieval. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002294300340042
Derlatka, Kacper, Maciej Manna, Oleksii Bulenok, David Zwicker, and Sylwester Arabas. 2024. “Numba-MPI v1.0: Enabling MPI Communication within Numba/LLVM JIT-Compiled Python Code.” SoftwareX 28: 101897. https://doi.org/10.1016/j.softx.2024.101897
Dernehl, Christian, Norman Hansen, and Stefan Kowalewski. 2016. “Combining Abstract Interpretation with Symbolic Execution for a Static Value Range Analysis of Block Diagrams.” In Software Engineering and Formal Methods. Springer International Publishing. https://doi.org/10.1007/978-3-319-41591-8_10
Desai, Chaitanya, Deva Ramanan, and Charless Fowlkes. 2009. “Discriminative Models for Multi-Class Object Layout.” In 2009 IEEE 12th International Conference on Computer Vision. IEEE. https://doi.org/10.1109/iccv.2009.5459256
Desai, Chaitanya, Deva Ramanan, and Charless C. Fowlkes. 2011. “Discriminative Models for Multi-Class Object Layout.” International Journal of Computer Vision 95 (1): 1–12. https://doi.org/10.1007/s11263-011-0439-x
Deshpande, Amol. 2026. “Living Databases: A Unified Model for Continuous Schema Evolution, Versioning, and Transformations.” In 2026 IEEE 42nd International Conference on Data Engineering (ICDE). IEEE. https://doi.org/10.1109/icde65706.2026.00333
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
Dewi, Renny Sari, and Yogantara Setya Dharmawan. 2024. “A Proposed Model for Embedding Risk Proportion in Software Development Effort Estimation.” Procedia Computer Science 234: 1777–84. https://doi.org/10.1016/j.procs.2024.03.185
Dewi, Renny Sari, Yogantara Setya Dharmawan, and Siti Nur Aisah. 2020. “Measuring Software Size and Effort Estimation on Islamic Banking Application.” In 2020 3rd International Conference on Information and Communications Technology (ICOIACT). IEEE. https://doi.org/10.1109/icoiact50329.2020.9332073
Deworetzki, Niklas, and Uwe Meyer. 2021. “Program Analysis for Reversible Languages.” In Proceedings of the 10th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. ACM. https://doi.org/10.1145/3460946.3464314
Dharmajee Rao, D. T. V., Ch. Vidyadhari, R. Barathy, Md Afzal, Shilpa Sargari, and A. S. Anakath. 2025. “Neuro-Symbolic AI-Driven Data Warehouses: Self-Learning Architectures for Dynamic Schema Evolution and Adaptive Query Optimization.” In 2025 International Conference on Metaverse and Current Trends in Computing (ICMCTC). IEEE. https://doi.org/10.1109/icmctc62214.2025.11196455
Dhiman, Smaarth, Vansh Vishnoi, and Yashu Swami. 2026. “Compiler Performance Analysis for AI Workloads on RISC-V: A Comprehensive Comparison of GCC and LLVM.” In 2026 International Conference on Intelligent Computing and Automation for Sustainable Solutions (ICASS). IEEE. https://doi.org/10.1109/icass69550.2026.11547433
Dhoke, Pratik, and Prasad Lokulwar. 2023. “Evaluating the Impact of No-Code/Low-Code Backend Services on API Development and Implementation: A Case Study Approach.” In 2023 14th International Conference on Computing Communication and Networking Technologies (ICCCNT). IEEE. https://doi.org/10.1109/icccnt56998.2023.10306945
Di Martino, Beniamino, Salvatore D’Angelo, and Antonio Esposito. 2017. “A Platform for MBDAaaS Based on Patterns and Skeletons: The Python Based Algorithms Compiler.” In 2017 IEEE 14th International Conference on Networking, Sensing and Control (ICNSC). IEEE. https://doi.org/10.1109/icnsc.2017.8000126
Di Martino, Sergio, Filomena Ferrucci, Carmine Gravino, and Federica Sarro. 2011. “Using Web Objects for Development Effort Estimation of Web Applications: A Replicated Study.” In Product-Focused Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-21843-9_16
Di Martino, Sergio, Filomena Ferrucci, Carmine Gravino, and Federica Sarro. 2020. “Assessing the Effectiveness of Approximate Functional Sizing Approaches for Effort Estimation.” Information and Software Technology 123: 106308. https://doi.org/10.1016/j.infsof.2020.106308
Di Martino, Beniamino, Antonino Mazzeo, Nicola Mazzocca, and Umberto Villano. 2001. “Parallel Program Analysis and Restructuring by Detection of Point-to-Point Interaction Patterns and Their Transformation into Collective Communication Constructs.” Science of Computer Programming 40 (2–3): 235–63. https://doi.org/10.1016/s0167-6423(01)00017-x
Di Penta, Massimiliano, and Sunghun Kim. 2016. “Guest Editorial: Special Section on Mining Software Repositories.” Empirical Software Engineering 21 (2): 301–2. https://doi.org/10.1007/s10664-016-9428-6
Di Penta, Massimiliano, and Tao Xie. 2015. “Guest Editorial: Special Section on Mining Software Repositories.” Empirical Software Engineering 20 (2): 291–93. https://doi.org/10.1007/s10664-015-9383-7
Di Pierro, Alessandra, Chris Hankin, and Herbert Wiklicky. 2007. “Abstract Interpretation for Worst and Average Case Analysis.” In Program Analysis and Compilation, Theory and Practice. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-71322-7_8
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
Diamantopoulos, Themistoklis, and Andreas L. Symeonidis. 2025. “A Directory of Datasets for Mining Software Repositories.” Data 10 (3): 28. https://doi.org/10.3390/data10030028
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
Diehl, Stephan, Harald C. Gall, and Ahmed E. Hassan. 2009. “Guest Editors Introduction: Special Issue on Mining Software Repositories.” Empirical Software Engineering 14 (3): 257–61. https://doi.org/10.1007/s10664-009-9110-3
Diels, Johan, Mario Cunha, Célia Manaia, Bernardo Sabugosa-Madeira, and Margarida Silva. 2011. “Association of Financial or Professional Conflict of Interest to Research Outcomes on Health Risks or Nutritional Assessment Studies of Genetically Modified Products.” Food Policy 36 (2): 197–203. https://doi.org/10.1016/j.foodpol.2010.11.016
Dietrich, Jens, and Behnaz Hassanshahi. 2025. “DALEQ: Explainable Equivalence for Java Bytecode.” In 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE. https://doi.org/10.1109/ase63991.2025.00300
Dietrich, Jens, Kamil Jezek, and Premek Brada. 2014. “Broken Promises: An Empirical Study into Evolution Problems in Java Programs Caused by Library Upgrades.” In 2014 Software Evolution Week - IEEE Conference on Software Maintenance, Reengineering, and Reverse Engineering (CSMR-WCRE). IEEE. https://doi.org/10.1109/csmr-wcre.2014.6747226
Dighe, Shalaka, and Anirudha Joshi. 2014. “An Autoethnographic Study of HCI Effort Estimation in Outsourced Software Development.” In Human-Centered Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-44811-3_2
Dikov, Alexander, Vladimir Zvorygin, and Valentin Malykh. 2025. “Diffusion vs Autoregression: An Empirical Study on Code Comment Translation.” In 2025 5th International Conference on Code Quality (ICCQ). IEEE. https://doi.org/10.1109/iccq65694.2025.11314568
Diks, Krzysztof, and Hagerup Torben. 1997. “More General Parallel Tree Contraction: Register Allocation and Broadcasting in a Tree.” In Graph-Theoretic Concepts in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-62559-3_12
Dillenberger, D., R. Bordawekar, C. W. Clark III, et al. 2000. “Building a Java Virtual Machine for Server Applications: The Jvm on OS/390.” IBM Systems Journal 39 (1): 194–210. https://doi.org/10.1147/sj.391.0194
Dillig, Isil, Thomas Dillig, and Alex Aiken. 2010. “Small Formulas for Large Programs: On-Line Constraint Simplification in Scalable Static Analysis.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-15769-1_15
Dimovski, Aleksandar S. 2019. “Lifted Static Analysis Using a Binary Decision Diagram Abstract Domain.” In Proceedings of the 18th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences. ACM. https://doi.org/10.1145/3357765.3359518
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. 2023a. “Error Invariants for Fault Localization via Abstract Interpretation.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-44245-2_10
Dimovski, Aleksandar S. 2023b. “Generalized Program Sketching by Abstract Interpretation and Logical Abduction.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-44245-2_11
Dimovski, Aleksandar S. 2025a. “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
Dimovski, Aleksandar S., Sven Apel, and Axel Legay. 2022. “Several Lifted Abstract Domains for Static Analysis of Numerical Program Families.” Science of Computer Programming 213: 102725. https://doi.org/10.1016/j.scico.2021.102725
Ding, Steven H. H., Benjamin C. M. Fung, and Philippe Charland. 2019. “Asm2Vec: Boosting Static Representation Robustness for Binary Clone Search against Code Obfuscation and Compiler Optimization.” In 2019 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp.2019.00003
Ding, Chen, and Ken Kennedy. 2004. “Improving Effective Bandwidth through Compiler Enhancement of Global Cache Reuse.” Journal of Parallel and Distributed Computing 64 (1): 108–34. https://doi.org/10.1016/j.jpdc.2003.09.005
Ding, Yuxin, Jia Mei, and Hu Cheng. 2000. “Design and Implementation of Java Just-in-Time Compiler.” Journal of Computer Science and Technology 15 (6): 584–90. https://doi.org/10.1007/bf02948840
Ding, Yufei, Lin Ning, Hui Guan, and Xipeng Shen. 2017. “Generalizations of the Theory and Deployment of Triangular Inequality for Compiler-Based Strength Reduction.” In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3062341.3062377
Ding, Wei, Jithendra Srinivas, Mahmut Kandemir, and Mustafa Karakoy. 2011. “Compiler Directed Data Locality Optimization for Multicore Architectures.” In 2011 International Conference on Parallel Architectures and Compilation Techniques. IEEE. https://doi.org/10.1109/pact.2011.24
Ding, Xiaohong, and Koetsu Yamazaki. 2005. “Adaptive Growth Technique of Stiffener Layout Pattern for Plate and Shell Structures to Achieve Minimum Compliance.” Engineering Optimization 37 (3): 259–76. https://doi.org/10.1080/0305215512331328231
Ding, Wei, Yuanrui Zhang, Mahmut Kandemir, and Seung Woo Son. 2012. “Compiler-Directed File Layout Optimization for Hierarchical Storage Systems.” In 2012 International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/sc.2012.35
Ding, Wei, Yuanrui Zhang, Mahmut Kandemir, and Seung Woo Son. 2013. “Compiler-Directed File Layout Optimization for Hierarchical Storage Systems.” Scientific Programming 21 (3–4): 65–78. https://doi.org/10.1155/2013/167581
Ding, Renhua, Aoyang Zhou, Xin Liu, Wei Wang, and Kun He. 2026. “Semantic Preservation Based Momentum Enhancement Adversarial Attack for SAR Target Recognition.” IEEE Transactions on Emerging Topics in Computational Intelligence: 1–15. https://doi.org/10.1109/tetci.2026.3699632
Dinkelaker, Tom, Michael Eichberg, and Mira Mezini. 2013. “Incremental Concrete Syntax for Embedded Languages with Support for Separate Compilation.” Science of Computer Programming 78 (6): 615–32. https://doi.org/10.1016/j.scico.2012.12.002
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
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
Ditzel, David R., and H. R. McLellan. 1982. “Register Allocation for Free: The C Machine Stack Cache.” ACM SIGPLAN Notices 17 (4): 48–56. https://doi.org/10.1145/960120.801825
Diwan, Amer, Eliot Moss, and Richard Hudson. 1992. “Compiler Support for Garbage Collection in a Statically Typed Language.” ACM SIGPLAN Notices 27 (7): 273–82. https://doi.org/10.1145/143103.143140
Djaneye-Boundjou, Ouboti, Temesguen Messay-Kebede, David Kapp, Jeremiah Greer, and Anca Ralescu. 2019. “Static Analysis through Topic Modeling and Its Application to Malware Programs Classification.” In 2019 IEEE National Aerospace and Electronics Conference (NAECON). IEEE. https://doi.org/10.1109/naecon46414.2019.9057876
Dobashi, Hiroki, Shoma Sumi, and Masaya Minami. 2024. “Quasi-Static Analysis of Orientational Alignment of a 2-D Part toward a 2nd-Order Form Closure Grasp with Circular Fingers.” In 2024 20th IEEE/ASME International Conference on Mechatronic and Embedded Systems and Applications (MESA). IEEE. https://doi.org/10.1109/mesa61532.2024.10704891
Dobes, Josef, Vaclav Panko, David Cerny, and Jan Divin. 2013. “A Flexible Algorithm for Solving Systems of Circuit Differential-Algebraic Equations with Integrated Fortran 95 Compiler for Modeling.” In 2013 Africon. IEEE. https://doi.org/10.1109/afrcon.2013.6757802
Dobravec, Tomaz. 2017. “Estimating the Time Complexity of the Algorithms by Counting the Java Bytecode Instructions.” In 2017 IEEE 14th International Scientific Conference on Informatics. IEEE. https://doi.org/10.1109/informatics.2017.8327225
Dobravec, Tomaž. 2019. “Java Virtual Machine Educational Tools.” In 2019 IEEE 15th International Scientific Conference on Informatics. IEEE. https://doi.org/10.1109/informatics47936.2019.9119263
Doh, Kyung-Goo, Hyunha Kim, and David A. Schmidt. 2009. “Abstract Parsing: Static Analysis of Dynamically Generated String Output Using LR-Parsing Technology.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-03237-0_18
Dolan, Stephen, and Alan Mycroft. 2017. “Polymorphism, Subtyping, and Type Inference in MLsub.” In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages. ACM. https://doi.org/10.1145/3009837.3009882
Dold, Axel, and Vincent Vialard. 2000. “Formal Verification of a Compiler Back-End Generic Checker Program.” In Perspectives of System Informatics. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-46562-6_42
Dömölki, Bálint. 1968. “A Universal Compiler System Based on Production Rules.” BIT 8 (4): 262–75. https://doi.org/10.1007/bf01933436
Donaldson, Alastair F., Leopold Haller, and Daniel Kroening. 2011. “Strengthening Induction-Based Race Checking with Lightweight Static Analysis.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-18275-4_13
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
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, Yifei, and C. R. Ramakrishnan. 1999. “An Optimizing Compiler for Efficient Model Checking.” In Formal Methods for Protocol Engineering and Distributed Systems. Springer US. https://doi.org/10.1007/978-0-387-35578-8_14
Dong, Junfeng, and Xiaohui Yu. 2007. “CSR+-Tree: Cache-Conscious Indexing for High-Dimensional Similarity Search.” In 19th International Conference on Scientific and Statistical Database Management (SSDBM 2007). IEEE. https://doi.org/10.1109/ssdbm.2007.9
Dongo, Irvin, and Richard Chbeir. 2019. “S-RDF: A New RDF Serialization Format for Better Storage without Losing Human Readability.” In On the Move to Meaningful Internet Systems: OTM 2019 Conferences. Springer International Publishing. https://doi.org/10.1007/978-3-030-33246-4_16
Doroshenko, A., and D. Ragozin. 2005. “Retargetable Code Generation for Application-Specific Processors.” Future Generation Computer Systems 21 (5): 679–85. https://doi.org/10.1016/j.future.2004.05.008
Doshi, Karishma, Suyash Shukla, and Sandeep Kumar. 2026. “Towards Interpretable Ensemble Learning for Software Effort Estimation.” 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/0015043100004015
Dot, Gem, Alejandro Martinez, and Antonio Gonzalez. 2016. “ERICO: Effective Removal of Inline Caching Overhead in Dynamic Typed Languages.” In 2016 IEEE 23rd International Conference on High Performance Computing (HiPC). IEEE. https://doi.org/10.1109/hipc.2016.050
Dougherty, Quinn, and Ronak Mehta. 2025. “Proving the Coding Interview: A Benchmark for Formally Verified Code Generation.” In 2025 IEEE/ACM International Workshop on Large Language Models for Code (LLM4Code). IEEE. https://doi.org/10.1109/llm4code66737.2025.00014
Downen, Paul. 2024. “Call-by-Unboxed-Value.” Proceedings of the ACM on Programming Languages 8 (ICFP): 845–79. https://doi.org/10.1145/3674654
Doyle, Patrick, Carlos Cavanna, and Tarek S. Abdelrahman. 2004. “The Design and Implementation of a Modular and Extensible Java Virtual Machine.” Software: Practice and Experience 34 (3): 287–313. https://doi.org/10.1002/spe.565
Doyon, S., and M. Debbabi. 2000a. “On Object Initialization in the Java Bytecode.” Computer Communications 23 (17): 1594–1605. https://doi.org/10.1016/s0140-3664(00)00245-0
Dragicevic, Srdjana, Stipe Celar, and Mili Turic. 2017. “Bayesian Network Model for Task Effort Estimation in Agile Software Development.” Journal of Systems and Software 127: 109–19. https://doi.org/10.1016/j.jss.2017.01.027
Draves, Scott. 1996. “Compiler Generation for Interactive Graphics Using Intermediate Code.” In Partial Evaluation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61580-6_6
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
Drescher, Florian, and Alexis Engelke. 2026. “Synthesizing Instruction Selection Back-Ends from ISA Specifications Made Practical.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395203
Dreyer, Derek. 2007. “A Type System for Recursive Modules.” In Proceedings of the 12th ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/1291151.1291196
Driesen, Karel, and Urs Hölzle. 1996. “The Direct Cost of Virtual Function Calls in C++.” In Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. ACM. https://doi.org/10.1145/236337.236369
Drobnjaković, Filip, Pavle Subotić, and Caterina Urban. 2024. “An Abstract Interpretation-Based Data Leakage Static Analysis.” In Theoretical Aspects of Software Engineering. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-64626-3_7
Du, Xikang. 2023. “Energy Saving Ocean Garbage Collection Return Algorithm and System Based on Machine Vision.” In 2023 4th International Conference for Emerging Technology (INCET). IEEE. https://doi.org/10.1109/incet57972.2023.10170301
Du, Yajuan, Wei Liu, Yuan Gao, and Rachata Ausavarungnirun. 2021. “Observation and Optimization on Garbage Collection of Flash Memories: The View in Performance Cliff.” Micromachines 12 (7): 846. https://doi.org/10.3390/mi12070846
Du, Yalong, Chaozheng Wang, and Huaijin Wang. 2025. “Programming Language Techniques for Bridging LLM Code Generation Semantic Gaps.” In Proceedings of the 1st ACM SIGPLAN International Workshop on Language Models and Programming Languages. ACM. https://doi.org/10.1145/3759425.3763383
Du, Jing, Dong Zhao, and Ou Zhang. 2018. “Impacts of Human Communication Network Topology on Group Optimism Bias in Capital Project Planning: A Human-Subject Experiment.” Construction Management and Economics 37 (1): 44–60. https://doi.org/10.1080/01446193.2018.1508848
Duan, Bin, Jun Wang, and Huajie Gu. 2014. “Modified Genetic Algorithm for Layout Optimization of Multi-Type Wind Turbines.” In 2014 American Control Conference. IEEE. https://doi.org/10.1109/acc.2014.6859416
Duarte, Ana, and Nuno Antunes. 2018. “An Empirical Study of Docker Vulnerabilities and of Static Code Analysis Applicability.” In 2018 Eighth Latin-American Symposium on Dependable Computing (LADC). IEEE. https://doi.org/10.1109/ladc.2018.00013
Dudeja, Tushar, and Abhishek Narayan Tripathi. 2026. “Explainable Ensemble Learning for FPGA Dynamic Power Estimation Using LLVM IR Features under Rigorous out-of-Sample Evaluation.” IEEE Access 14: 113249–60. https://doi.org/10.1109/access.2026.3716018
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
Dunaev, Dmitriy, Hassan Charaf, and Laszlo Lengyel. 2013. “A Method of Machine Code Translation to Intermediate Representation.” In 2013 IEEE 4th International Conference on Cognitive Infocommunications (CogInfoCom). IEEE. https://doi.org/10.1109/coginfocom.2013.6719206
Duncan, Ralph. 2017. “Managing Bytecode and ISA Compatibility with an Enhanced Toolchain.” In 2017 18th International Conference on Parallel and Distributed Computing, Applications and Technologies (PDCAT). IEEE. https://doi.org/10.1109/pdcat.2017.00073
Dung, Vu Quang, and Nguyen Viet Ha. 2008. “Real-Time Garbage Collection for Java Microprocessor.” In 2008 International Conference on Advanced Technologies for Communications. IEEE. https://doi.org/10.1109/atc.2008.4760590
Dxo, Mate Soos, Zoe Paraskevopoulou, Martin Lundfall, and Mikael Brockman. 2024. “Hevm, a Fast Symbolic Execution Framework for EVM Bytecode.” In Computer Aided Verification. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-65627-9_22
Dzhusupova, Rimma, Mina Ya-alimadad, Vasil Shteriyanov, Jan Bosch, and Helena Holmström Olsson. 2024. “Practical Software Development: Leveraging AI for Precise Cost Estimation in Lump-Sum EPC Projects.” In 2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner60148.2024.00110
D�az, A., and R. Lipton. 1997. “Optimal Material Layout for 3D Elastic Structures.” Structural Optimization 13 (1): 60–64. https://doi.org/10.1007/bf01198376
Eaddy, M., A. V. Aho, G. Antoniol, and Y.-G. Gueheneuc. 2008. “CERBERUS: Tracing Requirements to Source Code Using Information Retrieval, Dynamic Analysis, and Program Analysis.” In 2008 16th IEEE International Conference on Program Comprehension. IEEE. https://doi.org/10.1109/icpc.2008.39
Eberhart, Clovis, Jérémy Dubut, James Haydon, and Ichiro Hasuo. 2023. “Formal Verification of Safety Architectures for Automated Driving.” In 2023 IEEE Intelligent Vehicles Symposium (IV). IEEE. https://doi.org/10.1109/iv55152.2023.10186763
Eccles, John C. 1977. “An Instruction-Selection Theory of Learning in the Cerebellar Cortex.” Brain Research 127 (2): 327–52. https://doi.org/10.1016/0006-8993(77)90550-9
Eckart, J. D., and R. J. LeBlanc. 1987. “Distributed Garbage Collection.” ACM SIGPLAN Notices 22 (7): 264–73. https://doi.org/10.1145/960114.29678
Eckel, Natalie, and Joseph (Yossi) Gil. 2000. “Empirical Study of Object-Layout Strategies and Optimization Techniques.” In ECOOP 2000 — Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45102-1_20
Eckstein, Erik, Oliver König, and Bernhard Scholz. 2003. “Code Instruction Selection Based on SSA-Graphs.” In Software and Compilers for Embedded Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39920-9_5
Edison, Henry, and Nauman bin Ali. 2025. “Another Systematic Review? A Critical Analysis of Systematic Literature Reviews on Agile Effort and Cost Estimation.” In 2025 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). IEEE. https://doi.org/10.1109/esem64174.2025.00051
“Editor’s Note: Special Section on Mining Software Repositories.” 2019. Empirical Software Engineering 24 (6): 4107–8. https://doi.org/10.1007/s10664-019-09710-z
Eichberg, Michael. 2005. “BAT2XML: XML-Based Java Bytecode Representation.” Electronic Notes in Theoretical Computer Science 141 (1): 93–107. https://doi.org/10.1016/j.entcs.2005.02.035
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
Eigenmann, Rudi, and Sam Midkiff. 2013. “Compiler Infrastructure.” International Journal of Parallel Programming 41 (6): 751–52. https://doi.org/10.1007/s10766-013-0250-0
Eimouri, Taees, Kenneth B. Kent, and Aleksandar Micic. 2016a. “Effects of False Sharing and Locality on Object Layout Optimization for Multi-Threaded Applications.” In 2016 IEEE Canadian Conference on Electrical and Computer Engineering (CCECE). IEEE. https://doi.org/10.1109/ccece.2016.7726759
Eimouri, Taees, Kenneth B. Kent, Aleksandar Micic, and Karl Taylor. 2016b. “Object Layout Optimization in the JVM Based on Affinity.” In 2016 IEEE Canadian Conference on Electrical and Computer Engineering (CCECE). IEEE. https://doi.org/10.1109/ccece.2016.7726757
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
Ekman, Torbjörn, and Görel Hedin. 2007. “The JastAdd Extensible Java Compiler.” In Companion to the 22nd ACM SIGPLAN conference on Object-oriented programming systems and applications companion. ACM. https://doi.org/10.1145/1297846.1297938
El Beggar, Omar. 2023. “IFEJM: New Intuitionistic Fuzzy Expert Judgment Method for Effort Estimation in Agile Software Development.” Arabian Journal for Science and Engineering 49 (3): 2887–2908. https://doi.org/10.1007/s13369-023-07711-1
El Koutbi, Salma, and Ali Idri. 2017. “Entropy-Based Framework Dealing with Error in Software Development Effort Estimation.” In Proceedings of the 12th International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006312901950202
Elias, N. J., and A. W. Wetzel. 1983. “The IC Module Compiler, a VLSI System Design Aid.” In 20th Design Automation Conference Proceedings. IEEE. https://doi.org/10.1109/dac.1983.1585624
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
Ellul, Joshua, and Kirk Martinez. 2010. “Run-Time Compilation of Bytecode in Sensor Networks.” In 2010 Fourth International Conference on Sensor Technologies and Applications. IEEE. https://doi.org/10.1109/sensorcomm.2010.28
Elsheikh, yousef, Shaima Hameed, and Mohammad Azzeh. 2022. “An Optimized Case-Based Software Project Effort Estimation Using Genetic Algorithm.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.4019487
Elsman, Martin. 2003. “Garbage Collection Safety for Region-Based Memory Management.” ACM SIGPLAN Notices 38 (3): 123–34. https://doi.org/10.1145/640136.604190
Elsman, Martin. 2023. “Garbage-Collection Safety for Region-Based Type-Polymorphic Programs.” Proceedings of the ACM on Programming Languages 7 (PLDI): 221–43. https://doi.org/10.1145/3591229
Elsman, Martin, and Martin Dybdal. 2014. “Compiling a Subset of APL into a Typed Intermediate Language.” In Proceedings of ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming. ACM. https://doi.org/10.1145/2627373.2627390
Elsworth, W. F., and M. B. A. Parkes. 1990. “Automated Compiler Construction Based on Top-down Syntax Analysis and Attribute Evaluation.” ACM SIGPLAN Notices 25 (8): 37–42. https://doi.org/10.1145/87416.87429
Emrich, Frank, Sam Lindley, Jan Stolarek, James Cheney, and Jonathan Coates. 2020. “FreezeML: Complete and Easy Type Inference for First-Class Polymorphism.” In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3385412.3386003
Engelke, Alexis, and Martin Schulz. 2020. “Robust Practical Binary Optimization at Run-Time Using LLVM.” 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.00011
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
Engler, Dawson, and Madanlal Musuvathi. 2004. “Static Analysis versus Software Model Checking for Bug Finding.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24622-0_17
Enoumayri, Elhoussaine, Fatima Azzahra Amazal, and Fatima Ezzahra Boujida. 2025. “Feature Selection in Artificial Neural Network-Based Software Development Effort Estimation: A Systematic Mapping Study.” In 2025 International Conference on Intelligent Systems: Theories and Applications (SITA). IEEE. https://doi.org/10.1109/sita67914.2025.11273197
Erasmus, Izak Pierre, and Maya Daneva. 2013. “ERP Effort Estimation Based on Expert Judgments.” In 2013 Joint Conference of the 23rd International Workshop on Software Measurement and the 8th International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm-mensura.2013.25
Erasmus, Pierre, and Maya Daneva. 2015. “An Empirical Study on Memory Bias Situations and Correction Strategies in ERP Effort Estimation.” In Product-Focused Software Process Improvement. Springer International Publishing. https://doi.org/10.1007/978-3-319-26844-6_17
Ernst, Gidon, Jörg Pfähler, Gerhard Schellhorn, and Wolfgang Reif. 2016. “Inside a Verified Flash File System: Transactions and Garbage Collection.” In Verified Software: Theories, Tools, and Experiments. Springer International Publishing. https://doi.org/10.1007/978-3-319-29613-5_5
Ersoy, Ersin, and Hasan Sozer. 2022. “Effort Estimation for Architectural Refactoring of Data Tier Software.” In 2022 IEEE 19th International Conference on Software Architecture (ICSA). IEEE. https://doi.org/10.1109/icsa53651.2022.00016
Escobar-Avila, Javier. 2015. “Automatic Categorization of Software Libraries Using Bytecode.” In 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering. IEEE. https://doi.org/10.1109/icse.2015.249
Escobar-Avila, Javier, Mario Linares-Vasquez, and Sonia Haiduc. 2015. “Unsupervised Software Categorization Using Bytecode.” In 2015 IEEE 23rd International Conference on Program Comprehension. IEEE. https://doi.org/10.1109/icpc.2015.33
Evans, Huw, and Peter Dickman. 1997. “Garbage Collection and Memory Management.” In Addendum to the 1997 ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (Addendum). ACM. https://doi.org/10.1145/274567.274605
Evans, William S., and Christopher W. Fraser. 2001. “Bytecode Compression via Profiled Grammar Rewriting.” In Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/378795.378827
Eyolfson, Jonathan, and Patrick Lam. 2019. “How C++ Developers Use Immutability Declarations: An Empirical Study.” In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse.2019.00050
Ezghari, Soufiane, and Azeddine Zahi. 2018. “Uncertainty Management in Software Effort Estimation Using a Consistent Fuzzy Analogy-Based Method.” Applied Soft Computing 67: 540–57. https://doi.org/10.1016/j.asoc.2018.03.022
Ezghari, Soufiane, Azeddine Zahi, and Ali Idri. 2014. “A Learning Adaptation Cases Technique for Fuzzy Analogy-Based Software Development Effort Estimation.” In 2014 Second World Conference on Complex Systems (WCCS). IEEE. https://doi.org/10.1109/icocs.2014.7060958
“F2/XML: Managing XML Document Schema Evolution.” 2004. In Proceedings of the 4th International Workshop on Pattern Recognition in Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002640602510258
Fadhil, Anfal A., and Rasha Gh. Alsarraj. 2020. “Exploring the Whale Optimization Algorithm to Enhance Software Project Effort Estimation.” In 2020 6th International Engineering Conference “Sustainable Technology and Development” (IEC). IEEE. https://doi.org/10.1109/iec49899.2020.9122918
Fähndrich, Manuel, and Francesco Logozzo. 2011. “Static Contract Checking with Abstract Interpretation.” In Formal Verification of Object-Oriented Software. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-18070-5_2
Fairbairn, Jon. 1986. “A New Type-Checker for a Functional Language.” Science of Computer Programming 6: 273–90. https://doi.org/10.1016/0167-6423(86)90027-4
Falk, Heiko, Norman Schmitz, and Florian Schmoll. 2011. “WCET-Aware Register Allocation Based on Integer-Linear Programming.” In 2011 23rd Euromicro Conference on Real-Time Systems. IEEE. https://doi.org/10.1109/ecrts.2011.10
Famutimi, R. F., M. O. Oyelami, A. O. Ibitoye, and O. M. Awoniran. 2023. “An Empirical Comparison of the Performances of Single Structure Columnar in-Memory and Disk-Resident Data Storage Techniques Using Healthcare Big Data.” Journal of Big Data 10 (1): 25. https://doi.org/10.1186/s40537-023-00691-x
Fan, Penghao, Peiquan Jin, Yongping Luo, and Xiaoliang Wang. 2022. “Burger-Tree: A Three-Layer Cache-Conscious Tree Index for Persistent Memory.” In 2022 IEEE 24th Int Conf on High Performance Computing & Communications; 8th Int Conf on Data Science & Systems; 20th Int Conf on Smart City; 8th Int Conf on Dependability in Sensor, Cloud & Big Data Systems & Application (HPCC/DSS/SmartCity/DependSys). IEEE. https://doi.org/10.1109/hpcc-dss-smartcity-dependsys57074.2022.00152
Fan, Hao, and Alexandra Poulovassilis. 2004. “Schema Evolution in Data Warehousing Environments – a Schema Transformation-Based Approach.” In Conceptual Modeling – ER 2004. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30464-7_48
Fan, Guangsheng, and Dengping Wei. 2025. “Efficient Widening Operations for Static Analysis of Bit-Vector Programs.” In 2025 International Conference on Cyber Resilience and Endogenous Safety & Security (CRESS). IEEE. https://doi.org/10.1109/cress68073.2025.11452587
Fan, Yingying, Quanwei Yang, Kaisiyuan Wang, et al. 2025. “Re-HOLD: Video Hand Object Interaction Reenactment via Adaptive Layout-Instructed Diffusion Model.” In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE. https://doi.org/10.1109/cvpr52734.2025.01635
Fang, Huixing. 2026. “Compositional Formal Verification of Anti-Lock Braking System Neural Controllers.” Computers 15 (8): 509. https://doi.org/10.3390/computers15080509
Fang, Yong, Wenjie Zhang, Beibei Li, Fan Jing, and Lei Zhang. 2020. “Semi-Supervised Malware Clustering Based on the Weight of Bytecode and API.” IEEE Access 8: 2313–26. https://doi.org/10.1109/access.2019.2962198
Farhan, Athil Khaleel. 2023. “Divergence in the Translation of Criminal Law: A Corpus-Based Study of Prohibition in Iraqi Penal Code and Its English Translation.” Ampersand 10: 100104. https://doi.org/10.1016/j.amper.2022.100104
Faria, N., R. Silva, and J. L. Sobral. 2013. “Impact of Data Structure Layout on Performance.” In 2013 21st Euromicro International Conference on Parallel, Distributed, and Network-Based Processing. IEEE. https://doi.org/10.1109/pdp.2013.24
Farooq, Muhammad Umar, Lei Chen, and Lizy Kurian John. 2012. “Compiler Support for Value-Based Indirect Branch Prediction.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-28652-0_10
Farrow, Rodney. 1982. “Experience with an Attribute Grammar-Based Compiler.” In Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘82. ACM Press. https://doi.org/10.1145/582153.582164
Farrow, R., and A. G. Stanculescu. 1989. “A VHDL Compiler Based on Attribute Grammar Methodology.” In Proceedings of the ACM SIGPLAN 1989 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/73141.74829
“A Fault Injection Description Language for Compiler-Based SFI Tools.” 2015. In 2015 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW). IEEE. https://doi.org/10.1109/issrew.2015.7392034
Fawzy, Mohamed, Ahmed Elgohary, and Hala Ibrahim. 2020. “Noise Reduction in Reset Domain Crossings Verification Using Formal Verification.” In 2020 IEEE East-West Design & Test Symposium (EWDTS). IEEE. https://doi.org/10.1109/ewdts50664.2020.9224763
Feautrier, Paul. 2001. “Array Dataflow Analysis.” In Compiler Optimizations for Scalable Parallel Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45403-9_6
Fedushko, Solomiia, Roman Malyi, Yuriy Syerov, and Pavlo Serdyuk. 2024. “NoSQL Document Data Migration Strategy in the Context of Schema Evolution.” Data & Knowledge Engineering 154: 102369. https://doi.org/10.1016/j.datak.2024.102369
Fedyukovich, Grigory, Arie Gurfinkel, and Natasha Sharygina. 2014. “Incremental Verification of Compiler Optimizations.” In NASA Formal Methods. Springer International Publishing. https://doi.org/10.1007/978-3-319-06200-6_25
Feeley, Marc, and Guy Lapalme. 1987. “Using Closures for Code Generation.” Computer Languages 12 (1): 47–66. https://doi.org/10.1016/0096-0551(87)90012-9
Fei, Yang, and Yin Baolin. 2007. “Address Fragment-Compact Garbage Collection.” In Eighth ACIS International Conference on Software Engineering, Artificial Intelligence, Networking, and Parallel/Distributed Computing (SNPD 2007). IEEE. https://doi.org/10.1109/snpd.2007.248
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
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
Fellir, Fadoua, Khalid Nafil, and Lawrence Chung. 2018a. “Improving Case Based Software Effort Estimation by an Ant Colony Algorithm.” In 2018 6th International Conference on Control Engineering & Information Technology (CEIT). IEEE. https://doi.org/10.1109/ceit.2018.8751811
Fellir, Fadoua, Khalid Nafil, and Rajaa Touahni. 2015a. “Analyzing the Non-Functional Requirements to Improve Accuracy of Software Effort Estimation through Case Based Reasoning.” In 2015 10th International Conference on Intelligent Systems: Theories and Applications (SITA). IEEE. https://doi.org/10.1109/sita.2015.7358402
Feng, Wei, Xiaohua Shi, and Wenru Wang. 2018. “Eliminating Object Reference Checks by Escape Analysis on Real-Time Java Virtual Machine.” Cluster Computing 22 (S4): 9323–34. https://doi.org/10.1007/s10586-018-2145-8
Feng, Wei, Xiaohua Shi, and Hengyang Yu. 2015. “Optimizing Object Reference Checks on Real-Time Java Virtual Machine.” In 2015 6th IEEE International Conference on Software Engineering and Service Science (ICSESS). IEEE. https://doi.org/10.1109/icsess.2015.7339009
Feng, Zelin, and Rui Zhang. 2026. “Survey of Consensus Protocol’s Formal Verification.” Cybersecurity 9 (1): 81. https://doi.org/10.1186/s42400-025-00501-2
Fengxiang, Fan. 2006. “A Corpus-Based Empirical Study on Inter-Textual Vocabulary Growth.” Journal of Quantitative Linguistics 13 (1): 111–27. https://doi.org/10.1080/09296170500500603
Feret, Jérôme. 2001. “Abstract Interpretation-Based Static Analysis of Mobile Ambients.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-47764-0_24
Ferguson, Alex, and John Hughes. 1993. “Fast Abstract Interpretation Using Sequential Algorithms.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57264-3_28
Fernandez, J. C. 1993. “Abstract Interpretation and Verification of Reactive Systems.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57264-3_29
Fernandez-Basso, Carlos, Maria Dolores Ruiz, Miguel Molina-Solana, and Maria J. Martin-Bautista. 2026. “VizARE: An Intermediate Representation to Support the Visualization of Association Rules in Data Mining.” Future Internet 18 (7): 374. https://doi.org/10.3390/fi18070374
Fernandez-Diego, Marta, Sanae Elmouaden, and Jose-Maria Torralba-Martinez. 2012. “Software Effort Estimation Using NBC and SWR: A Comparison Based on ISBSG Projects.” In 2012 Joint Conference of the 22nd International Workshop on Software Measurement and the 2012 Seventh International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm-mensura.2012.28
Fernandez-Diego, Marta, Erwin R. Mendez, Fernando Gonzalez-Ladron-De-Guevara, Silvia Abrahao, and Emilio Insfran. 2020. “An Update on Effort Estimation in Agile Software Development: A Systematic Literature Review.” IEEE Access 8: 166768–166800. https://doi.org/10.1109/access.2020.3021664
Ferrara, Pietro. 2008. “Static Analysis of the Determinism of Multithreaded Programs.” In 2008 Sixth IEEE International Conference on Software Engineering and Formal Methods. IEEE. https://doi.org/10.1109/sefm.2008.14
Ferrara, Pietro. 2009. “Checkmate: A Generic Static Analyzer of Java Multithreaded Programs.” In 2009 Seventh IEEE International Conference on Software Engineering and Formal Methods. IEEE. https://doi.org/10.1109/sefm.2009.20
Ferrara, Pietro. 2010. “Static Type Analysis of Pattern Matching by Abstract Interpretation.” In Formal Techniques for Distributed Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-13464-7_15
Ferrara, Pietro, Agostino Cortesi, and Fausto Spoto. 2020. “From CIL to Java Bytecode: Semantics-Based Translation for Static Analysis Leveraging.” Science of Computer Programming 191: 102392. https://doi.org/10.1016/j.scico.2020.102392
Ferrari, Davide, Angela Sara Cacciapuoti, Michele Amoretti, and Marcello Caleffi. 2021. “Compiler Design for Distributed Quantum Computing.” IEEE Transactions on Quantum Engineering 2: 1–20. https://doi.org/10.1109/tqe.2021.3053921
Ferrari, Luca, and Haibin Zhu. 2009. “Making Agent Roles Perceivable through Proxy Bytecode Manipulation.” In 2009 International Symposium on Collaborative Technologies and Systems. IEEE. https://doi.org/10.1109/cts.2009.5067508
Ferrucci, Filomena, Carmine Gravino, Rocco Oliveto, and Federica Sarro. 2010. “Genetic Programming for Effort Estimation: An Analysis of the Impact of Different Fitness Functions.” In 2nd International Symposium on Search Based Software Engineering. IEEE. https://doi.org/10.1109/ssbse.2010.20
Ferrucci, Filomena, Carmine Gravino, and Federica Sarro. 2011. “How Multi-Objective Genetic Programming Is Effective for Software Development Effort Estimation?” In Search Based Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-23716-4_28
Ficara, D., S. Giordano, G. Procissi, and F. Vitucci. 2008. “Blooming Trees: Space-Efficient Structures for Data Representation.” In 2008 IEEE International Conference on Communications. IEEE. https://doi.org/10.1109/icc.2008.1090
Ficsor, Attila, Tímea Czvetkó, and János Abonyi. 2025. “Flow-Field Network-Based Analysis of Manufacturing Layout.” Results in Engineering 28: 107481. https://doi.org/10.1016/j.rineng.2025.107481
Fijalkow, Nathanaël, Engel Lefaucheux, Pierre Ohlmann, Joël Ouaknine, Amaury Pouly, and James Worrell. 2019. “On the Monniaux Problem in Abstract Interpretation.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-32304-2_9
Filatov, Alexander, and Vitaly Mikheev. 2020. “Evaluation of Thread-Local Garbage Collection.” In 2020 Ivannikov Memorial Workshop (IVMEM). IEEE. https://doi.org/10.1109/ivmem51402.2020.00009
Filè, G., and P. Sottero. 1991. “Abstract Interpretation for Type Checking.” In Programming Language Implementation and Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-54444-5_108
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
Finnie, G. R., G. E. Wittig, and J-M. Desharnais. 1997. “A Comparison of Software Effort Estimation Techniques: Using Function Points with Neural Networks, Case-Based Reasoning and Regression Models.” Journal of Systems and Software 39 (3): 281–89. https://doi.org/10.1016/s0164-1212(97)00055-1
“First Commercial Ada Compiler.” 1983. Data Processing 25 (7): 44. https://doi.org/10.1016/0011-684x(83)90258-7
Firth, Niall. 2014. “Code Generation.” New Scientist 223 (2985): 38–41. https://doi.org/10.1016/s0262-4079(14)61724-3
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
Florea, Adrian, and Arpad Gellert. 2016. “E-Learning Approach of the Graph Coloring Problem Applied to Register Allocation in Embedded Systems.” In 2016 Sixth International Conference on Innovative Computing Technology (INTECH). IEEE. https://doi.org/10.1109/intech.2016.7845027
Flyvbjerg, Bent. 2007. “Curbing Optimism Bias and Strategic Misrepresentation in Planning: Reference Class Forecasting in Practice.” European Planning Studies 16 (1): 3–21. https://doi.org/10.1080/09654310701747936
Flyvbjerg, Bent. 2018. “Planning Fallacy or Hiding Hand: Which Is the Better Explanation?” World Development 103: 383–86. https://doi.org/10.1016/j.worlddev.2017.10.002
Focardi, Riccardo. 2005. “Static Analysis of Authentication.” In Foundations of Security Analysis and Design III. Springer Berlin Heidelberg. https://doi.org/10.1007/11554578_4
Fong, Joseph, and San Kuen Cheung. 2005. “Translating Relational Schema into XML Schema Definition with Data Semantic Preservation and XSD Graph.” Information and Software Technology 47 (7): 437–62. https://doi.org/10.1016/j.infsof.2004.09.010
Fong, Anthony S., C. H. Yau, and Yiyu Tan. 2010. “An Object-Oriented Processor with Just-In-Time Compilation Support.” In 2010 International Symposium on Computer, Communication, Control and Automation (3CA). IEEE. https://doi.org/10.1109/3ca.2010.5533826
“Formal Verification of Financial Algorithms with Imandra.” 2018. In 2018 Formal Methods in Computer Aided Design (FMCAD). IEEE. https://doi.org/10.23919/fmcad.2018.8602992
“Formal Verification of Safety Behaviours of the Outdoor Robot Ravon.” 2007. In Proceedings of the Fourth International Conference on Informatics in Control, Automation and Robotics. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0001619101570164
“Formal Verification of Unsatisfiability Results.” 2018. In 2018 Formal Methods in Computer Aided Design (FMCAD). IEEE. https://doi.org/10.23919/fmcad.2018.8603012
Fornaia, Andrea, Stefano Scafiti, and Emiliano Tramontana. 2019. “JSCAN: Designing an Easy to Use LLVM-Based Static Analysis Framework.” In 2019 IEEE 28th International Conference on Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE). IEEE. https://doi.org/10.1109/wetice.2019.00058
Forsyth, D. K., and C. D. B. Burt. 2008. “Allocating Time to Future Tasks: The Effect of Task Segmentation on Planning Fallacy Bias.” Memory & Cognition 36 (4): 791–98. https://doi.org/10.3758/mc.36.4.791
“Fourth International Workshop on Mining Software Repositories-TOC.” 2007a. In Fourth International Workshop on Mining Software Repositories (MSR’07:ICSE Workshops 2007). IEEE. https://doi.org/10.1109/msr.2007.12
“Fourth International Workshop on Mining Software Repositories: Cover.” 2007b. In Fourth International Workshop on Mining Software Repositories (MSR’07:ICSE Workshops 2007). IEEE. https://doi.org/10.1109/msr.2007.11
Fox, G., and W. Furmanski. 1996. “Towards Web/Java-Based High Performance Distributed Computing-an Evolving Virtual Machine.” In Proceedings of 5th IEEE International Symposium on High Performance Distributed Computing HPDC-96. IEEE. https://doi.org/10.1109/hpdc.1996.546201
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
Franconi, Enrico, Fabio Grandi, and Federica Mandreoli. 2001. “Schema Evolution and Versioning: A Logical and Computational Characterisation.” In Database Schema Evolution and Meta-Modeling. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48196-6_5
Franz, M. 1998. “The Java Virtual Machine: A Passing Fad?” IEEE Software 15 (6): 26–29. https://doi.org/10.1109/52.730834
Frederiksen, Carl Christian. 2002. “Correctness of Classical Compiler Optimizations Using CTL.” Electronic Notes in Theoretical Computer Science 65 (2): 37–51. https://doi.org/10.1016/s1571-0661(04)80395-5
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. 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
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
Frias, Leonor, Jordi Petit, and Salvador Roura. 2006. “Lists Revisited: Cache Conscious STL Lists.” In Experimental Algorithms. Springer Berlin Heidelberg. https://doi.org/10.1007/11764298_11
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
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
Fromherz, Aymeric, Abdelraouf Ouadjaout, and Antoine Miné. 2018. “Static Value Analysis of Python Programs by Abstract Interpretation.” In NASA Formal Methods. Springer International Publishing. https://doi.org/10.1007/978-3-319-77935-5_14
Fruja, Nicu G. 2006. “Type Safety of Generics for the .NET Common Language Runtime.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/11693024_22
Fruja, Nicu G. 2008. “Towards Proving Type Safety of .NET CIL.” Science of Computer Programming 72 (3): 176–219. https://doi.org/10.1016/j.scico.2008.05.004
Fu, Xiong, and Ru-chuan Wang. 2009. “Structure Splitting Framework for Data-Layout Optimization.” Journal of China Universities of Posts and Telecommunications 16 (5): 107–13. https://doi.org/10.1016/s1005-8885(08)60276-9
Fu, Xiong, Yu Zhang, and Yiyun Chen. 2006. “Data-Layout Optimization Using Reuse Distance Distribution.” In Emerging Directions in Embedded and Ubiquitous Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/11807964_86
Fuchs, Matthew. 1995. “Garbage Collection on an Open Network.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_27
Fukai, Tomoki. 1994. “A Model of Cortical Memory Processing Based on Columnar Organization.” Biological Cybernetics 70 (5): 427–34. https://doi.org/10.1007/bf00203235
Fukui, Seiji, Akito Monden, and Zeynep Yucel. 2018. “Kurtosis and Skewness Adjustment for Software Effort Estimation.” In 2018 25th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2018.00065
Fumero, Juan, György Rethy, Athanasios Stratikopoulos, Nikos Foutris, and Christos Kotselidis. 2023. “Beehive SPIR-V Toolkit: A Composable and Functional API for Runtime SPIR-V Code Generation.” In Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3623507.3623555
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
Furr, Michael, and Jeffrey S. Foster. 2005. “Checking Type Safety of Foreign Function Calls.” In Proceedings of the 2005 ACM SIGPLAN conference on Programming language design and implementation. ACM. https://doi.org/10.1145/1065010.1065019
Furulund, Kristian Marius, and Kjetil Molkken-stvold. 2007. “Increasing Software Effort Estimation Accuracy Using Experience Data, Estimation Models and Checklists.” In Seventh International Conference on Quality Software (QSIC 2007). IEEE. https://doi.org/10.1109/qsic.2007.4385518
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
Gabrani, Goldie, and Neha Saini. 2016. “Effort Estimation Models Using Evolutionary Learning Algorithms for Software Development.” In 2016 Symposium on Colossal Data Analysis and Networking (CDAN). IEEE. https://doi.org/10.1109/cdan.2016.7570916
Gad, Ruediger, Martin Kappes, and Inmaculada Medina-Bulo. 2015. “Improving Network Traffic Acquisition and Processing with the Java Virtual Machine.” In 2015 IEEE Symposium on Computers and Communication (ISCC). IEEE. https://doi.org/10.1109/iscc.2015.7405539
Gadke, Hagen, and Andreas Koch. 2007. “Comrade: A Compiler for Adaptive Computing Systems Using a Novel Fast Speculation Technique.” In 2007 International Conference on Field Programmable Logic and Applications. IEEE. https://doi.org/10.1109/fpl.2007.4380700
Gagnon, Etienne, and Laurie Hendren. 2003. “Effective Inline-Threaded Interpretation of Java Bytecode Using Preparation Sequences.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36579-6_13
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
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
Galustov, Artemiy, Alexey Borodin, and Andrey Belevantsev. 2022. “Devirtualization for Static Analysis with Low Level Intermediate Representation.” In 2022 Ivannikov Ispras Open Conference (ISPRAS). IEEE. https://doi.org/10.1109/ispras57371.2022.10076859
Gamatie, Abdoulaye, and Laure Gonnord. 2011. “Static Analysis of Synchronous Programs in Signal for Efficient Design of Multi-Clocked Embedded Systems.” ACM SIGPLAN Notices 46 (5): 71–80. https://doi.org/10.1145/2016603.1967688
Gamatie, Abdoulaye, and Laure Gonnord. 2012. “Static Analysis of Synchronous Programs in Signal for Efficient Design of Multi-Clocked Embedded Systems.” ACM SIGPLAN Notices 47 (5): 71. https://doi.org/10.1145/2345141.1967688
Ganapathi, Mahadevan. 1989. “Prolog Based Retargetable Code Generation.” Computer Languages 14 (3): 193–204. https://doi.org/10.1016/0096-0551(89)90005-2
Ganesan, Karthik, Yao-Min Chen, and Xiaochen Pan. 2014. “Scaling Java Virtual Machine on a Many-Core System.” In 2014 International Symposium on Integrated Circuits (ISIC). IEEE. https://doi.org/10.1109/isicir.2014.7029556
Ganesh, Kalidas, Youngjae Kim, Monobrata Debnath, Sungyong Park, and Junghee Lee. 2017. “LAWC: Optimizing Write Cache Using Layout-Aware I/O Scheduling for All Flash Storage.” IEEE Transactions on Computers 66 (11): 1890–1902. https://doi.org/10.1109/tc.2017.2707408
Gangadharan, G. R., and Martin Butler. 2012. “Free and Open Source Software Adoption in Emerging Markets: An Empirical Study in the Education Sector.” In Open Source Systems: Long-Term Sustainability. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-33442-9_16
Gange, Graeme, Jorge A. Navas, Peter Schachte, Harald Søndergaard, and Peter J. Stuckey. 2013. “Abstract Interpretation over Non-Lattice Abstract Domains.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-38856-9_3
Gannon, John D. 1973. “Language and Compiler Design to Enhance Reliability.” ACM SIGPLAN Notices 8 (6): 47–49. https://doi.org/10.1145/986953.986975
Ganzinger, Harald, Robert Giegerich, Ulrich Möncke, and Reinhard Wilhelm. 1982. “A Truly Generative Semantics-Directed Compiler Generator.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.806993
Gao, Cuifeng, Ao Chen, Chengze Wu, Wenzhang Yang, Jiaming Ye, and Yinxing Xue. 2026. “Are Static Analysis Tools Still Working during the Evolution of Smart Contracts? A Comprehensive Empirical Study.” ACM Transactions on Software Engineering and Methodology 35 (8): 1–31. https://doi.org/10.1145/3779429
Gao, Du, and RuiJing Dong. 2025. “Stealthier Backdoor Attacks for Multimodal Models: Bidirectional Triggers via Coverless Steganography and Semantic Preservation.” In 2025 3rd International Conference On Mobile Internet, Cloud Computing and Information Security (MICCIS). IEEE. https://doi.org/10.1109/miccis66057.2025.00025
Gao, Xuesong, and Junfeng Zhao. 2023. “Context-Dependent Text-to-SQL Generation with Intermediate Representation.” In PRICAI 2023: Trends in Artificial Intelligence. Springer Nature Singapore. https://doi.org/10.1007/978-981-99-7019-3_21
Garcia, Miguel. 2010. “Compiler Plugins Can Handle Nested Languages: AST-Level Expansion of LINQ Queries for Java.” In Object Databases. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-14681-7_3
Garcia, Andres Amaya, David May, and Ed Nutting. 2020. “Garbage Collection for Edge Computing.” In 2020 IEEE/ACM Symposium on Edge Computing (SEC). IEEE. https://doi.org/10.1109/sec50012.2020.00044
Garcia-Diaz, Noel, Cuauhtemoc Lopez-Martin, and Arturo Chavoya. 2013. “A Comparative Study of Two Fuzzy Logic Models for Software Development Effort Estimation.” Procedia Technology 7: 305–14. https://doi.org/10.1016/j.protcy.2013.04.038
Garg, Radhika, and Xiao Wang. 2025. “Smaug: Modular Augmentation of LLVM for MPC.” In 2025 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp61157.2025.00188
Garzella, Jack J., Marek Baranowski, Shaobo He, and Zvonimir Rakamarić. 2020. “Leveraging Compiler Intermediate Representation for Multi- and Cross-Language Verification.” In Verification, Model Checking, and Abstract Interpretation. Springer International Publishing. https://doi.org/10.1007/978-3-030-39322-9_5
Gąsior, Dariusz, and Maciej Drwal. 2012. “Decentralized Algorithm for Joint Data Placement and Rate Allocation in Content-Aware Networks.” In Computer Networks. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-31217-5_4
Gasior, Dariusz, and Maciej Drwal. 2012. “Two-Level Heuristic Algorithm for Utility-Based Data Placement and Rate Allocation in Content-Aware Networks.” In 2012 IEEE/IPSJ 12th International Symposium on Applications and the Internet. IEEE. https://doi.org/10.1109/saint.2012.56
Gaudel, M. C. 1980. “Specification of Compilers as Abstract Data Type Representations.” In Semantics-Directed Compiler Generation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-10250-7_21
Gautam, Swarnima Singh, and Vrijendra Singh. 2017. “A Comparative Study of Hybrid Models of Selective Classification and Dynamic Selection of Analogies for Software Development Effort Estimation.” In 2017 IEEE International Conference on Industrial and Information Systems (ICIIS). IEEE. https://doi.org/10.1109/iciinfs.2017.8300360
Gautam, Swarnima Singh, and Vrijendra Singh. 2018. “The State-of-the-Art in Software Development Effort Estimation.” Journal of Software: Evolution and Process 30 (12): e1983. https://doi.org/10.1002/smr.1983
Gautam, Swarnima Singh, and Vrijendra Singh. 2022. “Adaptive Discretization Using Golden Section to Aid Outlier Detection for Software Development Effort Estimation.” IEEE Access 10: 90369–87. https://doi.org/10.1109/access.2022.3200149
Gawanmeh, A., S. Tahar, and K. Winter. 2003. “Formal Verification of ASM Designs Using the MDG Tool.” In First International Conference onSoftware Engineering and Formal Methods, 2003.Proceedings.. IEEE. https://doi.org/10.1109/sefm.2003.1236223
Gayatri, Rahulkumar, Stephen L. Olivier, Christian R. Trott, Johannes Doerfert, Jan Ciesko, and Damien Lebrun-Grandie. 2023. “The Kokkos OpenMPTarget Backend: Implementation and Lessons Learned.” In OpenMP: Advanced Task-Based, Device and Compiler Programming. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-40744-4_7
“GCLViz: Garbage Collection vs. Latency Visualization.” 2014. In Proceedings of the 5th International Conference on Information Visualization Theory and Applications. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0004740902920299
Ge, Bao-shan, Wen-sheng Zhang, Yang Zhang, and Bo Li. 2007. “Study on Message Zero-Copy Communication and Protocol among Multi-DSPs.” In 2007 IEEE International Conference on Automation and Logistics. IEEE. https://doi.org/10.1109/ical.2007.4338609
Geller, Adam T., Justine Frank, and William J. Bowman. 2024. “Indexed Types for a Statically Safe WebAssembly.” Proceedings of the ACM on Programming Languages 8 (POPL): 2395–2424. https://doi.org/10.1145/3632922
Genaim, Samir, and Fausto Spoto. 2005. “Information Flow Analysis for Java Bytecode.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30579-8_23
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
Gencel, Cigdem. 2008. “How to Use COSMIC Functional Size in Effort Estimation Models?” In Software Process and Product Measurement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-89403-2_17
Genevès, Pierre, Nabil Layaïda, and Vincent Quint. 2011. “Impact of XML Schema Evolution.” ACM Transactions on Internet Technology 11 (1): 1–27. https://doi.org/10.1145/1993083.1993087
Geng, Hongna, Ming Zhong, Peihua Zhang, Fang Lv, and Xiaobing Feng. 2023. “OPTango: Multi-Central Representation Learning against Innumerable Compiler Optimization for Binary Diffing.” In 2023 IEEE 34th International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre59848.2023.00013
Genius, Daniela, Letitia W. Li, and Ludovic Apvrille. 2017. “Model-Driven Performance Evaluation and Formal Verification for Multi-Level Embedded System Design.” In Proceedings of the 5th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006140600780089
Geoffray, N., G. Thomas, G. Muller, P. Parrend, S. Frenot, and B. Folliot. 2009. “I-JVM: A Java Virtual Machine for Component Isolation in OSGi.” In 2009 IEEE/IFIP International Conference on Dependable Systems & Networks. IEEE. https://doi.org/10.1109/dsn.2009.5270296
Gerber, Richard, and Insup Lee. 1992. “Specification and Analysis of Resource-Bound Real-Time Systems.” In Real-Time: Theory in Practice. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032001
Getzinger, Thomas W. 1994. “The Costs and Benefits of Abstract Interpretation-Driven Prolog Optimization.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-58485-4_30
Ghanbari, Ali, and Lingming Zhang. 2019. “PraPR: Practical Program Repair via Bytecode Mutation.” In 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE. https://doi.org/10.1109/ase.2019.00116
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
Ghidini, Yan, Matheus Moreira, Lucas Brahm, Thais Webber, Ney Calazans, and Cesar Marcon. 2013. “Lasio 3D NoC Vertical Links Serialization: Evaluation of Latency and Buffer Occupancy.” In 2013 26th Symposium on Integrated Circuits and Systems Design (SBCCI). IEEE. https://doi.org/10.1109/sbcci.2013.6644891
Ghiglio, Pietro, Uwe Dolinsky, Mehdi Goli, and Kumudha Narasimhan. 2023. “Improving Performance of SYCL Applications on CPU Architectures Using LLVM-Directed Compilation Flow.” Concurrency and Computation: Practice and Experience 35 (27): e7810. https://doi.org/10.1002/cpe.7810
Ghodrat, Mohammad Ali, Tony Givargis, and Alex Nicolau. 2007. “Short-Circuit Compiler Transformation: Optimizing Conditional Blocks.” In 2007 Asia and South Pacific Design Automation Conference. IEEE. https://doi.org/10.1109/aspdac.2007.358036
Ghosal, Arkadeb, Daniel Iercan, Christoph M. Kirsch, Thomas A. Henzinger, and Alberto Sangiovanni-Vincentelli. 2012. “Separate Compilation of Hierarchical Real-Time Programs into Linear-Bounded Embedded Machine Code.” Science of Computer Programming 77 (2): 96–112. https://doi.org/10.1016/j.scico.2010.06.004
Ghosh, Souradip, Michael Cuevas, Simone Campanoni, and Peter Dinda. 2020. “Compiler-Based Timing for Extremely Fine-Grain Preemptive Parallelism.” In SC20: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/sc41405.2020.00057
Ghosh, Somnath, Abhay Kanhere, Rakesh Krishnaiyer, et al. 2003. “Integrating High-Level Optimizations in a Production Compiler: Design and Implementation Experience.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36579-6_22
Ghoting, Amol, Gregory Buehrer, Matthew Goyder, et al. 2007. “Knowledge and Cache Conscious Algorithm Design and Systems Support for Data Mining Algorithms.” In 2007 IEEE International Parallel and Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2007.370500
Ghoting, Amol, Gregory Buehrer, Srinivasan Parthasarathy, et al. 2006. “Cache-Conscious Frequent Pattern Mining on Modern and Emerging Processors.” VLDB Journal 16 (1): 77–96. https://doi.org/10.1007/s00778-006-0025-y
Giacobazzi, Roberto. 1998. “A Tutorial on Domain Theory in Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-49727-7_21
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
Giacobazzi, Roberto, and Isabella Mastroeni. 2012. “Making Abstract Interpretation Incomplete: Modeling the Potency of Obfuscation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-33125-1_11
Giacobazzi, Roberto, and Isabella Mastroeni. 2022. “Property-Driven Code Obfuscations Reinterpreting Jones-Optimality in Abstract Interpretation.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-22308-2_12
Giacobazzi, Roberto, Isabella Mastroeni, and Elia Perantoni. 2024. “Adversities in Abstract Interpretation: Accommodating Robustness by Abstract Interpretation.” ACM Transactions on Programming Languages and Systems 46 (2): 1–31. https://doi.org/10.1145/3649309
Giacobazzi, Roberto, and Francesco Ranzato. 2002. “States vs. Traces in Model Checking by Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45789-5_32
Giagnorio, Alessandro, Alberto Martin-Lopez, and Gabriele Bavota. 2025. “Enhancing Code Generation for Low-Resource Languages: No Silver Bullet.” In 2025 IEEE/ACM 33rd International Conference on Program Comprehension (ICPC). IEEE. https://doi.org/10.1109/icpc66645.2025.00058
Gibert, E., J. Sanchez, and A. Gonzalez. 2003. “Flexible Compiler-Managed L0 Buffers for Clustered VLIW Processors.” In Proceedings. 36th Annual IEEE/ACM International Symposium on Microarchitecture, 2003. MICRO-36.. IEEE. https://doi.org/10.1109/micro.2003.1253205
Gil, Joseph (Yossi), William Pugh, Grant E. Weddell, and Yoav Zibin. 2008. “Two-Dimensional Bidirectional Object Layout.” ACM Transactions on Programming Languages and Systems 30 (5): 1–38. https://doi.org/10.1145/1387673.1387677
Giunta, Rosario, Giuseppe Pappalardo, and Emiliano Tramontana. 2014. “A Redundancy-Based Attack Detection Technique for Java Card Bytecode.” In 2014 IEEE 23rd International WETICE Conference. IEEE. https://doi.org/10.1109/wetice.2014.60
Gladstein, David S., and Mitchell Wand. 1996. “Compiler Correctness for Concurrent Languages.” In Coordination Languages and Models. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61052-9_49
Glaser, H. W., and P. Thompson. 1987. “Lazy Garbage Collection.” Software: Practice and Experience 17 (1): 1–4. https://doi.org/10.1002/spe.4380170102
Glew, Neal, Tim Sweeney, and Leaf Petersen. 2013. “A Multivalued Language with a Dependent Type System.” In Proceedings of the 2013 ACM SIGPLAN workshop on Dependently-typed programming. ACM. https://doi.org/10.1145/2502409.2502412
Glukhikh, Mikhail, Mikhail Moiseev, and Sergey Salishev. 2013. “A Static Analysis Approach for Verification of Synchronization Correctness of SystemC Designs.” In 2013 Euromicro Conference on Digital System Design. IEEE. https://doi.org/10.1109/dsd.2013.17
Gobert, Maxime, Jerome Maes, Anthony Cleve, and Jens Weber. 2013. “Understanding Schema Evolution as a Basis for Database Reengineering.” In 2013 IEEE International Conference on Software Maintenance. IEEE. https://doi.org/10.1109/icsm.2013.75
Goeders, Jeffrey, and Steve J. E. Wilton. 2015. “Using Dynamic Signal-Tracing to Debug Compiler-Optimized HLS Circuits on FPGAs.” In 2015 IEEE 23rd Annual International Symposium on Field-Programmable Custom Computing Machines. IEEE. https://doi.org/10.1109/fccm.2015.25
Goerigk, Wolfgang, and Ulrich Hoffmann. 1999. “Rigorous Compiler Implementation Correctness: How to Prove the Real Thing Correct.” In Applied Formal Methods — FM-Trends 98. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48257-1_7
Goldberg, Benjamin. 1991. “Tag-Free Garbage Collection for Strongly Typed Programming Languages.” ACM SIGPLAN Notices 26 (6): 165–76. https://doi.org/10.1145/113446.113460
Goldberg, Benjamin. 1992. “Incremental Garbage Collection without Tags.” In ESOP ‘92. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-55253-7_12
Goldenberg, Dror, Michael Kagan, Ran Ravid, and Michael S. Tsirkin. 2005. “Transparently Achieving Superior Socket Performance Using Zero Copy Socket Direct Protocol over 20Gb/s InfiniBand Links.” In 2005 IEEE International Conference on Cluster Computing. IEEE. https://doi.org/10.1109/clustr.2005.347027
Gomes, Renata Martins, and Marcel Baunach. 2019. “Code Generation from Formal Models for Automatic RTOS Portability.” In 2019 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2019.8661170
Gong, Hongbin, Zhirong Shen, and Jiwu Shu. 2022. “Accelerating Garbage Collection of 3D Flash Memory via Exploiting Inter-Channel Parallelism.” In 2022 IEEE 40th International Conference on Computer Design (ICCD). IEEE. https://doi.org/10.1109/iccd56317.2022.00033
Gong, Yujian, Wei Xi, Hui Han, and Jiawei Yan. 2020. “Research on a Reliable Method of Receiving Data Based on Zero-Copy Non-Drop Packet Network Card.” In 2020 22nd International Conference on Advanced Communication Technology (ICACT). IEEE. https://doi.org/10.23919/icact48636.2020.9061402
González-Castaño, F. J., L. Anido-Rifón, J. M. Pousada-Carballo, P. S. Rodríguez-Hernández, and R. López-Gómez. 2001. “A Java/CORBA Virtual Machine Architecture for Remote Execution of Optimization Solvers in Heterogeneous Networks.” Software: Practice and Experience 31 (1): 1–16. https://doi.org/10.1002/1097-024x(200101)31:1<1::aid-spe354>3.0.co;2-c
González-Ladrón-de-Guevara, Fernando, Marta Fernández-Diego, and Chris Lokan. 2016. “The Usage of ISBSG Data Fields in Software Effort Estimation: A Systematic Mapping Study.” Journal of Systems and Software 113: 188–215. https://doi.org/10.1016/j.jss.2015.11.040
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
Gopinath, P., T. Bihari, and R. Gupta. 1992. “Compiler Support for Object-Oriented Real-Time Software.” IEEE Software 9 (5): 45–50. https://doi.org/10.1109/52.156896
Gordon, J. D., C. K. Capstick, and A. Salvadori. 1977. “An Empirical Study of Cobol Programmers.” INFOR: Information Systems and Operational Research 15 (2): 229–41. https://doi.org/10.1080/03155986.1977.11731668
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
Gori, Roberta, and Giorgio Levi. 2002. “An Experiment in Type Inference and Verification by Abstract Interpretation.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-47813-2_16
Gorin, J., M. Wipliez, J. Piat, F. Preteux, and M. Raulet. 2010b. “An LLVM-Based Decoder for MPEG Reconfigurable Video Coding.” In 2010 IEEE Workshop On Signal Processing Systems. IEEE. https://doi.org/10.1109/sips.2010.5624767
Gorin, Jérôme, Matthieu Wipliez, Françoise Prêteux, and Mickaël Raulet. 2010a. “LLVM-Based and Scalable MPEG-RVC Decoder.” Journal of Real-Time Image Processing 6 (1): 59–70. https://doi.org/10.1007/s11554-010-0169-2
Gorin, J., M. Wipliez, F. Preteux, and M. Raulet. 2010c. “A Portable Video Tool Library for MPEG Reconfigurable Video Coding Using LLVM Representation.” In 2010 Conference on Design and Architectures for Signal and Image Processing (DASIP). IEEE. https://doi.org/10.1109/dasip.2010.5706263
Gorla, N., A. C. Benander, and B. A. Benander. 1990. “Debugging Effort Estimation Using Software Metrics.” IEEE Transactions on Software Engineering 16 (2): 223–31. https://doi.org/10.1109/32.44385
Gotti, Sara, and Samir Mbarki. 2016. “Toward IFVM Virtual Machine: A Model Driven IFML Interpretation.” In Proceedings of the 11th International Joint Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0005986102200225
Goubault, Eric. 2013. “Static Analysis by Abstract Interpretation of Numerical Programs and Systems, and FLUCTUAT.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-38856-9_1
Goubault, Eric, Stéphane Le Roux, Jeremy Leconte, Leo Liberti, and Fabrizio Marinelli. 2010. “Static Analysis by Abstract Interpretation: A Mathematical Programming Approach.” Electronic Notes in Theoretical Computer Science 267 (1): 73–87. https://doi.org/10.1016/j.entcs.2010.09.007
Goubault, Eric, and Sylvie Putot. 2011. “Static Analysis of Finite Precision Computations.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-18275-4_17
Gough, K. John, and Diane Corney. 2000. “Evaluating the Java Virtual Machine as a Target for Languages Other than Java.” In Modular Programming Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/10722581_22
Gouraud, Sandrine-Dominique, and Arnaud Gotlieb. 2005. “Using CHRs to Generate Functional Test Cases for the Java Card Virtual Machine.” In Practical Aspects of Declarative Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/11603023_1
Govil, Nikhil. 2021. “Analyzing Software Effort Estimation by Applying Static, Single & Multi-Variable Models.” In 2021 5th International Conference on Computing Methodologies and Communication (ICCMC). IEEE. https://doi.org/10.1109/iccmc51019.2021.9418286
Goyal, Somya. 2022b. “Effective Software Effort Estimation Using Heterogenous Stacked Ensemble.” In 2022 IEEE International Conference on Signal Processing, Informatics, Communication and Energy Systems (SPICES). IEEE. https://doi.org/10.1109/spices52834.2022.9774231
Graham. 1980. “Table-Driven Code Generation.” Computer 13 (8): 25–34. https://doi.org/10.1109/mc.1980.1653744
Granger, Philippe. 1997. “Static Analyses of Congruence Properties on Rational Numbers (Extended Abstract).” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032748
Granlund, Torbjörn, and Richard Kenner. 1992. “Eliminating Branches Using a Superoptimizer and the GNU C Compiler.” In Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation - PLDI ‘92. ACM Press. https://doi.org/10.1145/143095.143146
Graver, Justin O. 1992. “The Evolution of an Object-Oriented Compiler Framework.” Software: Practice and Experience 22 (7): 519–35. https://doi.org/10.1002/spe.4380220703
Gray, J. P., I. Buchanan, and P. S. Robertson. 1982. “Designing Gate Arrays Using a Silicon Compiler.” In 19th Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1982.1585527
Greaves, David. 1995. “The CSYN Verilog Compiler and Other Tools.” In Field-Programmable Logic and Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60294-1_113
Gregg, David, and M. Anton Ertl. 2006. “Optimizing Code-Copying JIT Compilers for Virtual Stack Machines.” Concurrency and Computation: Practice and Experience 18 (11): 1465–84. https://doi.org/10.1002/cpe.1016
Gregg, David, M. Anton Ertl, and Andreas Krall. 2001. “Implementing an Efficient Java Interpreter.” In High-Performance Computing and Networking. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48228-8_70
Gregg, David, James Power, and John Waldron. 2003. “Platform Independent Dynamic Java Virtual Machine Analysis: The Java Grande Forum Benchmark Suite.” Concurrency and Computation: Practice and Experience 15 (3–5): 459–84. https://doi.org/10.1002/cpe.666
Gregor, Michal, and Juraj Spalek. 2016. “Using LLVM-Based JIT Compilation in Genetic Programming.” In 2016 ELEKTRO. IEEE. https://doi.org/10.1109/elektro.2016.7512108
Grelck, Clemens. 2001. “Improving Cache Effectiveness through Array Data Layout Manipulation in SAC.” In Implementation of Functional Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45361-x_14
Griffiths, M. 1974. “Introduction to Compiler Compilers.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3540069585_59
Grimaud, Gilles, Jean-Louis Lanet, and Jean-Jacques Vandewalle. 1999. “FACADE: A Typed Intermediate Language Dedicated to Smart Cards.” In Software Engineering — ESEC/FSE ’99. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48166-4_29
Grimm, Tomás, Djones Lettnin, and Michael Hübner. 2018. “A Survey on Formal Verification Techniques for Safety-Critical Systems-on-Chip.” Electronics 7 (6): 81. https://doi.org/10.3390/electronics7060081
Grimstad, S., M. Jorgensen, and K. Molokken-Ostvold. 2005. “The Clients’ Impact on Effort Estimation Accuracy in Software Development Projects.” In 11th IEEE International Software Metrics Symposium (METRICS’05). IEEE. https://doi.org/10.1109/metrics.2005.30
Grimstad, Stein, Magne Jørgensen, and Kjetil Moløkken-Østvold. 2006. “Software Effort Estimation Terminology: The Tower of Babel.” Information and Software Technology 48 (4): 302–10. https://doi.org/10.1016/j.infsof.2005.04.004
Griss, Martin L., Eric Benson, and Anthony C. Hearn. 1982. “Current Status of a Portable LISP Compiler.” In Proceedings of the 1982 SIGPLAN symposium on Compiler construction - SIGPLAN ‘82. ACM Press. https://doi.org/10.1145/800230.807001
Grivas, Georgios. 1994. “Towards a Constraint Functional Logic Compiler for Symbolic Computation Systems.” In Programming Language Implementation and Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-58402-1_35
Grobelna, Iwona. 2020. “Formal Verification of Control Modules in Cyber-Physical Systems.” Sensors 20 (18): 5154. https://doi.org/10.3390/s20185154
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
Grolinger, Katarina, and Miriam A. M. Capretz. 2011. “A Unit Test Approach for Database Schema Evolution.” Information and Software Technology 53 (2): 159–70. https://doi.org/10.1016/j.infsof.2010.10.002
Grosse, Daniel, Hoang M. Le, and Rolf Drechsler. 2009. “Induction-Based Formal Verification of SystemC TLM Designs.” In 2009 10th International Workshop on Microprocessor Test and Verification. IEEE. https://doi.org/10.1109/mtv.2009.16
Grossman, Dan. 2007. “The Transactional Memory / Garbage Collection Analogy.” ACM SIGPLAN Notices 42 (10): 695–706. https://doi.org/10.1145/1297105.1297080
Grund, Daniel, and Jan Reineke. 2009. “Abstract Interpretation of FIFO Replacement.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-03237-0_10
Gu, W., N. A. Burns, M. T. Collins, and W. Y. P. Wong. 2000. “The Evolution of a High-Performing Java Virtual Machine.” IBM Systems Journal 39 (1): 135–50. https://doi.org/10.1147/sj.391.0135
Guan, Yuyan, Hai Lu, and M. H. Franco Wong. 2009. “Conflict-of-Interest Reforms and Analysts’ Research Biases.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.1340703
Guan, Dongli, Miguel Ramirez, and Zhilei Chen. 2013. “Split Intein Mediated Ultra-Rapid Purification of Tagless Protein (SIRP).” Biotechnology and Bioengineering 110 (9): 2471–81. https://doi.org/10.1002/bit.24913
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
Guan, Xiaofeng, Hao Zhou, Guoqing Bao, Handong Li, Liang Zhu, and Jianguo Yao. 2024. “PresCount: Effective Register Allocation for Bank Conflict Reduction.” In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo57630.2024.10444841
Guedes, Luiz Carlos Castro, Edward Hermann Haeusler, and José Lucas Rangel. 1995. “Object Oriented Semantics Directed Compiler Generation: A Prototype.” In TAPSOFT ‘95: Theory and Practice of Software Development. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-59293-8_244
Guellil, Safia, and Marc Sánchez-Artigas. 2025. “Optimizing WebAssembly Garbage Collection in Go: Performance Insights, Tuning Tips, and Batch Execution Strategies.” In 2025 IEEE 45th International Conference on Distributed Computing Systems (ICDCS). IEEE. https://doi.org/10.1109/icdcs63083.2025.00071
Güemes-Peña, Diego, Carlos López-Nozal, Raúl Marticorena-Sánchez, and Jesús Maudes-Raedo. 2018. “Emerging Topics in Mining Software Repositories: Machine Learning in Software Repositories and Datasets.” Progress in Artificial Intelligence 7 (3): 237–47. https://doi.org/10.1007/s13748-018-0147-7
Guendouzi, Badra Souhila, Samir Ouchani, Hiba Al Assaad, and Madeleine El Zaher. 2025. “Ensuring the Federation Correctness: Formal Verification of Federated Learning in Industrial Cyber-Physical Systems.” Future Generation Computer Systems 166: 107675. https://doi.org/10.1016/j.future.2024.107675
Guerrini, Giovanna, and Marco Mesiti. 2008. “X-Evolution: A Comprehensive Approach for XML Schema Evolution.” In 2008 19th International Conference on Database and Expert Systems Applications. IEEE. https://doi.org/10.1109/dexa.2008.128
Guglani, Samir. 2014. “Medicine Unboxed: Voices and Frontiers.” Lancet 384 (9946): 838–39. https://doi.org/10.1016/s0140-6736(14)61414-8
Guglani, Sam. 2023. “Medicine Unboxed 2023: Matter—What Is Your Substance, Whereof Are You Made?” Lancet 401 (10379): 805. https://doi.org/10.1016/s0140-6736(23)00332-x
Gui, Xian-Zhou. 1992. “Design of an Object-Oriented Real-Time Simulation Host Language YHSIM-1/VAX Compiler.” IFAC Proceedings Volumes 25 (11): 209–12. https://doi.org/10.1016/s1474-6670(17)50149-4
Guilan, Dai, Tian Jinlan, Zhang Suqing, and Jiang Weidu. 2003. “An Abstract Intermediate Representation in Compilation Systems.” ACM SIGPLAN Notices 38 (2): 12–18. https://doi.org/10.1145/772970.772972
Guimarães, José de Oliveira. 2003. “Experiences in Building a Compiler for an Object-Oriented Language.” ACM SIGPLAN Notices 38 (4): 25–33. https://doi.org/10.1145/844091.844098
Gulabovska, Hristina, and Zoltán Porkoláb. 2019. “Towards More Sophisticated Static Analysis Methods of Python Programs.” In 2019 IEEE 15th International Scientific Conference on Informatics. IEEE. https://doi.org/10.1109/informatics47936.2019.9119307
Gumasing, Ma. Janice J., and Zharlene B. Sasot. 2019. “An Occupational Risk Analysis of Garbage Collection Tasks in the Philippines.” In 2019 IEEE 6th International Conference on Industrial Engineering and Applications (ICIEA). IEEE. https://doi.org/10.1109/iea.2019.8715109
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
Gunawan, Dani, Amalia Amalia, Fanindia Purnamasari, and Charlie. 2021. “Application Prototype for Scientific Paper Layout Inspection.” In 2021 International Conference on Data Science, Artificial Intelligence, and Business Analytics (DATABIA). IEEE. https://doi.org/10.1109/databia53375.2021.9650110
Gunji, Kenta, Kazunori Ohno, Shotaro Kojima, et al. 2022. “LayoutSLAM: Object Layout Based Simultaneous Localization and Mapping for Reducing Object Map Distortion.” In 2022 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). IEEE. https://doi.org/10.1109/iros47612.2022.9981492
Guo, Zhi, Betul Buyukkurt, John Cortes, Abhishek Mitra, and Walild Najjar. 2008a. “A Compiler Intermediate Representation for Reconfigurable Fabrics.” International Journal of Parallel Programming 36 (5): 493–520. https://doi.org/10.1007/s10766-008-0080-7
Guo, Xiaolong, Raj Gautam Dutta, Prabhat Mishra, and Yier Jin. 2016. “Automatic RTL-to-Formal Code Converter for IP Security Formal Verification.” In 2016 17th International Workshop on Microprocessor and SOC Test and Verification (MTV). IEEE. https://doi.org/10.1109/mtv.2016.23
Guo, Jiayang, Yiming Hu, Bo Mao, and Suzhen Wu. 2017. “Parallelism and Garbage Collection Aware I/O Scheduler with Improved SSD Performance.” In 2017 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE. https://doi.org/10.1109/ipdps.2017.55
Guo, Hui, Ignacio Laguna, and Cindy Rubio-Gonzalez. 2020. “PLINER: Isolating Lines of Floating-Point Code for Compiler-Induced Variability.” In SC20: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/sc41405.2020.00053
Guo, Yijun, Zhenyu Liu, Yintan Ai, and Hua Li. 2024a. “SPV: Formal Verification of Stateful Parallel SFC Correctness.” In 2024 IEEE 48th Annual Computers, Software, and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac61105.2024.00107
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, Zhi, and Walid Najjar. 2006. “A Compiler Intermediate Representation for Reconfigurable Fabrics.” In 2006 International Conference on Field Programmable Logic and Applications. IEEE. https://doi.org/10.1109/fpl.2006.311304
Guo, Zhi, Walid Najjar, and Betul Buyukkurt. 2008b. “Efficient Hardware Code Generation for FPGAs.” ACM Transactions on Architecture and Code Optimization 5 (1): 1–26. https://doi.org/10.1145/1369396.1369402
Gupta, Manish, and Edith Schonberg. 1996. “Static Analysis to Reduce Synchronization Costs in Data-Parallel Programs.” In Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘96. ACM Press. https://doi.org/10.1145/237721.237799
Gupta, R., M. L. Soffa, and T. Steele. 1989. “Register Allocation via Clique Separators.” In Proceedings of the ACM SIGPLAN 1989 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/73141.74842
Gurumoorthy, Karthik S., Amit Dhurandhar, Guillermo Cecchi, and Charu Aggarwal. 2019. “Efficient Data Representation by Selecting Prototypes with Importance Weights.” In 2019 IEEE International Conference on Data Mining (ICDM). IEEE. https://doi.org/10.1109/icdm.2019.00036
Gutiérrez, David Basanta, Cándida Luengo Díez, Raul Izquierdo Castanedo, Jose Emilio Labra Gayo, and Juan Manuel Cueva. 2000. “Improving the Quality of Compiler Construction with Object-Oriented Techniques.” ACM SIGPLAN Notices 35 (12): 41–50. https://doi.org/10.1145/369928.369944
Gutjahr, W. J. 1995. “Optimal Test Distributions for Software Failure Cost Estimation.” IEEE Transactions on Software Engineering 21 (3): 219–28. https://doi.org/10.1109/32.372149
Gwak, Hyunho, Yunji Kang, and Dongkun Shin. 2015. “Reducing Garbage Collection Overhead of Log-Structured File Systems with GC Journaling.” In 2015 International Symposium on Consumer Electronics (ISCE). IEEE. https://doi.org/10.1109/isce.2015.7177770
Haarslev, Volker, and Ralf Möller. 1992. “Visualization and Graphical Layout in Object-Oriented Systems.” Journal of Visual Languages & Computing 3 (1): 1–23. https://doi.org/10.1016/1045-926x(92)90031-g
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
Haba, Cristian-Gyozo, and Derek Pappas. 2014. “CSLC: The Infrastructure Compiler for SoC Design.” In 2014 International Conference on Development and Application Systems (DAS). IEEE. https://doi.org/10.1109/daas.2014.6842445
Hackett, Brian, and Shu-yu Guo. 2012. “Fast and Precise Hybrid Type Inference for JavaScript.” In Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2254064.2254094
Hafez, Hisham, Michal P. Drewniok, Anne P. M. Velenturf, and Phil Purnell. 2024. “A Resource-Bound Critical Analysis of the Decarbonisation Roadmaps for the UK Foundation Industries by 2050.” Environments 11 (7): 153. https://doi.org/10.3390/environments11070153
Hafiz, Munawar, Samir Hasan, Zachary King, and Allen Wirfs-Brock. 2016. “Growing a Language: An Empirical Study on How (and Why) Developers Use Some Recently-Introduced And/or Recently-Evolving JavaScript Features.” Journal of Systems and Software 121: 191–208. https://doi.org/10.1016/j.jss.2016.04.045
Hagberg, Rasmus, Martin Hell, and Christoph Reichenbach. 2021. “Using Program Analysis to Identify the Use of Vulnerable Functions.” In Proceedings of the 18th International Conference on Security and Cryptography. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010548200002998
Hagen, George, and Cesare Tinelli. 2008. “Scaling up the Formal Verification of Lustre Programs with SMT-Based Techniques.” In 2008 Formal Methods in Computer-Aided Design. IEEE. https://doi.org/10.1109/fmcad.2008.ecp.19
Hagiya, Masami, and Akihiko Tozawa. 1998. “On a New Method for Dataflow Analysis of Java Virtual Machine Subroutines.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-49727-7_2
Haindl, Philipp, and Patrick Kochberger. 2026. “Twenty Years of the Java Virtual Machine Tool Interface: A Systematic Literature Review.” Information and Software Technology 198: 108233. https://doi.org/10.1016/j.infsof.2026.108233
Hajmasan, Gheorghe, Alexandra Mondoc, and Octavian Cret. 2019. “Bytecode Heuristic Signatures for Detecting Malware Behavior.” In 2019 Conference on Next Generation Computing Applications (NextComp). IEEE. https://doi.org/10.1109/nextcomp.2019.8883668
Halbwachs, Nicolas. 1994. “About Synchronous Programming and Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-58485-4_40
Hall, Mary. 2021. “Data Layout and Data Representation Optimizations to Reduce Data Movement (Keynote).” In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo51591.2021.9370325
Hall, Jon G., Clem Baker-Finch, Phil Trinder, and David J. King. 1999. “Towards an Operational Semantics for a Parallel Non-Strict Functional Language.” In Implementation of Functional Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48515-5_4
Hallem, Seth, Benjamin Chelf, Yichen Xie, and Dawson Engler. 2002. “A System and Language for Building System-Specific, Static Analyses.” In Proceedings of the ACM SIGPLAN 2002 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/512529.512539
Hallenberg, Niels, Martin Elsman, and Mads Tofte. 2002. “Combining Region Inference and Garbage Collection.” In Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation - PLDI ‘02. ACM Press. https://doi.org/10.1145/512545.512547
Hamada, Ryouji, and Xiao-Nan Lu. 2024. “Improved Quasi-Random Designs with Constant Pool Sizes for Group Testing.” In 2024 International Symposium on Information Theory and Its Applications (ISITA). IEEE. https://doi.org/10.23919/isita60732.2024.10858283
Hamann, Tobias, Mihai Herda, Heiko Mantel, Martin Mohr, David Schneider, and Markus Tasch. 2018. “A Uniform Information-Flow Security Benchmark Suite for Source Code and Bytecode.” In Secure IT Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-03638-6_27
Hamburg, Mark C. 1986. “Two Tagless Variations on the Deutsch-Schorr-Waite Algorithm.” Information Processing Letters 22 (4): 179–83. https://doi.org/10.1016/0020-0190(86)90024-4
Hameed, Shaima, Yousef Elsheikh, and Mohammad Azzeh. 2023. “An Optimized Case-Based Software Project Effort Estimation Using Genetic Algorithm.” Information and Software Technology 153: 107088. https://doi.org/10.1016/j.infsof.2022.107088
Hamilton, G. W. 1995. “Compile-Time Garbage Collection for Lazy Functional Languages.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_21
Hamilton, James, and Sebastian Danicic. 2009. “An Evaluation of Current Java Bytecode Decompilers.” In 2009 Ninth IEEE International Working Conference on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2009.24
Hammami, O. 2008. “Heterogeneous Multiprocessor on Chip Compiler, Architecture, Place and Route Design Space Exploration.” In MELECON 2008 - The 14th IEEE Mediterranean Electrotechnical Conference. IEEE. https://doi.org/10.1109/melcon.2008.4618468
Hammond, Simon, and David Lacey. 2006. “Loop Transformations in the Ahead-of-Time Optimization of Java Bytecode.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/11688839_11
Hamza, Haitham, Amr Kamel, and Khaled Shams. 2013. “Software Effort Estimation Using Artificial Neural Networks: A Survey of the Current Practices.” In 2013 10th International Conference on Information Technology: New Generations. IEEE. https://doi.org/10.1109/itng.2013.111
Han, Jongwoo, Haejoo Jeon, Dongmin Shin, and Chang-Gun Lee. 2022. “LC-CB: Low Computational Victim Selection Policy in Garbage Collection.” In 2022 IEEE International Conference on Networking, Architecture and Storage (NAS). IEEE. https://doi.org/10.1109/nas55553.2022.9925496
Han, Youngsun, Seon Wook Kim, and Chulwoo Kim. 2005. “Jaguar: A Compiler Infrastructure for Java Reconfigurable Computing.” In Embedded Software and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/11599555_37
Han, Hwansoo, Gabriel Rivera, and Chau-Wen Tseng. 2000. “Compiler and Run-Time Support for Improving Locality in Scientific Codes.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44905-1_30
Hance, Travis, Laila Elbeheiry, Yusuke Matsushita, and Derek Dreyer. 2026. “VerusBelt: A Semantic Foundation for Verus’s Proof-Oriented Extensions to the Rust Type System.” Proceedings of the ACM on Programming Languages 10 (PLDI): 1962–86. https://doi.org/10.1145/3808325
Handjieva, Maria. 1996. “Stan: A Static Analyzer for CLP({ie383-01}) Based on Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61739-6_54
Haneef, Israr, Rao Muhammad Adeel Nawab, Ehsan Ullah Munir, and Imran Sarwar Bajwa. 2019. “Design and Development of a Large Cross-Lingual Plagiarism Corpus for Urdu-English Language Pair.” Scientific Programming 2019: 1–11. https://doi.org/10.1155/2019/2962040
Hanenberg, Stefan, Sebastian Kleinschmager, Romain Robbes, Éric Tanter, and Andreas Stefik. 2013. “An Empirical Study on the Impact of Static Typing on Software Maintainability.” Empirical Software Engineering 19 (5): 1335–82. https://doi.org/10.1007/s10664-013-9289-1
Hang, Jen-Hin, Thein-Lai Wong, Wah-Pheng Lee, and Yee-Mei Lim. 2024. “Asset Modelling for Efficient Data Representation in Industry 4.0.” In 2024 3rd International Conference on Digital Transformation and Applications (ICDXA). IEEE. https://doi.org/10.1109/icdxa61007.2024.10470887
Hanna, Ziyad. 2014. “Challenging Problems in Industrial Formal Verification.” In 2014 Formal Methods in Computer-Aided Design (FMCAD). IEEE. https://doi.org/10.1109/fmcad.2014.6987583
Hanna, Ziyad. 2015. “Democratization of Formal Verification with Collective Intelligence.” In 2015 Formal Methods in Computer-Aided Design (FMCAD). IEEE. https://doi.org/10.1109/fmcad.2015.7542243
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
Hao, Song, Zhihui Du, David Bader, and Yin Ye. 2009. “A Partition-Merge Based Cache-Conscious Parallel Sorting Algorithm for CMP with Shared Cache.” In 2009 International Conference on Parallel Processing. IEEE. https://doi.org/10.1109/icpp.2009.26
Hao, Shuai, Ding Li, William G. J. Halfond, and Ramesh Govindan. 2012. “Estimating Android Applications’ CPU Energy Usage via Bytecode Profiling.” In 2012 First International Workshop on Green and Sustainable Software (GREENS). IEEE. https://doi.org/10.1109/greens.2012.6224263
Hardin, D. S. 2001. “Crafting a Java Virtual Machine in Silicon.” IEEE Instrumentation & Measurement Magazine 4 (1): 54–56. https://doi.org/10.1109/5289.911178
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
Haripriyan, H. K., Y. N. Srikant, and Priti Shankar. 1988. “A Compiler Writing System Based on Affix Grammars.” Computer Languages 13 (1): 1–11. https://doi.org/10.1016/0096-0551(88)90002-1
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
Haris, Mohammad, Fang-Fang Chua, and Amy Hui-Lan Lim. 2024. “Diverse Bagging Effort Estimation Model for Software Development Project.” In Computational Science and Its Applications – ICCSA 2024. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-64608-9_19
Harish Kumar, K., and K. Srinivas. 2024. “An Improved Analogy-Rule Based Software Effort Estimation Using HTRR-RNN in Software Project Management.” Expert Systems with Applications 251: 124107. https://doi.org/10.1016/j.eswa.2024.124107
Hariyanto, Aris Marjuni, Nova Rijati, and Zainal Arifin Hasibuan. 2024. “Systematic Literature Review of Software Effort Estimation: Research Trends, Methods, and Datasets.” In 2024 International Seminar on Application for Technology of Information and Communication (iSemantic). IEEE. https://doi.org/10.1109/isemantic63362.2024.10762707
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. 2007. “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
Harper, Robert, and Greg Morrisett. 1995. “Compiling Polymorphism Using Intensional Type Analysis.” In Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘95. ACM Press. https://doi.org/10.1145/199448.199475
Harrand, Nicolas, Cesar Soto-Valero, Martin Monperrus, and Benoit Baudry. 2019. “The Strengths and Behavioral Quirks of Java Bytecode Decompilers.” In 2019 19th International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE. https://doi.org/10.1109/scam.2019.00019
Harrison, W. H. 1977. “Compiler Analysis of the Value Ranges for Variables.” IEEE Transactions on Software Engineering SE-3 (3): 243–50. https://doi.org/10.1109/tse.1977.231133
Harrison, Luddy. 1997. “Can Abstract Interpretation Become a Mainstream Compiler Technology?” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032760
Harrison, John. 2003. “Formal Verification of Square Root Algorithms.” Formal Methods in System Design 22 (2): 143–53. https://doi.org/10.1023/a:1022973506233
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
Hartel, Pieter H., and Luc Moreau. 2001. “Formalizing the Safety of Java, the Java Virtual Machine, and Java Card.” ACM Computing Surveys 33 (4): 517–58. https://doi.org/10.1145/503112.503115
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
Hasabnis, Niranjan, Rui Qiao, and R. Sekar. 2015. “Checking Correctness of Code Generator Architecture Specifications.” In 2015 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2015.7054197
Hascoët, Laurent. 2024. “Data-Flow Reversal and Garbage Collection.” ACM Transactions on Mathematical Software 50 (1): 1–20. https://doi.org/10.1145/3627537
Hasegawa, Haruhiko, Masayuki Shimoda, Hiroki Nakahara, and Takefumi Miyoshi. 2025. “A Novel Data Representation towards Efficient FPGA-Based Quantum Computer Simulation.” In 2025 IEEE 55th International Symposium on Multiple-Valued Logic (ISMVL). IEEE. https://doi.org/10.1109/ismvl64713.2025.00031
Hashmi, Jahanzeb Maqbool, Sourav Chakraborty, Mohammadreza Bayatpour, Hari Subramoni, and Dhabaleswar K. Panda. 2019. “FALCON: Efficient Designs for Zero-Copy MPI Datatype Processing on Emerging Architectures.” In 2019 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE. https://doi.org/10.1109/ipdps.2019.00045
Haslbeck, Maximilian P. L., and Peter Lammich. 2022. “For a Few Dollars More: Verified Fine-Grained Algorithm Analysis down to LLVM.” ACM Transactions on Programming Languages and Systems 44 (3): 1–36. https://doi.org/10.1145/3486169
Hassan, Ahmed E. 2008. “The Road Ahead for Mining Software Repositories.” In 2008 Frontiers of Software Maintenance. IEEE. https://doi.org/10.1109/fosm.2008.4659248
Hassan, A. E., A. Mockus, R. C. Holt, and P. M. Johnson. 2005. “Guest Editor’s Introduction: Special Issue on Mining Software Repositories.” IEEE Transactions on Software Engineering 31 (6): 426–28. https://doi.org/10.1109/tse.2005.70
Hassanali, Maryam, Mohammadreza Soltanaghaei, Taghi Javdani Gandomani, and Farsad Zamani Boroujeni. 2024. “Software Development Effort Estimation Using Boosting Algorithms and Automatic Tuning of Hyperparameters with Optuna.” Journal of Software: Evolution and Process 36 (9): e2665. https://doi.org/10.1002/smr.2665
Hastings, T. E., and A. S. M. Sajeev. 2001. “A Vector-Based Approach to Software Size Measurement and Effort Estimation.” IEEE Transactions on Software Engineering 27 (4): 337–50. https://doi.org/10.1109/32.917523
Haxthausen, Anne Elisabeth, Hoang Nga Nguyen, and Markus Roggenbach. 2016. “Comparing Formal Verification Approaches of Interlocking Systems.” In Reliability, Safety, and Security of Railway Systems. Modelling, Analysis, Verification, and Certification. Springer International Publishing. https://doi.org/10.1007/978-3-319-33951-1_12
Hay, Iain D., Jinping Du, Patricia Rubio Reyes, and Bernd H. A. Rehm. 2015. “In Vivo Polyester Immobilized Sortase for Tagless Protein Purification.” Microbial Cell Factories 14 (1): 190. https://doi.org/10.1186/s12934-015-0385-3
Hayes, Brett K., Jeremy Ngo, Guy E. Hawkins, and Ben R. Newell. 2017. “Causal Explanation Improves Judgment under Uncertainty, but Rarely in a Bayesian Way.” Memory & Cognition 46 (1): 112–31. https://doi.org/10.3758/s13421-017-0750-z
Hazarika, Akaash Vishal, and Monojit Banerjee. 2025. “Zero-Downtime Schema Evolution in Distributed Databases: A Theoretical Framework.” In 2025 IEEE International Conference on Computer, Electronics, Electrical Engineering & their Applications (IC2E3). IEEE. https://doi.org/10.1109/ic2e365635.2025.11167401
He, Zhen, Richard Lai, and Alonso Marquez. 2006. “On Using Cache Conscious Clustering for Improving OODBMS Performance.” Information and Software Technology 48 (11): 1073–82. https://doi.org/10.1016/j.infsof.2006.01.006
He, Xincheng, Xiaojin Liu, Lei Xu, and Baowen Xu. 2023. “How Dynamic Features Affect API Usages? An Empirical Study of API Misuses in Python Programs.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00055
He, Jiaqi, Yangjun Luo, Rui Wang, and Kun Cai. 2022. “A Dimensionality Reduction and Layout Optimization Scheme for Grid-Stiffened Structures.” Engineering Optimization 56 (3): 413–29. https://doi.org/10.1080/0305215x.2022.2155147
He, Zhen, and Alonso Marquez. 2001. “Cache Conscious Clustering C3.” In Database and Expert Systems Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44759-8_79
He, Zhen, and Alonso Marquez. 2006. “Path and Cache Conscious Prefetching (PCCP).” VLDB Journal 16 (2): 235–49. https://doi.org/10.1007/s00778-005-0174-4
He, Shuibing, Yang Wang, and Xian-He Sun. 2016. “Improving Performance of Parallel I/O Systems through Selective and Layout-Aware SSD Cache.” IEEE Transactions on Parallel and Distributed Systems 27 (10): 2940–52. https://doi.org/10.1109/tpds.2016.2521363
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
“Heap Garbage Collection with Reference Counting.” 2010. In Proceedings of the 5th International Conference on Software and Data Technologies. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002917502670270
Heering, J., and P. Klint. 1986. “The Efficiency of the Equation Interpreter Compared with the UNH Prolog Interpreter.” ACM SIGPLAN Notices 21 (2): 18–21. https://doi.org/10.1145/15022.15023
Heidari, Sayed, and Alexey Paznikov. 2022. “Multipurpose Cloud-Based Compiler Based on Microservice Architecture and Container Orchestration.” Symmetry 14 (9): 1818. https://doi.org/10.3390/sym14091818
Heidrich, Jens. 2013. “Software Effort Estimation and Risk Management.” In Product-Focused Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-39259-7_37
Heidrich, Jens, Markku Oivo, and Andreas Jedlitschka. 2015. “Software Productivity and Effort Estimation.” Journal of Software: Evolution and Process 27 (7): 465–66. https://doi.org/10.1002/smr.1722
Heines, T. S., and P. J. Jalics. 1988. “Compiler Performance Analysis Tools.” Software: Practice and Experience 18 (9): 917–21. https://doi.org/10.1002/spe.4380180908
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
Heldmann, Tim, Thomas Schneider, Oleksandr Tkachenko, Christian Weinert, and Hossein Yalame. 2021. “LLVM-Based Circuit Compilation for Practical Secure Computation.” In Applied Cryptography and Network Security. Springer International Publishing. https://doi.org/10.1007/978-3-030-78375-4_5
Helmstetter, Claude, and Olivier Ponsini. 2008. “A Comparison of Two SystemC/TLM Semantics for Formal Verification.” In 2008 6th ACM/IEEE International Conference on Formal Methods and Models for Co-Design. IEEE. https://doi.org/10.1109/memcod.2008.4547687
Henda, Noamen Ben, Karl Norrman, and Katharina Pfeffer. 2015. “Formal Verification of the Security for Dual Connectivity in LTE.” In 2015 IEEE/ACM 3rd FME Workshop on Formal Methods in Software Engineering. IEEE. https://doi.org/10.1109/formalise.2015.10
Henderson, Fergus. 2002. “Accurate Garbage Collection in an Uncooperative Environment.” ACM SIGPLAN Notices 38 (2 supplement): 150–56. https://doi.org/10.1145/773039.512449
Hendrawan, Yogi Muldani, Andri Pratama, Herman Budi Harja, Muhammad Udin Harun Al Rasyid, and Idris Winarno. 2021. “Inspection Code Generator for Hole Cylindrical Feature Evaluation in on-Machine Measurement Process for Computer-Aided Inspection Planning.” In 2021 International Conference on Computer Science and Engineering (IC2SE). IEEE. https://doi.org/10.1109/ic2se52832.2021.9791987
Henglein, Fritz, and Jesper Jørgensen. 1994. “Formally Optimal Boxing.” In Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘94. ACM Press. https://doi.org/10.1145/174675.177874
Henretty, Tom, Kevin Stock, Louis-Noël Pouchet, Franz Franchetti, J. Ramanujam, and P. Sadayappan. 2011. “Data Layout Transformation for Stencil Computations on Short-Vector SIMD Architectures.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-19861-8_13
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, David Monniaux, and Matthieu Moy. 2012. “Succinct Representations for Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-33125-1_20
Henry, Robert R., Kenneth M. Whaley, and Bruce Forstall. 1990. “The University of Washington Illustrating Compiler.” In Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation - PLDI ‘90. ACM Press. https://doi.org/10.1145/93542.93571
Hentenryck, Pascal, Olivier Degimbe, Baudouin Charlier, and Laurent Michel. 1993. “The Impact of Granularity in Abstract Interpretation of Prolog.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57264-3_25
Hentschel, Johannes, Yannis Rammos, Markus Neuwirth, and Martin Rohrmeier. 2025. “A Corpus and a Modular Infrastructure for the Empirical Study of (An)notated Music.” Scientific Data 12 (1): 685. https://doi.org/10.1038/s41597-025-04976-z
Henzinger, Thomas A., Rupak Majumdar, Freddy Mang, and Jean-François Raskin. 2000. “Abstract Interpretation of Game Properties.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-45099-3_12
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
Heo, Jun, Seungjin Woo, Hakbeom Jang, Kyungyeon Yang, and Jae W. Lee. 2016. “Improving JavaScript Performance via Efficient in-Memory Bytecode Caching.” In 2016 IEEE International Conference on Consumer Electronics-Asia (ICCE-Asia). IEEE. https://doi.org/10.1109/icce-asia.2016.7804810
Herber, Tobias, and Markus Weninger. 2025. “Trace-Based Bytecode Interpreter Visualization for Compiler Construction Education.” In 2025 IEEE Working Conference on Software Visualization (VISSOFT). IEEE. https://doi.org/10.1109/vissoft67405.2025.00010
Hericko, Tjasa, and Bostjan Sumak. 2022. “Analyzing Linter Usage and Warnings through Mining Software Repositories: A Longitudinal Case Study of JavaScript Packages.” In 2022 45th Jubilee International Convention on Information, Communication and Electronic Technology (MIPRO). IEEE. https://doi.org/10.23919/mipro55190.2022.9803554
Hermenegildo, Manuel V., Germán Puebla, Francisco Bueno, and Pedro López-García. 2003. “Program Development Using Abstract Interpretation (and the Ciao System Preprocessor).” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44898-5_8
Hertz, Matthew, Yi Feng, and Emery D. Berger. 2005. “Garbage Collection without Paging.” ACM SIGPLAN Notices 40 (6): 143–53. https://doi.org/10.1145/1064978.1065028
Hetherington, Marc J., Michael MacKuen, Isaac Mehlhaff, and Timothy J. Ryan. 2020. “Political Judgment under Uncertainty: Dampening Heuristics and Biases (Appendix).” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.3673492
Hewson, Fergus, Jens Dietrich, and Stephen Marsland. 2015. “Performance Regression Testing on the Java Virtual Machine Using Statistical Test Oracles.” In 2015 24th Australasian Software Engineering Conference. IEEE. https://doi.org/10.1109/aswec.2015.14
Heymann, Jürgen. 1991. “A Comprehensive Analytical Model for Garbage Collection Algorithms.” ACM SIGPLAN Notices 26 (8): 50–59. https://doi.org/10.1145/122598.122602
Hickey, Jason, Aleksey Nogin, and Adam Granicz. 2003a. “Compiler Implementation in a Formal Logical Framework.” In Proceedings of the 2003 ACM SIGPLAN workshop on Mechanized reasoning about languages with variable binding. ACM. https://doi.org/10.1145/976571.976575
Higuera-Toledano, M. Teresa. 2012. “Hardware-Based Object Layout in an Embedded Real-Time Java Environments.” In Proceedings of 2012 IEEE 17th International Conference on Emerging Technologies & Factory Automation (ETFA 2012). IEEE. https://doi.org/10.1109/etfa.2012.6489727
Hillenbrand, Andrea, Uta Storl, Maksym Levchenko, Shamil Nabiyev, and Meike Klettke. 2020. “Towards Self-Adapting Data Migration in the Context of Schema Evolution in NoSQL Databases.” In 2020 IEEE 36th International Conference on Data Engineering Workshops (ICDEW). IEEE. https://doi.org/10.1109/icdew49219.2020.00013
Hirnschrott, Ulrich, Andreas Krall, and Bernhard Scholz. 2003. “Graph Coloring vs. Optimal Register Allocation for Optimizing Compilers.” In Modular Programming Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-45213-3_26
Hirzel, Martin, and Amer Diwan. 2000. “On the Type Accuracy of Garbage Collection.” ACM SIGPLAN Notices 36 (1): 1–11. https://doi.org/10.1145/362426.362428
Hirzel, Martin, Amer Diwan, and Matthew Hertz. 2003. “Connectivity-Based Garbage Collection.” ACM SIGPLAN Notices 38 (11): 359–73. https://doi.org/10.1145/949343.949337
Hladůvka, Jiřı́, and Eduard Gröller. 2002. “Smallest Second-Order Derivatives for Efficient Volume-Data Representation.” Computers & Graphics 26 (2): 229–38. https://doi.org/10.1016/s0097-8493(02)00054-7
Ho, Manh-Toan. 2026. “Unboxing Japanese Videogames: A Metadata-Based Approach to the Production and Distribution of Spatial Instability: Martin Roth, Cambridge, Massachusetts: The MIT Press, 2025, Xvi, 129 Pp. + Notes, Bibliography, Index, (eBook), ISBN 978-0-26238-289-2 Https://direct.mit.edu/books/oa-monograph/5911/Unboxing-Japanese-VideogamesA-Metadata-Based.” Japanese Studies 46 (1): 135–37. https://doi.org/10.1080/10371397.2026.2657344
Hoaglin, David C. 1973. “An Analysis of the Loop Optimization Scores in Knuth’s ‘Empirical Study of FORTRAN Programs’.” Software: Practice and Experience 3 (2): 161–69. https://doi.org/10.1002/spe.4380030209
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
Hoare, C. A. R. 1974. “Optimization of Store Size for Garbage Collection.” Information Processing Letters 2 (6): 165–66. https://doi.org/10.1016/0020-0190(74)90005-2
Hoare, Tony. 2004. “Towards the Verifying Compiler.” In From Object-Orientation to Formal Methods. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39993-3_8
Hoare, C. A. R., He Jifeng, and A. Sampaio. 1993. “Normal Form Approach to Compiler Design.” Acta Informatica 30 (8): 701–39. https://doi.org/10.1007/bf01191809
Hoefler, Torsten, and Steven Gottlieb. 2010. “Parallel Zero-Copy Algorithms for Fast Fourier Transform and Conjugate Gradient Using MPI Datatypes.” In Recent Advances in the Message Passing Interface. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-15646-5_14
Hofer-Schmitz, Katharina, and Branka Stojanović. 2020. “Towards Formal Verification of IoT Protocols: A Review.” Computer Networks 174: 107233. https://doi.org/10.1016/j.comnet.2020.107233
Hoffmann, Christoph M. 1978. “Design and Correctness of a Compiler for a Non-Procedural Language.” Acta Informatica 9 (3): 217–41. https://doi.org/10.1007/bf00288883
Hoffmann, Christoph M. 1980. “Semantic Properties of Lucid’s Compute Clause and Its Compilation.” Acta Informatica 13 (1): 9–20. https://doi.org/10.1007/bf00288532
Hoffmann, Jan, Ankush Das, and Shu-Chun Weng. 2017. “Towards Automatic Resource Bound Analysis for OCaml.” ACM SIGPLAN Notices 52 (1): 359–73. https://doi.org/10.1145/3093333.3009842
Hofmann, Martin. 1996. “Conservativity of Equality Reflection over Intensional Type Theory.” In Types for Proofs and Programs. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61780-9_68
Hollmann, Jochen, Ruben Titos-Gil, and Per Stenstrom. 2015. “Enhancing Garbage Collection Synchronization Using Explicit Bit Barriers.” In 2015 44th International Conference on Parallel Processing. IEEE. https://doi.org/10.1109/icpp.2015.86
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
Holter, Karoliine, Juhan Oskar Hennoste, Patrick Lam, Simmo Saan, and Vesal Vojdani. 2024. “Abstract Debuggers: Exploring Program Behaviors Using Static Analysis Results.” In Proceedings of the 2024 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. ACM. https://doi.org/10.1145/3689492.3690053
Homma, Shota, Tatsuya Abe, and Hidekazu Suzuki. 2025. “Development of Grafana-Based Dashboard in Garbage Collection Visualization System.” In 2025 IEEE 14th Global Conference on Consumer Electronics (GCCE). IEEE. https://doi.org/10.1109/gcce65946.2025.11275331
Honda, Kohei, Vasco T. Vasconcelos, and Nobuko Yoshida. 2009. “Type-Directed Compilation for Multicore Programming.” Electronic Notes in Theoretical Computer Science 241: 101–11. https://doi.org/10.1016/j.entcs.2009.06.006
Hong, Jiaxin, Jianguo Hu, and Ge Lin. 2018. “A Java Card Virtual Machine Design Based on off-card/On-Card Co-Design Pre-Processing.” In Computer Engineering and Technology. Springer Singapore. https://doi.org/10.1007/978-981-10-7844-6_2
Hong, Tang, Chen Hua, Zhao Gang, Liu Qiang, and Zhao Jinjin. 2009. “The Vulnerability Analysis Framework for Java Bytecode.” In 2009 15th International Conference on Parallel and Distributed Systems. IEEE. https://doi.org/10.1109/icpads.2009.74
Hong, Sunghyun, Jin-Chul Kim, Soo-Mook Moon, et al. 2008. “Client Ahead-of-Time Compiler for Embedded Java Platforms.” Software: Practice and Experience 39 (3): 259–78. https://doi.org/10.1002/spe.897
Hong, SungHyun, Jin-Chul Kim, Jin Woo Shin, et al. 2007. “Java Client Ahead-of-Time Compiler for Embedded Systems.” ACM SIGPLAN Notices 42 (7): 63–72. https://doi.org/10.1145/1273444.1254776
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
Hongsasurath, Kritsada, and Twittie Senivongse. 2026. “Exploring Generative AI Factors and Their Impact on Software Development Effort Estimation.” In 2026 23rd International Joint Conference on Computer Science and Software Engineering (JCSSE). IEEE. https://doi.org/10.1109/jcsse68839.2026.11596763
Honsel, Verena, Daniel Honsel, and Jens Grabowski. 2014. “Software Process Simulation Based on Mining Software Repositories.” In 2014 IEEE International Conference on Data Mining Workshop. IEEE. https://doi.org/10.1109/icdmw.2014.35
Horning, James J. 1974. “Structuring Compiler Development.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-21549-4_18
Horton, Steven V., Thomas C. Lovitt, and Charles C. Christensen. 1991. “Notetaking from Textbooks: Effects of a Columnar Format on Three Categories of Secondary Students.” Exceptionality 2 (1): 19–40. https://doi.org/10.1080/09362839109524764
Horváth, Ferenc, Tamás Gergely, Árpád Beszédes, Dávid Tengeri, Gergő Balogh, and Tibor Gyimóthy. 2017. “Code Coverage Differences of Java Bytecode and Source Code Instrumentation Tools.” Software Quality Journal 27 (1): 79–123. https://doi.org/10.1007/s11219-017-9389-z
Horvath, Oswin, and Matthias Meyer. 2010. “Fine-Grained Parallel Compacting Garbage Collection through Hardware-Supported Synchronization.” In 2010 39th International Conference on Parallel Processing Workshops. IEEE. https://doi.org/10.1109/icppw.2010.28
Hosabettu, Ravi, Ganesh Gopalakrishnan, and Mandayam Srivas. 2003. “Formal Verification of a Complex Pipelined Processor.” Formal Methods in System Design 23 (2): 171–213. https://doi.org/10.1023/a:1024716316140
Hoshino, Tetsuya, Naoya Maruyama, and Satoshi Matsuoka. 2014. “An OpenACC Extension for Data Layout Transformation.” In 2014 First Workshop on Accelerator Programming using Directives. IEEE. https://doi.org/10.1109/waccpd.2014.12
Hosni, Mohamed. 2023. “Encoding Techniques for Handling Categorical Data in Machine Learning-Based Software Development Effort Estimation.” In Proceedings of the 15th International Joint Conference on Knowledge Discovery, Knowledge Engineering and Knowledge Management. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0012259400003598
Hosni, Mohamed. 2024. “Comparative Analysis of Single and Ensemble Support Vector Regression Methods for Software Development Effort Estimation.” In Proceedings of the 16th International Joint Conference on Knowledge Discovery, Knowledge Engineering and Knowledge Management. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013072300003838
Hosni, Mohamed, Ali Idri, and Alain Abran. 2018a. “Evaluating Filter Fuzzy Analogy Homogenous Ensembles for Software Development Effort Estimation.” Journal of Software: Evolution and Process 31 (2): e2117. https://doi.org/10.1002/smr.2117
Hosni, Mohamed, Ali Idri, and Alain Abran. 2018b. “Improved Effort Estimation of Heterogeneous Ensembles Using Filter Feature Selection.” In Proceedings of the 13th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006929104390446
Hosni, Mohamed, Ali Idri, Ali Bou Nassif, and Alain Abran. 2016. “Heterogeneous Ensembles for Software Development Effort Estimation.” In 2016 3rd International Conference on Soft Computing & Machine Intelligence (ISCMI). IEEE. https://doi.org/10.1109/iscmi.2016.15
Hosni, Mohamed, Ibtissam Medarhri, and Juan Carrillo de Gea. 2024. “Software Testing Effort Estimation Based on Machine Learning Techniques: Single and Ensemble Methods.” In Proceedings of the 16th International Joint Conference on Knowledge Discovery, Knowledge Engineering and Knowledge Management. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013072400003838
Hosoya, Haruo, and Akinori Yonezawa. 1998. “Garbage Collection via Dynamic Type Inference: A Formal Treatment -.” In Types in Compilation. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0055520
Höst, Martin, and Claes Wohlin. 1997. “A Subjective Effort Estimation Experiment.” Information and Software Technology 39 (11): 755–62. https://doi.org/10.1016/s0950-5849(97)00027-x
Hou, Jiawei, Wenhao Guan, Longfei Liang, Jianfeng Feng, Xiangyang Xue, and Taiping Zeng. 2025. “Topo-Field: Topometric Mapping with Brain-Inspired Hierarchical Layout-Object-Position Fields.” IEEE Robotics and Automation Letters 10 (6): 5385–92. https://doi.org/10.1109/lra.2025.3559836
Houy, Sabine, and Alexandre Bartel. 2024. “Lessons Learned and Challenges of Deploying Control Flow Integrity in Complex Software: The Case of OpenJDK’s Java Virtual Machine.” In 2024 IEEE Secure Development Conference (SecDev). IEEE. https://doi.org/10.1109/secdev61143.2024.00020
Howarth, Jason, Irfan Altas, and Barney Dalgarno. 2010. “Information Flow Control Using the Java Virtual Machine Tool Interface (JVMTI).” In 2010 International Conference on Availability, Reliability and Security. IEEE. https://doi.org/10.1109/ares.2010.75
Hsu, J., and O. Bair. 1992. “A Compiler for Optimal Adder Design.” In 1992 Proceedings of the IEEE Custom Integrated Circuits Conference. IEEE. https://doi.org/10.1109/cicc.1992.591843
Hsu, Chao-jung, and Chin-yu Huang. 2006. “Comparison and Assessment of Improved Grey Relation Analysis for Software Development Effort Estimation.” In 2006 IEEE International Conference on Management of Innovation and Technology, vol. 2. IEEE. https://doi.org/10.1109/icmit.2006.262302
Hsu, Chao-Jung, and Chin-Yu Huang. 2007. “Improving Effort Estimation Accuracy by Weighted Grey Relational Analysis during Software Development.” In 14th Asia-Pacific Software Engineering Conference (APSEC’07). IEEE. https://doi.org/10.1109/aspec.2007.62
Hsu, Chao-Jung, and Chin-Yu Huang. 2010. “Comparison of Weighted Grey Relational Analysis for Software Effort Estimation.” Software Quality Journal 19 (1): 165–200. https://doi.org/10.1007/s11219-010-9110-y
Hsu, Chung-Hsing, and Ulrich Kremer. 2003. “The Design, Implementation, and Evaluation of a Compiler Algorithm for CPU Energy Reduction.” ACM SIGPLAN Notices 38 (5): 38–48. https://doi.org/10.1145/780822.781137
Hsu, HsiaoYuan, and Yuxin Peng. 2025. “PosterO: Structuring Layout Trees to Enable Language Models in Generalized Content-Aware Layout Generation.” In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE. https://doi.org/10.1109/cvpr52734.2025.00760
Hu, Menghao. 2024. “Advancements and Prospects in Machine Learning-Driven Code Generation and Completion.” In Proceedings of the 1st International Conference on Modern Logistics and Supply Chain Management. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013332700004558
Hu, Weifang, Lin Han, Pu Han, and Jiandong Shang. 2021. “Automatic Thread Block Size Selection Strategy in GPU Parallel Code Generation.” In Parallel Architectures, Algorithms and Programming. Springer Singapore. https://doi.org/10.1007/978-981-16-0010-4_34
Hu, J. S., M. Kandemir, N. Vijaykrishnan, M. J. Irwin, H. Saputra, and W. Zhang. 2002. “Compiler-Directed Cache Polymorphism.” ACM SIGPLAN Notices 37 (7): 165–74. https://doi.org/10.1145/566225.513858
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, Naitian, Xingkong Ma, Fuqiang Lin, Bo Liu, and Tong Lu. 2020. “DexFus: An Android Obfuscation Technique Based on Dalvik Bytecode Translation.” In Frontiers in Cyber Security. Springer Singapore. https://doi.org/10.1007/978-981-15-9739-8_32
Hu, Jason Z. S., and Brigitte Pientka. 2024a. “A Layered Approach to Intensional Analysis in Type Theory.” ACM Transactions on Programming Languages and Systems 46 (4): 1–43. https://doi.org/10.1145/3707203
Hu, Jason Z. S., and Brigitte Pientka. 2024b. “Layered Modal Type Theory: Where Meta-Programming Meets Intensional Analysis.” In Programming Languages and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-57262-3_3
Hu, Jason Z. S., and Brigitte Pientka. 2025. “A Dependent Type Theory for Meta-Programming with Intensional Analysis.” Proceedings of the ACM on Programming Languages 9 (POPL): 416–45. https://doi.org/10.1145/3704851
Hu, Erik Yu-Shing, Andy J. Wellings, and Guillem Bernat. 2003. “Deriving Java Virtual Machine Timing Models for Portable Worst-Case Execution Time Analysis.” In On The Move to Meaningful Internet Systems 2003: OTM 2003 Workshops. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39962-9_48
Hu, Yonghua, Xin Zhang, Shuying Wang, Wei Liang, and Kuan-Ching Li. 2022b. “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
Hu Li, Tianjia Chen, and Wei Xu. 2016. “Improving Spark Performance with Zero-Copy Buffer Management and RDMA.” In 2016 IEEE Conference on Computer Communications Workshops (INFOCOM WKSHPS). IEEE. https://doi.org/10.1109/infcomw.2016.7562041
Huang, Zheng-Wei. 2009. “Cost Estimation of Software Project Development by Using Case-Based Reasoning Technology with Clustering Index Mechanism.” In 2009 Fourth International Conference on Innovative Computing, Information and Control (ICICIC). IEEE. https://doi.org/10.1109/icicic.2009.151
Huang, Claire, Stephen Blackburn, and Zixian Cai. 2023. “Improving Garbage Collection Observability with Performance Tracing.” In Proceedings of the 20th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3617651.3622986
Huang, Jiaxin, Kecheng Chen, Yazhou Ren, Jiayu Sun, Xiaorong Pu, and Ce Zhu. 2024. “Cross-Domain Low-Dose CT Image Denoising with Semantic Preservation and Noise Alignment.” IEEE Transactions on Multimedia 26: 8771–82. https://doi.org/10.1109/tmm.2024.3382509
Huang, Yukun, Rong Chen, Jingbo Wei, et al. 2014. “Hybrid PolyLingual Object Model: An Efficient and Seamless Integration of Java and Native Components on the Dalvik Virtual Machine.” Scientific World Journal 2014: 1–13. https://doi.org/10.1155/2014/785434
Huang, Sun-Jen, and Nan-Hsing Chiu. 2006. “Optimization of Analogy Weights by Genetic Algorithm for Software Effort Estimation.” Information and Software Technology 48 (11): 1034–45. https://doi.org/10.1016/j.infsof.2005.12.020
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
Huang, Jingjia, and Xincheng Huang. 2023. “Optimization of Data Protection in IoT Field of Cloud Computing Using Compiler Privacy Calculation Method.” In 2023 IEEE 8th International Conference On Software Engineering and Computer Systems (ICSECS). IEEE. https://doi.org/10.1109/icsecs58457.2023.10256412
Huang, Yuan, Jinbo Huang, Xiangping Chen, and Zibin Zheng. 2025d. “Towards Improving the Performance of Comment Generation Models by Using Bytecode Information.” IEEE Transactions on Software Engineering 51 (2): 503–20. https://doi.org/10.1109/tse.2024.3523713
Huang, Zixin, Jacob Laurel, Saikat Dutta, and Sasa Misailovic. 2025a. “AURA: Precise Abstract Interpretation of Probabilistic Programs with Interval Data Uncertainty.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-07106-4_6
Huang, Jianglin, Yan-Fu Li, Jacky Wai Keung, Yuen Tak Yu, and W. K. Chan. 2017. “An Empirical Analysis of Three-Stage Data-Preprocessing for Analogy-Based Software Effort Estimation on the ISBSG Data.” In 2017 IEEE International Conference on Software Quality, Reliability and Security (QRS). IEEE. https://doi.org/10.1109/qrs.2017.54
Huang, Shan, Jingjing Liang, Ting Su, and Qirun Zhang. 2025c. “Robustifying Debug Information Updates in LLVM via Control-Flow Conformance Analysis.” Proceedings of the ACM on Programming Languages 9 (PLDI): 527–49. https://doi.org/10.1145/3729267
Huang, Yanlong, Jierui Liu, Yuhan She, et al. 2026. “Chariot: Compiler-Aware Heterogeneous Graph Representation Learning for Automated HLS Optimization.” In 2026 IEEE 34th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm68464.2026.00052
Huang, Mingkai, Xianhua Liu, Tingyu Zhang, and Xu Cheng. 2015. “Exploration of the Relationship between Just-in-Time Compilation Policy and Number of Cores.” In Algorithms and Architectures for Parallel Processing. Springer International Publishing. https://doi.org/10.1007/978-3-319-27140-8_21
Huang, Changyun, Kazuhiro Yamashita, Yasutaka Kamei, Kenji Hisazumi, and Naoyasu Ubayashi. 2013a. “Domain Analysis for Mining Software Repositories: Towards Feature-Based DSL Construction.” In 2013 4th International Workshop on Product LinE Approaches in Software Engineering (PLEASE). IEEE. https://doi.org/10.1109/please.2013.6608663
Huangfu, Yijie, and Wei Zhang. 2014. “Compiler-Directed Leakage Energy Reduction for Instruction Scratch-Pad Memories.” In Fifteenth International Symposium on Quality Electronic Design. IEEE. https://doi.org/10.1109/isqed.2014.6783352
Hück, Alexander, Sebastian Kreutzer, and Christian Bischof. 2025. “Llvm-Dimeta: A Library for Extracting Source-Level Type Information in LLVM IR Using Debug Metadata.” In 2025 IEEE International Conference on Source Code Analysis & Manipulation (SCAM). IEEE. https://doi.org/10.1109/scam67354.2025.00019
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
Hughes, John. 1985. “A Distributed Garbage Collection Algorithm.” In Functional Programming Languages and Computer Architecture. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-15975-4_41
Hughes, Jacob, and Laurence Tratt. 2025. “Garbage Collection for Rust: The Finalizer Frontier.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 3588–3614. https://doi.org/10.1145/3763179
Huisman, Marieke. 2014. “SCP Special Issue on Bytecode 2012 – Preface.” Science of Computer Programming 92: 1. https://doi.org/10.1016/j.scico.2014.02.003
Hulaas, Jarle, and Walter Binder. 2008. “Program Transformations for Light-Weight CPU Accounting and Control in the Java Virtual Machine: A Systematic Review.” Higher-Order and Symbolic Computation 21 (1–2): 119–46. https://doi.org/10.1007/s10990-008-9026-4
Hung, Jason C., and Chun-Chia Wang. 2020. “Exploring the Website Object Layout of Responsive Web Design: Results of Eye Tracking Evaluations.” Journal of Supercomputing 77 (1): 343–65. https://doi.org/10.1007/s11227-020-03283-1
Hung, Po-Cheng, Po-Hsun Wu, Sheng-Kai Chen, and Shin-Hung Chang. 2024. “An Intelligent Robot with Autonomous for Garbage Collection and Compression.” In 2024 International Automatic Control Conference (CACS). IEEE. https://doi.org/10.1109/cacs63404.2024.10773273
Hur, Chung-Kil, Derek Dreyer, and Viktor Vafeiadis. 2011. “Separation Logic in the Presence of Garbage Collection.” In 2011 IEEE 26th Annual Symposium on Logic in Computer Science. IEEE. https://doi.org/10.1109/lics.2011.46
Hussain, Shujaat, Maqbool Hussain, Muhammad Afzal, et al. 2019. “Semantic Preservation of Standardized Healthcare Documents in Big Data.” International Journal of Medical Informatics 129: 133–45. https://doi.org/10.1016/j.ijmedinf.2019.05.024
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
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
Hymans, Charles. 2002. “Checking Safety Properties of Behavioral VHDL Descriptions by Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45789-5_31
Ida, Tetsuo. 2009. “A Compiler for Origami Construction and Verification.” In 2009 11th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing. IEEE. https://doi.org/10.1109/synasc.2009.61
Ide, Ichiro, Reiko Hamada, Shuichi Sakai, and Hidehiko Tanaka. 2003. “Compilation of Dictionaries for Semantic Attribute Analysis of Television News Captions.” Systems and Computers in Japan 34 (12): 32–44. https://doi.org/10.1002/scj.10417
Idri, Ali, and Ibtissam Abnane. 2017. “Fuzzy Analogy Based Effort Estimation: An Empirical Comparative Study.” In 2017 IEEE International Conference on Computer and Information Technology (CIT). IEEE. https://doi.org/10.1109/cit.2017.29
Idri, Ali, Ibtissam Abnane, and Alain Abran. 2016a. “Missing Data Techniques in Analogy-Based Software Development Effort Estimation.” Journal of Systems and Software 117: 595–611. https://doi.org/10.1016/j.jss.2016.04.058
Idri, Ali, Ibtissam Abnane, and Alain Abran. 2017. “Evaluating Pred(p) and Standardized Accuracy Criteria in Software Development Effort Estimation.” Journal of Software: Evolution and Process 30 (4): e1925. https://doi.org/10.1002/smr.1925
Idri, Ali, Ibtissam Abnane, and Alain Abran. 2018. “Support Vector Regression-Based Imputation in Analogy-Based Software Development Effort Estimation.” Journal of Software: Evolution and Process 30 (12): e2114. https://doi.org/10.1002/smr.2114
Idri, Ali, Fatima azzahra Amazal, and Alain Abran. 2015a. “Accuracy Comparison of Analogy-Based Software Development Effort Estimation Techniques.” International Journal of Intelligent Systems 31 (2): 128–52. https://doi.org/10.1002/int.21748
Idri, Ali, Fatima azzahra Amazal, and Alain Abran. 2015b. “Analogy-Based Software Development Effort Estimation: A Systematic Mapping and Review.” Information and Software Technology 58: 206–30. https://doi.org/10.1016/j.infsof.2014.07.013
Idri, Ali, and Safae Cherradi. 2016. “Improving Effort Estimation of Fuzzy Analogy Using Feature Subset Selection.” In 2016 IEEE Symposium Series on Computational Intelligence (SSCI). IEEE. https://doi.org/10.1109/ssci.2016.7849928
Idri, Ali, Mohamed Hosni, and Alain Abran. 2016b. “Systematic Literature Review of Ensemble Effort Estimation.” Journal of Systems and Software 118: 151–75. https://doi.org/10.1016/j.jss.2016.05.016
Idri, Ali, Mohamed Hosni, and Alain Abran. 2016c. “Systematic Mapping Study of Ensemble Effort Estimation.” In Proceedings of the 11th International Conference on Evaluation of Novel Software Approaches to Software Engineering. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005822701320139
Idrisov, Baskhad, and Tim Schlippe. 2024. “Program Code Generation with Generative AIs.” Algorithms 17 (2): 62. https://doi.org/10.3390/a17020062
Ignatyev, Valery. 2014. “Static Analysis Usage for Customizable Semantic Checks of C and C++ Programming Languages Constraints.” In 2014 IEEE Seventh International Conference on Software Testing, Verification and Validation Workshops. IEEE. https://doi.org/10.1109/icstw.2014.59
Ika, Lavagnon, and Simon Feeny. 2022. “Optimism Bias and World Bank Project Performance.” Journal of Development Studies 58 (12): 2604–23. https://doi.org/10.1080/00220388.2022.2102901
Iliasov, Alex. 2003. “Templates-Based Portable Just-in-Time Compiler.” ACM SIGPLAN Notices 38 (8): 37–43. https://doi.org/10.1145/944579.944588
Ilic, Dubravka, Elena Troubitsyna, Linas Laibinis, and Sari Leppänen. 2006. “Formal Verification of Consistency in Model-Driven Development of Distributed Communicating Systems and Communication Protocols.” In Second International Symposium on Leveraging Applications of Formal Methods, Verification and Validation (isola 2006). IEEE. https://doi.org/10.1109/isola.2006.40
“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
Imtiaz, Nasif, Brendan Murphy, and Laurie Williams. 2019. “How Do Developers Act on Static Analysis Alerts? An Empirical Study of Coverity Usage.” In 2019 IEEE 30th International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre.2019.00040
Infantolino, Jamie, and David Richie. 2016. “Compile-Time Type Selection of Optimized Data Layout and Memory Access Patterns for FDTD Calculations.” In 2016 IEEE/ACES International Conference on Wireless Information Technology and Systems (ICWITS) and Applied Computational Electromagnetics (ACES). IEEE. https://doi.org/10.1109/ropaces.2016.7465383
Ingber, Lester. 2011. “Columnar Electromagnetic Influences on Short-Term Memory at Multiple Scales.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.1838903
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
“International Symposium on Code Generation and Optimization.” 2004. In International Symposium on Code Generation and Optimization, 2004. CGO 2004.. IEEE. https://doi.org/10.1109/cgo.2004.1281650
“International Symposium on Code Generation and Optimization.” 2005. In International Symposium on Code Generation and Optimization. IEEE. https://doi.org/10.1109/cgo.2005.36
“International Symposium on Code Generation and Optimization.” 2006a. In International Symposium on Code Generation and Optimization (CGO’06). IEEE. https://doi.org/10.1109/cgo.2006.19
“International Symposium on Code Generation and Optimization. CGO 2003.” 2003. In International Symposium on Code Generation and Optimization 2003 CGO 2003 CGO-03. IEEE. https://doi.org/10.1109/cgo.2003.1191528
“International Symposium on Code Generation and Optimization: Copyright.” 2006b. In International Symposium on Code Generation and Optimization (CGO’06). IEEE. https://doi.org/10.1109/cgo.2006.18
“International Symposium on Code Generation and Optimization: Copyright.” 2007a. In International Symposium on Code Generation and Optimization (CGO’07). IEEE. https://doi.org/10.1109/cgo.2007.16
“International Symposium on Code Generation and Optimization: Cover.” 2007b. In International Symposium on Code Generation and Optimization (CGO’07). IEEE. https://doi.org/10.1109/cgo.2007.17
“International Symposium on Code Generation and Optimization: Table of Contents.” 2006c. In International Symposium on Code Generation and Optimization (CGO’06). IEEE. https://doi.org/10.1109/cgo.2006.20
“International Symposium on Code Generation and Optimization: Table of Contents.” 2007c. In International Symposium on Code Generation and Optimization (CGO’07). IEEE. https://doi.org/10.1109/cgo.2007.18
“International Symposium on Code Generation and Optimization: Title.” 2007d. In International Symposium on Code Generation and Optimization (CGO’07). IEEE. https://doi.org/10.1109/cgo.2007.19
“International Symposium on Code Generation and Optimization: Title Page.” 2006d. In International Symposium on Code Generation and Optimization (CGO’06). IEEE. https://doi.org/10.1109/cgo.2006.21
“An Introduction to Elementary Computer and Compiler Design.” 1981. Mathematics and Computers in Simulation 23 (2): 214. https://doi.org/10.1016/0378-4754(81)90063-x
Ion, Iulia, Boris Dragovic, and Bruno Crispo. 2007. “Extending the Java Virtual Machine to Enforce Fine-Grained Security Policies in Mobile Devices.” In Twenty-Third Annual Computer Security Applications Conference (ACSAC 2007). IEEE. https://doi.org/10.1109/acsac.2007.4412992
Ionescu, Vlad-Sebastian. 2017. “An Approach to Software Development Effort Estimation Using Machine Learning.” In 2017 13th IEEE International Conference on Intelligent Computer Communication and Processing (ICCP). IEEE. https://doi.org/10.1109/iccp.2017.8117004
Ishikawa–Aso, Takahiro, and Shinpei Kato. 2025. “ROS 2 Agnocast: Supporting Unsized Message Types for True Zero-Copy Publish/Subscribe IPC.” In 2025 28th International Symposium on Real-Time Distributed Computing (ISORC). IEEE. https://doi.org/10.1109/isorc65339.2025.00026
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
Ishitobi, Yuriko, Tohru Ishihara, and Hiroto Yasuura. 2008. “Code and Data Placement for Embedded Processors with Scratchpad and Cache Memories.” Journal of Signal Processing Systems 60 (2): 211–24. https://doi.org/10.1007/s11265-008-0306-3
Ishizaka, Kazuhisa, Motoki Obata, and Hironori Kasahara. 2000. “Coarse-Grain Task Parallel Processing Using the OpenMP Backend of the OSCAR Multigrain Parallelizing Compiler.” In High Performance Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-39999-2_43
Ishizaki, Kazuaki, Motohiro Kawahito, Toshiaki Yasue, Hideaki Komatsu, and Toshio Nakatani. 2000. “A Study of Devirtualization Techniques for a Java Just-In-Time Compiler.” In Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. ACM. https://doi.org/10.1145/353171.353191
Ishizaki, Kazuaki, Takeshi Ogasawara, Jose Castanos, Priya Nagpurkar, David Edelsohn, and Toshio Nakatani. 2012. “Adding Dynamically-Typed Language Support to a Statically-Typed Language Compiler: Performance Evaluation, Analysis, and Tradeoffs.” ACM SIGPLAN Notices 47 (7): 169–80. https://doi.org/10.1145/2365864.2151047
Iskandar, Veronia, Mohamed A. Abd El Ghany, and Diana Goehringer. 2023. “Compiler-Assisted Kernel Selection for FPGA-Based near-Memory Computing Platforms.” In 2023 IEEE 31st Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm57271.2023.00050
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
Ismail, Maliha, Yan Lin, DongGyun Han, and Debin Gao. 2023. “BinAlign: Alignment Padding Based Compiler Provenance Recovery.” In Information Security and Privacy. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-35486-1_26
Ivanikov, Viktor, Shamil Kurmangaleev, Andrey Belevantsev, and Arutyun Avetisyan. 2013. “Performance Optimizations in an LLVM-Based Cloud Application Store.” In Ninth International Conference on Computer Science and Information Technologies Revised Selected Papers. IEEE. https://doi.org/10.1109/csitechnol.2013.6710362
Ivanov, Dmitry, and Sibylle Schupp. 2019. “Static Analysis for Worst-Case Battery Utilization.” In 2019 IEEE/ACM 7th International Conference on Formal Methods in Software Engineering (FormaliSE). IEEE. https://doi.org/10.1109/formalise.2019.00009
Ivgi, Maor, Yaniv Benny, Avichai Ben-David, Jonathan Berant, and Lior Wolf. 2021. “Scene Graph tO Image Generation with Contextualized Object Layout Refinement.” In 2021 IEEE International Conference on Image Processing (ICIP). IEEE. https://doi.org/10.1109/icip42928.2021.9506651
Iwasaki, H., M. Murakata, and T. Mitsuhashi. 1991. “An Effective Data Structure for VLSI Layout Systems.” In 1991 IEEE International Symposium on Circuits and Systems (ISCAS). IEEE. https://doi.org/10.1109/iscas.1991.176215
Izadinia, Hamid, Fereshteh Sadeghi, and Ali Farhadi. 2014. “Incorporating Scene Context and Object Layout into Appearance Modeling.” In 2014 IEEE Conference on Computer Vision and Pattern Recognition. IEEE. https://doi.org/10.1109/cvpr.2014.37
Jaafar, Fehmi, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Giuliano Antoniol. 2013. “Detecting Asynchrony and Dephase Change Patterns by Mining Software Repositories.” Journal of Software: Evolution and Process 26 (1): 77–106. https://doi.org/10.1002/smr.1635
Jackson, Paul B. 1998. “Verifying a Garbage Collection Algorithm.” In Theorem Proving in Higher Order Logics. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0055139
Jackson, Samuel, Nathan Cummings, and Saiful Khan. 2024. “Streaming Technologies and Serialization Protocols: Empirical Performance Analysis.” IEEE Access 12: 158025–39. https://doi.org/10.1109/access.2024.3486054
Jacobitz, Sven, and Xiaobo Liu-Henke. 2022. “Automatic Code Generation for a Seamless Low-Cost Development Platform.” In Proceedings of the 10th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010894300003119
Jacobs, Dean, and Anno Langen. 1992. “Static Analysis of Logic Programs for Independent and Parallelism.” Journal of Logic Programming 13 (2–3): 291–314. https://doi.org/10.1016/0743-1066(92)90034-z
Jacobs, Alexander E., Derek R. Soled, and Jonah Rubin. 2026. “Judgment under Uncertainty.” CHEST 169 (6): 1653–59. https://doi.org/10.1016/j.chest.2026.01.014
Jagannathan, Suresh, Vincent Laporte, Gustavo Petri, David Pichardie, and Jan Vitek. 2014. “Atomicity Refinement for Verified Compilation.” ACM SIGPLAN Notices 49 (6): 27–27. https://doi.org/10.1145/2666356.2594346
Jagannathan, Suresh, Stephen Weeks, and Andrew Wright. 1997. “Type-Directed Flow Analysis for Typed Intermediate Languages.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032745
Jain, Shalini, Utpal Bora, Prateek Kumar, Vaibhav B. Sinha, Suresh Purini, and Ramakrishna Upadrasta. 2019. “An Analysis of Executable Size Reduction by LLVM Passes.” CSI Transactions on ICT 7 (2): 105–10. https://doi.org/10.1007/s40012-019-00248-5
Jain, Diksha, Pravali Manchala, Sarika Mustyala, and Manjubala Bisi. 2024. “Software Development Effort Estimation Using SNS Algorithm.” In 2024 15th International Conference on Computing Communication and Networking Technologies (ICCCNT). IEEE. https://doi.org/10.1109/icccnt61001.2024.10725750
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
Jamner, Dustin, Gabriel Kammer, Ritam Nag, and Adam Chlipala. 2025. “Pyrosome: Verified Compilation for Modular Metatheory.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 58–85. https://doi.org/10.1145/3763052
Jang, Kyoung-ae, and Woo-Je Kim. 2021. “A Method of Activity-Based Software Maintenance Cost Estimation for Package Software.” Journal of Supercomputing 77 (8): 8151–71. https://doi.org/10.1007/s11227-020-03610-6
Jang, Minwoo, Sungju Kim, and Daehoon Kim. 2026. “Nighthawk: Zero-Copy Cache Quarantine for Invisible Speculation.” IEEE Computer Architecture Letters 25 (1): 134–37. https://doi.org/10.1109/lca.2026.3677441
Jang, Hohyeon, Nozima Murodova, and Hyungjoon Koo. 2024. “ToolPhet: Inference of Compiler Provenance from Stripped Binaries with Emerging Compilation Toolchains.” IEEE Access 12: 12667–82. https://doi.org/10.1109/access.2024.3355098
Jang, Hung-Chin, and Sin-Chun Wu. 2022. “Tracking of Hardware Development Schedule Based on Software Effort Estimation.” In 2022 IEEE 13th Annual Information Technology, Electronics and Mobile Communication Conference (IEMCON). IEEE. https://doi.org/10.1109/iemcon56893.2022.9946524
Janssen, Theo M. V. 1998. “Algebraic Translations, Correctness and Algebraic Compiler Construction.” Theoretical Computer Science 199 (1–2): 25–56. https://doi.org/10.1016/s0304-3975(97)00267-3
Jaswal, Reshav, and Mamta Khosla. 2026. “Towards Comprehensive Semi-Formal Verification of AMBA AHB/APB Interconnects: Configuration Coverage, Mutation Testing, and Safety-Aware Design-for-Verification.” In 2026 International Conference on Intelligent Processing, Hardware, Electronics, and Radio Systems (CIPHER). IEEE. https://doi.org/10.1109/cipher70417.2026.11523956
“Java Virtual Machine.” 1997. Computers & Mathematics with Applications 34 (10): 135. https://doi.org/10.1016/s0898-1221(97)90189-9
Javani, Mohamad, Behzad Soleimani Neysiani, and Seyed Morteza Babamir. 2015. “Formal Verification of UML Statecharts Using the LOTOS Formal Language.” In 2015 2nd International Conference on Knowledge-Based Engineering and Innovation (KBEI). IEEE. https://doi.org/10.1109/kbei.2015.7436139
Javdani Gandomani, Taghi, Maedeh Dashti, Hazura Zulzalil, and Abu Bakar Md Sultan. 2024. “Enhancing Software Effort Estimation in the Analogy-Based Approach through the Combination of Regression Methods.” IEEE Access 12: 152122–37. https://doi.org/10.1109/access.2024.3480829
Jawa, Misha, and Shweta Meena. 2022b. “Software Effort Estimation Using Synthetic Minority over-Sampling Technique for Regression (SMOTER).” In 2022 3rd International Conference for Emerging Technology (INCET). IEEE. https://doi.org/10.1109/incet54531.2022.9824043
Jay, Barry. 2025. “Typed Program Analysis without Encodings.” In Proceedings of the 2025 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3704253.3706138
Jayadi, Puguh, Didik Dwi Prasetya, and Triyanna Widiyaningtyas. 2025. “Explanation of a Simple Machine Learning Model for Software Effort Estimation Using SHAP (SHapley Additive exPlanations).” In 2025 9th International Conference On Electrical, Electronics And Information Engineering (ICEEIE). IEEE. https://doi.org/10.1109/iceeie66203.2025.11254827
Jayasena, Sanath, Milinda Fernando, Tharindu Rusira, Chalitha Perera, and Chamara Philips. 2015. “Auto-Tuning the Java Virtual Machine.” In 2015 IEEE International Parallel and Distributed Processing Symposium Workshop. IEEE. https://doi.org/10.1109/ipdpsw.2015.84
Jeannerod, Nicolas, Claude Marché, and Ralf Treinen. 2017. “A Formally Verified Interpreter for a Shell-Like Programming Language.” In Verified Software. Theories, Tools, and Experiments. Springer International Publishing. https://doi.org/10.1007/978-3-319-72308-2_1
Jeannet, B. 2002. “Representing and Approximating Transfer Functions in Abstract Interpretation of Hetereogeneous Datatypes.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45789-5_7
Jeannet, Bertrand, and Pascal Sotin. 2012. “Inferring Effective Types for Static Analysis of C Programs.” Electronic Notes in Theoretical Computer Science 288: 37–47. https://doi.org/10.1016/j.entcs.2012.10.006
Jensen, Jørn. 1965. “Generation of Machine Code in ALGOL Compilers.” BIT 5 (4): 235–45. https://doi.org/10.1007/bf01937503
Jensen, Thomas P., and Torben Æ. Mogensen. 1990. “A Backwards Analysis for Compile-Time Garbage Collection.” In ESOP ‘90. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-52592-0_66
Jeon, Geochang, Minseong Choi, Sunjun Lee, Jeong Hyun Yi, and Haehyun Cho. 2021. “Automated Multi-Layered Bytecode Generation for Preventing Sensitive Information Leaks from Android Applications.” IEEE Access 9: 119578–90. https://doi.org/10.1109/access.2021.3107601
Jeon, Gihyeon, and Daejin Park. 2024. “Optimizing Multithreaded Access to Global Variables in SPM through Compiler-Enhanced Dependency Analysis.” In TENCON 2024 - 2024 IEEE Region 10 Conference (TENCON). IEEE. https://doi.org/10.1109/tencon61640.2024.10902979
Jeon, Gihyeon, and Daejin Park. 2026. “LLVM-Based Efficient Hybrid Cache and TCM Memory Allocation for Low Latency.” IEEE Embedded Systems Letters 18 (3): 245–48. https://doi.org/10.1109/les.2025.3625376
JeongWon Kim, SeungWon Lee, and KiDong Chung. 2001. “Implementation of Zero-Copy with Caching for Efficient Networked Multimedia Service in Linux Kernel.” In IEEE International Conference on Multimedia and Expo, 2001. ICME 2001.. IEEE. https://doi.org/10.1109/icme.2001.1237947
Jerraya, A., P. Varinot, R. Jamier, and B. Courtois. 1986. “Principles of the SYCO Compiler.” In 23rd ACM/IEEE Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1986.1586169
Jézéquel, J. -M. 1993. “Transparent Parallelisation through Reuse: Between a Compiler and a Library Approach.” In ECOOP’ 93 — Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-47910-4_20
Ji, Dong, Songran Liu, Yangjie Wei, and Wang Yi. 2022. “Memory Layout Optimization for Task-Based Intermittent Computing Systems.” In 2022 2nd International Conference on Intelligent Technology and Embedded Systems (ICITES). IEEE. https://doi.org/10.1109/icites56274.2022.9943754
Ji, Xiaomei, Dan Nicolaescu, Alexander Veidenbaum, Alexandru Nicolau, and Rajesh Gupta. 2000. “Compiler-Directed Cache Assist Adaptivity.” In High Performance Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-39999-2_9
Ji, Seunggu, and Dongkun Shin. 2010. “Locality and Duplication-Aware Garbage Collection for Flash Memory-Based Virtual Memory Systems.” In 2010 10th IEEE International Conference on Computer and Information Technology. IEEE. https://doi.org/10.1109/cit.2010.307
Jia, Changjiang, and W. K. Chan. 2013a. “A Study on the Efficiency Aspect of Data Race Detection: A Compiler Optimization Level Perspective.” In 2013 13th International Conference on Quality Software. IEEE. https://doi.org/10.1109/qsic.2013.58
Jia, Changjiang, and W. K. Chan. 2013b. “Which Compiler Optimization Options Should I Use for Detecting Data Races in Multithreaded Programs?” In 2013 8th International Workshop on Automation of Software Test (AST). IEEE. https://doi.org/10.1109/iwast.2013.6595791
Jiang, Xinyan. 2023. “Vision-Based Outdoor Garbage Collection Robot.” In 2023 IEEE 3rd International Conference on Data Science and Computer Application (ICDSCA). IEEE. https://doi.org/10.1109/icdsca59871.2023.10392429
Jiang, Peng, and Xiaodong Cai. 2025. “A Symmetric Dual-Drive Text Matching Model Based on Dynamically Gated Sparse Attention Feature Distillation with a Faithful Semantic Preservation Strategy.” Symmetry 17 (5): 772. https://doi.org/10.3390/sym17050772
Jiang, Bo, Yifei Chen, Dong Wang, Imran Ashraf, and W. K. Chan. 2021. “WANA: Symbolic Execution of Wasm Bytecode for Extensible Smart Contract Vulnerability Detection.” In 2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS). IEEE. https://doi.org/10.1109/qrs54544.2021.00102
Jiang, Hao, and Baojian Hua. 2025. “JasLoad: Dynamically Analyzing Javascript Bytecode via a Load-Time Instrumentation Approach.” In 2025 25th International Conference on Software Quality, Reliability and Security (QRS). IEEE. https://doi.org/10.1109/qrs65678.2025.00078
Jiang, He, Zhide Zhou, Zhilei Ren, Jingxuan Zhang, and Xiaochen Li. 2022. “CTOS: Compiler Testing for Optimization Sequences of LLVM.” IEEE Transactions on Software Engineering 48 (7): 2339–58. https://doi.org/10.1109/tse.2021.3058671
Jiao, Hong-Yu, Ying Li, and Lan-Yu Yang. 2019. “Periodic Layout Optimization of Cyclic Symmetric Structure.” IEEE Access 7: 55269–76. https://doi.org/10.1109/access.2019.2913188
Jiao, Hongyan, Zhigang Liu, and Chengxing Cui. 2026. “Structure of a Star Light Source Layout Model in Visible Light Communication.” In 2026 13th International Conference on Machine Intelligence Theory and Applications (MiTA). IEEE. https://doi.org/10.1109/mita69365.2026.11582167
Jiao, Fangzhou, Nilesh Mahajan, Jeremiah Willcock, Arun Chauhan, and Andrew Lumsdaine. 2011. “Partial Globalization of Partitioned Address Spaces for Zero-Copy Communication with Shared Memory.” In 2011 18th International Conference on High Performance Computing. IEEE. https://doi.org/10.1109/hipc.2011.6152733
Jie Lin, Jiankun Yu, and Zhiyong Zeng. 2010. “The Predicate Formulae for Object-Oriented Database Schema Evolution.” In 2010 Second World Congress on Software Engineering. IEEE. https://doi.org/10.1109/wcse.2010.13
Jimenez-Gonzalez, D., J. J. Navarro, and J.-L. Larriba-Pey. 2003. “CC-Radix: A Cache Conscious Sorting Based on Radix Sort.” In Eleventh Euromicro Conference on Parallel, Distributed and Network-Based Processing, 2003. Proceedings.. IEEE. https://doi.org/10.1109/empdp.2003.1183573
Jin, Bo, and Huimin Ma. 2025. “Garbage Collection and Transportation Path Optimization Using Deep Learning.” In 2025 IEEE 26th China Conference on System Simulation Technology and its Applications (CCSSTA). IEEE. https://doi.org/10.1109/ieeeconf65522.2025.11137287
Jin, Yihong, and Ze Yang. 2026. “Zero-Copy Proxy Tunneling via Linux Splice for Cloud Infrastructure.” In 2026 IEEE 8th International Conference on Communications, Information System and Computer Engineering (CISCE). IEEE. https://doi.org/10.1109/cisce69494.2026.11504706
Jin, Fengling, Ye Yang, Zhibin Xiao, Boqing Gao, and Haopeng Lou. 2023. “Shear Wall Layout Optimization of Multi-Tower Buildings Based on Conceptual Design and Extended Evolutionary Structural Optimization Method.” Engineering Optimization 56 (4): 486–505. https://doi.org/10.1080/0305215x.2022.2161535
Jin, Hai, Minghu Zhang, and Pengliu Tan. 2006. “Lightweight Messages: True Zero-Copy Communication for Commodity Gigabit Ethernet.” In Emerging Directions in Embedded and Ubiquitous Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/11807964_16
Jingmei Li and Bo Zhang. 2011. “Garbage Collection Algorithm Based on Embedded KVM.” In 2011 International Conference on Multimedia Technology. IEEE. https://doi.org/10.1109/icmt.2011.6002098
Jo, Yong-Yeon, Myung-Hwan Jang, Sang-Wook Kim, and Sunju Park. 2021. “A Data Layout with Good Data Locality for Single-Machine Based Graph Engines.” IEEE Transactions on Computers: 1–1. https://doi.org/10.1109/tc.2021.3107725
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
Jodpimai, Pichai, Peraphon Sophatsathit, and Chidchanok Lursinsap. 2009. “Analysis of Effort Estimation Based on Software Project Models.” In 2009 9th International Symposium on Communications and Information Technology. IEEE. https://doi.org/10.1109/iscit.2009.5341149
Johannsen, D. 1979. “Bristle Blocks: A Silicon Compiler.” In 16th Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1979.1600125
Johnson, Brittany. 2012. “A Study on Improving Static Analysis Tools: Why Are We Not Using Them?” In 2012 34th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse.2012.6227228
Johnson, Neil, and Alan Mycroft. 2003. “Combined Code Motion and Register Allocation Using the Value State Dependence Graph.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36579-6_1
Johnsson, Thomas. 1987. “Target Code Generation from G-Machine Code.” In Graph Reduction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-18420-1_53
Joisha, Pramod G. 2008. “A Principled Approach to Nondeferred Reference-Counting Garbage Collection.” In Proceedings of the fourth ACM SIGPLAN/SIGOPS international conference on Virtual execution environments. ACM. https://doi.org/10.1145/1346256.1346275
Jolicard, Georges. 1987. “Effective Hamiltonian Theory: An Intermediate Representation Method for the Wave Operator Calculation.” Chemical Physics 115 (1): 57–68. https://doi.org/10.1016/0301-0104(87)80178-7
Jones, Neil D. 1997a. “Combining Abstract Interpretation and Partial Evaluation (Brief Overview).” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032761
Jones, Mark P. 1997b. “First-Class Polymorphism with Type Inference.” In Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘97. ACM Press. https://doi.org/10.1145/263699.263765
Jones, Timothy M., Sandro Bartolini, Bruno De Bus, John Cavazos, and Michael F. P. O’Boyle. 2008. “Instruction Cache Energy Saving through Compiler Way-Placement.” In 2008 Design, Automation and Test in Europe. IEEE. https://doi.org/10.1109/date.2008.4484841
Jones, Timothy M., Sandro Bartolini, Jonas Maebe, and Dominique Chanet. 2011. “Link-Time Optimization for Power Efficiency in a Tagless Instruction Cache.” In International Symposium on Code Generation and Optimization (CGO 2011). IEEE. https://doi.org/10.1109/cgo.2011.5764672
Jones, T. M., M. F. R. O’Boyle, J. Abella, A. Gonzalez, and O. Ergin. 2005. “Compiler Directed Early Register Release.” In 14th International Conference on Parallel Architectures and Compilation Techniques (PACT’05). IEEE. https://doi.org/10.1109/pact.2005.14
Jones, Luke, Andrew Sellers, and Martin Carlisle. 2016. “CARDINAL: Similarity Analysis to Defeat Malware Compiler Variations.” In 2016 11th International Conference on Malicious and Unwanted Software (MALWARE). IEEE. https://doi.org/10.1109/malware.2016.7888728
Jones, Robert B., Jens U. Skakkebæk, and David L. Dill. 2002a. “Formal Verification of out-of-Order Execution with Incremental Flushing.” Formal Methods in System Design 20 (2): 139–58. https://doi.org/10.1023/a:1014118529369
Jong, Michael de, and Arie van Deursen. 2015. “Continuous Deployment and Schema Evolution in SQL Databases.” In 2015 IEEE/ACM 3rd International Workshop on Release Engineering. IEEE. https://doi.org/10.1109/releng.2015.14
Jonker, Jan E. 1992. “On-the-Fly Garbage Collection for Several Mutators.” Distributed Computing 5 (4): 187–99. https://doi.org/10.1007/bf02277666
Jordan, Connor, Joseba Agirre, and Athanasios Angeloudis. 2024. “Objective Representative Flow Field Selection for Tidal Array Layout Design.” Renewable Energy 236: 121381. https://doi.org/10.1016/j.renene.2024.121381
Jordan, Herbert, Simone Pellegrini, Peter Thoman, Klaus Kofler, and Thomas Fahringer. 2013a. “INSPIRE: The Insieme Parallel Intermediate Representation.” In Proceedings of the 22nd International Conference on Parallel Architectures and Compilation Techniques. IEEE. https://doi.org/10.1109/pact.2013.6618792
Jorgensen, M. 2004. “Realism in Assessment of Effort Estimation Uncertainty: It Matters How You Ask.” IEEE Transactions on Software Engineering 30 (4): 209–17. https://doi.org/10.1109/tse.2004.1274041
Jorgensen, M. 2005. “Practical Guidelines for Expert-Judgment-Based Software Effort Estimation.” IEEE Software 22 (3): 57–63. https://doi.org/10.1109/ms.2005.73
Jorgensen, Magne, Barry Boehm, and Stan Rifkin. 2009. “Software Development Effort Estimation: Formal Models or Expert Judgment?” IEEE Software 26 (2): 14–19. https://doi.org/10.1109/ms.2009.47
Jorgensen, M., and T. M. Gruschke. 2009. “The Impact of Lessons-Learned Sessions on Effort Estimation and Uncertainty Assessments.” IEEE Transactions on Software Engineering 35 (3): 368–83. https://doi.org/10.1109/tse.2009.2
Jorgensen, M., and K. Molokken-Ostvold. 2004. “Reasons for Software Effort Estimation Error: Impact of Respondent Role, Information Collection Approach, and Data Analysis Method.” IEEE Transactions on Software Engineering 30 (12): 993–1007. https://doi.org/10.1109/tse.2004.103
Journault, Matthieu, and Antoine Miné. 2016. “Static Analysis by Abstract Interpretation of the Functional Correctness of Matrix Manipulating Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-53413-7_13
Journault, Matthieu, Antoine Miné, and Abdelraouf Ouadjaout. 2018. “Modular Static Analysis of String Manipulations in C Programs.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-99725-4_16
“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
Jucovschi, Constantin, Peter Baumann, and Sorin Stancu-Mara. 2008. “Speeding up Array Query Processing by Just-In-Time Compilation.” In 2008 IEEE International Conference on Data Mining Workshops. IEEE. https://doi.org/10.1109/icdmw.2008.73
Julien, Jeffrey A., Sarah G. Mutchek, Martin G. Fernandez, and Kerney Jebrell Glover. 2022. “Facile Production of Tagless Membrane Scaffold Protein for Nanodiscs.” Analytical Biochemistry 638: 114497. https://doi.org/10.1016/j.ab.2021.114497
Jun, Eung Sup, and Jae Kyu Lee. 2001. “Quasi-Optimal Case-Selective Neural Network Model for Software Effort Estimation.” Expert Systems with Applications 21 (1): 1–14. https://doi.org/10.1016/s0957-4174(01)00021-5
Jun-Lin, Qiu, Zhang Ya-Hong, Feng Wan-Li, and Han Cheng-Hao. 2012. “Different Shape Object Layout Problem Solving Based on Genetic Algorithm.” In 2012 International Conference on Industrial Control and Electronics Engineering. IEEE. https://doi.org/10.1109/icicee.2012.467
Jung, Jun-Young, and Min-Soo Jung. 2002. “Design and Implementation of Small-Sized Java Virtual Machine on Java Platform Jini.” In Information Networking: Wired Communications and Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45803-4_51
Jung, Dong-Heon, Soo-Mook Moon, and Sung-Hwan Bae. 2008a. “Design and Optimization of a Java Ahead-of-Time Compiler for Embedded Systems.” In 2008 IEEE/IFIP International Conference on Embedded and Ubiquitous Computing. IEEE. https://doi.org/10.1109/euc.2008.80
Jung, Dong-Heon, JongKuk Park, Sung-Hwan Bae, Jaemok Lee, and Soo-Mook Moon. 2008b. “Efficient Exception Handling in Java Bytecode-to-C Ahead-of-Time Compiler for Embedded Systems.” Computer Languages, Systems & Structures 34 (4): 170–83. https://doi.org/10.1016/j.cl.2007.06.004
Jung, Seungwon, Seunghee Seo, Yeog Kim, and Changhoon Lee. 2021. “Memory Layout Extraction and Verification Method for Reliable Physical Memory Acquisition.” Electronics 10 (12): 1380. https://doi.org/10.3390/electronics10121380
Jung Sung-Ok, Lee Sung-Joo, and Ko Kwang-man. 2000. “Retargetable Code Generator for Java Bytecode.” In Proceedings Fourth International Conference/Exhibition on High Performance Computing in the Asia-Pacific Region. IEEE. https://doi.org/10.1109/hpc.2000.846609
Junlin Qiu and Haizhou Kou. 2011. “Irregular Object Layout Solution Based on Improved Genetic Algorithm.” In 2011 2nd International Conference on Artificial Intelligence, Management Science and Electronic Commerce (AIMSEC). IEEE. https://doi.org/10.1109/aimsec.2011.6010903
Jørgensen, Magne. 2002. “Comments on ‘a Simulation Tool for Efficient Analogy Based Cost Estimation’, by L. Angelis and I. Stamelos, Published in Empirical Software Engineering, 5, 35–68 (2000).” Empirical Software Engineering 7 (4): 375–76. https://doi.org/10.1023/a:1020571206993
Jørgensen, Magne. 2004a. “Regression Models of Software Development Effort Estimation Accuracy and Bias.” Empirical Software Engineering 9 (4): 297–314. https://doi.org/10.1023/b:emse.0000039881.57613.cb
Jørgensen, M. 2004b. “A Review of Studies on Expert Estimation of Software Development Effort.” Journal of Systems and Software 70 (1–2): 37–60. https://doi.org/10.1016/s0164-1212(02)00156-5
Jørgensen, Magne. 2004c. “Top-down and Bottom-up Expert Estimation of Software Development Effort.” Information and Software Technology 46 (1): 3–16. https://doi.org/10.1016/s0950-5849(03)00093-4
Jørgensen, Magne. 2010. “Selection of Strategies in Judgment-Based Effort Estimation.” Journal of Systems and Software 83 (6): 1039–50. https://doi.org/10.1016/j.jss.2009.12.028
Jørgensen, Magne. 2011. “Contrasting Ideal and Realistic Conditions as a Means to Improve Judgment-Based Software Development Effort Estimation.” Information and Software Technology 53 (12): 1382–90. https://doi.org/10.1016/j.infsof.2011.07.001
Jørgensen, Magne. 2016. “Unit Effects in Software Project Effort Estimation: Work-Hours Gives Lower Effort Estimates than Workdays.” Journal of Systems and Software 117: 274–81. https://doi.org/10.1016/j.jss.2016.03.048
Jørgensen, Magne. 2023. “Improved Measurement of Software Development Effort Estimation Bias.” Information and Software Technology 157: 107157. https://doi.org/10.1016/j.infsof.2023.107157
Jørgensen, Magne, and Stein Grimstad. 2011. “The Impact of Irrelevant and Misleading Information on Software Development Effort Estimates: A Randomized Controlled Field Experiment.” IEEE Transactions on Software Engineering 37 (5): 695–707. https://doi.org/10.1109/tse.2010.78
Jørgensen, Magne, and Torleif Halkjelsvik. 2010. “The Effects of Request Formats on Judgment-Based Effort Estimation.” Journal of Systems and Software 83 (1): 29–36. https://doi.org/10.1016/j.jss.2009.03.076
Jørgensen, Magne, Torleif Halkjelsvik, and Knut Liestøl. 2022. “When Should We (Not) Use the Mean Magnitude of Relative Error (MMRE) as an Error Measure in Software Development Effort Estimation?” Information and Software Technology 143: 106784. https://doi.org/10.1016/j.infsof.2021.106784
Jørgensen, Magne, Ulf Indahl, and Dag Sjøberg. 2003. “Software Effort Estimation by Analogy and “Regression toward the Mean”.” Journal of Systems and Software 68 (3): 253–62. https://doi.org/10.1016/s0164-1212(03)00066-9
Jørgensen, Magne, and Martin Shepperd. 2007. “A Systematic Review of Software Development Cost Estimation Studies.” IEEE Transactions on Software Engineering 33 (1): 33–53. https://doi.org/10.1109/tse.2007.256943
Kaczmarek, J., and M. Kucharski. 2004. “Size and Effort Estimation for Applications Written in Java.” Information and Software Technology 46 (9): 589–601. https://doi.org/10.1016/j.infsof.2003.11.001
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
Kafura, Dennis, Doug Washabaugh, and Jeff Nelson. 1990. “Garbage Collection of Actors.” ACM SIGPLAN Notices 25 (10): 126–34. https://doi.org/10.1145/97946.97961
Kagdi, Huzefa, Michael L. Collard, and Jonathan I. Maletic. 2007. “A Survey and Taxonomy of Approaches for Mining Software Repositories in the Context of Software Evolution.” Journal of Software Maintenance and Evolution: Research and Practice 19 (2): 77–131. https://doi.org/10.1002/smr.344
Kailas, Krishnan, Viresh Paruthi, and Brian Monwai. 2009. “Formal Verification of Correctness and Performance of Random Priority-Based Arbiters.” In 2009 Formal Methods in Computer-Aided Design. IEEE. https://doi.org/10.1109/fmcad.2009.5351137
Kain, R. Y. 1969. “Block Structures, Indirect Addressing, and Garbage Collection.” Communications of the ACM 12 (7): 395–98. https://doi.org/10.1145/363156.363175
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
Kalhauge, Christian Gram, and Jens Palsberg. 2021. “Logical Bytecode Reduction.” In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3453483.3454091
Kalibera, Tomas, Filip Pizlo, Antony L. Hosking, and Jan Vitek. 2009. “Scheduling Hard Real-Time Garbage Collection.” In 2009 30th IEEE Real-Time Systems Symposium. IEEE. https://doi.org/10.1109/rtss.2009.40
Kalla, Priyank. 2015. “Formal Verification of Arithmetic Datapaths Using Algebraic Geometry and Symbolic Computation.” In 2015 Formal Methods in Computer-Aided Design (FMCAD). IEEE. https://doi.org/10.1109/fmcad.2015.7542240
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
Kama, Nazri, Sufyan Basri, Mehran Halimi Asl, and Roslina Ibrahim. 2015. “An Evaluation of COCHCOMO Tool for Change Effort Estimation in Software Development Phase.” In Intelligent Software Methodologies, Tools and Techniques. Springer International Publishing. https://doi.org/10.1007/978-3-319-17530-0_22
Kamal, Mohammed Wajahat, Moataz A. Ahmed, and Mohamed El-Attar. 2011. “Use Case-Based Effort Estimation Approaches: A Comparison Criteria.” In Software Engineering and Computer Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-22203-0_62
Kamei, Yasutaka, and Andy Zaidman. 2020. “Guest Editorial: Mining Software Repositories 2018.” Empirical Software Engineering 25 (3): 2055–57. https://doi.org/10.1007/s10664-020-09817-8
Kamucheka, Tendayi, and David Andrews. 2024. “Ph.D. Project: A Compiler-Driven Approach to HW/SW Co-Design of Deep-Learning Accelerators.” In 2024 IEEE 32nd Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm60383.2024.00053
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
Kandemir, M., and A. Choudhary. 2002. “Compiler-Directed Scratch Pad Memory Hierarchy Design and Management.” In Proceedings 2002 Design Automation Conference (IEEE Cat. No.02CH37324). IEEE. https://doi.org/10.1109/dac.2002.1012701
Kandemir, M., A. Choudhary, and J. Ramanujam. 1998b. “Improving Locality in out-of-Core Computations Using Data Layout Transformations.” In Languages, Compilers, and Run-Time Systems for Scalable Computers. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-49530-4_27
Kandemir, M., A. Choudhary, J. Ramanujam, N. Shenoy, and P. Banerjee. 1998a. “Enhancing Spatial Locality via Data Layout Optimizations.” In Euro-Par’98 Parallel Processing. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0057885
Kandemir, M., J. Ramanujam, and A. Choudhary. 2000. “Compiler Algorithms for Optimizing Locality and Parallelism on Shared and Distributed-Memory Machines.” Journal of Parallel and Distributed Computing 60 (8): 924–65. https://doi.org/10.1006/jpdc.2000.1639
Kandemir, M., J. Ramanujam, A. Choudhary, and P. Banerjee. 1999. “A Loop Transformation Algorithm Based on Explicit Data Layout Representation for Optimizing Locality.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48319-5_3
Kane, J. V. 1964. “The design of experiments using compiler language computer programs.” Nuclear Instruments and Methods 31 (1): 83–86. https://doi.org/10.1016/0029-554x(64)90326-x
Kang, Eun-Young. 2024. “Combining Security and Safety Engineering with Formal Verification to Improve Reliability of Industrial Robots.” In 2024 8th International Conference on System Reliability and Safety (ICSRS). IEEE. https://doi.org/10.1109/icsrs63046.2024.10927482
Kang, Sungjoo, Okjoo Choi, and Jongmoon Baik. 2010. “Model-Based Dynamic Cost Estimation and Tracking Method for Agile Software Development.” In 2010 IEEE/ACIS 9th International Conference on Computer and Information Science. IEEE. https://doi.org/10.1109/icis.2010.126
Kang, Jeehoon, Yoonseung Kim, Youngju Song, et al. 2018. “Crellvm: Verified Credible Compilation for LLVM.” ACM SIGPLAN Notices 53 (4): 631–45. https://doi.org/10.1145/3296979.3192377
Kangasharju, Jaakko, and Oskari Koskimies. 2009. “Binary Serialization for Mobile XForms Services.” In Enterprise Information Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-00670-8_18
Kao, Hsu-Yu, Liang-Ying Su, Shih-Hsu Huang, and Wei-Kai Cheng. 2025. “A Neural Network Compiler for Efficient Data Storage Optimization in ReRAM-Based DNN Accelerators.” Electronics 14 (12): 2352. https://doi.org/10.3390/electronics14122352
Kapadia, Viral V., and Darshak G. Thakore. 2009. “Distributed Garbage Collection Using Client Server Approach in Train Algorithm.” In 2009 IEEE International Advance Computing Conference. IEEE. https://doi.org/10.1109/iadcc.2009.4809060
Kapulkin, Krzysztof, and Yufeng Li. 2025. “Extensional Concepts in Intensional Type Theory, Revisited.” Theoretical Computer Science 1029: 115051. https://doi.org/10.1016/j.tcs.2024.115051
Kapur, Ritu, and Balwinder Sodhi. 2022. “OSS Effort Estimation Using Software Features Similarity and Developer Activity-Based Metrics.” ACM Transactions on Software Engineering and Methodology 31 (2): 1–35. https://doi.org/10.1145/3485819
Karer, Hiral H., and Purvi B. Soni. 2015. “Dead Code Elimination Technique in Eclipse Compiler for Java.” In 2015 International Conference on Control, Instrumentation, Communication and Computational Technologies (ICCICCT). IEEE. https://doi.org/10.1109/iccicct.2015.7475289
Karger, B.v. 1990. “Aspects of Proving Compiler Correctness.” IFAC Proceedings Volumes 23 (6): 19–24. https://doi.org/10.1016/s1474-6670(17)52171-0
Karna, Hrvoje, and Sven Gotovac. 2014a. “Estimators Characteristics and Effort Estimation of Software Projects.” In Proceedings of the 9th International Conference on Software Engineering and Applications. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005002600260035
Karna, Hrvoje, and Sven Gotovac. 2014b. “Modeling Expert Effort Estimation of Software Projects.” In 2014 22nd International Conference on Software, Telecommunications and Computer Networks (SoftCOM). IEEE. https://doi.org/10.1109/softcom.2014.7039106
Karna, Hrvoje, Linda Vicković, and Sven Gotovac. 2018. “Application of Data Mining Methods for Effort Estimation of Software Projects.” Software: Practice and Experience 49 (2): 171–91. https://doi.org/10.1002/spe.2651
Karnalim, Oscar. 2016. “Detecting Source Code Plagiarism on Introductory Programming Course Assignments Using a Bytecode Approach.” In 2016 International Conference on Information & Communication Technology and Systems (ICTS). IEEE. https://doi.org/10.1109/icts.2016.7910274
Kasahara, Hironori, Keiji Kimura, Boma A. Adhi, Yuhei Hosokawa, Yohei Kishimoto, and Masayoshi Mase. 2017. “Multicore Cache Coherence Control by a Parallelizing Compiler.” In 2017 IEEE 41st Annual Computer Software and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac.2017.174
Kasgen, Philipp, Mohamed Messelka, and Markus Weinhardt. 2021. “HiPReP: High-Performance Reconfigurable Processor: Architecture and Compiler.” In 2021 31st International Conference on Field-Programmable Logic and Applications (FPL). IEEE. https://doi.org/10.1109/fpl53798.2021.00074
Kasmi, Mohammed Amine, Azizi Mostafa, and Jean Louis Lanet. 2014. “Methodology to Reverse Engineer a Scrambled Java Card Virtual Machine Using Electromagnetic Analysis.” In 2014 International Conference on Next Generation Networks and Services (NGNS). IEEE. https://doi.org/10.1109/ngns.2014.6990264
Kassab, Mohamed, Maya Daneva, and Olga Ormandjieva. 2009. “Towards an Early Software Effort Estimation Based on Functional and Non-Functional Requirements.” In Software Process and Product Measurement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-05415-0_14
Kästner, Daniel, and Christian Ferdinand. 2016. “Applying Abstract Interpretation to Verify EN-50128 Software Safety Requirements.” In Reliability, Safety, and Security of Railway Systems. Modelling, Analysis, Verification, and Certification. Springer International Publishing. https://doi.org/10.1007/978-3-319-33951-1_14
Kästner, Daniel, Reinhard Wilhelm, and Christian Ferdinand. 2023. “Abstract Interpretation in Industry – Experience and Lessons Learned.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-44245-2_2
Kataev, Nikita. 2018a. “Application of the LLVM Compiler Infrastructure to the Program Analysis in SAPFOR.” In Supercomputing. Springer International Publishing. https://doi.org/10.1007/978-3-030-05807-4_41
Kataev, Nikita. 2018b. “LLVM Based Approach to Static Analysis of C Programs in SAPFOR.” In 2018 Ivannikov Memorial Workshop (IVMEM). IEEE. https://doi.org/10.1109/ivmem.2018.00011
Kataev, Nikita. 2020. “LLVM Based Parallelization of C Programs for GPU.” In Supercomputing. Springer International Publishing. https://doi.org/10.1007/978-3-030-64616-5_38
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
Kats, Lennart C. L., Martin Bravenboer, and Eelco Visser. 2008. “Mixing Source and Bytecode: A Case for Compilation by Normalization.” ACM SIGPLAN Notices 43 (10): 91–108. https://doi.org/10.1145/1449955.1449772
Kaur, Anureet, and Kulwant Kaur. 2019. “Investigation on Test Effort Estimation of Mobile Applications: Systematic Literature Review and Survey.” Information and Software Technology 110: 56–77. https://doi.org/10.1016/j.infsof.2019.02.003
Kaushik, Anupama, Prabhjot Kaur, Nisha Choudhary, and Priyanka. 2022b. “Stacking Regularization in Analogy-Based Software Effort Estimation.” Soft Computing 26 (3): 1197–1216. https://doi.org/10.1007/s00500-021-06564-w
Kavitha, M., and Purohit Shrinivasacharya. 2025. “Advancing Monolingual Classification: An Empirical Study Using arXiv Scientific Corpus.” In 2025 2nd Asia Pacific Conference on Innovation in Technology (APCIT). IEEE. https://doi.org/10.1109/apcit65661.2025.11411058
Kawachiya, Kiyokuni, Mikio Takeuchi, Salikh Zakirov, and Tamiya Onodera. 2012. “Distributed Garbage Collection for Managed X10.” In Proceedings of the 2012 ACM SIGPLAN X10 Workshop. ACM. https://doi.org/10.1145/2246056.2246061
Kawashima, Ryota, and Hiroshi Matsuo. 2018. “IOVTee: A Fast and Pragmatic Software-Based Zero-copy/Pass-through Mechanism for NFV-Nodes.” In 2018 IEEE Conference on Network Function Virtualization and Software Defined Networks (NFV-SDN). IEEE. https://doi.org/10.1109/nfv-sdn.2018.8725720
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
Kayraklioglu, Engin, Elliot Ronaghan, Michael P. Ferguson, and Bradford L. Chamberlain. 2022. “Locality-Based Optimizations in the Chapel Compiler.” In Languages and Compilers for Parallel Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-99372-6_1
Kchaou, Dhikra, Nadia Bouassida, and Hanene Ben-Abdallah. 2015. “Change Effort Estimation Based on UML Diagrams Application in UCP and COCOMOII.” In Proceedings of the 10th International Conference on Software Engineering and Applications. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005510503010308
Kearns, C. F., and G. McConnell. 1986. “Interactive Microcomputer Programs for Linear and Non-Linear Static Analysis of Frameworks.” Advances in Engineering Software (1978) 8 (4): 190–93. https://doi.org/10.1016/0141-1195(86)90058-6
Keim, Martin, Rolf Drechsler, Bernd Becker, Michael Martin, and Paul Molitor. 2003. “Polynomial Formal Verification of Multipliers.” Formal Methods in System Design 22 (1): 39–58. https://doi.org/10.1023/a:1021752130394
Keivanloo, Iman. 2012. “Online Sharing and Integration of Results from Mining Software Repositories.” In 2012 34th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse.2012.6227215
Keivanloo, I., C. Forbes, A. Hmood, et al. 2012b. “A Linked Data Platform for Mining Software Repositories.” In 2012 9th IEEE Working Conference on Mining Software Repositories (MSR). IEEE. https://doi.org/10.1109/msr.2012.6224296
Keivanloo, Iman, Chanchai K. Roy, and Juergen Rilling. 2012a. “Java Bytecode Clone Detection via Relaxation on Code Fingerprint and Semantic Web Reasoning.” In 2012 6th International Workshop on Software Clones (IWSC). IEEE. https://doi.org/10.1109/iwsc.2012.6227864
Kejariwal, A. 2013. “A Tool for Practical Garbage Collection Analysis in the Cloud.” In 2013 IEEE International Conference on Cloud Engineering (IC2E). IEEE. https://doi.org/10.1109/ic2e.2013.13
Kerimov, M. K. 1980. “Compiler Design Theory.” USSR Computational Mathematics and Mathematical Physics 20 (3): 283. https://doi.org/10.1016/0041-5553(80)90339-0
Kern, Philipp, and Carsten Sinz. 2025. “Abstract Interpretation of ReLU Neural Networks with Optimizable Polynomial Relaxations.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-74776-2_7
Kerschbaumer, Christoph, Eric Hennigan, Per Larsen, Stefan Brunthaler, and Michael Franz. 2013. “Information Flow Tracking Meets Just-in-Time Compilation.” ACM Transactions on Architecture and Code Optimization 10 (4): 1–25. https://doi.org/10.1145/2555289.2555295
Kessler, R. R., J. C. Peterson, H. Carr, G. P. Duggan, and J. Knell. 1986. “EPIC: A Retargetable, Highly Optimizing Lisp Compiler.” In Proceedings of the 1986 SIGPLAN symposium on Compiler construction. ACM. https://doi.org/10.1145/12276.13323
Keung, Jacky. 2007. “SPACE 2007: 1st International Workshop on Software Productivity Analysis and Cost Estimation.” In 14th Asia-Pacific Software Engineering Conference (APSEC’07). IEEE. https://doi.org/10.1109/apsec.2007.84
Keung, Jacky, Ekrem Kocaguneli, and Tim Menzies. 2012. “Finding Conclusion Stability for Selecting the Best Effort Predictor in Software Effort Estimation.” Automated Software Engineering 20 (4): 543–67. https://doi.org/10.1007/s10515-012-0108-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
Khaldi, Dounia, Yuanke Luo, Bing Yu, Alexey Sotkin, Bruno Morais, and Milind Girkar. 2021. “Extending LLVM IR for DPC++ Matrix Support: A Case Study with Intel® Advanced Matrix Extensions (Intel® AMX).” In 2021 IEEE/ACM 7th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvmhpc54804.2021.00008
Khaled Saifullah, C. M., Muhammad Asaduzzaman, and Chanchal K. Roy. 2020. “Exploring Type Inference Techniques of Dynamically Typed Languages.” In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner48275.2020.9054814
Khalid, Tarig Ahmed, and Eng-Thiam Yeoh. 2017. “Early Cost Estimation of Software Reworks Using Fuzzy Requirement-Based Model.” In 2017 International Conference on Communication, Control, Computing and Electronics Engineering (ICCCCEE). IEEE. https://doi.org/10.1109/iccccee.2017.7866082
Khan, Junaid Ali, Saif Ur Rehman Khan, Javed Iqbal, and Inayat Ur Rehman. 2021. “Empirical Investigation about the Factors Affecting the Cost Estimation in Global Software Development Context.” IEEE Access 9: 22274–94. https://doi.org/10.1109/access.2021.3055858
Khan, Jahangir, Zubair A. Shaikh, and Abou Bakar Nauman. 2011. “Development of Intelligent Effort Estimation Model Based on Fuzzy Logic Using Bayesian Networks.” In Software Engineering, Business Continuity, and Education. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-27207-3_9
Khatibi Bardsiri, Vahid, Dayang Norhayati Abang Jawawi, Siti Zaiton Mohd Hashim, and Elham Khatibi. 2012b. “A PSO-Based Model to Increase the Accuracy of Software Development Effort Estimation.” Software Quality Journal 21 (3): 501–26. https://doi.org/10.1007/s11219-012-9183-x
Khatibi Bardsiri, Vahid, and Elham Khatibi. 2014. “Insightful Analogy-Based Software Development Effort Estimation through Selective Classification and Localization.” Innovations in Systems and Software Engineering 11 (1): 25–38. https://doi.org/10.1007/s11334-014-0242-2
Khatri, Sushma, and Pratosh Bansal. 2024. “Hyperparameter Tuning and Validation of Neural Network Model for Software Effort Estimation with NCA Based Feature Selection.” In 2024 IEEE International Conference on Information Technology, Electronics and Intelligent Communication Systems (ICITEICS). IEEE. https://doi.org/10.1109/iciteics61368.2024.10625522
Khokhar, Waqar Ul-Hasnain, and Shahbaz Ahmed. 2012. “Architecture Based Software System Cost Estimation.” In 2012 International Conference on Open Source Systems and Technologies. IEEE. https://doi.org/10.1109/icosst.2012.6472837
Kibune, Masaya, and Michael G. Lee. 2017. “Efficient Learning Algorithm Using Compact Data Representation in Neural Networks.” In Neural Information Processing. Springer International Publishing. https://doi.org/10.1007/978-3-319-70096-0_33
Kido, Kengo, Swarat Chaudhuri, and Ichiro Hasuo. 2015. “Abstract Interpretation with Infinitesimals: Towards Scalability in Nonstandard Static Analysis.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-49122-5_11
Kiefer, Christoph, Abraham Bernstein, and Jonas Tappolet. 2007. “Mining Software Repositories with iSPAROL and a Software Evolution Ontology.” In Fourth International Workshop on Mining Software Repositories (MSR’07:ICSE Workshops 2007). IEEE. https://doi.org/10.1109/msr.2007.21
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
Kiepas, Patryk, Corinne Ancourt, Claude Tadonki, and Jarosław Koźlak. 2021. “Using Performance Event Profiles to Deduce an Execution Model of MATLAB with Just-In-Time Compilation.” In Languages and Compilers for Parallel Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-72789-5_6
Kim, Yoonseung. 2025. “A Formal Verification Library Design for Behavioral Refinement of CompCert Clight.” IEEE Access 13: 26927–44. https://doi.org/10.1109/access.2025.3539584
Kim, Austin, and Morris Chang. 2000. “Java Bytecode Optimization with Advanced Instruction Folding Mechanism.” In High Performance Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-39999-2_24
Kim, Jisoo, and Eun-Sun Cho. 2021. “Support for the Safety of EVM Bytecode via Function-Call Interceptor.” In 2021 IEEE 21st International Conference on Software Quality, Reliability and Security Companion (QRS-C). IEEE. https://doi.org/10.1109/qrs-c55045.2021.00102
Kim, Se-Won, and Kwang-Moo Choe. 2011. “String Analysis as an Abstract Interpretation.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-18275-4_21
Kim, Hansoo, Kanchi Gopinath, and Vinod Kathail. 2000b. “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, H. S., M. J. Irwin, N. Vijaykrishnan, and M. Kandemir. 2000a. “Effect of Compiler Optimizations on Memory Energy.” In 2000 IEEE Workshop on SiGNAL PROCESSING SYSTEMS. SiPS 2000. Design and Implementation (Cat. No.00TH8528). IEEE. https://doi.org/10.1109/sips.2000.886764
Kim, Jonghwan, Daehee Jang, Yunjong Jeong, and Brent Byunghoon Kang. 2019b. “POLaR: Per-Allocation Object Layout Randomization.” In 2019 49th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN). IEEE. https://doi.org/10.1109/dsn.2019.00058
Kim, Donghoon, and Hokeun Kim. 2025. “Empirical Analysis of Security Vulnerabilities in Open Source Software Using Static Analysis Tools.” In 2025 Cyber Awareness and Research Symposium (CARS). IEEE. https://doi.org/10.1109/cars67163.2025.11337539
Kim, D., I. Kim, J. Oh, and H. Cho. 2009. “Lightweight Static Analysis to Detect Polymorphic Exploit Code with Static Analysis Resistant Technique.” In 2009 IEEE International Conference on Communications. IEEE. https://doi.org/10.1109/icc.2009.5199134
Kim, Jinyeol, Raehyeong Kim, Jongwon Oh, and Seung Eun Lee. 2024a. “Accelerating Embedded WebAssembly Based on FPGA.” In 2024 21st International SoC Design Conference (ISOCC). IEEE. https://doi.org/10.1109/isocc62682.2024.10762325
Kim, Donggyu, Taemin Kim, Jiho Shin, Song Wang, Heeyoul Choi, and Jaechang Nam. 2025. “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, Jiseung, Hyunsei Lee, Mohsen Imani, and Yeseong Kim. 2023. “Efficient Hyperdimensional Learning with Trainable, Quantizable, and Holistic Data Representation.” In 2023 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE. https://doi.org/10.23919/date56975.2023.10137134
Kim, Jae-Jin, Seok-Young Lee, Soo-Mook Moon, and Suhyun Kim. 2010. “Comparison of LLVM and GCC on the ARM Platform.” In 2010 5th International Conference on Embedded and Multimedia Computing. IEEE. https://doi.org/10.1109/emc.2010.5575631
Kim, Jinyeol, Chaebin Lee, Jongwon Oh, Joungmin Park, and Seung Eun Lee. 2026. “WPU: A Pipelined WebAssembly Processing Unit for Embedded IoT Systems.” In 2026 31st Asia and South Pacific Design Automation Conference (ASP-DAC). IEEE. https://doi.org/10.1109/asp-dac66049.2026.11420760
Kim, Won-Sik, Woong-Kee Loh, and Wook-Shin Han. 2006a. “CC-GiST: Cache Conscious-Generalized Search Tree for Supporting Various Fast Intelligent Applications.” In Intelligence and Security Informatics. Springer Berlin Heidelberg. https://doi.org/10.1007/11760146_77
Kim, Won-Sik, Woong-Kee Loh, and Wook-Shin Han. 2006b. “Performance Analysis of the Cache Conscious-Generalized Search Tree.” In Computational Science – ICCS 2006. Springer Berlin Heidelberg. https://doi.org/10.1007/11758532_85
Kim, Suhyun, and Soo-Mook Moon. 2007. “Rotating Register Allocation for Enhanced Pipeline Scheduling.” In 16th International Conference on Parallel Architecture and Compilation Techniques (PACT 2007). IEEE. https://doi.org/10.1109/pact.2007.4336200
Kim, Yuntae, Dohyun Pak, and Jonghyup Lee. 2019c. “ScanAT: Identification of Bytecode-Only Smart Contracts with Multiple Attribute Tags.” IEEE Access 7: 98669–83. https://doi.org/10.1109/access.2019.2927003
Kim, Minsu, Jeong-Keun Park, and Soo-Mook Moon. 2022. “Solving PBQP-Based Register Allocation Using Deep Reinforcement Learning.” In 2022 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo53902.2022.9741272
Kim, Dongkeun, and Donald Yeung. 2002. “Design and Evaluation of Compiler Algorithms for Pre-Execution.” ACM SIGPLAN Notices 37 (10): 159–70. https://doi.org/10.1145/605432.605415
Kim, Ik-Soon, Kwangkeun Yi, and Cristiano Calcagno. 2006c. “A Polymorphic Modal Type System for Lisp-like Multi-Staged Languages.” In Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/1111037.1111060
Kim, Kyung-Chang, and Suk-Woo Yun. 2005. “MR-Tree: A Cache-Conscious Main Memory Spatial Index Structure for Mobile GIS.” In Web and Wireless Geographical Information Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/11427865_13
Kim Nhung, Ho Le Thi, Petr Silhavy, and Radek Silhavy. 2024. “Enhancing Software Effort Estimation through Influencers-Based Project Similarity Measurement.” Procedia Computer Science 246: 3256–64. https://doi.org/10.1016/j.procs.2024.09.314
Kind, Andreas. 1997. “Bytecode-Interpretierung.” Informatik-Spektrum 20 (2): 109–10. https://doi.org/10.1007/s002870050059
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
Kiran, D. C., J. P. Misra, D. Yashas, and S. Gurunarayanan. 2013. “Integrated Scheduling and Register Allocation for Multicore Architecture.” In 2013 National Conference on Parallel Computing Technologies (PARCOMPTECH). IEEE. https://doi.org/10.1109/parcomptech.2013.6621400
Kirner, Raimund, and Walter Haas. 2012. “Optimizing Compilation with Preservation of Structural Code Coverage Metrics to Support Software Testing.” Software Testing, Verification and Reliability 24 (3): 184–218. https://doi.org/10.1002/stvr.1485
Kirner, Raimund, Stephan Herhut, and Sven-Bodo Scholz. 2010. “Compiler-Support for Robust Multi-Core Computing.” In Leveraging Applications of Formal Methods, Verification, and Validation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-16558-0_6
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, 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. “Typed Tagless Final Interpreters.” In Generic and Indexed Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-32202-0_3
Kitchenham, Ba. 1992. “Empirical Studies of Assumptions That Underlie Software Cost-Estimation Models.” Information and Software Technology 34 (4): 211–18. https://doi.org/10.1016/0950-5849(92)90077-3
Kittilsen, Edward. 1900. “An Efficient System of Garbage Collection for a Small City.” Scientific American 29 (5build): 99–99. https://doi.org/10.1038/scientificamerican05011900-99bbuild
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 Tobias Nipkow. 2003. “Verified Bytecode Verifiers.” Theoretical Computer Science 298 (3): 583–626. https://doi.org/10.1016/s0304-3975(02)00869-1
Klein, Gerwin, and Tobias Nipkow. 2006. “A Machine-Checked Model for a Java-like Language, Virtual Machine, and Compiler.” ACM Transactions on Programming Languages and Systems 28 (4): 619–95. https://doi.org/10.1145/1146809.1146811
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
Kleinschmager, Sebastian, Romain Robbes, Andreas Stefik, Stefan Hanenberg, and Eric Tanter. 2012. “Do Static Type Systems Improve the Maintainability of Software Systems? An Empirical Study.” In 2012 20th IEEE International Conference on Program Comprehension (ICPC). IEEE. https://doi.org/10.1109/icpc.2012.6240483
Klettke, Meike, Uta Storl, Manuel Shenavai, and Stefanie Scherzinger. 2016. “NoSQL Schema Evolution and Big Data Migration at Scale.” In 2016 IEEE International Conference on Big Data (Big Data). IEEE. https://doi.org/10.1109/bigdata.2016.7840924
Klock, Felix S., and William D. Clinger. 2011. “Bounded-Latency Regional Garbage Collection.” ACM SIGPLAN Notices 47 (2): 73–84. https://doi.org/10.1145/2168696.2047859
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
Klosowski, Piotr. 2016. “Statistical Analysis of Polish Language Corpus for Speech Recognition Application.” In 2016 Signal Processing: Algorithms, Architectures, Arrangements, and Applications (SPA). IEEE. https://doi.org/10.1109/spa.2016.7763632
Knapp, Michael, Vanessa Kohl, Tatjana Best, Oliver Rammo, and Sybille Ebert. 2024. “Chromatographic Single-Step Purification of Tagless Proteins Using gp41-1 Split Inteins.” Frontiers in Bioengineering and Biotechnology 11: 1319916. https://doi.org/10.3389/fbioe.2023.1319916
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
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
Knoop, Jens, and Wolf Zimmermann. 2010. “On the Role of Non-Functional Properties in Compiler Verification.” In Leveraging Applications of Formal Methods, Verification, and Validation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-16561-0_46
Knuth, Donald E. 1971. “An Empirical Study of FORTRAN Programs.” Software: Practice and Experience 1 (2): 105–33. https://doi.org/10.1002/spe.4380010203
Ko, Sohyang, Seonsoo Jun, Kiyong Kim, and Yeonseung Ryu. 2008. “Study on Garbage Collection Schemes for Flash-Based Linux Swap System.” In 2008 Advanced Software Engineering and Its Applications. IEEE. https://doi.org/10.1109/asea.2008.55
Ko, Kwang-Man, and Soon-Gohn Kim. 2004. “Target Code Generation Sing the Code Expansion Technique for Java Bytecode.” In Parallel and Distributed Computing: Applications and Technologies. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30501-9_147
Kocaguneli, Ekrem, and Tim Menzies. 2011. “How to Find Relevant Data for Effort Estimation?” In 2011 International Symposium on Empirical Software Engineering and Measurement. IEEE. https://doi.org/10.1109/esem.2011.34
Kocaguneli, E., T. Menzies, A. Bener, and J. W. Keung. 2012a. “Exploiting the Essential Assumptions of Analogy-Based Effort Estimation.” IEEE Transactions on Software Engineering 38 (2): 425–38. https://doi.org/10.1109/tse.2011.27
Kocaguneli, Ekrem, Tim Menzies, and Jacky W. Keung. 2011. “Kernel Methods for Software Effort Estimation: Effects of Different Kernel Functions and Bandwidths on Estimation Accuracy.” Empirical Software Engineering 18 (1): 1–24. https://doi.org/10.1007/s10664-011-9189-1
Kocaguneli, Ekrem, Tim Menzies, and Jacky W. Keung. 2012b. “On the Value of Ensemble Effort Estimation.” IEEE Transactions on Software Engineering 38 (6): 1403–16. https://doi.org/10.1109/tse.2011.111
Kocaguneli, Ekrem, Tim Menzies, Jacky Keung, David Cok, and Ray Madachy. 2013. “Active Learning and Effort Estimation: Finding the Essential Content of Software Effort Estimation Data.” IEEE Transactions on Software Engineering 39 (8): 1040–53. https://doi.org/10.1109/tse.2012.88
Kocaguneli, Ekrem, Tim Menzies, and Emilia Mendes. 2014. “Transfer Learning in Effort Estimation.” Empirical Software Engineering 20 (3): 813–43. https://doi.org/10.1007/s10664-014-9300-5
Kocaguneli, Ekrem, Ayse Tosun, and Ayse Bener. 2010. “AI-Based Models for Software Effort Estimation.” In 2010 36th EUROMICRO Conference on Software Engineering and Advanced Applications. IEEE. https://doi.org/10.1109/seaa.2010.19
Koch, Stefan, and Johann Mitlöhner. 2009. “Software Project Effort Estimation with Voting Rules.” Decision Support Systems 46 (4): 895–901. https://doi.org/10.1016/j.dss.2008.12.002
Kochhar, Pavneet Singh, Tegawende F. Bissyande, David Lo, and Lingxiao Jiang. 2013. “An Empirical Study of Adoption of Software Testing in Open Source Projects.” In 2013 13th International Conference on Quality Software. IEEE. https://doi.org/10.1109/qsic.2013.57
Kochkina, Nataliia, Silvia Macchia, and Michela Floris. 2024. “Strategic Language Use in Sustainability Reporting: An Empirical Study.” Sustainability 16 (23): 10229. https://doi.org/10.3390/su162310229
Koelmeyer, Hamish, and Sithamparanathan Kandeepan. 2017. “Tagless Tolling Using DSRC for Intelligent Transport System: An Interference Study.” In 2017 Asia Modelling Symposium (AMS). IEEE. https://doi.org/10.1109/ams.2017.33
Koetter, Falko, Monika Kochanowski, Maximilien Kintz, Benedikt Kersjes, Ivan Bogicevic, and Stefan Wagner. 2019. “Assessing Software Quality of Agile Student Projects by Data-Mining Software Repositories.” In Proceedings of the 11th International Conference on Computer Supported Education. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0007688600002176
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
Köller, Jörg, and Markus Mohnen. 1999. “A New Class of Functions for Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48294-6_16
Kolte, Priyadarshan, and Mary Jean Harrold. 1993. “Load/store Range Analysis for Global Register Allocation.” In Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/155090.155116
Komondoor, Raghavan. 2013. “Precise Slicing in Imperative Programs via Term-Rewriting and Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-38856-9_15
Kondo, Yurie, Shima Okada, Moemi Saito, Takahide Tanaka, and Kanaru Fumimoto. 2022. “Development of Boxing Glove Type Sensation Device for Exercise Induction and Continuation.” In 2022 IEEE 11th Global Conference on Consumer Electronics (GCCE). IEEE. https://doi.org/10.1109/gcce56475.2022.10014049
Kong, Martin, Louis-Noel Pouchet, P. Sadayappan, and Vivek Sarkar. 2016. “PIPES: A Language and Compiler for Task-Based Programming on Distributed-Memory Clusters.” In SC16: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/sc.2016.38
König, Barbara. 2005. “Analysing Input/output-Capabilities of Mobile Processes with a Generic Type System.” Journal of Logic and Algebraic Programming 63 (1): 35–58. https://doi.org/10.1016/j.jlap.2004.01.004
Koole, Sander, and Mascha van’t Spijker. 2000. “Overcoming the Planning Fallacy through Willpower: Effects of Implementation Intentions on Actual and Predicted Task-Completion Times.” European Journal of Social Psychology 30 (6): 873–88. https://doi.org/10.1002/1099-0992(200011/12)30:6<873::aid-ejsp22>3.0.co;2-u
Koop, M. J., J. K. Sridhar, and D. K. Panda. 2009. “TupleQ: Fully-Asynchronous and Zero-Copy MPI over InfiniBand.” In 2009 IEEE International Symposium on Parallel & Distributed Processing. IEEE. https://doi.org/10.1109/ipdps.2009.5161056
Koop, Matthew J., Sayantan Sur, and Dhabaleswar K. Panda. 2007. “Zero-Copy Protocol for MPI Using Infiniband Unreliable Datagram.” In 2007 IEEE International Conference on Cluster Computing. IEEE. https://doi.org/10.1109/clustr.2007.4629230
Kopp, Bruno. 2026. “Weighting Bayesian Information in Human Judgment under Uncertainty: A Hierarchical Theory of Cognitive Biases.” Frontiers in Psychology 17: 1861515. https://doi.org/10.3389/fpsyg.2026.1861515
Korenaga, Kento, Akito Monden, and Zeynep Yucel. 2019. “Data Smoothing for Software Effort Estimation.” In 2019 20th IEEE/ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD). IEEE. https://doi.org/10.1109/snpd.2019.8935841
Körner, Philipp, David Schneider, and Michael Leuschel. 2021. “On the Performance of Bytecode Interpreters in Prolog.” In Functional and Constraint Logic Programming. Springer International Publishing. https://doi.org/10.1007/978-3-030-75333-7_3
Kornerup, Peter, Bent Bruun Kristensen, and Ole Lehrmann Madsen. 1980. “Interpretation and Code Generation Based on Intermediate Languages.” Software: Practice and Experience 10 (8): 635–58. https://doi.org/10.1002/spe.4380100804
Kortik, Sitar, and Uluc Saranli. 2014. “Linear Planning Logic: An Efficient Language and Theorem Prover for Robotic Task Planning.” In 2014 IEEE International Conference on Robotics and Automation (ICRA). IEEE. https://doi.org/10.1109/icra.2014.6907404
Kortright, E. V. 1991. “Model Verification in Lambda Sigma: A Type Inference Approach.” In [1991] Proceedings of the 24th Annual Simulation Symposium. IEEE. https://doi.org/10.1109/simsym.1991.151516
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
Kosmatov, Nikolai, Delphine Longuet, and Romain Soulat. 2020. “Formal Verification of an Industrial Distributed Algorithm: An Experience Report.” In Leveraging Applications of Formal Methods, Verification and Validation: Verification Principles. Springer International Publishing. https://doi.org/10.1007/978-3-030-61362-4_30
Kostelansky, Jozef, and Lubomir Dedera. 2017. “An Evaluation of Output from Current Java Bytecode Decompilers: Is It Android Which Is Responsible for Such Quality Boost?” In 2017 Communication and Information Technologies (KIT). IEEE. https://doi.org/10.23919/kit.2017.8109451
Koster, C. H. A. 1974. “Using the CDL Compiler-Compiler.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-21549-4_16
Koster, C. H. A. 1977. “CDL — A Compiler Implementation Language.” In Methods of Algorithmic Language Implementation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-08065-1_22
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
Kourai, Kenichi, and Hiroki Ooba. 2016. “VMBeam: Zero-Copy Migration of Virtual Machines for Virtual IaaS Clouds.” In 2016 IEEE 35th Symposium on Reliable Distributed Systems (SRDS). IEEE. https://doi.org/10.1109/srds.2016.024
Koutbi, Salma El, and Ali Idri. 2017. “A Quantum-Based Approach to Error in Software Development Effort Estimation.” In 2017 4th International Conference on Control, Decision and Information Technologies (CoDIT). IEEE. https://doi.org/10.1109/codit.2017.8102599
Koutbi, Salma El, Ali Idri, and Alain Abran. 2016. “Systematic Mapping Study of Dealing with Error in Software Development Effort Estimation.” In 2016 42th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2016.39
Kovács, András. 2022. “Staged Compilation with Two-Level Type Theory.” Proceedings of the ACM on Programming Languages 6 (ICFP): 540–69. https://doi.org/10.1145/3547641
Kradolfer, M., and A. Geppert. 1999. “Dynamic Workflow Schema Evolution Based on Workflow Type Versioning and Workflow Migration.” In Proceedings Fourth IFCIS International Conference on Cooperative Information Systems. CoopIS 99 (Cat. No.PR00384). IEEE. https://doi.org/10.1109/coopis.1999.792162
Krakowski, Filip, Fabian Ruhland, and Michael Schöttner. 2023. “High-Performance Object Serialization Based on Ahead-of-Time Schema Generation.” In 2023 IEEE 22nd International Conference on Trust, Security and Privacy in Computing and Communications (TrustCom). IEEE. https://doi.org/10.1109/trustcom60117.2023.00335
Krall, A., I. Pryanishnikov, U. Hirnschrott, and C. Panis. 2004. “XDSPCORE: A Compiler-Based Configurable Digital Signal Processor.” IEEE Micro 24 (4): 67–78. https://doi.org/10.1109/mm.2004.40
Krall, Andreas, and Philipp Tomsich. 1999. “Garbage Collection for Large Memory Java Applications.” In High-Performance Computing and Networking. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0100649
Krasniqi, Rrezarta, Depeng Xu, and Marco Vieira. 2025. “SE Perspective on LLMs: Biases in Code Generation, Code Interpretability, and Code Security Risks.” ACM Computing Surveys 58 (5): 1–16. https://doi.org/10.1145/3774324
Krause, Philipp Klaus. 2014. “The Complexity of Register Allocation.” Discrete Applied Mathematics 168: 51–59. https://doi.org/10.1016/j.dam.2013.03.015
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
Krekelberg, D. E., E. Shragowitz, G. E. Sobelman, and LI-Shin Lin. 1986. “Automated Layout Synthesis in the YASC Silicon Compiler.” In 23rd ACM/IEEE Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1986.1586127
Krekelberg, D. E., G. E. Sobelman, and C. S. Jhon. 1985. “Yet Another Silicon Compiler.” In 22nd ACM/IEEE Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1985.1585932
Krichen, Moez. 2023. “A Survey on Formal Verification and Validation Techniques for Internet of Things.” Applied Sciences 13 (14): 8122. https://doi.org/10.3390/app13148122
Krijnen, Thomas, and Jakob Beetz. 2017. “An IFC Schema Extension and Binary Serialization Format to Efficiently Integrate Point Cloud Data into Building Models.” Advanced Engineering Informatics 33: 473–90. https://doi.org/10.1016/j.aei.2017.03.008
Krishnapillai, Vijayakumar, Prasad Sundaramoorthy, Anam Haider Khan, and Sashi Kiran Kaata. 2025. “Contract-Centric ETL: Adaptive Schema Evolution with Real-Time Data Contract, Repair, and Risk-Budgeted Rollout.” In 2025 International Conference on Computational Engineering, Sensing Technology and Management (ICCETM). IEEE. https://doi.org/10.1109/iccetm66557.2025.11557754
Kritz, Joshua, Mart de Roos, Luís Pires, João Moreira, and Giancarlo Guizzardi. 2022. “UgameFeature: Automatic Code Generation for Unity Game Projects.” In Proceedings of the 10th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010990000003119
Krummes, Cedric, and Astrid Ensslin. 2012. “Formulaic Language and Collocations in German Essays: From Corpus-Driven Data to Corpus-Based Materials.” Language Learning Journal 43 (1): 110–27. https://doi.org/10.1080/09571736.2012.694900
Krylov, Georgiy, Maria Patrou, Gerhard W. Dueck, and Joran Siu. 2020. “The Evolution of Garbage Collection in V8: Google’s JavaScript Engine.” In 2020 9th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco49872.2020.9134326
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
Kucher, Vladyslav, and Sergei Gorlatch. 2021. “Implicit Data Layout Optimization for Portable Parallel Programming in C++.” In Parallel Computing Technologies. Springer International Publishing. https://doi.org/10.1007/978-3-030-86359-3_17
Kucheryavskiy, Sergey. 2026. “Unboxing Deep Learning Models Using Gradient-Based Methods — A Tutorial.” Analytica Chimica Acta 1407: 345489. https://doi.org/10.1016/j.aca.2026.345489
Küchler, Alexander, and Christian Banse. 2022. “Representing LLVM-IR in a Code Property Graph.” In Information Security. Springer International Publishing. https://doi.org/10.1007/978-3-031-22390-7_21
Kuepper, Joel, Andres Erbsen, Jason Gross, et al. 2023. “CryptOpt: Verified Compilation with Randomized Program Search for Cryptographic Primitives.” Proceedings of the ACM on Programming Languages 7 (PLDI): 1268–92. https://doi.org/10.1145/3591272
Kulkarni, C., C. Ghez, M. Miranda, F. Catthoor, and H. De Man. 2005. “Cache Conscious Data Layout Organization for Conflict Miss Reduction in Embedded Multimedia Applications.” IEEE Transactions on Computers 54 (1): 76–81. https://doi.org/10.1109/tc.2005.2
Kultur, Yigit, Ekrem Kocaguneli, and Ayse B. Bener. 2009. “Domain Specific Phase by Phase Effort Estimation in Software Projects.” In 2009 24th International Symposium on Computer and Information Sciences. IEEE. https://doi.org/10.1109/iscis.2009.5291873
Kumar, Sandeep, Mohit Arora, Sakshi, and Shivali Chopra. 2022. “A Review of Effort Estimation in Agile Software Development Using Machine Learning Techniques.” In 2022 4th International Conference on Inventive Research in Computing Applications (ICIRCA). IEEE. https://doi.org/10.1109/icirca54612.2022.9985542
Kumar, Natesh, Mariano Falcitelli, Francesco Kotopulos De Angelis, Paolo Pagano, and Sandro Noto. 2026. “Evaluating Binary Serialization Protocols for IoT/M2M Applications over Hybrid Terrestrial and Non-Terrestrial Networks.” Telecom 7 (2): 43. https://doi.org/10.3390/telecom7020043
Kumar, K. Shiva, and N. Raghu Kisore. 2014. “Protection against Buffer Overflow Attacks through Runtime Memory Layout Randomization.” In 2014 International Conference on Information Technology. IEEE. https://doi.org/10.1109/icit.2014.57
Kumar, Anoop P., Sathia Narayanan, and Vijayalakshmi Mallenahalli Siddaiah. 2010. “COTS Integrations: Effort Estimation Best Practices.” In 2010 IEEE 34th Annual Computer Software and Applications Conference Workshops. IEEE. https://doi.org/10.1109/compsacw.2010.24
Kumar, Anil, and B. D. K. Patro. 2021. “Modeling and Representation of Software Framework Cost Estimation Using Convolution Neural Networks.” In 2021 5th International Conference on Information Systems and Computer Networks (ISCON). IEEE. https://doi.org/10.1109/iscon52037.2021.9702391
Kumar, R. Lokesh, R. Ramya, M. Jaya Balaji, V. Hari, and M. Malarvizhi. 2024. “Garbage Collection and Segregation Using Computer Vision.” In 2024 International Conference on Inventive Computation Technologies (ICICT). IEEE. https://doi.org/10.1109/icict60155.2024.10544861
Kumar, Tarun, and Rajeev Kumar Singh. 2015. “Analysis of Compiler Optimization Techniques by Using Feature Mining Technique.” In 2015 39th National Systems Conference (NSC). IEEE. https://doi.org/10.1109/natsys.2015.7489089
Kumar, K. Harish, and K. Srinivas. 2021. “Preliminary Performance Study of a Brief Review on Machine Learning Techniques for Analogy Based Software Effort Estimation.” Journal of Ambient Intelligence and Humanized Computing 14 (3): 2141–65. https://doi.org/10.1007/s12652-021-03427-y
Kumar, K. Harish, and K. Srinivas. 2023. “An Accurate Analogy Based Software Effort Estimation Using Hybrid Optimization and Machine Learning Techniques.” Multimedia Tools and Applications 82 (20): 30463–90. https://doi.org/10.1007/s11042-023-14522-x
Kumar, Ravi B. N., and Yeresime Suresh. 2023. “Software Effort Estimation Using ANN (Back Propagation).” In 2023 7th International Conference on Computing Methodologies and Communication (ICCMC). IEEE. https://doi.org/10.1109/iccmc56507.2023.10084264
Kumar K., Prasanna, Amitabha Sanyal, and Amey Karkare. 2016. “Liveness-Based Garbage Collection for Lazy Languages.” ACM SIGPLAN Notices 51 (11): 122–33. https://doi.org/10.1145/3241624.2926698
Kumar K. S., Vipin, Albin Abraham Itty, B. Arjunlal, and Sheena Mathew. 2011. “Compiler Based Approach to Estimate Software Reliability Using Metrics.” In 2011 Annual IEEE India Conference. IEEE. https://doi.org/10.1109/indcon.2011.6139399
Kumari, Sweta, and Shashank Pushkar. 2018. “Cuckoo Search Based Hybrid Models for Improving the Accuracy of Software Effort Estimation.” Microsystem Technologies 24 (12): 4767–74. https://doi.org/10.1007/s00542-018-3871-9
Kume, Izuru, Masahide Nakamura, and Naoya Nitta. 2018. “Revealing Implicit Correspondence between Bytecode Instructions and Expressions Determined by Java Compilers.” In 2018 25th Australasian Software Engineering Conference (ASWEC). IEEE. https://doi.org/10.1109/aswec.2018.00025
Kung, H. T., and S. W. Song. 1977. “An Efficient Parallel Garbage Collection System and ITS Correctness Proof.” In 18th Annual Symposium on Foundations of Computer Science (sfcs 1977). IEEE. https://doi.org/10.1109/sfcs.1977.5
Kunieda, Yuki, Tatsuya Abe, and Hidekazu Suzuki. 2024. “Implementation of MERN Stack-Based Web Application to Visualize Garbage Collection Status.” In 2024 IEEE 13th Global Conference on Consumer Electronics (GCCE). IEEE. https://doi.org/10.1109/gcce62371.2024.10761051
Kuo, Li-Wei, Chun-Chieh Yang, Jenq-Kuen Lee, and Shau-Yin Tseng. 2014. “The Design of LLVM-Based Shader Compiler for Embedded Architecture.” In 2014 20th IEEE International Conference on Parallel and Distributed Systems (ICPADS). IEEE. https://doi.org/10.1109/padsw.2014.7097916
Kurlander, Steven M., and Charles N. Fischer. 1996. “Minimum Cost Interprocedural Register Allocation.” In Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘96. ACM Press. https://doi.org/10.1145/237721.237780
Kurmann, Christian, Felix Rauch, and Thomas M. Stricker. 2001. “Speculative Defragmentation – Leading Gigabit Ethernet to True Zero-Copy Communication.” Cluster Computing 4 (1): 7–18. https://doi.org/10.1023/a:1011456024871
Kuroda, I., A. Hirano, and T. Nishitani. 1991. “A Knowledge-Based Compiler Enhancing DSP Internal Parallelism.” In 1991 IEEE International Symposium on Circuits and Systems (ISCAS). IEEE. https://doi.org/10.1109/iscas.1991.176317
Kusters, R. J., M. J. I. M. van Genuchten, and F. J. Heemstra. 1990. “Are Software Cost-Estimation Models Accurate?” Information and Software Technology 32 (3): 187–90. https://doi.org/10.1016/0950-5849(90)90176-r
Kusuma, Indra Jaya, Hilal H. Nuha, and Gandeva Bayu. 2023. “Performance Analysis of Forensic Programs on SQLite Corpus.” In 2023 IEEE Asia Pacific Conference on Wireless and Mobile (APWiMob). IEEE. https://doi.org/10.1109/apwimob59963.2023.10365603
Kuszera, Evandro, Leticia Peres, and Marcos Fabro. 2024. “MfCodeGenerator: A Code Generation Tool for NoSQL Data Access with ONM Support.” In Proceedings of the 26th International Conference on Enterprise Information Systems. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0012557800003690
Kuzmicz, Wieslaw. 2016. “Extension of the Corner Stitching Data Structure for Arbitrary Layout Shapes.” In 2016 IEEE East-West Design & Test Symposium (EWDTS). IEEE. https://doi.org/10.1109/ewdts.2016.7807626
Kwon, Yujin, Yujeong Choi, Dohwan Ji, and Jinyoung Kim. 2026. “eBPF-VulnBench: A Benchmark of Real-World eBPF Malicious Bytecode.” In 2026 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner67736.2026.00076
Kwon, Osang, Yongho Lee, and Seokin Hong. 2025. “Improving Address Translation in Tagless DRAM Cache by Caching PTE Pages.” In 2025 Design, Automation & Test in Europe Conference (DATE). IEEE. https://doi.org/10.23919/date64628.2025.10992823
La, Vinh Quang. 2008. “A Study on Java Virtual Machine for Real-Time Embedded Systems.” In 2008 International Conference on Computer Science and Software Engineering. IEEE. https://doi.org/10.1109/csse.2008.366
Lacey, David, Neil D. Jones, Eric Van Wyk, and Carl Christian Frederiksen. 2002. “Proving Correctness of Compiler Optimizations by Temporal Logic.” ACM SIGPLAN Notices 37 (1): 283–94. https://doi.org/10.1145/565816.503299
Lacey, David, Neil D. Jones, Eric Van Wyk, and Carl Christian Frederiksen. 2004. “Compiler Optimization Correctness by Temporal Logic.” Higher-Order and Symbolic Computation 17 (3): 173–206. https://doi.org/10.1023/b:lisp.0000029444.99264.c0
Lackner, Michael, Reinhard Berlach, Michael Hraschan, Reinhold Weiss, and Christian Steger. 2013. “A Defensive Java Card Virtual Machine to Thwart Fault Attacks by Microarchitectural Support.” In 2013 International Conference on Risks and Security of Internet and Systems (CRiSIS). IEEE. https://doi.org/10.1109/crisis.2013.6766360
Lackner, Michael, Reinhard Berlach, Michael Hraschan, Reinhold Weiss, and Christian Steger. 2014. “A Fault Attack Emulation Environment to Evaluate Java Card Virtual-Machine Security.” In 2014 17th Euromicro Conference on Digital System Design. IEEE. https://doi.org/10.1109/dsd.2014.51
Lafond, Sébastien, and Johan Lilius. 2006. “An Energy Consumption Model for an Embedded Java Virtual Machine.” In Architecture of Computing Systems - ARCS 2006. Springer Berlin Heidelberg. https://doi.org/10.1007/11682127_22
Lagerström, Robert, Pontus Johnson, and Mathias Ekstedt. 2010. “Architecture Analysis of Enterprise Systems Modifiability: A Metamodel for Software Change Cost Estimation.” Software Quality Journal 18 (4): 437–68. https://doi.org/10.1007/s11219-010-9100-0
Lahaie-Bertrand, Frédéric, Léonard Oest O’Leary, Olivier Melançon, Marc Feeley, and Stefan Monnier. 2025. “Arborescent Garbage Collection: A Dynamic Graph Approach to Immediate Cycle Collection.” In Proceedings of the 2025 ACM SIGPLAN International Symposium on Memory Management. ACM. https://doi.org/10.1145/3735950.3735953
Lahouij, Aida, Lazhar Hamel, and Mohamed Graiet. 2013. “Formal Verification of SCA Assembly Model with Event-B.” In 2013 Ninth International Conference on Semantics, Knowledge and Grids. IEEE. https://doi.org/10.1109/skg.2013.31
Lai, Xiaoyan. 2014. “A Design of General Compiler for NC Code in Embedded NC System.” In 2014 9th IEEE Conference on Industrial Electronics and Applications. IEEE. https://doi.org/10.1109/iciea.2014.6931409
Lai, M. C. L., S. S. Y. Ho, and W. W. Y. Hui. 2003. “Adoption Process of Upgrading Software: An Empirical Study of Windows XP.” In 36th Annual Hawaii International Conference on System Sciences, 2003. Proceedings of the. IEEE. https://doi.org/10.1109/hicss.2003.1174773
Lai, Yong, Kuldeep S. Meel, and Roland H. C. Yap. 2025. “Panini: An Efficient and Flexible Knowledge Compiler.” In Computer Aided Verification. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-98682-6_6
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
Lai, Jyun-Kai, and Wuu Yang. 2022. “Hyperchaining for LLVM-Based Binary Translators on the x86-64 Platform.” Journal of Signal Processing Systems 94 (12): 1569–89. https://doi.org/10.1007/s11265-022-01803-1
Laily Zen, Evynurul. 2018. “Corpus-Driven Analysis on the Language of Children’s Literature.” In Proceedings of the 1st International Conference on Recent Innovations. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0009912700170022
Lakhlifi, Camille, and Benjamin Rohaut. 2023. “Heuristics and Biases in Medical Decision-Making under Uncertainty: The Case of Neuropronostication for Consciousness Disorders.” La Presse Médicale 52 (2): 104181. https://doi.org/10.1016/j.lpm.2023.104181
Lal, Supriya, Lakshmithejaswi Narasannagari, Sowmyanka Andalam, and Shilpa Shastri. 2025. “An Empirical Study of Industry Awareness and Adoption of Green Practices in Modern Software Architectures.” In 2025 IEEE International Conference on Service-Oriented System Engineering (SOSE). IEEE. https://doi.org/10.1109/sose67019.2025.00016
LaLonde, Wilf R., and Jim des Rivieres. 1982. “A Flexible Compiler Structure That Allows Dynamic Phase Ordering.” ACM SIGPLAN Notices 17 (6): 134–39. https://doi.org/10.1145/872726.806989
Lambert, Jonathan M., and James F. Power. 2008. “Platform Independent Timing of Java Virtual Machine Bytecode Instructions.” Electronic Notes in Theoretical Computer Science 220 (3): 97–113. https://doi.org/10.1016/j.entcs.2008.11.021
Lameed, Nurudeen A., and Laurie J. Hendren. 2013. “A Modular Approach to on-Stack Replacement in LLVM.” ACM SIGPLAN Notices 48 (7): 143–54. https://doi.org/10.1145/2517326.2451541
Lammich, Peter. 2024. “Refinement of Parallel Algorithms down to LLVM: Applied to Practically Efficient Parallel Sorting.” Journal of Automated Reasoning 68 (3): 14. https://doi.org/10.1007/s10817-024-09701-w
Lancia, Julien, and Guillaume Bouffard. 2016. “Java Card Virtual Machine Compromising from a Bytecode Verified Applet.” In Smart Card Research and Advanced Applications. Springer International Publishing. https://doi.org/10.1007/978-3-319-31271-2_5
Landeis, Katharina, Gerhard Pews, and Mirjam Minor. 2022. “Particle Swarm Optimization in Small Case Bases for Software Effort Estimation.” In Case-Based Reasoning Research and Development. Springer International Publishing. https://doi.org/10.1007/978-3-031-14923-8_14
Landman, Davy, Alexander Serebrenik, and Jurgen J. Vinju. 2017. “Challenges for Static Analysis of Java Reflection: Literature Review and Empirical Study.” In 2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse.2017.53
Landry, Kenneth, and James D. Arthur. 1995. “Instructional Footprinting and Semantic Preservation in Linda.” Concurrency: Practice and Experience 7 (3): 191–207. https://doi.org/10.1002/cpe.4330070303
Lang, B., and F. Dupont. 1987. “Incremental Incrementally Compacting Garbage Collection.” ACM SIGPLAN Notices 22 (7): 253–63. https://doi.org/10.1145/960114.29677
Langhammer, Martin, and Tom VanCourt. 2009. “FPGA Floating Point Datapath Compiler.” In 2009 17th IEEE Symposium on Field Programmable Custom Computing Machines. IEEE. https://doi.org/10.1109/fccm.2009.54
Langmaack, Hans. 1997. “Contribution to Goodenough’s and Gerhart’s Theory of Software Testing and Verification: Relation between Strong Compiler Test and Compiler Implementation Verification.” In Foundations of Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0052101
“Language Extensions for the Automation of Database Schema Evolution.” 2008. In Proceedings of the Tenth International Conference on Enterprise Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0001716400740081
Lano, Kevin, and Qiaomu Xue. 2022. “Code Generation by Example.” In Proceedings of the 10th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010973600003119
Lantz, Patrik, and Bjorn Johansson. 2015. “Towards Bridging the Gap between Dalvik Bytecode and Native Code during Static Analysis of Android Applications.” In 2015 International Wireless Communications and Mobile Computing Conference (IWCMC). IEEE. https://doi.org/10.1109/iwcmc.2015.7289149
Laqrichi, Safae, Francois Marmier, Didier Gourc, and Jean Nevoux. 2015. “Integrating Uncertainty in Software Effort Estimation Using Bootstrap Based Neural Networks.” IFAC-PapersOnLine 48 (3): 954–59. https://doi.org/10.1016/j.ifacol.2015.06.206
Laretto, Andrea, Fosco Loregian, and Niccolò Veltri. 2026. “Di- Is for Directed: First-Order Directed Type Theory via Dinaturality.” Proceedings of the ACM on Programming Languages 10 (POPL): 1759–89. https://doi.org/10.1145/3776703
Larner, R. 1963. “Design of an Integrated Programming and Operating System, Part IV: The System’s FORTRAN Compiler.” IBM Systems Journal 2 (3): 311–21. https://doi.org/10.1147/sj.23.0311
Larose, Octave, Sophie Kaleba, Humphrey Burchell, and Stefan Marr. 2023. “AST vs. Bytecode: Interpreters in the Age of Meta-Compilation.” Proceedings of the ACM on Programming Languages 7 (OOPSLA2): 318–46. https://doi.org/10.1145/3622808
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
Larus, J. R., M. D. Hill, and T. M. Chilimbi. 2000. “Making Pointer-Based Data Structures Cache Conscious.” Computer 33 (12): 67–74. https://doi.org/10.1109/2.889095
Larvet, Philippe, and Frédérique Vallée. 2002. “UML Developments: Cost Estimation from Requirements.” In Software Quality — ECSQ 2002. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-47984-8_19
“Lattice Logic Improve Silicon Compiler.” 1984. Computer-Aided Design 16 (4): 239. https://doi.org/10.1016/0010-4485(84)90030-7
Latticelogic. 1984. “Adapted Silicon Compiler Goes to USA.” Computer-Aided Design 16 (6): 348–348. https://doi.org/10.1016/0010-4485(84)90156-8
Lattner, Chris, and Vikram Adve. 2005a. “Automatic Pool Allocation: Improving Performance by Controlling Data Structure Layout in the Heap.” In Proceedings of the 2005 ACM SIGPLAN conference on Programming language design and implementation. ACM. https://doi.org/10.1145/1065010.1065027
Lattner, Chris, and Vikram Adve. 2005b. “The LLVM Compiler Framework and Infrastructure Tutorial.” In Languages and Compilers for High Performance Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/11532378_2
Laufer, Batia, and Tina Waldman. 2011. “Verb-Noun Collocations in Second Language Writing: A Corpus Analysis of Learners’ English.” Language Learning 61 (2): 647–72. https://doi.org/10.1111/j.1467-9922.2010.00621.x
Laurent, Mickaël, Jakob Hain, Filip Křikava, Sebastián Krynski, and Jan Vitek. 2026. “A Typed Intermediate Representation for Dynamic Languages.” ACM Transactions on Programming Languages and Systems 48 (2): 1–33. https://doi.org/10.1145/3811921
Laursen, Mathias Rud, Wenyuan Xu, and Anders Møller. 2024. “Reducing Static Analysis Unsoundness with Approximate Interpretation.” Proceedings of the ACM on Programming Languages 8 (PLDI): 1165–88. https://doi.org/10.1145/3656424
Lavazza, Luigi, Angela Locoro, and Roberto Meli. 2024. “Software Development and Maintenance Effort Estimation Using Function Points and Simpler Functional Measures.” Software 3 (4): 442–72. https://doi.org/10.3390/software3040022
Lavazza, Luigi, Sandro Morasca, and Davide Tosi. 2021. “Comparing Static Analysis and Code Smells as Defect Predictors: An Empirical Study.” In Open Source Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-75251-4_1
Laviron, Vincent, and Francesco Logozzo. 2009. “Refining Abstract Interpretation-Based Static Analyses with Hints.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-10672-9_24
Lavoie, Erick, Bruno Dufour, and Marc Feeley. 2014. “Portable and Efficient Run-Time Monitoring of JavaScript Applications Using Virtual Machine Layering.” In ECOOP 2014 – Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-44202-9_22
Lawson, Aidan. 2026. “Garbage Collection.” Nature. https://doi.org/10.1038/d41586-026-01720-4
Lazo, Joaquín, Vicente Barrios, and David Watts. 2026. “Dynamic Dispatch Optimization of Green Hydrogen Electrolyzers under Price Volatility: A Real Options Approach.” Renewable and Sustainable Energy Reviews 226: 116445. https://doi.org/10.1016/j.rser.2025.116445
Le, Hoang M. 2019. “KLUZZER: Whitebox Fuzzing on Top of LLVM.” In Automated Technology for Verification and Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-31784-3_14
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.” In Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications. ACM. https://doi.org/10.1145/2814270.2814319
Le Charlier, Baudouin, and Pierre Flener. 1997. “On the Desirable Link between Theory and Practice in Abstract Interpretation (Extended Abstract).” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032758
Le Fessant, Fabrice, Ian Piumarta, and Marc Shapiro. 1998. “An Implementation of Complete, Asynchronous, Distributed Garbage Collection.” In Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/277650.277715
Le-Do, Tuan Khanh, Kyung-A. Yoon, Yeong-Seok Seo, and Doo-Hwan Bae. 2010. “Filtering of Inconsistent Software Project Data for Analogy-Based Effort Estimation.” In 2010 IEEE 34th Annual Computer Software and Applications Conference. IEEE. https://doi.org/10.1109/compsac.2010.56
League, Christopher, Zhong Shao, and Valery Trifonov. 1999. “Representing Java Classes in a Typed Intermediate Language.” ACM SIGPLAN Notices 34 (9): 183–96. https://doi.org/10.1145/317765.317798
Leão, Gabriel, Edward Moreno, and Methanias Colaço Júnior. 2026. “Android Malware Detection through Static Analysis Using Machine Learning.” In Proceedings of the 28th International Conference on Enterprise Information Systems. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0014800200004018
Leather, Hugh, Edwin Bonilla, and Michael O’Boyle. 2009. “Automatic Feature Generation for Machine Learning Based Optimizing Compilation.” In 2009 International Symposium on Code Generation and Optimization. IEEE. https://doi.org/10.1109/cgo.2009.21
Leather, Hugh, Edwin Bonilla, and Michael O’boyle. 2014. “Automatic Feature Generation for Machine Learning–Based Optimising Compilation.” ACM Transactions on Architecture and Code Optimization 11 (1): 1–32. https://doi.org/10.1145/2536688
LeCompte, Travis, Fang Qi, and Lu Peng. 2020. “Robust Cache-Aware Quantum Processor Layout.” In 2020 International Symposium on Reliable Distributed Systems (SRDS). IEEE. https://doi.org/10.1109/srds51746.2020.00035
Lee, John. 2012. “A Corpus-Based Analysis of Mixed Code in Hong Kong Speech.” In 2012 International Conference on Asian Language Processing. IEEE. https://doi.org/10.1109/ialp.2012.10
Lee, Young, Syeda Jannatul Boshra, Jeong Yang, Zechun Cao, and Gongbo Liang. 2025. “Machine Learning-Based Vulnerability Detection in Rust Code Using LLVM IR and Transformer Model.” Machine Learning and Knowledge Extraction 7 (3): 79. https://doi.org/10.3390/make7030079
Lee, I., P. Bremond-Gregoire, and R. Gerber. 1994. “A Process Algebraic Approach to the Specification and Analysis of Resource-Bound Real-Time Systems.” Proceedings of the IEEE 82 (1): 158–71. https://doi.org/10.1109/5.259433
Lee, Woo Hyong, and J. Morris Chang. 2004. “A Garbage Collection Policy Based on Empirical Behavior.” Information Sciences 167 (1–4): 129–46. https://doi.org/10.1016/j.ins.2003.05.014
Lee, Cheng-Yu, Jen-Chieh Chang, and Rong-Guey Chang. 2012b. “Compiler Optimization to Reduce Cache Power with Victim Cache.” In 2012 9th International Conference on Ubiquitous Intelligence and Computing and 9th International Conference on Autonomic and Trusted Computing. IEEE. https://doi.org/10.1109/uic-atc.2012.36
Lee, Hyeyun, Wooseok Choi, and Youpyo Hong. 2023c. “On-Demand Garbage Collection Algorithm with Prioritized Victim Blocks for SSDs.” Electronics 12 (9): 2142. https://doi.org/10.3390/electronics12092142
Lee, Young, Ernesto Diaz, Jeong Yang, and Bozhen Liu. 2026. “Enhancing Concurrency Bug Detection in Rust Programs through LLVM IR Based Graph Visualization.” High-Confidence Computing 6 (3): 100377. https://doi.org/10.1016/j.hcc.2025.100377
Lee, Wen-Tin, Kuo-Hsun Hsu, Jonathan Lee, and Jong Yih Kuo. 2012a. “Applying Software Effort Estimation Model Based on Work Breakdown Structure.” In 2012 Sixth International Conference on Genetic and Evolutionary Computing. IEEE. https://doi.org/10.1109/icgec.2012.68
Lee, Cheng-En, and Shi-Yu Huang. 2018. “A Cell-Based Fractional-N Phase-Locked Loop Compiler.” In 2018 15th International Conference on Synthesis, Modeling, Analysis and Simulation Methods and Applications to Circuit Design (SMACD). IEEE. https://doi.org/10.1109/smacd.2018.8434856
Lee, YangSun, Junho Jeong, and Yunsik Son. 2017a. “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, Dongjun, Youngbin Jin, Han Jang, and Ben Lee. 2022. “CATDOG: Cost-Age-Time Data Organized Garbage Collection.” In 2022 IEEE International Conference on Networking, Architecture and Storage (NAS). IEEE. https://doi.org/10.1109/nas55553.2022.9925402
Lee, Hakun, and Keiichi Kaneko. 2008. “New Approaches for Software Watermarking by Register Allocation.” In 2008 Ninth ACIS International Conference on Software Engineering, Artificial Intelligence, Networking, and Parallel/Distributed Computing. IEEE. https://doi.org/10.1109/snpd.2008.137
Lee, Hakun, and Keiichi Kaneko. 2009. “Two New Algorithms for Software Watermarking by Register Allocation and Their Empirical Evaluation.” In 2009 Sixth International Conference on Information Technology: New Generations. IEEE. https://doi.org/10.1109/itng.2009.15
Lee, Hae Young, and Hyung-Jong Kim. 2014. “Cost Estimation of Simulation Models for the Effectiveness Estimation of Simulation-Based Acquisition.” In 2014 7th International Conference on Advanced Software Engineering and Its Applications. IEEE. https://doi.org/10.1109/asea.2014.9
Lee, Edward, Daehyun Kim, Venkata Chaitanya Krishna Chekuri, Yun Long, and Saibal Mukhopadhyay. 2019. “A ReRAM Memory Compiler with Layout-Precise Performance Evaluation.” In 2019 IEEE SOI-3D-Subthreshold Microelectronics Technology Unified Conference (S3S). IEEE. https://doi.org/10.1109/s3s46989.2019.9320750
Lee, Juneyoung, Yoonseung Kim, Youngju Song, et al. 2017b. “Taming Undefined Behavior in LLVM.” ACM SIGPLAN Notices 52 (6): 633–47. https://doi.org/10.1145/3140587.3062343
Lee, Sheayun, Jaejin Lee, Sang Lyul Min, Jason Hiser, and Jack W. Davidson. 2003. “Code Generation for a Dual Instruction Set Processor Based on Selective Code Transformation.” In Software and Compilers for Embedded Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39920-9_4
Lee, Woosuk, Wonchan Lee, and Kwangkeun Yi. 2012c. “Sound Non-Statistical Clustering of Static Analysis Alarms.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-27940-9_20
Lee, Young, Arlen McDonald, and Jeong Yang. 2023b. “Identifying Code Tampering Using a Bytecode Comparison Analysis Tool.” In 2023 IEEE/ACIS 21st International Conference on Software Engineering Research, Management and Applications (SERA). IEEE. https://doi.org/10.1109/sera57763.2023.10197775
Lee, Sheayun, Sang Lyul Min, Chong Sang Kim, Chang-Gun Lee, and Minsuk Lee. 1999. “Cache-Conscious Limited Preemptive Scheduling.” Real-Time Systems 17 (2–3): 257–82. https://doi.org/10.1023/a:1008194508956
Lee, J.-Y., and I.-C. Park. 2003. “Address Code Generation for DSP Instruction-Set Architectures.” ACM Transactions on Design Automation of Electronic Systems 8 (3): 384–95. https://doi.org/10.1145/785411.785417
Lee, Wonyeol, and Sungwoo Park. 2014. “A Proof System for Separation Logic with Magic Wand.” In Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM. https://doi.org/10.1145/2535838.2535871
Lee, Sean Jonathon, and Mali Senapathi. 2025. “Agile Effort Estimation Usage in the Sri Lankan Software Industry.” In Agile Processes in Software Engineering and Extreme Programming. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-94544-1_14
Lee, Jongeun, and Aviral Shrivastava. 2009. “Compiler-Managed Register File Protection for Energy-Efficient Soft Error Reduction.” In 2009 Asia and South Pacific Design Automation Conference. IEEE. https://doi.org/10.1109/aspdac.2009.4796549
Lee, Seyong, and Jeffrey S. Vetter. 2014. “OpenARC: Extensible OpenACC Compiler Framework for Directive-Based Accelerator Programming Study.” In 2014 First Workshop on Accelerator Programming using Directives. IEEE. https://doi.org/10.1109/waccpd.2014.7
Lee, SeungIl, Byung-Sun Yang, and Soo-Mook Moon. 2004. “Efficient Java Exception Handling in Just-in-Time Compilation.” Software: Practice and Experience 34 (15): 1463–80. https://doi.org/10.1002/spe.622
Lefley, Martin, and Martin J. Shepperd. 2003. “Using Genetic Programming to Improve Software Effort Estimation Based on General Data Sets.” In Genetic and Evolutionary Computation — GECCO 2003. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45110-2_151
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
Lehner, Hermann, and Peter Müller. 2007. “Formal Translation of Bytecode into BoogiePL.” Electronic Notes in Theoretical Computer Science 190 (1): 35–50. https://doi.org/10.1016/j.entcs.2007.02.059
Lehr, Jan-Patrick, Alexander Hück, Yannic Fischler, and Christian Bischof. 2020. “MetaCG: Annotated Call-Graphs to Facilitate Whole-Program Analysis.” In Proceedings of the 11th ACM SIGPLAN International Workshop on Tools for Automatic Program Analysis. ACM. https://doi.org/10.1145/3427764.3428320
Lei Wang and Gui Chen. 2010. “Architecture-Dependent Register Allocation and Instruction Scheduling on VLIW.” In 2010 2nd International Conference on Computer Engineering and Technology. IEEE. https://doi.org/10.1109/iccet.2010.5485441
Leidel, John, Ryan Kabrick, and David Donofrio. 2021. “Toward an Automated Hardware Pipelining LLVM Pass Infrastructure.” In 2021 IEEE/ACM 7th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvmhpc54804.2021.00010
Leinenbach, D., W. Paul, and E. Petrova. 2005. “Towards the Formal Verification of a C0 Compiler: Code Generation and Implementation Correctness.” In Third IEEE International Conference on Software Engineering and Formal Methods (SEFM’05). IEEE. https://doi.org/10.1109/sefm.2005.51
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
Leisa, Roland, Marcel Koster, and Sebastian Hack. 2015. “A Graph-Based Higher-Order Intermediate Representation.” In 2015 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2015.7054200
Lemerre, Matthieu. 2023. “Reverse Template Processing Using Abstract Interpretation.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-44245-2_18
Lenarduzzi, Valentina, Ilaria Lunesu, Martina Matta, and Davide Taibi. 2015. “Functional Size Measures and Effort Estimation in Agile Development: A Replicated Study.” In Agile Processes in Software Engineering and Extreme Programming. Springer International Publishing. https://doi.org/10.1007/978-3-319-18612-2_9
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. 2018. “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
Lerner, Barbara Staudt. 2000. “A Model for Compound Type Changes Encountered in Schema Evolution.” ACM Transactions on Database Systems 25 (1): 83–127. https://doi.org/10.1145/352958.352983
Lerner, Barbara Staudt, and A. Nico Habermann. 1990. “Beyond Schema Evolution to Database Reorganization.” ACM SIGPLAN Notices 25 (10): 67–76. https://doi.org/10.1145/97946.97956
Lerner, Sorin, Todd Millstein, and Craig Chambers. 2003. “Automatically Proving the Correctness of Compiler Optimizations.” ACM SIGPLAN Notices 38 (5): 220–31. https://doi.org/10.1145/780822.781156
Leroy, Xavier. 1992. “Unboxed Objects and Polymorphic Typing.” In Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘92. ACM Press. https://doi.org/10.1145/143165.143205
Leroy, Xavier. 2001a. “Java Bytecode Verification: An Overview.” In Computer Aided Verification. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44585-4_26
Leroy, Xavier. 2001b. “On-Card Bytecode Verification for Java Card.” In Smart Card Programming and Security. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45418-7_13
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. 2007. “Formal Verification of an Optimizing Compiler.” In 2007 5th IEEE/ACM International Conference on Formal Methods and Models for Codesign (MEMOCODE 2007). IEEE. https://doi.org/10.1109/memcod.2007.371254
Leroy, Xavier. 2014. “Compiler Verification for Fun and Profit.” In 2014 Formal Methods in Computer-Aided Design (FMCAD). IEEE. https://doi.org/10.1109/fmcad.2014.6987587
Lester, David R. 1989. “An Efficient Distributed Garbage Collection Algorithm.” In PARLE ‘89 Parallel Architectures and Languages Europe. Springer Berlin Heidelberg. https://doi.org/10.1007/3540512845_41
Lester, David, and Sava Mintchev. 1995. “Towards Machine-Checked Compiler Correctness for Higher-Order Pure Functional Languages.” In Computer Science Logic. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0022269
Leuchs, G., and H. Walther. 1979. “Quantum Interference Effects in Field Ionization: Application to the Measurement of the Fine Structure Splitting of Highly Excited Na2 D States.” Zeitschrift für Physik A Atoms and Nuclei 293 (2): 93–101. https://doi.org/10.1007/bf01559750
Leupers, R. 2002. “Compiler Design Issues for Embedded Processors.” IEEE Design & Test of Computers 19 (4): 51–58. https://doi.org/10.1109/mdt.2002.1018133
Leupers, Rainer, and Jeronimo Castrillon. 2010. “MPSoC Programming Using the MAPS Compiler.” In 2010 15th Asia and South Pacific Design Automation Conference (ASP-DAC). IEEE. https://doi.org/10.1109/aspdac.2010.5419677
Lévai, Zalán, Donghwan Shin, and Phil McMinn. 2026. “Mutest-Rs: Flexible, Efficient Mutation Analysis Tool for Rust Programs, Using Extensive Static Analysis.” In 2026 IEEE International Conference on Software Testing, Verification and Validation (ICST). IEEE. https://doi.org/10.1109/icst69053.2026.00038
Leverett, Cattell, Hobbs, et al. 1980. “An Overview of the Production-Quality Compiler-Compiler Project.” Computer 13 (8): 38–49. https://doi.org/10.1109/mc.1980.1653748
Levi, Francesca, and Sergio Maffeis. 2001. “An Abstract Interpretation Framework for Analysing Mobile Ambients.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-47764-0_23
Levy, Michael R. 1984. “Type Checking, Separate Compilation and Reusability.” ACM SIGPLAN Notices 19 (6): 285–89. https://doi.org/10.1145/502949.502902
Lewis, Michael. 1992. “Many Minds Make Madness: Judgment under Uncertainty and Certainty.” Psychological Inquiry 3 (2): 170–72. https://doi.org/10.1207/s15327965pli0302_19
Lewis, Brian, Bernd Mathiske, and Neal Gafter. 2001. “Architecture of the PEVM: A High-Performance Orthogonally Persistent Java™ Virtual Machine.” In Persistent Object Systems: Design, Implementation, and Use. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45498-5_3
Lhoták, Jennifer, Ondřej Lhoták, and Laurie Hendren. 2004. “Integrating the Soot Compiler Infrastructure into an IDE.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24723-4_19
Li, Tingting. 2022. “Planting Structure Adjustment and Layout Optimization of Feed Grain and Food Grain in China Based on Productive Potentials.” Land 12 (1): 45. https://doi.org/10.3390/land12010045
Li, Jingkai. 2025a. “Can “Consciousness” Be Observed from Large Language Model (LLM) Internal States? Dissecting LLM Representations Obtained from Theory of Mind Test with Integrated Information Theory and Span Representation Analysis.” Natural Language Processing Journal 12: 100163. https://doi.org/10.1016/j.nlp.2025.100163
Li, Hongrui. 2025b. “Compiler Provenance Identification via Machine Learning: A Framework Based on Reverse Engineering and Density-Based Clustering.” In 2025 IEEE 5th International Conference on Data Science and Computer Application (ICDSCA). IEEE. https://doi.org/10.1109/icdsca67083.2025.11350139
Li, Jingzhou, Ahmed Al-Emran, and Guenther Ruhe. 2007. “Impact Analysis of Missing Values on the Prediction Accuracy of Analogy-Based Software Effort Estimation Method AQUA.” In First International Symposium on Empirical Software Engineering and Measurement (ESEM 2007). IEEE. https://doi.org/10.1109/esem.2007.10
Li, F., G. Chen, M. Kandemir, and R. Brooks. 2005. “A Compiler-Based Approach to Data Security.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-31985-6_13
Li, Yandong, Yu Cheng, Zhe Gan, Licheng Yu, Liqiang Wang, and Jingjing Liu. 2020b. “BachGAN: High-Resolution Image Synthesis from Salient Object Layout.” In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE. https://doi.org/10.1109/cvpr42600.2020.00839
Li, Yanchuan, and Gordon Fraser. 2011. “Bytecode Testability Transformation.” In Search Based Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-23716-4_21
Li, Zixi, Tianle Gao, Guojing Huang, and Gaoqi Rao. 2022c. “Modern Chinese Diachronic Corpus Construction and the Language Development Based on a 77-Year Corpus.” In 2022 International Conference on Asian Language Processing (IALP). IEEE. https://doi.org/10.1109/ialp57159.2022.9961262
Li, Qingan, Yanxiang He, Jianhua Li, Liang Shi, Yiran Chen, and Chun Jason Xue. 2015. “Compiler-Assisted Refresh Minimization for Volatile STT-RAM Cache.” IEEE Transactions on Computers 64 (8): 2169–81. https://doi.org/10.1109/tc.2014.2360527
Li, Shuai, and Xiaojun Huang. 2017. “Dubbo’s Serialization Protocol Extension and Optimization of Its RPC Protocol Thrift.” In 2017 8th IEEE International Conference on Software Engineering and Service Science (ICSESS). IEEE. https://doi.org/10.1109/icsess.2017.8343015
Li, Chenyang, and Jiye Jiao. 2023. “LLVM Framework: Research and Applications.” In 2023 19th International Conference on Natural Computation, Fuzzy Systems and Knowledge Discovery (ICNC-FSKD). IEEE. https://doi.org/10.1109/icnc-fskd59587.2023.10281186
Li, Xuyang, Hongjin Liang, and Xinyu Feng. 2024e. “Verified Validation for Affine Scheduling in Polyhedral Compilation.” In Theoretical Aspects of Software Engineering. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-64626-3_17
Li, Jun, and Quan Liu. 2010. “Design of a Software Watermarking Algorithm Based on Register Allocation.” In 2010 2nd International Conference on E-business and Information System Security. IEEE. https://doi.org/10.1109/ebiss.2010.5473660
Li, Weixia, and Zhuohua Liu. 2023. “Stack Data Protection Mechanism for LLVM Intermediate Representation.” In 2023 5th International Conference on Communications, Information System and Computer Engineering (CISCE). IEEE. https://doi.org/10.1109/cisce58541.2023.10142426
Li, Zhe, and Xinxi Lu. 2025. “Research on Compressed Input Sequences Based on Compiler Tokenization.” Information 16 (2): 73. https://doi.org/10.3390/info16020073
Li, Pengcheng, Hao Luo, Chen Ding, Ziang Hu, and Handong Ye. 2014. “Code Layout Optimization for Defensiveness and Politeness in Shared Cache.” In 2014 43rd International Conference on Parallel Processing. IEEE. https://doi.org/10.1109/icpp.2014.24
Li, Jiqi, Jingyi Mei, Wang Fang, and Ji Guan. 2026b. “Formal Verification of Quantum Ancilla Safety.” In Computer Aided Verification. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-32537-2_16
Li, Nan, Xin Meng, Jeff Offutt, and Lin Deng. 2013b. “Is Bytecode Instrumentation as Good as Source Code Instrumentation: An Empirical Study with Industrial Tools (Experience Report).” In 2013 IEEE 24th International Symposium on Software Reliability Engineering (ISSRE). IEEE. https://doi.org/10.1109/issre.2013.6698891
Li, Zheng, Liam O’Brien, and He Zhang. 2011. “Circumstantial-Evidence-Based Judgment for Software Effort Estimation.” In Proceeding of the 1st International Workshop on Evidential Assessment of Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0003560600180027
Li, Jingzhou, and Guenther Ruhe. 2007a. “Analysis of Attribute Weighting Heuristics for Analogy-Based Software Effort Estimation Method AQUA+.” Empirical Software Engineering 13 (1): 63–96. https://doi.org/10.1007/s10664-007-9054-4
Li, Jingzhou, and Guenther Ruhe. 2007b. “Decision Support Analysis for Software Effort Estimation by Analogy.” In Third International Workshop on Predictor Models in Software Engineering (PROMISE’07: ICSE Workshops 2007). IEEE. https://doi.org/10.1109/promise.2007.5
Li, Jingzhou, Guenther Ruhe, Ahmed Al-Emran, and Michael M. Richter. 2006. “A Flexible Method for Software Effort Estimation by Analogy.” Empirical Software Engineering 12 (1): 65–106. https://doi.org/10.1007/s10664-006-7552-4
Li, Xiuhe, Yang Shen, Zhongwei Lin, Shunkai Zhao, Qianqian Shi, and Shaoqi Dai. 2023c. “Towards Order-Preserving and Zero-Copy Communication on Shared Memory for Large Scale Simulation.” Chinese Journal of Electronics 32 (5): 1066–76. https://doi.org/10.23919/cje.2021.00.393
Li, Donghua, Hui Sun, and Xiao Qin. 2026c. “iGC: Reinforcement Learning-Guided Intelligent Garbage Collection Strategy for Multi-Tenant SSDs.” Knowledge-Based Systems 335: 115013. https://doi.org/10.1016/j.knosys.2025.115013
Li, Liyi, Finn Voichick, Kesha Hietala, Yuxiang Peng, Xiaodi Wu, and Michael Hicks. 2022e. “Verified Compilation of Quantum Oracles.” Proceedings of the ACM on Programming Languages 6 (OOPSLA2): 589–615. https://doi.org/10.1145/3563309
Li, Xin, Lu Wang, Yang Xin, Yixian Yang, and Yuling Chen. 2020a. “Automated Vulnerability Detection in Source Code Using Minimum Intermediate Representation Learning.” Applied Sciences 10 (5): 1692. https://doi.org/10.3390/app10051692
Li, Yuanhao, Tianyuan Wu, Guancheng Li, Yanjie Song, and Shu Yin. 2024d. “Portus: Efficient DNN Checkpointing to Persistent Memory with Zero-Copy.” In 2024 IEEE 44th International Conference on Distributed Computing Systems (ICDCS). IEEE. https://doi.org/10.1109/icdcs60910.2024.00015
Li, Y. F., M. Xie, and T. N. Goh. 2008a. “Bayesian Inference Approach for Probabilistic Analogy Based Software Maintenance Effort Estimation.” In 2008 14th IEEE Pacific Rim International Symposium on Dependable Computing. IEEE. https://doi.org/10.1109/prdc.2008.21
Li, Y. F., M. Xie, and T. N. Goh. 2008b. “Optimization of Feature Weights and Number of Neighbors for Analogy Based Cost Estimation in Software Project Management.” In 2008 IEEE International Conference on Industrial Engineering and Engineering Management. IEEE. https://doi.org/10.1109/ieem.2008.4738130
Li, Y. F., M. Xie, and T. N. Goh. 2008c. “A Study of Analogy Based Sampling for Interval Based Cost Estimation for Software Project Management.” In 2008 4th IEEE International Conference on Management of Innovation and Technology. IEEE. https://doi.org/10.1109/icmit.2008.4654377
Li, Xue, Jiong Yu, Junlong Cheng, Ziyang Li, and Chen Bian. 2025. “Semantic Preservation-Based Hash Code Generation for Fine-Grained Image Retrieval.” Expert Systems with Applications 271: 126668. https://doi.org/10.1016/j.eswa.2025.126668
Li, Chunlin, Yong Zhang, and Youlong Luo. 2022b. “Intermediate Data Placement and Cache Replacement Strategy under Spark Platform.” Journal of Parallel and Distributed Computing 163: 114–35. https://doi.org/10.1016/j.jpdc.2022.01.020
Li, Jing, Han Zhang, Shengxiang Sun, et al. 2026d. “SHAP-Value-Weighted Case-Based Reasoning Model with Improved Mixup Data Augmentation for Software Effort Estimation.” Information 17 (5): 431. https://doi.org/10.3390/info17050431
Li, Yuzhang, Xi Zhang, Tao Xu, and Chunlu Wang. 2026a. “DecIR: Enhancing LLM-Based LLVM IR Decompilation through Program Analysis.” Science of Computer Programming 254: 103512. https://doi.org/10.1016/j.scico.2026.103512
Li, Jiangnan, Zhengyi Zhang, Xuegong Zhou, and Lingli Wang. 2024c. “An MLIR-Based Compiler for Hardware Acceleration with Recursion Support: (PhD Forum Paper).” In 2024 International Conference on Field Programmable Technology (ICFPT). IEEE. https://doi.org/10.1109/icfpt64416.2024.11113451
Li, Hui-qi, and Zhi-zhuo Zhao. 2010. “The Implementation of Polymorphic Many-Dorted Type System for Logic Programming Language Gödel.” In 2010 Second WRI Global Congress on Intelligent Systems. IEEE. https://doi.org/10.1109/gcis.2010.131
Li, Qingan, Mengying Zhao, Chun Jason Xue, and Yanxiang He. 2012. “Compiler-Assisted Preferred Caching for Embedded Systems with STT-RAM Based Hybrid Cache.” ACM SIGPLAN Notices 47 (5): 109–18. https://doi.org/10.1145/2345141.2248434
Li Huiqi and Zhao Zhizhuo. 2008. “A Polymorphic Type System in Logic Programming.” In 2008 3rd International Conference on Intelligent System and Knowledge Engineering. IEEE. https://doi.org/10.1109/iske.2008.4730911
Lian, Qihao, and Di Wang. 2025. “Automatic Linear Resource Bound Analysis for Rust via Prophecy Potentials.” Proceedings of the ACM on Programming Languages 9 (OOPSLA1): 1406–33. https://doi.org/10.1145/3720492
Liang, Sheng, and Gilad Bracha. 1998. “Dynamic Class Loading in the Java Virtual Machine.” ACM SIGPLAN Notices 33 (10): 36–44. https://doi.org/10.1145/286942.286945
Liang, Tyng-Yeu, and Yu-Jie Lin. 2016. “Heterogeneous Computation Migration on LLVM.” In Green, Pervasive, and Cloud Computing. Springer International Publishing. https://doi.org/10.1007/978-3-319-39077-2_10
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
Liang, Hongliang, Lei Wang, Dongyang Wu, and Jiuyun Xu. 2016. “MLSA: A Static Bugs Analysis Tool Based on LLVM IR.” International Journal of Networked and Distributed Computing 4 (3): 137. https://doi.org/10.2991/ijndc.2016.4.3.1
Liao, Minli, and Jack Sampson. 2020. “Emerging Memories as Enablers for in-Memory Layout Transformation Acceleration and Virtualization.” In 2020 25th Asia and South Pacific Design Automation Conference (ASP-DAC). IEEE. https://doi.org/10.1109/asp-dac47756.2020.9045410
Lichter, Paul R. 1989. “Biomedical Research, Conflict of Interest, and the Public Trust.” Ophthalmology 96 (5): 575–78. https://doi.org/10.1016/s0161-6420(89)32847-8
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
Liem, Clifford, Yuan Xiang Gu, and Harold Johnson. 2008. “A Compiler-Based Infrastructure for Software-Protection.” In Proceedings of the third ACM SIGPLAN workshop on Programming languages and analysis for security. ACM. https://doi.org/10.1145/1375696.1375702
Lim, Hock-Beng, Lynn Choi, and Pen-Chung Yew. 1997. “Compiler Support for Maintaining Cache Coherence Using Data Prefetching (Extended Abstract).” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0017278
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
Lim, Ser-Nam, Gianfranco Doretto, and Jens Rittscher. 2011. “Multi-Class Object Layout with Unsupervised Image Classification and Object Localization.” In Advances in Visual Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-24028-7_53
Lim, Hock-Beng, and Pen-Chung Yew. 1998. “Maintaining Cache Coherence through Compiler-Directed Data Prefetching.” Journal of Parallel and Distributed Computing 53 (2): 144–73. https://doi.org/10.1006/jpdc.1998.1480
Lim, Hock-Beng, and Pen-Chung Yew. 1999. “An Integrated Framework for Compiler-Directed Cache Coherence and Data Prefetching.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48319-5_4
Lim, Hock-Beng, and Pen-Chung Yew. 2001. “Efficient Integration of Compiler-Directed Cache Coherence and Data Prefetching.” Journal of Parallel and Distributed Computing 61 (12): 1775–1802. https://doi.org/10.1006/jpdc.2001.1784
Limna, Thanathip, and Pichaya Tandayya. 2015. “Video Surveillance as a Service Cost Estimation and Pricing Model.” In 2015 12th International Joint Conference on Computer Science and Software Engineering (JCSSE). IEEE. https://doi.org/10.1109/jcsse.2015.7219791
Lin, Zhengyao, Yi Cai, and Milijana Surbatovich. 2026. “Let It Flow: A Formally Verified Compilation Framework for Asynchronous Dataflow.” Proceedings of the ACM on Programming Languages 10 (PLDI): 405–29. https://doi.org/10.1145/3808263
Lin, Zhongyi, Evangelos Georganas, and John D. Owens. 2021. “Towards Flexible and Compiler-Friendly Layer Fusion for CNNs on Multicore CPUs.” In Euro-Par 2021: Parallel Processing. Springer International Publishing. https://doi.org/10.1007/978-3-030-85665-6_15
Lin, Jin, Wei-Chung Hsu, Pen-Chung Yew, Roy Dz-Ching Ju, and Tin-Fook Ngai. 2006. “Recovery Code Generation for General Speculative Optimizations.” ACM Transactions on Architecture and Code Optimization 3 (1): 67–89. https://doi.org/10.1145/1132462.1132466
Lin, Zhongwei, Xiuhe Li, Yi Mao, Yang Shen, Bei An, and Kui Ma. 2019. “DISHM: A Zero-Copy Intra-Node Communication Approach in Large Scale Simulation.” In 2019 IEEE 19th International Conference on Communication Technology (ICCT). IEEE. https://doi.org/10.1109/icct46805.2019.8947207
Lin, Mian, YouCong Ni, Yu Lin, and Xin Du. 2025c. “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. 2000a. “Analysis of Irregular Single-Indexed Array Accesses and Its Applications in Compiler Optimizations.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-46423-9_14
Lin, Yuan, and David Padua. 2000b. “Compiler Analysis of Irregular Memory Accesses.” ACM SIGPLAN Notices 35 (5): 157–68. https://doi.org/10.1145/358438.349322
Lin, Y., and S. H. Son. 1990. “Concurrency Control in Real-Time Databases by Dynamic Adjustment of Serialization Order.” In [1990] Proceedings 11th Real-Time Systems Symposium. IEEE. https://doi.org/10.1109/real.1990.128735
Lin, Zhigui, Xiaofeng Zhang, Qi Liu, and Jun Cui. 2025b. “Design of a Heterogeneous-Based Network Intrusion Detection System and Compiler.” Applied Sciences 15 (9): 5012. https://doi.org/10.3390/app15095012
Lindahl, Tobias, and Konstantinos Sagonas. 2003. “Unboxed Compilation of Floating Point Arithmetic in a Dynamically Typed Language Environment.” In Implementation of Functional Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44854-3_9
Lindgren, Thomas. 2005. “Atom Garbage Collection.” In Proceedings of the 2005 ACM SIGPLAN workshop on Erlang. ACM. https://doi.org/10.1145/1088361.1088369
Lindgren, Per, Pawel Dzialo, Antti Nurmi, and Henri Lunnikivi. 2023. “Static and Dynamic Memory Protection Using Type-Based Memory Layout in Rust.” In 2023 IEEE 2nd Industrial Electronics Society Annual On-Line Conference (ONCON). IEEE. https://doi.org/10.1109/oncon60463.2023.10431237
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
Lintzmayer, Carla Negri, Mauro Henrique Mulati, and Anderson Faustino da Silva. 2012. “Register Allocation by Evolutionary Algorithm.” In 2012 31st International Conference of the Chilean Computer Science Society. IEEE. https://doi.org/10.1109/sccc.2012.31
Liny, Hai, Xuan Guany, Yunsi Feiy, and Zhijie Jerry Shi. 2007. “Compiler-Assisted Architectural Support for Program Code Integrity Monitoring in Application-Specific Instruction Set Processors.” In 2007 25th International Conference on Computer Design. IEEE. https://doi.org/10.1109/iccd.2007.4601899
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, A. X. 2008. “Formal Verification of Firewall Policies.” In 2008 IEEE International Conference on Communications. IEEE. https://doi.org/10.1109/icc.2008.289
Liu, Shaoying. 2016. “Testing-Based Formal Verification for Algorithmic Function Theorems and Its Application to Software Verification and Validation.” In 2016 International Symposium on System and Software Reliability (ISSSR). IEEE. https://doi.org/10.1109/isssr.2016.010
Liu, Ji, Luciano Bello, and Huiyang Zhou. 2021c. “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, Yuxing, Jianying Chen, Jiamin Tang, Xiaoyi Tong, Liping Cai, and Hengyuan Liu. 2024a. “An Empirical Study of Fault Localization on Novice Programs.” In 2024 IEEE 48th Annual Computers, Software, and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac61105.2024.00381
Liu, Jun, Wei Ding, Ohyoung Jang, and Mahmut Kandemir. 2013a. “Data Layout Optimization for GPGPU Architectures.” ACM SIGPLAN Notices 48 (8): 283–84. https://doi.org/10.1145/2517327.2442546
Liu, Mingxuan, and Jianhua Gu. 2022. “uCleaner: An Efficient Adaptive Garbage Collection Mechanism for KV-Separated LSM-Stores.” In 2022 5th International Conference on Data Science and Information Technology (DSIT). IEEE. https://doi.org/10.1109/dsit55514.2022.9943889
Liu, Huimin, Canhui Jiang, Yan Liu, Marcel Hertogh, and Xue Lyu. 2018b. “Optimism Bias Evaluation and Decision-Making Risk Forecast on Bridge Project Cost Based on Reference Class Forecasting: Evidence from China.” Sustainability 10 (11): 3981. https://doi.org/10.3390/su10113981
Liu, Samuel, Jen-Ho Kuo, Luba Tang, et al. 2021b. “ONNC Compiler Used in Fault-Mitigating Mechanisms Analysis on NVDLA-Based and ReRAM-Based Edge AI Chip Design.” In 2021 International Symposium on VLSI Design, Automation and Test (VLSI-DAT). IEEE. https://doi.org/10.1109/vlsi-dat52063.2021.9427328
Liu, Xiangyu, Huiba Li, Shun Gai, Youmin Chen, and Yiming Zhang. 2026c. “zBuffer: Zero-Copy and Metadata-Free Serialization for Fast RPC with Scatter-Gather Reflection.” In Proceedings of the 31st ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming. ACM. https://doi.org/10.1145/3774934.3786426
Liu, Songyan, Zhigang Mao, and Yizheng Ye. 2000. “Implementation of Java Card Virtual Machine.” Journal of Computer Science and Technology 15 (6): 591–96. https://doi.org/10.1007/bf02948841
Liu, Yuxuan, Yadong Shi, Zhongyuan Qin, and Yubo Song. 2024b. “EtherEditor: Bytecode Defense Framework for Unleashing Proactive Smart Contract Security.” In 2024 IEEE International Conference on High Performance Computing and Communications (HPCC). IEEE. https://doi.org/10.1109/hpcc64274.2024.00174
Liu, Shu-Ming, Luba Tang, Ning-Chi Huang, Der-Yu Tsai, Ming-Xue Yang, and Kai-Chiang Wu. 2020. “Fault-Tolerance Mechanism Analysis on NVDLA-Based Design Using Open Neural Network Compiler and Quantization Calibrator.” In 2020 International Symposium on VLSI Design, Automation and Test (VLSI-DAT). IEEE. https://doi.org/10.1109/vlsi-dat49148.2020.9196335
Liu, Yi, Guanyu Wang, Xinyi Zheng, et al. 2026a. “SPOLRE: Semantic Preserving Object Layout Reconstruction for Image Captioning System Testing.” ACM Transactions on Software Engineering and Methodology 35 (5): 1–25. https://doi.org/10.1145/3748306
Liu, Liusheng, and Aihua Wen. 2013. “A Study on the Changes of Yunnan Higher Education Spatial Layout Structure Based on GIS.” In 2013 21st International Conference on Geoinformatics. IEEE. https://doi.org/10.1109/geoinformatics.2013.6626180
Liu, Qin, Jiakai Xiao, and Hongming Zhu. 2017b. “Threshold Based Neighborhood Selection for Case-Based Reasoning in Software Effort Estimation.” In 2017 International Conference on Computer Systems, Electronics and Control (ICCSEC). IEEE. https://doi.org/10.1109/iccsec.2017.8446890
Liu, Qin, Jiakai Xiao, and Hongming Zhu. 2018a. “Feature Selection for Software Effort Estimation with Localized Neighborhood Mutual Information.” Cluster Computing 22 (S3): 6953–61. https://doi.org/10.1007/s10586-018-1884-x
Liu, Xuying, Wenjian Yin, Qing Yin, and Liehui Jiang. 2010. “A SSA-Based Intermediate Representation Technique.” In 2010 International Conference on Computer, Mechatronics, Control and Electronic Engineering. IEEE. https://doi.org/10.1109/cmce.2010.5609916
Liu, Dengfeng, Jucai Zhai, Weixuan Sun, Xiaoguang Jiang, and Ziqun Li. 2026b. “Structure-Aware Corpus Construction and User-Perception-Aligned Metrics for Large-Language-Model Code Completion.” In ICASSP 2026 - 2026 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE. https://doi.org/10.1109/icassp55912.2026.11464386
Liu, Jun, Yuanrui Zhang, Ohyoung Jang, Wei Ding, and Mahmut Kandemir. 2012. “A Compiler Framework for Extracting Superword Level Parallelism.” In Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2254064.2254106
Liu, Kaixuan, Zhiqiang Zhang, Baohui Wu, and Zedong Wu. 2023c. “NX MCD-Based Unboxing Machine Model Design and Virtual Commissioning.” In 2023 IEEE 16th International Conference on Electronic Measurement & Instruments (ICEMI). IEEE. https://doi.org/10.1109/icemi59194.2023.10270052
Liu, Yuxing, Zhanwen Zhang, Xuchuan Zhou, and Wentao Liu. 2023b. “An Empirical Study on Spectrum-Based Fault Localization for Student Programs.” In 2023 3rd International Symposium on Computer Technology and Information Science (ISCTIS). IEEE. https://doi.org/10.1109/isctis58954.2023.10213072
Liu, Changlan, Yingsong Zhang, Peng Zuo, and Peng Wang. 2025b. “Compiler Identification with Divisive Analysis and Support Vector Machine.” Symmetry 17 (6): 867. https://doi.org/10.3390/sym17060867
“LLVM-HPC 2024: The Tenth Annual Workshop on the LLVM Compiler Infrastructure in HPC.” 2024. In SC24-W: Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/scw63240.2024.00130
Lo, Jack L., and Susan J. Eggers. 1995. “Improving Balanced Scheduling with Compiler Optimizations That Increase Instruction-Level Parallelism.” In Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/207110.207132
Lo, Anthony, Tansel Özyer, Radwan Tahboob, Keivan Kianmehr, Jamal Jida, and Reda Alhajj. 2010. “XML Materialized Views and Schema Evolution in VIREX.” Information Sciences 180 (24): 4940–57. https://doi.org/10.1016/j.ins.2010.08.025
Lo Duca, Angelica. 2024. “An Empirical Study to Use Large Language Models to Extract Named Entities from Repetitive Texts.” In Proceedings of the 20th International Conference on Web Information Systems and Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013066500003825
Lobo, Pedro, John McIver, George Mitenkov, Juneyoung Lee, Kirshanthan Sundararajah, and Nuno P. Lopes. 2026. “Towards Removing Undef Values from LLVM IR.” Proceedings of the ACM on Programming Languages 10 (PLDI): 76–99. https://doi.org/10.1145/3808250
Lokan, Chris, and Emilia Mendes. 2009a. “Applying Moving Windows to Software Effort Estimation.” In 2009 3rd International Symposium on Empirical Software Engineering and Measurement. IEEE. https://doi.org/10.1109/esem.2009.5316019
Lokuciejewski, Paul, Sascha Plazar, Heiko Falk, Peter Marwedel, and Lothar Thiele. 2010. “Multi-Objective Exploration of Compiler Optimizations for Real-Time Systems.” In 2010 13th IEEE International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing. IEEE. https://doi.org/10.1109/isorc.2010.15
Long, Wang, Zhao Qixin, and Yang Luxia. 2025. “Software Effort Estimation Based on Inception Network Optimized by Enhanced Banyan Tree Growth Optimizer.” Scientific Reports 16 (1): 143. https://doi.org/10.1038/s41598-025-29028-9
Long, Shun, and Weiheng Zhu. 2010. “Outlier Detection for Learning-Based Optimizing Compiler.” In 2010 Fifth International Conference on Frontier of Computer Science and Technology. IEEE. https://doi.org/10.1109/fcst.2010.31
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
Lööw, Andreas, Ramana Kumar, Yong Kiam Tan, et al. 2019. “Verified Compilation on a Verified Processor.” In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/3314221.3314622
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
López-Martín, Cuauhtémoc, Arturo Chavoya, and M. E. Meda-Campaña. 2011. “Software Development Effort Estimation in Academic Environments Applying a General Regression Neural Network Involving Size and People Factors.” In Pattern Recognition. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-21587-2_29
Lopez-Martin, Cuauhtemoc, Cornelio Yanez-Marquez, and Agustin Gutierrez-Tornes. 2006a. “A Fuzzy Logic Model Based upon Reused and New & Changed Code for Software Development Effort Estimation at Personal Level.” In 2006 15th International Conference on Computing. IEEE. https://doi.org/10.1109/cic.2006.5
Lopez-Martin, Cuauhtemoc, Cornelio Yanez-Marquez, and Agustin Gutierrez-Tornes. 2006b. “Fuzzy Logic Systems for Software Development Effort Estimation Based upon Clustering of Programs Segmented by Personal Practices.” In Electronics, Robotics and Automotive Mechanics Conference (CERMA’06), vol. 2. IEEE. https://doi.org/10.1109/cerma.2006.114
Lorko, Matej, Maroš Servátka, and Le Zhang. 2019. “Anchoring in Project Duration Estimation.” Journal of Economic Behavior & Organization 162: 49–65. https://doi.org/10.1016/j.jebo.2019.04.014
Louden, Kenneth. 1990. “P-Code and Compiler Portability: Experience with a Modula-2 Optimizing Compiler.” ACM SIGPLAN Notices 25 (5): 53–59. https://doi.org/10.1145/382080.382632
Loureiro-Porto, LUCÍA. 2017. “ICE vs GloWbE: Big Data and Corpus Compilation.” World Englishes 36 (3): 448–70. https://doi.org/10.1111/weng.12281
Love, Peter E. D., David J. Edwards, and Zahir Irani. 2012. “Moving beyond Optimism Bias and Strategic Misrepresentation: An Explanation for Social Infrastructure Project Cost Overruns.” IEEE Transactions on Engineering Management 59 (4): 560–71. https://doi.org/10.1109/tem.2011.2163628
Love, Peter E. D., Michael C. P. Sing, Lavagnon A. Ika, and Sidney Newton. 2019. “The Cost Performance of Transportation Projects: The Fallacy of the Planning Fallacy Account.” Transportation Research Part A: Policy and Practice 122: 1–20. https://doi.org/10.1016/j.tra.2019.02.004
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, Yuan. 2023. “Research on Optimal Layout of Sensors in Civil Engineering Structure Based on Association Rule Mining Algorithm.” In 2023 International Conference on Power, Electrical Engineering, Electronics and Control (PEEEC). IEEE. https://doi.org/10.1109/peeec60561.2023.00073
Lu, Qingda, Christophe Alias, Uday Bondhugula, et al. 2009. “Data Layout Transformation for Enhancing Data Locality on NUCA Chip Multiprocessors.” In 2009 18th International Conference on Parallel Architectures and Compilation Techniques. IEEE. https://doi.org/10.1109/pact.2009.36
Lu, Shengyou, Yujie Hu, Feipeng Li, Dan Huang, and Chuxuan Zeng. 2024. “Automatic Reference Counting Implementation and Optimization of the Octave JIT Compiler for High-Performance Computing Platforms.” In 2024 5th International Conference on Computer Engineering and Application (ICCEA). IEEE. https://doi.org/10.1109/iccea62105.2024.10603933
Lu, Lunjin, and Andy King. 2002. “Backward Type Inference Generalises Type Checking.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45789-5_9
Lu, Yue, Thomas Nolte, Iain Bate, and Liliana Cucu-Grosjean. 2011. “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, Yu-Sheng, Sheng-Jung Yu, and Yao-Wen Chang. 2020b. “Topological Structure and Physical Layout Codesign for Wavelength-Routed Optical Networks-on-Chip.” In 2020 57th ACM/IEEE Design Automation Conference (DAC). IEEE. https://doi.org/10.1109/dac18072.2020.9218625
Lu, Ziqian, Yunlong Yu, Zhe-Ming Lu, Feng-Li Shen, and Zhongfei Zhang. 2020a. “Attentive Semantic Preservation Network for Zero-Shot Learning.” In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops (CVPRW). IEEE. https://doi.org/10.1109/cvprw50498.2020.00349
Lu, Xiaohan, Min Zhu, Yilong Liu, Shengao Wang, Zijian Xu, and Shengnan Li. 2023. “Triangular Position Multi-Bolt Layout Structure Optimization.” Applied Sciences 13 (15): 8786. https://doi.org/10.3390/app13158786
Luan, Hua, Xiao-Yong Du, and Shan Wang. 2009. “Cache-Conscious Data Cube Computation on a Modern Processor.” Journal of Computer Science and Technology 24 (4): 708–22. https://doi.org/10.1007/s11390-009-9253-0
Lublinerman, Roberto, Christian Szegedy, and Stavros Tripakis. 2009. “Modular Code Generation from Synchronous Block Diagrams: Modularity vs. Code Size.” ACM SIGPLAN Notices 44 (1): 78–89. https://doi.org/10.1145/1594834.1480893
Luckow, Kasper Søe, Bent Thomsen, and Stephan Erbs Korsholm. 2016. “HVMTP: A Time Predictable and Portable Java Virtual Machine for Hard Real-Time Embedded Systems.” Concurrency and Computation: Practice and Experience 29 (22): e3828. https://doi.org/10.1002/cpe.3828
Ludmir, Jason, and Tirthak Patel. 2024. “PARALLAX: A Compiler for Neutral Atom Quantum Computers under Hardware Constraints.” In SC24: International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/sc41406.2024.00079
Lueh, Guei-Yuan, and Thomas Gross. 1997. “Call-Cost Directed Register Allocation.” In Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/258915.258942
Lueh, Guei-Yuan, Thomas Gross, and Ali-Reza Adl-Tabatabai. 1997. “Global Register Allocation Based on Graph Fusion.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0017257
Luis, Álvaro, Pablo Casares, Juan J. Cuadrado-Gallego, and Miguel A. Patricio. 2021. “PSON: A Serialization Format for IoT Sensor Networks.” Sensors 21 (13): 4559. https://doi.org/10.3390/s21134559
Lumsdaine, Peter LeFanu. 2009. “Weak ω-Categories from Intensional Type Theory.” In Typed Lambda Calculi and Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-02273-9_14
Lund, Johannes, Mads R. B. Kristensen, Simon A. F. Lund, and Brian Vinter. 2014. “Just-In-Time Compilation of NumPy Vector Operations.” GSTF Journal on Computing (JoC) 3 (3): 21. https://doi.org/10.7603/s40601-013-0021-1
Luo, Zhaohui. 2009. “Manifest Fields and Module Mechanisms in Intensional Type Theory.” In Types for Proofs and Programs. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-02444-3_15
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, Chenguang, Guanhua He, and Shengchao Qin. 2008. “A Heap Model for Java Bytecode to Support Separation Logic.” In 2008 15th Asia-Pacific Software Engineering Conference. IEEE. https://doi.org/10.1109/apsec.2008.72
Luo, Yongping, Peiquan Jin, and Shouhong Wan. 2020. “Optimal Data Placement for Data-Centric Algorithms on NVM-Based Hybrid Memory.” In 2020 IEEE 7th International Conference on Data Science and Advanced Analytics (DSAA). IEEE. https://doi.org/10.1109/dsaa49011.2020.00035
Luo, Chenke, Jiang Ming, Jianming Fu, Guojun Peng, and Zhetao Li. 2023. “Reverse Engineering of Obfuscated Lua Bytecode via Interpreter Semantics Testing.” IEEE Transactions on Information Forensics and Security 18: 3891–3905. https://doi.org/10.1109/tifs.2023.3289254
Luo, Zhengqin, and Tamara Rezk. 2012. “Mashic Compiler: Mashup Sandboxing Based on Inter-Frame Communication.” In 2012 IEEE 25th Computer Security Foundations Symposium. IEEE. https://doi.org/10.1109/csf.2012.22
Luo, Junjie, and Jianjun Zhao. 2023. “Enhancing Code Safety in Quantum Intermediate Representation.” In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE. https://doi.org/10.1109/ase56229.2023.00195
Lutteroth, Christof, Dirk Draheim, and Gerald Weber. 2011. “A Type System for Reflective Program Generators.” Science of Computer Programming 76 (5): 392–422. https://doi.org/10.1016/j.scico.2010.12.002
Lv, Mingsong, Nan Guan, Qingxu Deng, Ge Yu, and Yi Wang. 2010b. “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
Lv, Fang, Hao Li, Lei Wang, et al. 2020. “Referee: A Pattern-Guided Approach for Auto Design in Compiler-Based Analyzers.” In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner48275.2020.9054849
Lv, Mingsong, Wang Yi, Nan Guan, and Ge Yu. 2010a. “Combining Abstract Interpretation with Model Checking for Timing Analysis of Multicore Software.” In 2010 31st IEEE Real-Time Systems Symposium. IEEE. https://doi.org/10.1109/rtss.2010.30
Lyon, Gordon. 1988. “A Tagless Marking That Is Linear over Subtrees.” Information Processing Letters 27 (1): 23–28. https://doi.org/10.1016/0020-0190(88)90077-4
Ma, Yung-Cheng. 2020. “Compiler-Directed Parallelism Scaling Framework for Performance Constrained Energy Optimization.” IEEE Access 8: 1733–54. https://doi.org/10.1109/access.2019.2961568
Ma, Zeyuan, Yue-Jiao Gong, Hongshu Guo, et al. 2026. “LLaMoCo: Instruction Tuning of Large Language Models for Optimization Code Generation.” IEEE Transactions on Evolutionary Computation 30 (4): 1390–1404. https://doi.org/10.1109/tevc.2026.3656374
Ma, Yunfei, and Edwin C. Kan. 2016. “Ubiquitous Tagless Object Locating with Ambient Harmonic Tags.” In IEEE INFOCOM 2016 - The 35th Annual IEEE International Conference on Computer Communications. IEEE. https://doi.org/10.1109/infocom.2016.7524577
Ma, Liang, Luciano Lavagno, Mihai Teodor Lazarescu, and Arslan Arif. 2017. “Acceleration by Inline Cache for Memory-Intensive Algorithms on FPGA via High-Level Synthesis.” IEEE Access 5: 18953–74. https://doi.org/10.1109/access.2017.2750923
Ma, Jinsuo, and Guoqi Li. 2009. “Research of Achiveing Structural Coverage Analysis without Compiler Verification under DO-178B Context.” In 2009 8th International Conference on Reliability, Maintainability and Safety. IEEE. https://doi.org/10.1109/icrms.2009.5270084
Ma, Miao, Zhengyi Yang, Kongzhang Hao, Liuyi Chen, Chunling Wang, and Yi Jin. 2023a. “An Empirical Analysis of Just-in-Time Compilation in Modern Databases.” In Databases Theory and Applications. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-47843-7_16
Ma, Xiangnan, Tao Yang, Yunlong Wang, Huqiang Yuan, Zhijian Liu, and Rongbiao Xu. 2023b. “Optimization Method of AC Filter Field Layout Structure in UHV Converter Station.” In 2023 IEEE International Conference on Power Science and Technology (ICPST). IEEE. https://doi.org/10.1109/icpst56889.2023.10164866
Maas, Martin, Krste Asanovic, and John Kubiatowicz. 2018. “A Hardware Accelerator for Tracing Garbage Collection.” In 2018 ACM/IEEE 45th Annual International Symposium on Computer Architecture (ISCA). IEEE. https://doi.org/10.1109/isca.2018.00022
Maas, Martin, Krste Asanovic, and John Kubiatowicz. 2019. “A Hardware Accelerator for Tracing Garbage Collection.” IEEE Micro 39 (3): 38–46. https://doi.org/10.1109/mm.2019.2910509
MacDonell, Stephen G., and Martin J. Shepperd. 2007. “Comparing Local and Global Software Effort Estimation Models – Reflections on a Systematic Review.” In First International Symposium on Empirical Software Engineering and Measurement (ESEM 2007). IEEE. https://doi.org/10.1109/esem.2007.45
Madhavan, Ravichandhran, and Viktor Kuncak. 2014. “Symbolic Resource Bound Inference for Functional Programs.” In Computer Aided Verification. Springer International Publishing. https://doi.org/10.1007/978-3-319-08867-9_51
Madhavan, Ravichandhran, Ganesan Ramalingam, and Kapil Vaswani. 2011. “Purity Analysis: An Abstract Interpretation Formulation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-23702-7_6
Madsen, Magnus, and Esben Andreasen. 2014. “String Analysis for Dynamic Field Access.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-54807-9_12
Maeda, Kazuaki. 2012. “Performance Evaluation of Object Serialization Libraries in XML, JSON and Binary Formats.” In 2012 Second International Conference on Digital Information and Communication Technology and it’s Applications (DICTAP). IEEE. https://doi.org/10.1109/dictap.2012.6215346
Maeda, D., K. Mizugaki, R. Fujiwara, et al. 2009. “Tagless Location System Using UWB Impulse Radio.” In 2009 IEEE Radio and Wireless Symposium. IEEE. https://doi.org/10.1109/rws.2009.4957441
Maejima, Aoi, Yoshiki Higo, Junnosuke Matsumoto, and Shinji Kusumoto. 2020. “Does This Code Change Affect Program Behavior? Identifying Nonbehavioral Changes with Bytecode.” In 2020 IEEE 44th Annual Computers, Software, and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac48688.2020.0-119
Maeng, Kiwan, and Brandon Lucia. 2024. “Compiler-Based Memory Encryption for Machine Learning on Commodity Low-Power Devices.” In Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3640537.3641564
Maessen, Jan-Willem, Vivek Sarkar, and David Grove. 2001. “Program Analysis for Safety Guarantees in a Java Virtual Machine Written in Java.” In Proceedings of the 2001 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. ACM. https://doi.org/10.1145/379605.379668
Magnani, Gabriele, Davide Baroffio, Federico Reghenzani, Giovanni Agosta, and William Fornaciari. 2025. “Modern Llvm-Based Compiler Autotuning for Wcet Optimization.” In 2025 IEEE Real-Time Systems Symposium (RTSS). IEEE. https://doi.org/10.1109/rtss66672.2025.00043
Magnusson, Boris, and Roger Henriksson. 1995. “Garbage Collection for Control Systems.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_32
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, Anjali, and M. S. Ali. 2009. “Hybrid Evolutionary Algorithm for the Graph Coloring Register Allocation Problem for Embedded Systems.” In Transactions on Computational Science V. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-02097-1_11
Maheshwari, Abhishek, Abhishek Tyagi, and Neeraj Joshi. 2020. “To Improve Efficiency of Garbage Collection System for Smart Cities: Review Paper.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.3607004
Mahmoudi, Charif, and Fabrice Mourlin. 2017. “Formal Verification of Mobile Orchestration Agents: Model Checking for Orchestration Verification.” In 2017 International Conference on Wireless Technologies, Embedded and Intelligent Systems (WITS). IEEE. https://doi.org/10.1109/wits.2017.7934672
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
Majeti, Deepak, Rajkishore Barik, Jisheng Zhao, Max Grossman, and Vivek Sarkar. 2014. “Compiler-Driven Data Layout Transformation for Heterogeneous Platforms.” In Euro-Par 2013: Parallel Processing Workshops. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-54420-0_19
Majumder, Abhilash. 2026. “Inductor-TV: Formal Methods for the Pytorch Compiler.” In 2026 7th International Conference on Artificial Intelligence, Robotics, and Control (AIRC). IEEE. https://doi.org/10.1109/airc69745.2026.11631461
Makholm, Henning, and J. B. Wells. 2005. “Type Inference, Principal Typings, and Let-Polymorphism for First-Class Mixin Modules.” In Proceedings of the tenth ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/1086365.1086386
Malagón, Pedro, Juan-Mariano De Goyeneche, Marina Zapater, José M. Moya, and Zorana Banković. 2012. “Compiler Optimizations as a Countermeasure against Side-Channel Analysis in MSP430-Based Devices.” Sensors 12 (6): 7994–8012. https://doi.org/10.3390/s120607994
Malathi, S., and S. Sridhar. 2014. “Effort Estimation in Software Cost Using Team Characteristics Based on Fuzzy Analogy Method – a Diverse Approach.” In Signal Processing and Information Technology. Springer International Publishing. https://doi.org/10.1007/978-3-319-11629-7_1
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
Malik, Vikrant, Renuka Arora, Deepti Mehrotra, and Hitesh Singh. 2024. “Agile Software Development Effort Estimation: A Comprehensive Survey.” In 2024 International Conference on Emerging Technologies and Innovation for Sustainability (EmergIN). IEEE. https://doi.org/10.1109/emergin63207.2024.10961288
Malviya, Shreekant, Abhishek Jaiswal, and Vivek Koli. 2025. “AI-Guided Schema Evolution and Real-Time Data Quality Enhancement in Multi-Source Pipelines.” In 2025 1st International Conference on Data Science and Intelligent Network Computing (ICDSINC). IEEE. https://doi.org/10.1109/icdsinc66221.2025.11448159
Malyi, Roman, and Pavlo Serdyuk. 2025. “Large Language Models for Schema Evolution in Event-Sourced Systems.” In 2025 IEEE 13th International Conference on Intelligent Data Acquisition and Advanced Computing Systems: Technology and Applications (IDAACS). IEEE. https://doi.org/10.1109/idaacs68557.2025.11321978
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
Mamedov, Tural, Anatoliy Doroshenko, and Ruslan Shevchenko. 2020. “Static Analysis of Resource Consumption in Programs Using Rewriting Rules.” In 2020 IEEE 2nd International Conference on Advanced Trends in Information Theory (ATIT). IEEE. https://doi.org/10.1109/atit50783.2020.9349290
Mammadli, Rahim, Ali Jannesari, and Felix Wolf. 2020. “Static Neural Compiler Optimization via Deep Reinforcement Learning.” 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.00006
Manaresi, N., R. Rovatti, E. Franchi, R. Guerrieri, and G. Baccarani. 1996. “A Silicon Compiler of Analog Fuzzy Controllers: From Behavioral Specifications to Layout.” IEEE Transactions on Fuzzy Systems 4 (4): 418–28. https://doi.org/10.1109/91.544302
Manchala, Pravali, and Manjubala Bisi. 2024. “TSoptEE: Two-Stage Optimization Technique for Software Development Effort Estimation.” Cluster Computing 27 (7): 8889–8908. https://doi.org/10.1007/s10586-024-04418-2
Mandal, Rahul Kumar, Jagannath Singh, and Debolina Ghosh. 2024. “Software Development Effort Estimation Using Regression Models Delve with Explainable Machine Learning (XAI).” In 2024 OITS International Conference on Information Technology (OCIT). IEEE. https://doi.org/10.1109/ocit65031.2024.00029
Manjunath, T. K., and Sharmila Chidaravalli. 2011. “Static Analysis of Designing a Compiler Tool That Generates Machine Codes for the Predicted Execution Path: A Bypass Compiler.” In 2011 IEEE 3rd International Conference on Communication Software and Networks. IEEE. https://doi.org/10.1109/iccsn.2011.6014926
Mannarswamy, Sandya, and Ramaswamy Govindarajan. 2011. “Making STMs Cache Friendly with Compiler Transformations.” In 2011 International Conference on Parallel Architectures and Compilation Techniques. IEEE. https://doi.org/10.1109/pact.2011.55
Mannarswamy, Sandya S., Ramaswamy Govindarajan, and Rishi Surendran. 2009. “Region Based Structure Layout Optimization by Selective Data Copying.” In 2009 18th International Conference on Parallel Architectures and Compilation Techniques. IEEE. https://doi.org/10.1109/pact.2009.43
Mansky, William, and Elsa Gunter. 2010. “A Framework for Formal Verification of Compiler Optimizations.” In Interactive Theorem Proving. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-14052-5_26
Mansoor, Niloofar, Tukaram Muske, Alexander Serebrenik, and Bonita Sharif. 2022. “An Empirical Assessment on Merging and Repositioning of Static Analysis Alarms.” In 2022 IEEE 22nd International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE. https://doi.org/10.1109/scam55253.2022.00031
Mansor, Zulkefli, Saadiah Yahya, and Noor Habibah Hj Arshad. 2011. “Success Factors in Cost Estimation for Software Development Project.” In Software Engineering and Computer Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-22170-5_19
Mansouri, Nazanin, and Ranga Vemuri. 2000. “Automated Correctness Condition Generation for Formal Verification of Synthesized RTL Designs.” Formal Methods in System Design 16 (1): 59–91. https://doi.org/10.1023/a:1008777509016
Mao, Jiacheng, Zukai Tang, and Wenbi Rao. 2023. “Cross-Language Binary-Source Code Matching Based on Rust and Intermediate Representation.” In 2023 IEEE 3rd International Conference on Computer Communication and Artificial Intelligence (CCAI). IEEE. https://doi.org/10.1109/ccai57533.2023.10201266
Marcou, G., D. Horvath, and A. Varnek. 2017. “Neighboring Structure Visualization on a Grid-Based Layout.” Molecular Informatics 36 (10): 1700047. https://doi.org/10.1002/minf.201700047
Marcus, Leo. 1996. “The Incorporation of Testing into Formal Verification: Direct, Modular, and Hierarchical Correctness Degrees.” Formal Methods in System Design 9 (3): 235–61. https://doi.org/10.1007/bf00122083
Marinelli, Tommaso, José Ignacio Gómez Pérez, Christian Tenllado, and Francky Catthoor. 2023. “COMPAD: A Heterogeneous Cache-Scratchpad CPU Architecture with Data Layout Compaction for Embedded Loop-Dominated Applications.” Journal of Systems Architecture 145: 103022. https://doi.org/10.1016/j.sysarc.2023.103022
Marino, Daniel, Abhayendra Singh, Todd Millstein, Madanlal Musuvathi, and Satish Narayanasamy. 2011. “A Case for an SC-Preserving Compiler.” In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/1993498.1993522
Mariz, Leila M. R. de Souza, A. Cesar C. Franca, and Fabio Q. B. da Silva. 2010. “An Empirical Study on the Relationship between the Use of Agile Practices and the Success of Software Projects That Use Scrum.” In 2010 Brazilian Symposium on Software Engineering. IEEE. https://doi.org/10.1109/sbes.2010.17
Marks, B. L. 1973. “Design of a Checkout Compiler.” IBM Systems Journal 12 (3): 315–27. https://doi.org/10.1147/sj.123.0315
Marlow, Simon, and Simon Peyton Jones. 2011. “Multicore Garbage Collection with Local Heaps.” ACM SIGPLAN Notices 46 (11): 21–32. https://doi.org/10.1145/2076022.1993482
Marotta, Adriana, Regina Motz, and Raul Ruggia. 2002. “Managing Source Schema Evolution in Web Warehouses.” Journal of the Brazilian Computer Society 8 (2): 20–31. https://doi.org/10.1590/s0104-65002002000200003
Maroun, Emad Jacob, Martin Schoeberl, and Peter Puschner. 2024. “Two-Step Register Allocation for Implementing Single-Path Code.” In 2024 IEEE 27th International Symposium on Real-Time Distributed Computing (ISORC). IEEE. https://doi.org/10.1109/isorc61049.2024.10551362
Marref, Amine, and Guillem Bernat. 2009. “Predicated Worst-Case Execution-Time Analysis.” In Reliable Software Technologies – Ada-Europe 2009. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-01924-1_10
Marriott, Kim. 1997. “Abstract Interpretation: A Theory of Approximate Computation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032757
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
Martin, S., and G. Leduc. 2009. “A Practical Bytecode Interpreter for Programmable Routers on IXP Network Processors.” Computer Networks 53 (15): 2740–51. https://doi.org/10.1016/j.comnet.2009.06.007
Martinez, A., and S. Nance. 1984. “Methodology for Compiler Generated Silicon Structures.” In 21st Design Automation Conference Proceedings. IEEE. https://doi.org/10.1109/dac.1984.1585883
Martínez C. Branco, Daniel Tadeu, Edson Cesar Cunha de Oliveira, Leandro Galvão, Rafael Prikladnicki, and Tayana Conte. 2015. “An Empirical Study about the Influence of Project Manager Personality in Software Project Effort.” In Proceedings of the 17th International Conference on Enterprise Information Systems. SCITEPRESS - Science and and Technology Publications. https://doi.org/10.5220/0005373001020113
Martínez-Aguilar, Sulem, Ángel J. Sánchez-García, Cuauhtémoc López-Martín, and Jorge Octavio Ocharán-Hernández. 2025. “Systematic Literature Review on Effort Estimation by Software Development Life Cycle Phases.” IEEE Access 13: 153340–58. https://doi.org/10.1109/access.2025.3605102
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
Mashhadi, Ehsan, Shaiful Chowdhury, Somayeh Modaberi, Hadi Hemmati, and Gias Uddin. 2024. “An Empirical Study on Bug Severity Estimation Using Source Code Metrics and Static Analysis.” Journal of Systems and Software 217: 112179. https://doi.org/10.1016/j.jss.2024.112179
Mason, Dave. 2023. “Revisiting Dynamic Dispatch for Modern Architectures.” In Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3623507.3623551
Masood, Nayyer, and Naira Andleeb. 2014. “A Taxonomy of Changes in Schema Evolution.” In 2014 International Conference on Computational Science and Technology (ICCST). IEEE. https://doi.org/10.1109/iccst.2014.7045196
Massé, Damien. 2002a. “Property Checking Driven Abstract Interpretation-Based Static Analysis.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36384-x_8
Massé, Damien. 2002b. “Semantics for Abstract Interpretation-Based Static Analyzes of Temporal Properties.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45789-5_30
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
Mastroeni, Isabella. 2004. “Algebraic Power Analysis by Abstract Interpretation.” Higher-Order and Symbolic Computation 17 (4): 297–345. https://doi.org/10.1007/s10990-004-4867-y
Mastroeni, Isabella, and Michele Pasqua. 2023. “Domain Precision in Galois Connection-Less Abstract Interpretation.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-44245-2_19
Mastroeni, Isabella, and Michele Pasqua. 2026. “Abstract Interpretation-Based Verification for Confidentiality: Information Hiding and Code Protection by Abstract Interpretation.” ACM Transactions on Privacy and Security 29 (1): 1–30. https://doi.org/10.1145/3786347
Masuhara, Hidehiko, and Akinori Yonezawa. 2001. “Run-Time Bytecode Specialization.” In Programs as Data Objects. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44978-7_9
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
Matar, Samir F. 2017. “First Principles Studies of Hydrogen Insertion Effects on Magnetic Properties, Bonding and Structure Reordering of UZr 2.” Computational Condensed Matter 12: 19–24. https://doi.org/10.1016/j.cocom.2017.08.001
Matsubara, Patrícia G. F., Igor Steinmacher, Bruno Gadelha, and Tayana Conte. 2023. “Much More than a Prediction: Expert-Based Software Effort Estimation as a Behavioral Act.” Empirical Software Engineering 28 (4): 98. https://doi.org/10.1007/s10664-023-10332-9
Matsumoto, Hidekazu. 1985. “A Static Analysis of Prolog Programs.” ACM SIGPLAN Notices 20 (10): 48–59. https://doi.org/10.1145/382286.382380
Matthes, Ralph. 2011. “Map Fusion for Nested Datatypes in Intensional Type Theory.” Science of Computer Programming 76 (3): 204–24. https://doi.org/10.1016/j.scico.2010.05.008
Matusik, Sharon F., Jennifer M. George, and Michael B. Heeley. 2008. “Values and Judgment under Uncertainty: Evidence from Venture Capitalist Assessments of Founders.” Strategic Entrepreneurship Journal 2 (2): 95–115. https://doi.org/10.1002/sej.45
Mauborgne, Laurent. 1994. “Abstract Interpretation Using TDGs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-58485-4_52
Mauborgne, Laurent, and Xavier Rival. 2005. “Trace Partitioning in Abstract Interpretation Based Static Analyzers.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-31987-0_2
McDonell, Trevor L., Manuel M. T. Chakravarty, Vinod Grover, and Ryan R. Newton. 2015. “Type-Safe Runtime Code Generation: Accelerate to LLVM.” ACM SIGPLAN Notices 50 (12): 201–12. https://doi.org/10.1145/2887747.2804313
McDowell, Charles E. 1989. “A Practical Algorithm for Static Analysis of Parallel Programs.” Journal of Parallel and Distributed Computing 6 (3): 515–36. https://doi.org/10.1016/0743-7315(89)90004-x
McEntee, Timothy J. 1987. “Overview of Garbage Collection in Symbolic Computing.” ACM SIGPLAN Lisp Pointers 1 (3): 8–16. https://doi.org/10.1145/1317203.1317205
McEwan, Alistair A., and Muhammed Ziya Komsul. 2016. “Pre-Emptive Garbage Collection for SSD RAID.” In 2016 Euromicro Conference on Digital System Design (DSD). IEEE. https://doi.org/10.1109/dsd.2016.96
McEwan, Alistair A., and Muhammed Ziya Komsul. 2018. “Age Aware Pre-Emptive Garbage Collection for SSD RAID.” Microprocessors and Microsystems 56: 13–21. https://doi.org/10.1016/j.micpro.2017.10.008
McGhan, H., and M. O’Connor. 1998. “PicoJava: A Direct Execution Engine for Java Bytecode.” Computer 31 (10): 22–30. https://doi.org/10.1109/2.722273
McGough, Keith. 1988. “Cost Estimation in Software Engineering.” Journal of Parametrics 8 (2): 5–11. https://doi.org/10.1080/10157891.1988.10472824
McKeeman, W. M. 1974. “Compiler Construction.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3540069585_45
McKenzie, Edwin, and Richard Snodgrass. 1990. “Schema Evolution and the Relational Algebra.” Information Systems 15 (2): 207–32. https://doi.org/10.1016/0306-4379(90)90036-o
McMillan, T. 1987. “The Brain Code: Mechanisms of Transfer and the Role of the Corpus Callosom.” Behaviour Research and Therapy 25 (6): 537. https://doi.org/10.1016/0005-7967(87)90074-x
McMillan, Kenneth L., and Lenore D. Zuck. 2011. “Invisible Invariants and Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-23702-7_20
McNally, Randall, and Michael J. Eck. 2014. “JAK–cytokine Receptor Recognition, Unboxed.” Nature Structural & Molecular Biology 21 (5): 431–33. https://doi.org/10.1038/nsmb.2824
McNerney, Timothy S. 1991. “Verifying the Correctness of Compiler Transformations on Basic Blocks Using Abstract Interpretation.” ACM SIGPLAN Notices 26 (9): 106–15. https://doi.org/10.1145/115866.115877
Medina Barrera, María Guadalupe, Rosa María Cantón Croda, and Damián Emilio Gibaja Romero. 2024. “Effort Estimation in Insourcing Agile Software Development by a Game Theoretical Framework.” In 2024 13th International Conference On Software Process Improvement (CIMPS). IEEE. https://doi.org/10.1109/cimps65195.2024.11095950
Medvet, Eric, and Francesco Mercaldo. 2016. “Exploring the Usage of Topic Modeling for Android Malware Static Analysis.” In 2016 11th International Conference on Availability, Reliability and Security (ARES). IEEE. https://doi.org/10.1109/ares.2016.10
Meehan, A., and T. Lunney. 2001. “Java Garbage Collection — A Generic Solution?” Information and Software Technology 43 (2): 151–55. https://doi.org/10.1016/s0950-5849(00)00146-4
Meenakshi, B. 2005. “Formal Verification.” Resonance 10 (5): 26–38. https://doi.org/10.1007/bf02871329
Mehrpour, Sahar, and Thomas D. LaToza. 2022. “Can Static Analysis Tools Find More Defects?: A Qualitative Study of Design Rule Violations Found by Code Review.” Empirical Software Engineering 28 (1): 5. https://doi.org/10.1007/s10664-022-10232-4
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
Melo, Gustavo C. G., Pedro H. B. Nascimento, Ícaro B. Q. Araújo, and Allan M. Martins. 2026. “A Hardware Architecture for Native Execution of Python Bytecode on FPGA: A Proof-of-Concept.” IEEE Access 14: 88338–50. https://doi.org/10.1109/access.2026.3701603
Menard, Daniel, and Olivier Sentieys. 2004. “DSP Code Generation with Optimized Data Word-Length Selection.” In Software and Compilers for Embedded Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30113-4_16
Mendes, Emilia. 2007. “A Comparison of Techniques for Web Effort Estimation.” In First International Symposium on Empirical Software Engineering and Measurement (ESEM 2007). IEEE. https://doi.org/10.1109/esem.2007.14
Mendes, Emilia. 2012a. “Improving Software Effort Estimation Using an Expert-Centred Approach.” In Human-Centered Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-34347-6_2
Mendes, Emilia. 2012c. “Using Knowledge Elicitation to Improve Web Effort Estimation: Lessons from Six Industrial Case Studies.” In 2012 34th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse.2012.6227108
Mendes, Emilia. 2014a. “Applying a Knowledge Management Technique to Improve Risk Assessment and Effort Estimation of Healthcare Software Projects.” In Software Technologies. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-44920-2_3
Mendes, Emilia, Veronica Taquete Vaz, and Fernando Muradas. 2015. “An Expert-Based Requirements Effort Estimation Model Using Bayesian Networks.” In Software Quality. The Future of Systems- and Software Development. Springer International Publishing. https://doi.org/10.1007/978-3-319-27033-3_6
Menendez, David, and Santosh Nagarakatte. 2017. “Alive-Infer: Data-Driven Precondition Inference for Peephole Optimizations in LLVM.” ACM SIGPLAN Notices 52 (6): 49–63. https://doi.org/10.1145/3140587.3062372
Menendez, David, Santosh Nagarakatte, and Aarti Gupta. 2016. “Alive-FP: Automated Verification of Floating Point Based Peephole Optimizations in LLVM.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-53413-7_16
Meng, Fan, Bing Chen, Xiu Zhang, and Shaohong Zhu. 2023. “A Progressive Real-Time System Performance Defect Diagnosis Framework Based on Java Virtual Machine Run-Time Data.” In 2023 5th International Conference on Frontiers Technology of Information and Computer (ICFTIC). IEEE. https://doi.org/10.1109/icftic59930.2023.10456094
Meng, Jiayuan, and Kevin Skadron. 2009. “Avoiding Cache Thrashing Due to Private Data Placement in Last-Level Cache for Manycore Scaling.” In 2009 IEEE International Conference on Computer Design. IEEE. https://doi.org/10.1109/iccd.2009.5413143
Mengin, Jérôme. 1995. “A Theorem Prover for Default Logic Based on Prioritized Conflict Resolution and an Extended Resolution Principle.” In Symbolic and Quantitative Approaches to Reasoning and Uncertainty. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60112-0_35
Menon, Vijay S., Neal Glew, Brian R. Murphy, et al. 2006. “A Verifiable SSA Program Representation for Aggressive Compiler Optimization.” ACM SIGPLAN Notices 41 (1): 397–408. https://doi.org/10.1145/1111320.1111072
Mensah, Solomon, Jacky Keung, Michael Franklin Bosu, and Kwabena Ebo Bennin. 2018. “Duplex Output Software Effort Estimation Model with Self-Guided Interpretation.” Information and Software Technology 94: 1–13. https://doi.org/10.1016/j.infsof.2017.09.010
Mensah, Solomon, Jacky Keung, Stephen G. MacDonell, Michael F. Bosu, and Kwabena E. Bennin. 2017. “Investigating the Significance of Bellwether Effect to Improve Software Effort Estimation.” In 2017 IEEE International Conference on Software Quality, Reliability and Security (QRS). IEEE. https://doi.org/10.1109/qrs.2017.44
Menzies, Tim, Zhihao Chen, Jairus Hihn, and Karen Lum. 2006. “Selecting Best Practices for Effort Estimation.” IEEE Transactions on Software Engineering 32 (11): 883–95. https://doi.org/10.1109/tse.2006.114
Menzies, M., and J. Hihn. 2006. “Evidence-Based Cost Estimation Better-Quality for Software.” IEEE Software 23 (4): 64–66. https://doi.org/10.1109/ms.2006.99
Menzies, Tim, Ye Yang, George Mathew, Barry Boehm, and Jairus Hihn. 2016. “Negative Results for Software Effort Estimation.” Empirical Software Engineering 22 (5): 2658–83. https://doi.org/10.1007/s10664-016-9472-2
Meqdadi, Omar, Nouh Alhindawi, Jamal Alsakran, Ahmad Saifan, and Hatim Migdadi. 2019. “Mining Software Repositories for Adaptive Change Commits Using Machine Learning Techniques.” Information and Software Technology 109: 80–91. https://doi.org/10.1016/j.infsof.2019.01.008
Mercuri, M., P. Karsmakers, P. Leroux, D. Schreurs, and A. Beyer. 2015. “Real-Time Fall Detection and Tagless Localization Using Radar Techniques.” In 2015 IEEE 16th Annual Wireless and Microwave Technology Conference (WAMICON). IEEE. https://doi.org/10.1109/wamicon.2015.7120363
Merigoux, Denis, Raphaël Monat, and Jonathan Protzenko. 2021. “A Modern Compiler for the French Tax Code.” In Proceedings of the 30th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3446804.3446850
Merritt, M., A. Orda, and S. R. Sachs. 1997. “Formal Verification of a Distributed Computer System.” Formal Methods in System Design 10 (1): 93–125. https://doi.org/10.1023/a:1008667631119
Mesnard, Fred, and Ulrich Neumerkel. 2001. “Applying Static Analysis Techniques for Inferring Termination Conditions of Logic Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-47764-0_6
Metcalfe, Howard H. 1964. “A Parameterized Compiler Based on Mechanical Linguistics.” Annual Review in Automatic Programming 4: 125–65. https://doi.org/10.1016/0066-4138(64)90016-3
Meurice, Loup, and Anthony Cleve. 2014. “DAHLIA: A Visual Analyzer of Database Schema Evolution.” In 2014 Software Evolution Week - IEEE Conference on Software Maintenance, Reengineering, and Reverse Engineering (CSMR-WCRE). IEEE. https://doi.org/10.1109/csmr-wcre.2014.6747219
Meurice, Loup, and Anthony Cleve. 2017. “Supporting Schema Evolution in Schema-Less NoSQL Data Stores.” In 2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner.2017.7884653
Meurice, Loup, Csaba Nagy, and Anthony Cleve. 2016. “Detecting and Preventing Program Inconsistencies under Database Schema Evolution.” In 2016 IEEE International Conference on Software Quality, Reliability and Security (QRS). IEEE. https://doi.org/10.1109/qrs.2016.38
Meyer, B. 1996. “Schema Evolution: Concepts, Terminology, and Solutions.” Computer 29 (10): 119–21. https://doi.org/10.1109/2.539929
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
Miao, Miao, Austin Mordahl, Dakota Soles, Alice Beideck, and Shiyi Wei. 2025. “An Extensive Empirical Study of Nondeterministic Behavior in Static Analysis Tools.” In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse55347.2025.00125
Michael, F. Dossis. 2010. “Using an XML Schema to Validate a Formal Hardware Compiler.” In 2010 Fifth International Workshop Semantic Media Adaptation and Personalization. IEEE. https://doi.org/10.1109/smap.2010.5706871
Michael, James Bret, Doron Drusinsky, and Duminda Wijesekera. 2021. “Formal Verification of Cyberphysical Systems.” Computer 54 (9): 15–24. https://doi.org/10.1109/mc.2021.3055883
Michaud, Marc-Antoine, and Roland Maranzana. 2017. “Cost Estimation Aided Software for Machined Parts: An Hybrid Model Based on PLM Tools and Data.” In Product Lifecycle Management and the Industry of the Future. Springer International Publishing. https://doi.org/10.1007/978-3-319-72905-3_18
Michelbrink, Markus. 2006. “Interfaces as Functors, Programs as Coalgebras—a Final Coalgebra Theorem in Intensional Type Theory.” Theoretical Computer Science 360 (1–3): 415–39. https://doi.org/10.1016/j.tcs.2006.05.033
Midtgaard, Jan, and Thomas P. Jensen. 2009. “Control-Flow Analysis of Function Calls and Returns by Abstract Interpretation.” In Proceedings of the 14th ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/1596550.1596592
Miecznikowski, Jerome, and Laurie Hendren. 2002. “Decompiling Java Bytecode: Problems, Traps and Pitfalls.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45937-5_10
Might, Matthew, and David Van Horn. 2011. “A Family of Abstract Interpretations for Static Analysis of Concurrent Higher-Order Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-23702-7_16
Mihăescu, Vlad Mihai, Paul Ştefan Popescu, and Marian Cristian Mihăescu. 2025. “Optimizing Cache Utilization in CPU Compilation through Compiler Autotuning.” In Artificial Intelligence Applications and Innovations. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-96239-4_28
Mikaelian, Sarkis S., Lloyd Manglapus, and Marek Tuszynski. 2025. “Evaluating Flight Software Effort Estimation and Reusability Approaches for Planetary Exploration.” In 2025 IEEE Aerospace Conference. IEEE. https://doi.org/10.1109/aero63441.2025.11068455
Mikek, Benjamin. 2025. “Towards Compiler-Guided Static Analysis.” 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.3762823
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
Milanova, Ana, and Yin Liu. 2010. “Static Analysis for Understanding Shared Objects in Open Concurrent Java Programs.” In 2010 17th Working Conference on Reverse Engineering. IEEE. https://doi.org/10.1109/wcre.2010.14
Millet, Laurent, and Ted Baker. 1998. “Porting the GNAT Tasking Runtime System to the Java Virtual Machine.” In Reliable Software Technologies — Ada-Europe. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0054991
Milojković, Nevena, Clément Béra, Mohammad Ghafari, and Oscar Nierstrasz. 2018. “Mining Inline Cache Data to Order Inferred Types in Dynamic Languages.” Science of Computer Programming 161: 105–21. https://doi.org/10.1016/j.scico.2017.11.003
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
Milton, D. R., L. W. Kirchhoff, and B. R. Rowland. 1979. “An all(1) Compiler Generator.” In Proceedings of the 1979 SIGPLAN symposium on Compiler construction - SIGPLAN ‘79. ACM Press. https://doi.org/10.1145/800229.806965
Min, Young Soo, Chang Yong Yang, Jae Soo Yoo, Jeong Min Shim, and Seok Il Song. 2004. “PCR-Tree: An Enhanced Cache Conscious Multi-Dimensional Index Structures.” In Database and Expert Systems Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30075-5_21
Minamide, Yasuhiko, and Jacques Garrigue. 1998. “On the Runtime Complexity of Type-Directed Unboxing.” In Proceedings of the third ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/289423.289424
Miné, Antoine. 2014. “Relational Thread-Modular Static Value Analysis by Abstract Interpretation.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-54013-4_3
Ming, Chen, and Bai Na. 2012. “An Efficient and Flexible Embedded Memory IP Compiler.” In 2012 International Conference on Cyber-Enabled Distributed Computing and Knowledge Discovery. IEEE. https://doi.org/10.1109/cyberc.2012.52
Minku, Leandro L. 2019. “A Novel Online Supervised Hyperparameter Tuning Procedure Applied to Cross-Company Software Effort Estimation.” Empirical Software Engineering 24 (5): 3153–3204. https://doi.org/10.1007/s10664-019-09686-w
Minku, Leandro L., and Xin Yao. 2013b. “Ensembles and Locality: Insight on Improving Software Effort Estimation.” Information and Software Technology 55 (8): 1512–28. https://doi.org/10.1016/j.infsof.2012.09.012
Minku, Leandro L., and Xin Yao. 2013c. “Software Effort Estimation as a Multiobjective Learning Problem.” ACM Transactions on Software Engineering and Methodology 22 (4): 1–32. https://doi.org/10.1145/2522920.2522928
Mirenkov, N. N. 1987. “Parallel Algorithms and Static Analysis of Parallel Programs.” In Parallel Algorithms and Architectures. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-18099-0_28
Misek, Jakub, and Filip Zavoral. 2017. “Control Flow Ambiguous-Type Inter-Procedural Semantic Analysis for Dynamic Language Compilation.” Procedia Computer Science 109: 955–62. https://doi.org/10.1016/j.procs.2017.05.452
Mishra, Prerna. 2023. “Domain Adaptive Learning for Document Layout Analysis and Object Detection Using Classifier Alignment Mechanism.” Signal Processing: Image Communication 116: 116986. https://doi.org/10.1016/j.image.2023.116986
Mishra, Alok, Abid M. Malik, and Barbara Chapman. 2020. “Extending the LLVM/Clang Framework for OpenMP Metadirective Support.” 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.00009
Misra, Ashitabh, Jacob Laurel, and Sasa Misailovic. 2023. “ViX: Analysis-Driven Compiler for Efficient Low-Precision Variational Inference.” In 2023 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE. https://doi.org/10.23919/date56975.2023.10137324
Mitchell, John. 1984. “Type Inference and Type Containment.” In Semantics of Data Types. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-13346-1_13
Mitsch, Stefan, Marco Gario, Christof J. Budnik, Michael Golm, and André Platzer. 2017. “Formal Verification of Train Control with Air Pressure Brakes.” In Reliability, Safety, and Security of Railway Systems. Modelling, Analysis, Verification, and Certification. Springer International Publishing. https://doi.org/10.1007/978-3-319-68499-4_12
Mitsuishi, T., K. Wasaki, K. Ohkubo, J. Kawabe, and Y. Shidama. 2000. “Fuzzy Optimal Control Using Simple Inference Method and Function Type Inference Method.” In Proceedings of the 2000 American Control Conference. ACC (IEEE Cat. No.00CH36334). IEEE. https://doi.org/10.1109/acc.2000.879541
Mittas, Nikolaos, and Lefteris Angelis. 2020. “Data-Driven Benchmarking in Software Development Effort Estimation: The Few Define the Bulk.” Journal of Software: Evolution and Process 32 (9): e2258. https://doi.org/10.1002/smr.2258
Miyoshi, T., and N. Sugino. 2004. “An Approach to Unified Phase Compiler by Use of 3D Representation Space.” In 2004 IEEE Region 10 Conference TENCON 2004.. IEEE. https://doi.org/10.1109/tencon.2004.1414603
Mizell, Carolyn, and Linda Malone. 2007. “A Project Management Approach to Using Simulation for Cost Estimation on Large, Complex Software Development Projects.” Engineering Management Journal 19 (4): 28–34. https://doi.org/10.1080/10429247.2007.11431746
Mizell, Carolyn, and Linda Malone. 2009. “A Project Management Approach to Using Simulation for Cost Estimation on Large, Complex Software Development Projects.” IEEE Engineering Management Review 37 (2): 92–92. https://doi.org/10.1109/emr.2009.5235459
Mo, Lianguang. 2015. “Research of the Relationship between Industrial Structure and Spatial Layout Based on GIS.” In 2015 International Conference on Intelligent Transportation, Big Data and Smart City. IEEE. https://doi.org/10.1109/icitbs.2015.157
“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
Moechtar, Handy Reypiyandika, Selo Sulistyo, and Ridi Ferdiana. 2024. “A Review on Improving the Accuracy of Effort Estimation in Software Development with Agile Method.” In 2024 11th International Conference on Information Technology, Computer, and Electrical Engineering (ICITACEE). IEEE. https://doi.org/10.1109/icitacee62763.2024.10761956
Mogensen, Torben Ægidius. 2018. “Reversible Garbage Collection for Reversible Functional Languages.” New Generation Computing 36 (3): 203–32. https://doi.org/10.1007/s00354-018-0037-3
Mohamedin, Mohamed, Binoy Ravindran, and Roberto Palmieri. 2013. “ByteSTM: Virtual Machine-Level Java Software Transactional Memory.” In Coordination Models and Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-38493-6_12
Mohammed, Tanko Y., and Mohammed Hamada. 2016. “A Cloud-Based Java Compiler for Smart Devices.” In 2016 15th International Conference on Information Technology Based Higher Education and Training (ITHET). IEEE. https://doi.org/10.1109/ithet.2016.7760742
Mohanty, Hansa, Vaisakh Naduvodi Viswambharan, and Deepak Narayan Gadde. 2025. “Formal That “Floats” High: Formal Verification of Floating Point Arithmetic.” In 2025 37th International Conference on Microelectronics (ICM). IEEE. https://doi.org/10.1109/icm66518.2025.11321329
Moharreri, Kayhan, Alhad Vinayak Sapre, Jayashree Ramanathan, and Rajiv Ramnath. 2016. “Cost-Effective Supervised Learning Models for Software Effort Estimation in Agile Environments.” In 2016 IEEE 40th Annual Computer Software and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac.2016.85
Mohneu, Markus. 1995. “Efficient Compile-Time Garbage Collection for Arbitrary Data Structures.” In Programming Languages: Implementations, Logics and Programs. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0026824
Mokhov, Serguei A., and Joey Paquet. 2010. “A Type System for Higher-Order Intensional Logic Support for Variable Bindings in Hybrid Intensional-Imperative Programs in GIPSY.” In 2010 IEEE/ACIS 9th International Conference on Computer and Information Science. IEEE. https://doi.org/10.1109/icis.2010.156
Mokrinskii, Nikita, Pavel Sharikov, and Andrey Krasov. 2026. “The Technique of Embedding Digital Watermarks in Metadata and Annotations of Kotlin Bytecode.” In 2026 International Russian Smart Industry Conference (SmartIndustryCon). IEEE. https://doi.org/10.1109/smartindustrycon68821.2026.11492892
Molina, C., A. Gonzalez, and J. Tubella. 2005. “Compiler Analysis for Trace-Level Speculative Multithreaded Architectures.” In 9th Annual Workshop on Interaction between Compilers and Computer Architectures (INTERACT’05). IEEE. https://doi.org/10.1109/interact.2005.6
Moller, Mark Lukas, Meike Klettke, and Uta Storl. 2020. “EvoBench – a Framework for Benchmarking Schema Evolution in NoSQL.” In 2020 IEEE International Conference on Big Data (Big Data). IEEE. https://doi.org/10.1109/bigdata50022.2020.9378278
Moløkken, Kjetil. 2003. “Software Effort Estimation: Planning XP Guidelines Compared to Research on Traditional Software Development.” In Extreme Programming and Agile Processes in Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44870-5_77
Moløkken, Kjetil, and Magne Jørgensen. 2005. “Expert Estimation of Web-Development Projects: Are Software Professionals in Technical Roles More Optimistic than Those in Non-Technical Roles?” Empirical Software Engineering 10 (1): 7–30. https://doi.org/10.1023/b:emse.0000048321.46871.2e
Moløkken-Østvold, Kjetil, and Magne Jørgensen. 2004. “Group Processes in Software Effort Estimation.” Empirical Software Engineering 9 (4): 315–34. https://doi.org/10.1023/b:emse.0000039882.39206.5a
Monat, Raphaël. 2026. “Try-Mopsa: Relational Static Analysis in Your Pocket.” In Verification, Model Checking, and Abstract Interpretation. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-15700-3_10
Monat, Raphaël, Abdelraouf Ouadjaout, and Antoine Miné. 2021. “A Multilanguage Static Analysis of Python Programs with Native C Extensions.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-88806-0_16
Monika and Om Prakash Sangwan. 2017. “Software Effort Estimation Using Machine Learning Techniques.” In 2017 7th International Conference on Cloud Computing, Data Science & Engineering - Confluence. IEEE. https://doi.org/10.1109/confluence.2017.7943130
Monniaux, David. 2000. “Abstract Interpretation of Probabilistic Semantics.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-45099-3_17
Monniaux, David. 2003. “Abstract Interpretation of Programs as Markov Decision Processes.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44898-5_13
Monniaux, David. 2024. “Pragmatics of Formally Verified Yet Efficient Static Analysis, in Particular, for Formally Verified Compilers.” International Journal on Software Tools for Technology Transfer 26 (4): 463–77. https://doi.org/10.1007/s10009-024-00760-3
Monsuez, B. 1992. “Polymorphic Typing by Abstract Interpretation.” In Foundations of Software Technology and Theoretical Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-56287-7_107
Monsuez, B. 1995. “System F and Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60360-3_45
Montandon, João Eduardo, Luciana Lourdes Silva, Cristiano Politowski, Ghizlane El Boussaidi, and Marco Tulio Valente. 2023. “Unboxing Default Argument Breaking Changes in Scikit Learn.” In 2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE. https://doi.org/10.1109/scam59687.2023.00030
Montenegro, Manuel, Ricardo Peña, and Jaime Sánchez-Hernández. 2015a. “A Generic Intermediate Representation for Verification Condition Generation.” In Logic-Based Program Synthesis and Transformation. Springer International Publishing. https://doi.org/10.1007/978-3-319-27436-2_14
Montenegro, Manuel, Ricardo Peña, and Clara Segura. 2008. “A Type System for Safe Memory Management and Its Proof of Correctness.” In Proceedings of the 10th international ACM SIGPLAN conference on Principles and practice of declarative programming. ACM. https://doi.org/10.1145/1389449.1389468
Montenegro, Manuel, Ricardo Peña, and Clara Segura. 2015b. “Space Consumption Analysis by Abstract Interpretation: Inference of Recursive Functions.” Science of Computer Programming 111: 426–57. https://doi.org/10.1016/j.scico.2014.04.006
Montenegro, Manuel, Ricardo Peña, and Clara Segura. 2015c. “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
Montenyohl, Margaret, and Mitchell Wand. 1989. “Incorporating Static Analysis in a Combinator-Based Compiler.” Information and Computation 82 (2): 151–84. https://doi.org/10.1016/0890-5401(89)90052-7
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
Moore, Scott, and Stephen Chong. 2011. “Static Analysis for Efficient Hybrid Information-Flow Control.” In 2011 IEEE 24th Computer Security Foundations Symposium. IEEE. https://doi.org/10.1109/csf.2011.17
Morales Huanca, Luis Alberto, and Sussy Bayona Ore. 2017. “Improvement Proposal of the Effort Estimation in Software Projects Using Use Case Points.” In 2017 12th Iberian Conference on Information Systems and Technologies (CISTI). IEEE. https://doi.org/10.23919/cisti.2017.7975928
Morazán, Marco T. 2014. “Bytecode and Memoized Closure Performance.” In Trends in Functional Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-45340-3_4
Moreno-Seco, Francisco, and Mikel L. Forcada. 1996. “Learning Compiler Design as a Research Activity.” Computer Science Education 7 (1): 73–98. https://doi.org/10.1080/0899340960070105
Morgenshtern, Ofer, Tzvi Raz, and Dov Dvir. 2007. “Factors Affecting Duration and Effort Estimation Errors in Software Development Projects.” Information and Software Technology 49 (8): 827–37. https://doi.org/10.1016/j.infsof.2006.09.006
Moritz, Csaba Andras, Matthew I. Frank, and Saman Amarasinghe. 2001. “FlexCache: A Framework for Flexible Compiler Generated Data Caching.” In Intelligent Memory Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44570-6_9
Mork, Peter, Walt Melo, Sylvia Dutcher, Chris Curtis, and Melissa Scroggs. 2014. “Cost Estimation for Model-Driven Interoperability: A Canonical Data Modeling Approach.” In 2014 14th International Conference on Quality Software. IEEE. https://doi.org/10.1109/qsic.2014.51
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
Morrisett, Greg. 2003. “Achieving Type Safety for Low-Level Code.” In Logic Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24599-5_1
Morrisett, Greg, David Walker, Karl Crary, and Neal Glew. 1999. “From System F to Typed Assembly Language.” ACM Transactions on Programming Languages and Systems 21 (3): 527–68. https://doi.org/10.1145/319301.319345
Moser, Simon, Brian Henderson-Sellers, and Vojislav B. Mišić. 1999. “Cost Estimation Based on Business Models.” Journal of Systems and Software 49 (1): 33–42. https://doi.org/10.1016/s0164-1212(99)00064-3
Moser, Georg, and Michael Schaper. 2018. “From Jinja Bytecode to Term Rewriting: A Complexity Reflecting Transformation.” Information and Computation 261: 116–43. https://doi.org/10.1016/j.ic.2018.05.007
Moses, John. 2002. “Measuring Effort Estimation Uncertainty to Improve Client Confidence.” Software Quality Journal 10 (2): 135–48. https://doi.org/10.1023/a:1020523923715
Moses, John, and Malcolm Farrow. 2003. “A Procedure for Assessing the Influence of Problem Domain on Effort Estimation Consistency.” Software Quality Journal 11 (4): 283–300. https://doi.org/10.1023/a:1025861011126
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
Mössenböck, Hanspeter, and Michael Pfeiffer. 2002. “Linear Scan Register Allocation in the Context of SSA Form and Register Constraints.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45937-5_17
Mostoslavski, David, David Mejia, Xuan Wu, and Kamilo Melo. 2026. “Static and Dynamic Dispatch in Robotics Control Loops: A Practical Performance Study in Rust.” In 2026 12th International Conference on Mechatronics and Robotics Engineering (ICMRE). IEEE. https://doi.org/10.1109/icmre69538.2026.11533996
Mountjoy, Jon. 1998. “The Spineless Tagless G-Machine, Naturally.” ACM SIGPLAN Notices 34 (1): 163–73. https://doi.org/10.1145/291251.289439
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
“MSR 2004 International Workshop on Mining Software Repositories.” 2004. In Proceedings. 26th International Conference on Software Engineering. IEEE. https://doi.org/10.1109/icse.2004.1317529
Mu, Wenlong, Yilei Zhang, Bo Huang, Jianmei Guo, and Shiqiang Cui. 2023. “A Hotspot-Driven Semi-Automated Competitive Analysis Framework for Identifying Compiler Key Optimizations.” In Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3578360.3580255
Mueller, Frank. 1995. “Compiler Support for Software-Based Cache Partitioning.” ACM SIGPLAN Notices 30 (11): 125–33. https://doi.org/10.1145/216633.216677
Mukhin, Ilya S., and Elena Yu. Avksentieva. 2026. “Analysis of the Russian-Language Sarcasm Corpus: Surface Signs, Pragmatic Subtypes and Borderline Cases.” In 2026 XXIX International Conference on Soft Computing and Measurements (SCM). IEEE. https://doi.org/10.1109/scm71573.2026.11625869
Muller, Stephan, Lars Butzmann, Kai Howelmeyer, Stefan Klauck, and Hasso Plattner. 2013a. “Efficient View Maintenance for Enterprise Applications in Columnar in-Memory Databases.” In 2013 17th IEEE International Enterprise Distributed Object Computing Conference. IEEE. https://doi.org/10.1109/edoc.2013.35
Muller, Stephan, Lars Butzmann, Stefan Klauck, and Hasso Plattner. 2013b. “Workload-Aware Aggregate Maintenance in Columnar in-Memory Databases.” In 2013 IEEE International Conference on Big Data. IEEE. https://doi.org/10.1109/bigdata.2013.6691699
“Multi-MOS Structure Speeds Layout of VLSI Chips.” 1982. Microelectronics Reliability 22 (4): 903. https://doi.org/10.1016/s0026-2714(82)80280-1
“Multi-MOS Structure Speeds Layout of VLSI Chips.” 1983. Microelectronics Journal 14 (4): 61. https://doi.org/10.1016/s0026-2692(83)80013-5
“MULTIDIMENSIONAL SCHEMA EVOLUTION: Integrating New OLAP Requirements.” 2006. In Proceedings of the Eighth International Conference on Enterprise Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002461303310334
Mun, Hyunho, and Youpyo Hong. 2025. “Adaptive Channel-Aware Garbage Collection Control for Multi-Channel SSDs.” Electronics 14 (23): 4741. https://doi.org/10.3390/electronics14234741
Mun, Chong Kam, G. S. V. R. KrishnaRao, Hai-Shuan Lam, C. Eswaran, and Somnuk Phon-Amnuaisuk. 2007. “Performance Optimization of Java Virtual Machine on Dual-Core Technology for Web Services: A Study.” In The 9th International Conference on Advanced Communication Technology. IEEE. https://doi.org/10.1109/icact.2007.358419
Munjal, Dishant, Jagannath Singh, Subhrakanta Panda, and Durga Prasad Mohapatra. 2015. “Automated Slicing of Aspect-Oriented Programs Using Bytecode Analysis.” In 2015 IEEE 39th Annual Computer Software and Applications Conference. IEEE. https://doi.org/10.1109/compsac.2015.98
Murdaca, Clara. 2009. “An Object-Relational Compiler.” In 2009 WRI World Congress on Computer Science and Information Engineering. IEEE. https://doi.org/10.1109/csie.2009.856
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
Mustafa, Dheya, and Rudolf Eigenmann. 2012. “Portable Section-Level Tuning of Compiler Parallelized Applications.” In 2012 International Conference for High Performance Computing, Networking, Storage and Analysis. IEEE. https://doi.org/10.1109/sc.2012.97
Mustafa, Emtinan I., and Rasha Osman. 2024. “A Random Forest Model for Early-Stage Software Effort Estimation for the SEERA Dataset.” Information and Software Technology 169: 107413. https://doi.org/10.1016/j.infsof.2024.107413
Mustyala, Sarika, and Manjubala Bisi. 2024. “Ensembling Harmony Search Algorithm with Case-Based Reasoning for Software Development Effort Estimation.” Cluster Computing 28 (2): 97. https://doi.org/10.1007/s10586-024-04858-w
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
Myalapalli, Vamsi Krishna, and Sunitha Geloth. 2015. “Minimizing Impact on JAVA Virtual Machine via JAVA Code Optimization.” In 2015 International Conference on Energy Systems and Applications. IEEE. https://doi.org/10.1109/icesa.2015.7503306
Myers, Andrew C. 1995. “Bidirectional Object Layout for Separate Compilation.” ACM SIGPLAN Notices 30 (10): 124–39. https://doi.org/10.1145/217839.217849
Myers, Andrew. 2005. “Making Distributed Systems Secure with Program Analysis and Transformation.” In Proceedings of the 6th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. ACM. https://doi.org/10.1145/1108792.1108805
Myreen, Magnus O., and Jared Davis. 2011. “A Verified Runtime for a Verified Theorem Prover.” In Interactive Theorem Proving. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-22863-6_20
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
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
Na, Geonbae, Jongsu Lim, Sunjun Lee, and Jeong Hyun Yi. 2019. “Mobile Code Anti-Reversing Scheme Based on Bytecode Trapping in ART.” Sensors 19 (11): 2625. https://doi.org/10.3390/s19112625
Nadir, Shahab, Detlef Streitferdt, and Christina Burggraf. 2016. “Industrial Software Developments Effort Estimation Model.” In 2016 International Conference on Computational Science and Computational Intelligence (CSCI). IEEE. https://doi.org/10.1109/csci.2016.0235
Nadjm-Tehrani, Simin, and Jan-Erik Strömberg. 1999. “Formal Verification of Dynamic Properties in an Aerospace Application.” Formal Methods in System Design 14 (2): 135–69. https://doi.org/10.1023/a:1008651801000
Nagata, Akihito, Naoki Kobayashi, and Akinori Yonezawa. 2004. “Region-Based Memory Management for a Dynamically-Typed Language.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30477-7_16
Nagayama, Ryoga, Lu Chen, and Hiroyuki Inaba. 2019. “Digital Watermarks for LLVM Intermediate Representation.” In 2019 IEEE 8th Global Conference on Consumer Electronics (GCCE). IEEE. https://doi.org/10.1109/gcce46687.2019.9015601
Naik, Mayur, and Rajeev Kumar. 1999. “Object-Oriented Symbol Management in Syntax-Directed Compiler Systems.” ACM SIGPLAN Notices 34 (6): 58–67. https://doi.org/10.1145/606666.606677
Najadat, Hassan, Izzat Alsmadi, and Yazan Shboul. 2012. “Predicting Software Projects Cost Estimation Based on Mining Historical Data.” ISRN Software Engineering 2012: 1–8. https://doi.org/10.5402/2012/823437
Najm, Assia, Abdelali Zakrani, and Abdelaziz Marzak. 2019. “Decision Trees Based Software Development Effort Estimation: A Systematic Mapping Study.” In 2019 International Conference of Computer Science and Renewable Energies (ICCSRE). IEEE. https://doi.org/10.1109/iccsre.2019.8807544
Nakamura, Hiroki, Rina Nagano, Kenji Hisazumi, Yasutaka Kamei, Naoyasu Ubayashi, and Akira Fukuda. 2012. “QORAL: An External Domain-Specific Language for Mining Software Repositories.” In 2012 Fourth International Workshop on Empirical Software Engineering in Practice. IEEE. https://doi.org/10.1109/iwesep.2012.20
Nam, Wonhong, and Hyunyoung Kil. 2022. “Formal Verification of Blockchain Smart Contracts via ATL Model Checking.” IEEE Access 10: 8151–62. https://doi.org/10.1109/access.2022.3143145
Namaziandost, Ehsan, Tahereh Heydarnejad, and Ahmad Goodarzi. 2025. “Unboxing the Gifts of WhatsApp in Language Learning: Magnifying the Impacts on English Achievement, Academic Engagement, Foreign Language Anxiety, and Learner Autonomy.” Smart Learning Environments 12 (1): 28. https://doi.org/10.1186/s40561-025-00383-4
Nambiar, Sindhya K., and Sumam Mary Idicula. 2013. “A Multi-Agent Vehicle Routing System for Garbage Collection.” In 2013 Fifth International Conference on Advanced Computing (ICoAC). IEEE. https://doi.org/10.1109/icoac.2013.6921930
Nandivada, V. Krishna, and Jens Palsberg. 2006. “SARA: Combining Stack Allocation and Register Allocation.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/11688839_19
Nanevski, Aleksandar, Greg Morrisett, and Lars Birkedal. 2006. “Polymorphism and Separation in Hoare Type Theory.” In Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/1159803.1159812
Nanri, Takeshi, Hiroyuki Sato, and Masaaki Shimasaki. 1997. “Cost Estimation of Coherence Protocols of Software Managed Cache on Distributed Shared Memory System.” In High Performance Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0024228
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
Narappa, Anvaya B., Federico Parola, Shixiong Qi, and K. K. Ramakrishnan. 2024. “Z-Stack: A High-Performance DPDK-Based Zero-Copy TCP/IP Protocol Stack.” In 2024 IEEE 30th International Symposium on Local and Metropolitan Area Networks (LANMAN). IEEE. https://doi.org/10.1109/lanman61958.2024.10621881
Narasimhan, Krishna, Christoph Reichenbach, and Julia Lawall. 2017. “Interactive Data Representation Migration: Exploiting Program Dependence to Aid Program Transformation.” In Proceedings of the 2017 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation. ACM. https://doi.org/10.1145/3018882.3018890
Narendra, Nanjangud C., Karthikeyan Ponnalagu, Nianjun Zhou, and Wesley M. Gifford. 2012. “Towards a Formal Model for Optimal Task-Site Allocation and Effort Estimation in Global Software Development.” In 2012 Annual SRII Global Conference. IEEE. https://doi.org/10.1109/srii.2012.58
Narodytska, Nina. 2018. “Formal Verification of Deep Neural Networks.” In 2018 Formal Methods in Computer Aided Design (FMCAD). IEEE. https://doi.org/10.23919/fmcad.2018.8603017
Naseer, Asma, Tanzeela Shakeel, Kinza Arshad, and Zeenia Ather. 2021. “Analysis of Corpus Development for Urdu Language.” In 2021 International Conference on Innovative Computing (ICIC). IEEE. https://doi.org/10.1109/icic53490.2021.9693048
Nasr, Ehsan, and Keyvan Mohebbi. 2023. “Enhancing Software Effort Estimation with an Integrated Approach of Particle Swarm Optimization and Genetic Algorithms in Analogy-Based Method.” In 2023 14th International Conference on Information and Knowledge Technology (IKT). IEEE. https://doi.org/10.1109/ikt62039.2023.10433026
Nassif, Ali Bou, Mohammad Azzeh, Luiz Fernando Capretz, and Danny Ho. 2013. “A Comparison between Decision Trees and Decision Tree Forest Models for Software Development Effort Estimation.” In 2013 Third International Conference on Communications and Information Technology (ICCIT). IEEE. https://doi.org/10.1109/iccitechnology.2013.6579553
Nassif, Ali Bou, Luiz Fernando Capretz, Danny Ho, and Mohammad Azzeh. 2012. “A Treeboost Model for Software Effort Estimation Based on Use Case Points.” In 2012 11th International Conference on Machine Learning and Applications. IEEE. https://doi.org/10.1109/icmla.2012.155
Naur, Peter. 1963a. “The Design of the GIER ALGOL Compiler Part I.” BIT 3 (2): 124–40. https://doi.org/10.1007/bf01935579
Naur, Peter. 1963b. “The Design of the GIER ALGOL Compiler Part II.” BIT 3 (3): 145–66. https://doi.org/10.1007/bf01939983
Naur, Peter. 1964. “The Design of the GIER ALGOL Compiler.” Annual Review in Automatic Programming 4: 49–85. https://doi.org/10.1016/0066-4138(64)90014-x
Naylor, Matthew, and Simon W. Moore. 2014. “Rapid Codesign of a Soft Vector Processor and Its Compiler.” In 2014 24th International Conference on Field Programmable Logic and Applications (FPL). IEEE. https://doi.org/10.1109/fpl.2014.6927425
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
Negrini, Luca, Vincenzo Arceri, Pietro Ferrara, and Agostino Cortesi. 2021. “Twinning Automata and Regular Expressions for String Static Analysis.” In Verification, Model Checking, and Abstract Interpretation. Springer International Publishing. https://doi.org/10.1007/978-3-030-67067-2_13
“NerveCenter: (1) Conflict of Interest: Research Lapses Draw Front-Page Attention (2) Announcements from the American Neurological Association.” 2008. Annals of Neurology 63 (5). https://doi.org/10.1002/ana.21257
Nesi, P., and T. Querci. 1998. “Effort Estimation and Prediction of Object-Oriented Systems.” Journal of Systems and Software 42 (1): 89–102. https://doi.org/10.1016/s0164-1212(97)10021-8
Nettles, Scott, and James O’Toole. 1993. “Real-Time Replication Garbage Collection.” ACM SIGPLAN Notices 28 (6): 217–26. https://doi.org/10.1145/173262.155111
Neufeld, G. N., and Y. Yang. 1990. “The Design and Implementation of an ASN.1-C Compiler.” IEEE Transactions on Software Engineering 16 (10): 1209–20. https://doi.org/10.1109/32.60300
“The Next Generation of Compilers.” 2009. In 2009 International Symposium on Code Generation and Optimization. IEEE. https://doi.org/10.1109/cgo.2009.37
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
Nezzari, Y., and C. P. Bridges. 2018. “Modelling Processor Reliability Using LLVM Compiler Fault Injection.” In 2018 IEEE Aerospace Conference. IEEE. https://doi.org/10.1109/aero.2018.8396489
Ng, Nyx L., Dillon M. Luke, and Bertram Gawronski. 2023. “Moral Judgment under Uncertainty: A CNI Model Analysis.” European Journal of Social Psychology 53 (6): 1055–77. https://doi.org/10.1002/ejsp.2952
Ngo, Van Chan, Jean-Pierre Talpin, Thierry Gautier, Paul Le Guernic, and Loïc Besnard. 2012. “Formal Verification of Compiler Transformations on Polychronous Equations.” In Integrated Formal Methods. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-30729-4_9
Nguyen, Vu. 2010. “Improved Size and Effort Estimation Models for Software Maintenance.” In 2010 IEEE International Conference on Software Maintenance. IEEE. https://doi.org/10.1109/icsm.2010.5609554
Nguyen, Viet Anh, Damien Hardy, and Isabelle Puaut. 2019a. “Cache-Conscious off-Line Real-Time Scheduling for Multi-Core Platforms: Algorithms and Implementation.” Real-Time Systems 55 (4): 810–49. https://doi.org/10.1007/s11241-019-09333-z
Nguyen, Trung N., Zhiyuan Li’, and David J. Lilja. 1993. “Efficient Use of Dynamically Tagged Directories through Compiler Analysis.” In 1993 International Conference on Parallel Processing - ICPP’93 Vol2. IEEE. https://doi.org/10.1109/icpp.1993.75
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
Nguyen, Huu-Duc, and Atsushi Ohori. 2006. “Compiling ML Polymorphism with Explicit Layout Bitmap.” In Proceedings of the 8th ACM SIGPLAN international conference on Principles and practice of declarative programming. ACM. https://doi.org/10.1145/1140335.1140364
Nguyen, G. T., and D. Rieu. 1989. “Schema Evolution in Object-Oriented Database Systems.” Data & Knowledge Engineering 4 (1): 43–67. https://doi.org/10.1016/0169-023x(89)90004-9
Ni, Youcong, Xin Du, Liyan Song, Ruliang Xiao, Peng Ye, and Jianwen Wang. 2024. “A Two-Stage LLVM Option Sequence Optimization Method to Minimize Energy Consumption.” Swarm and Evolutionary Computation 88: 101591. https://doi.org/10.1016/j.swevo.2024.101591
Niang, Mohamed, Alexandre Philippot, François Gellot, Raphaël Coupat, Bernard Riera, and Sébastien Lefebvre. 2017. “Formal Verification for Validation of PSEEL’s PLC Program.” In Proceedings of the 14th International Conference on Informatics in Control, Automation and Robotics. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006418705670574
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
Nicolaescu, Dan, Xiaomei Ji, Alexander Veidenbaum, Alexandru Nicolau, and Rajesh Gupta. 2001. “Compiler-Directed Cache Line Size Adaptivity ⋆.” In Intelligent Memory Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44570-6_15
Nicolosi, Niccolò, Gabriele Magnani, Emilio Corigliano, Davide Baroffio, Federico Reghenzani, and Giovanni Agosta. 2026. “Type Deduction Analysis: Reconstructing Transparent Pointer Types in LLVM-IR.” In Proceedings of the 35th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3771775.3786268
Nie, Yinyu, Xiaoguang Han, Shihui Guo, Yujian Zheng, Jian Chang, and Jian Jun Zhang. 2020. “Total3DUnderstanding: Joint Layout, Object Pose and Mesh Reconstruction for Indoor Scenes from a Single Image.” In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE. https://doi.org/10.1109/cvpr42600.2020.00013
Nielsen, Ivan Riis. 1995. “A C-T Filter Compiler: From Specifications to Layout.” Analog Integrated Circuits and Signal Processing 7 (1): 21–33. https://doi.org/10.1007/bf01256444
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
Niewiadomski, Robert, José Nelson Amaral, and Robert C. Holte. 2004. “A Performance Study of Data Layout Techniques for Improving Data Locality in Refinement-Based Pathfinding.” ACM Journal of Experimental Algorithmics 9. https://doi.org/10.1145/1005813.1041511
Nikanjam, Amin, and Foutse Khomh. 2021. “Design Smells in Deep Learning Programs: An Empirical Study.” In 2021 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE. https://doi.org/10.1109/icsme52107.2021.00036
Ņikiforova, Oksana, Vitaly Zabiniako, Jurijs Kornienko, Pāvels Garkalns, Ruslan Rizhko, and Madara Gasparoviča-Asīte. 2022. “Solution to CAD Designer Effort Estimation Based on Analogy with Software Development Metrics.” 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/0011032700003176
Nikith, Boda Venkata, Shaik Reeha, G. Mani Prakash Reddy, and Meena Belwal. 2024. “An Experimental Analysis of RL Based Compiler Optimization Techniques Using Compiler GYM.” In 2024 IEEE 9th International Conference for Convergence in Technology (I2CT). IEEE. https://doi.org/10.1109/i2ct61223.2024.10543642
Nilsen, Kelvin. 1995. “Progress in Hardware-Assisted Real-Time Garbage Collection.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_34
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
Ning, Zhuorui, Naijie Gu, Junjie Su, and Dongsheng Qi. 2022. “STAFF: A Model for Structure Layout Optimization.” In 2022 7th International Conference on Computer and Communication Systems (ICCCS). IEEE. https://doi.org/10.1109/icccs55155.2022.9846314
Ning, Yuqiao, Yanan Zhang, Chao Ma, Zhen Guo, and Longhai Yu. 2024. “Empirical Study of Software Composition Analysis Tools for C/C++ Binary Programs.” IEEE Access 12: 50418–30. https://doi.org/10.1109/access.2023.3341224
Ning, Zhang, Chunyu Zhang, Yang Xia, and Guangze Xiong. 2008. “A Hybrid Distributed Garbage Collection of Active Objects.” In 2008 International Conference on Embedded Software and Systems Symposia. IEEE. https://doi.org/10.1109/icess.symposia.2008.63
Nipkow, Tobias. 1990. “Formal Verification of Data Type Refinement — Theory and Practice.” In Stepwise Refinement of Distributed Systems Models, Formalisms, Correctness. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-52559-9_79
Nipkow, Tobias. 2001. “Verified Bytecode Verifiers.” In Foundations of Software Science and Computation Structures. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45315-6_23
Nipkow, Tobias. 2003. “Java Bytecode Verification.” Journal of Automated Reasoning 30 (3–4): 233–233. https://doi.org/10.1023/a:1025086804452
Nisar, M. W., Yong-Ji Wang, and M. Elahi. 2008. “Software Development Effort Estimation Using Fuzzy Logic: A Survey.” In 2008 Fifth International Conference on Fuzzy Systems and Knowledge Discovery. IEEE. https://doi.org/10.1109/fskd.2008.370
Nishanov, Gor V., and Sibylle Schupp. 1998. “Garbage Collection in Generic Libraries.” ACM SIGPLAN Notices 34 (3): 86–96. https://doi.org/10.1145/301589.286870
Nitze, Andre, Andreas Schmietendorf, and Reiner Dumke. 2014. “An Analogy-Based Effort Estimation Approach for Mobile Application Development Projects.” In 2014 Joint Conference of the International Workshop on Software Measurement and the International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm.mensura.2014.9
Niu, Junpeng, Jun Xu, and Lihua Xie. 2017. “Optimal Selection of Garbage Collection Dirty Threshold to Balance Power Consumption and Space Release.” In 2017 Chinese Automation Congress (CAC). IEEE. https://doi.org/10.1109/cac.2017.8243897
Nolan, Andy J., and Silvia Abrahão. 2010. “Dealing with Cost Estimation in Software Product Lines: Experiences and Future Directions.” In Software Product Lines: Going Beyond. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-15579-6_9
Noonan, Matt, Alexey Loginov, and David Cok. 2016. “Polymorphic Type Inference for Machine Code.” In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2908080.2908119
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
Norris, C., and L. L. Pollock. 1995. “An Experimental Study of Several Cooperative Register Allocation and Instruction Scheduling Strategies.” In Proceedings of the 28th Annual International Symposium on Microarchitecture. IEEE. https://doi.org/10.1109/micro.1995.476824
Notkin, David. 2002. “Longitudinal Program Analysis.” In Proceedings of the 2002 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. ACM. https://doi.org/10.1145/586094.586095
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
Noy, Natalya F., and Michel Klein. 2004. “Ontology Evolution: Not the Same as Schema Evolution.” Knowledge and Information Systems 6 (4): 428–40. https://doi.org/10.1007/s10115-003-0137-2
Nugroho, Yosep Novento, Dana Sulistyo Kusumo, and Muhammad Johan Alibasa. 2022. “Clean Architecture Implementation Impacts on Maintainability Aspect for Backend System Code Base.” In 2022 10th International Conference on Information and Communication Technology (ICoICT). IEEE. https://doi.org/10.1109/icoict55009.2022.9914890
Nunes, Paulo, Iberia Medeiros, Jose Fonseca, Nuno Neves, Miguel Correia, and Marco Vieira. 2017. “On Combining Diverse Static Analysis Tools for Web Security: An Empirical Study.” In 2017 13th European Dependable Computing Conference (EDCC). IEEE. https://doi.org/10.1109/edcc.2017.16
Nunes, Paulo, Ibéria Medeiros, José Fonseca, Nuno Neves, Miguel Correia, and Marco Vieira. 2018. “An Empirical Study on Combining Diverse Static Analysis Tools for Web Security Vulnerabilities Based on Development Scenarios.” Computing 101 (2): 161–85. https://doi.org/10.1007/s00607-018-0664-z
Nyamawe, Ally S. 2023. “Research on Mining Software Repositories to Facilitate Refactoring.” WIREs Data Mining and Knowledge Discovery 13 (5): e1508. https://doi.org/10.1002/widm.1508
O’Brien, Liam. 2009. “A Framework for Scope, Cost and Effort Estimation for Service Oriented Architecture (SOA) Projects.” In 2009 Australian Software Engineering Conference. IEEE. https://doi.org/10.1109/aswec.2009.35
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’Connor, J. M., and M. Tremblay. 1997. “picoJava-I: The Java Virtual Machine in Hardware.” IEEE Micro 17 (2): 45–53. https://doi.org/10.1109/40.592314
O’Leary, John, Roope Kaivola, and Tom Melham. 2013. “Relational STE and Theorem Proving for Formal Verification of Industrial Circuit Designs.” In 2013 Formal Methods in Computer-Aided Design. IEEE. https://doi.org/10.1109/fmcad.2013.6679397
O’Toole, James, and Scott Nettles. 1994. “Concurrent Replicating Garbage Collection.” ACM SIGPLAN Lisp Pointers VII (3): 34–42. https://doi.org/10.1145/182590.182425
Ochodek, M., J. Nawrocki, and K. Kwarciak. 2011. “Simplifying Effort Estimation Based on Use Case Points.” Information and Software Technology 53 (3): 200–213. https://doi.org/10.1016/j.infsof.2010.10.005
Ofir, Chezy. 1988. “Pseudodiagnosticity in Judgment under Uncertainty.” Organizational Behavior and Human Decision Processes 42 (3): 343–63. https://doi.org/10.1016/0749-5978(88)90005-2
Ogawa, Hirotaka, Kouya Shimura, Satoshi Matsuoka, Fuyuhiko Maruyama, Yukihiko Sohda, and Yasunori Kimura. 2000. “OpenJIT: An Open-Ended, Reflective JIT Compiler Framework for Java.” In ECOOP 2000 — Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45102-1_18
Oh, Hakjoo, and Kwangkeun Yi. 2013. “Access-Based Abstract Memory Localization in Static Analysis.” Science of Computer Programming 78 (9): 1701–27. https://doi.org/10.1016/j.scico.2013.04.002
Ohlsson, M. C., C. Wohlin, and B. Regnell. 1998. “A Project Effort Estimation Study.” Information and Software Technology 40 (14): 831–39. https://doi.org/10.1016/s0950-5849(98)00097-4
Ohn, Kyungoh, and Haengrae Cho. 2004. “Cache Conscious Dynamic Transaction Routing in a Shared Disks Cluster.” In Computational Science and Its Applications – ICCSA 2004. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24767-8_57
Ohori, Atsushi. 1992. “A Compilation Method for ML-Style Polymorphic Record Calculi.” In Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘92. ACM Press. https://doi.org/10.1145/143165.143200
Ohori, Atsushi. 1995. “A Polymorphic Record Calculus and Its Compilation.” ACM Transactions on Programming Languages and Systems 17 (6): 844–95. https://doi.org/10.1145/218570.218572
Ohori, Atsushi. 2004. “Register Allocation by Proof Transformation.” Science of Computer Programming 50 (1–3): 161–87. https://doi.org/10.1016/j.scico.2004.01.005
Ohori, Atsushi, and Nobuaki Yoshida. 1999. “Type Inference with Rank 1 Polymorphism for Type-Directed Compilation of ML.” ACM SIGPLAN Notices 34 (9): 160–71. https://doi.org/10.1145/317765.317796
Ohsugi, Naoki, Masateru Tsunoda, Akito Monden, and Ken-ichi Matsumoto. 2004. “Effort Estimation Based on Collaborative Filtering.” In Product Focused Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24659-6_20
Oi, Hitoshi. 2005. “On the Design of the Local Variable Cache in a Hardware Translation-Based Java Virtual Machine.” ACM SIGPLAN Notices 40 (7): 87–94. https://doi.org/10.1145/1070891.1065923
Oi, Hitoshi. 2008. “Local Variable Access Behavior of a Hardware-Translation Based Java Virtual Machine.” Journal of Systems and Software 81 (11): 2059–68. https://doi.org/10.1016/j.jss.2008.03.057
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
Oliveira, Adriano L. I., Petronio L. Braga, Ricardo M. F. Lima, and Márcio L. Cornélio. 2010. “GA-Based Method for Feature Selection and Parameters Optimization for Machine Learning Regression Applied to Software Effort Estimation.” Information and Software Technology 52 (11): 1155–66. https://doi.org/10.1016/j.infsof.2010.05.009
Omural, Neslihan Kucukates, and Onur Demirors. 2017. “Effort Estimation for ERP Projects — A Systematic Review.” In 2017 43rd Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2017.68
Ong, Theng Theng. 2025. “A Corpus-Assisted Analysis of Language Convergence and Meaning Divergence of ‘Mental Health’ in Asian Countries.” Language and Health 3 (2): 100053. https://doi.org/10.1016/j.laheal.2025.100053
Onishi, Rina, Takashi Hoshino, and Hideyuki Kawashima. 2022. “EPO-R: An Efficient Garbage Collection Scheme for Long-Term Transactions.” In 2022 Tenth International Symposium on Computing and Networking (CANDAR), vol. 15. IEEE. https://doi.org/10.1109/candar57322.2022.00027
Ono, Kenichi, Masateru Tsunoda, Akito Monden, and Kenichi Matsumoto. 2016. “Influence of Outliers on Analogy Based Software Development Effort Estimation.” In 2016 IEEE/ACIS 15th International Conference on Computer and Information Science (ICIS). IEEE. https://doi.org/10.1109/icis.2016.7550865
“Open and Dynamic Schema Evolution in Content-Intensive Web Applications.” 2006. In Proceedings of WEBIST 2006 - Second International Conference on Web Information Systems and Technologies. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0001255501090116
Orford, Jim. 2002. “Potential Conflict of Interest in Gambling Research.” Addiction 97 (5): 600–601. https://doi.org/10.1046/j.1360-0443.2002.t01-6-00134.x
Orlando, Tancredi, Michele Arena, Luca D’Agati, Giovanni Merlino, and Francesco Longo. 2025. “Secure and Flexible WebAssembly Deployment Infrastructure for Automotive Cyber-Physical Systems.” In 2025 IEEE 31st International Symposium on On-Line Testing and Robust System Design (IOLTS). IEEE. https://doi.org/10.1109/iolts65288.2025.11116815
Osada, Shigeyuki, Kazutoshi Kajita, Yukinobu Fukushima, and Tokumi Yokohira. 2013. “TCP Incast Avoidance Based on Connection Serialization in Data Center Networks.” In 2013 19th Asia-Pacific Conference on Communications (APCC). IEEE. https://doi.org/10.1109/apcc.2013.6765931
Österlund, Erik, and Welf Löwe. 2012. “Analysis of Pure Methods Using Garbage Collection.” In Proceedings of the 2012 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness. ACM. https://doi.org/10.1145/2247684.2247694
Otrompke, John. 2003. “Navigating US Conflict-of-Interest Rules When Commercializing Research.” Bioentrepreneur. https://doi.org/10.1038/bioent760
Ott, Jordan, Abigail Atchison, and Erik J. Linstead. 2019. “Exploring the Applicability of Low-Shot Learning in Mining Software Repositories.” Journal of Big Data 6 (1): 35. https://doi.org/10.1186/s40537-019-0198-z
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, Noureddine Lasla, Miloud Bagaa, and Nadjib Badache. 2014. “Poster Abstract: Static Analysis of Device Drivers in TinyOS.” In IPSN-14 Proceedings of the 13th International Symposium on Information Processing in Sensor Networks. IEEE. https://doi.org/10.1109/ipsn.2014.6846771
Ouadjaout, Abdelraouf, and Antoine Miné. 2017. “Quantitative Static Analysis of Communication Protocols Using Abstract Markov Chains.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-66706-5_14
Ouadjaout, Abdelraouf, and Antoine Miné. 2019. “Quantitative Static Analysis of Communication Protocols Using Abstract Markov Chains.” Formal Methods in System Design 54 (1): 64–109. https://doi.org/10.1007/s10703-019-00331-2
Ouadjaout, Abdelraouf, and Antoine Miné. 2020. “A Library Modeling Language for the Static Analysis of C Programs.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-65474-0_11
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
Ouh, Eng Lieh, and Benjamin Kok Siew Gan. 2023. “An Exploratory Study of Architectural Style and Effort Estimation for Multi-Tenant Microservices-Based Software as a Service (SaaS).” In 2023 IEEE 20th International Conference on Software Architecture Companion (ICSA-C). IEEE. https://doi.org/10.1109/icsa-c57050.2023.00043
Ould Biha, Sidi. 2011. “A Formal Semantics of PLC Programs in Coq.” In 2011 IEEE 35th Annual Computer Software and Applications Conference. IEEE. https://doi.org/10.1109/compsac.2011.23
Owais, Mohd., and R. Ramakishore. 2016. “Effort, Duration and Cost Estimation in Agile Software Development.” In 2016 Ninth International Conference on Contemporary Computing (IC3). IEEE. https://doi.org/10.1109/ic3.2016.7880216
Owicki, Susan. 1981. “Making the World Safe for Garbage Collection.” In Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘81. ACM Press. https://doi.org/10.1145/567532.567539
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
Ozdemir, Alex, Riad S. Wahby, Fraser Brown, and Clark Barrett. 2025. “Bounded Verification for Finite-Field-Blasting in a Compiler for Zero Knowledge Proofs.” Formal Methods in System Design 67 (2): 161–88. https://doi.org/10.1007/s10703-025-00476-3
Ozen, Guray, Simone Atzeni, Michael Wolfe, Annemarie Southwell, and Gary Klimowicz. 2018. “OpenMP GPU Offload in Flang and LLVM.” In 2018 IEEE/ACM 5th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc.2018.8639434
Ozkan, Baris, Oktay Turetken, and Onur Demirors. 2008. “Software Functional Size: For Cost Estimation and More.” In Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-85936-9_6
Öztürk, Fatih, Erdem Sarılı, Hasan Sözer, and Barış Aktemur. 2014. “Effort Estimation for Architectural Refactoring to Introduce Module Isolation.” In Software Architecture. Springer International Publishing. https://doi.org/10.1007/978-3-319-09970-5_26
Paek, Yunheung, Jay Hoeflinger, and David Padua. 1998. “Simplification of Array Access Patterns for Compiler Optimizations.” In Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/277650.277664
Pai, Dinesh R., Kevin S. McFall, and Girish H. Subramanian. 2013. “Software Effort Estimation Using a Neural Network Ensemble.” Journal of Computer Information Systems 53 (4): 49–58. https://doi.org/10.1080/08874417.2013.11645650
Paik, Incheon, and Jun-Wei Wang. 2021. “Improving Text-to-Code Generation with Features of Code Graph on GPT-2.” Electronics 10 (21): 2706. https://doi.org/10.3390/electronics10212706
Pal, Nisha, Mahendra Pratap Yadav, and Dharmendra Kumar Yadav. 2023. “Appropriate Number of Analogues in Analogy Based Software Effort Estimation Using Quality Datasets.” Cluster Computing 27 (1): 531–46. https://doi.org/10.1007/s10586-023-03967-2
Palermo, Daniel J., Eugene W. Hodges, and Prithviraj Banerjee. 2001. “Compiler Optimization of Dynamic Data Distributions for Distributed-Memory Multicomputers.” In Compiler Optimizations for Scalable Parallel Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45403-9_13
Palsberg, J. 1996. “Compiler Technology for Object-Oriented Languages.” ACM Computing Surveys 28 (4es): 161. https://doi.org/10.1145/242224.242428
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
Panainte, Elena Moscu, Koen Bertels, and Stamatis Vassiliadis. 2004. “The PowerPC Backend Molen Compiler.” In Field Programmable Logic and Application. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30117-2_45
Pandey, Manish. 2016. “Machine Learning and Systems for the Next Frontier in Formal Verification.” In 2016 Formal Methods in Computer-Aided Design (FMCAD). IEEE. https://doi.org/10.1109/fmcad.2016.7886650
Panigrahi, Priyanka, and Chandan Karfa. 2023. “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
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
Papalitsas, Christos, and Theodore Andronikos. 2019. “Unconventional GVNS for Solving the Garbage Collection Problem with Time Windows.” Technologies 7 (3): 61. https://doi.org/10.3390/technologies7030061
Papalitsas, Christos, Panayiotis Karakostas, Theodore Andronikos, Spyros Sioutas, and Konstantinos Giannakis. 2018. “Combinatorial GVNS (General Variable Neighborhood Search) Optimization for Dynamic Garbage Collection.” Algorithms 11 (4): 38. https://doi.org/10.3390/a11040038
Papastefanatos, George, Fotini Anagnostou, Yannis Vassiliou, and Panos Vassiliadis. 2008. “Hecataeus: A What-If Analysis Tool for Database Schema Evolution.” In 2008 12th European Conference on Software Maintenance and Reengineering. IEEE. https://doi.org/10.1109/csmr.2008.4493341
Papastefanatos, George, Panos Vassiliadis, Alkis Simitsis, and Yannis Vassiliou. 2010. “HECATAEUS: Regulating Schema Evolution.” In 2010 IEEE 26th International Conference on Data Engineering (ICDE 2010). IEEE. https://doi.org/10.1109/icde.2010.5447778
Paquet, Joey, Aihua Wu, and Peter Grogono. 2004. “Towards a Framework for the General Intensional Programming Compiler in the GIPSY.” In Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications. ACM. https://doi.org/10.1145/1028664.1028731
Parillaud, Camille, Yoann Fonteneau, and Fabien Belmonte. 2019. “Interlocking Formal Verification at Alstom Signalling.” In Reliability, Safety, and Security of Railway Systems. Modelling, Analysis, Verification, and Certification. Springer International Publishing. https://doi.org/10.1007/978-3-030-18744-6_14
Parízek, Pavel, and Ondřej Lhoták. 2015. “Model Checking of Concurrent Programs with Static Analysis of Field Accesses.” Science of Computer Programming 98: 735–63. https://doi.org/10.1016/j.scico.2014.10.008
Park, Heejun, and Seung Baek. 2008. “An Empirical Validation of a Neural Network Model for Software Effort Estimation.” Expert Systems with Applications 35 (3): 929–37. https://doi.org/10.1016/j.eswa.2007.08.001
Park, Chanhyun, Miseon Han, Hokyoon Lee, and Seon Wook Kim. 2014. “Performance Comparison of GCC and LLVM on the EISC Processor.” In 2014 International Conference on Electronics, Information and Communications (ICEIC). IEEE. https://doi.org/10.1109/elinfocom.2014.6914394
Park, Jung Kyu, and Jaeho Kim. 2017. “A Method for Reducing Garbage Collection Overhead of SSD Using Machine Learning Algorithms.” In 2017 International Conference on Information and Communication Technology Convergence (ICTC). IEEE. https://doi.org/10.1109/ictc.2017.8190778
Park, Hyunchan, Youngpil Kim, and Seehwan Yoo. 2020. “AvaTar: Zero-Copy Archiving with New Kernel-Level Operations.” IEEE Access 8: 59315–25. https://doi.org/10.1109/access.2020.2982688
Park, Jinpyo, Je-Hyung Lee, and Soo-Mook Moon. 2001. “Register Allocation for Banked Register File.” ACM SIGPLAN Notices 36 (8): 39–47. https://doi.org/10.1145/384196.384205
Park, Jiwoong, Cheolgi Min, Heon Young Yeom, and Yongseok Son. 2019. “z-READ: Towards Efficient and Transparent Zero-Copy Read.” In 2019 IEEE 12th International Conference on Cloud Computing (CLOUD). IEEE. https://doi.org/10.1109/cloud.2019.00066
Park, Jiwoong, Cheolgi Min, Heonyoung Yeom, and Yongseok Son. 2024. “Design and Implementation of Efficient and Transparent Zero Copy Read.” IEEE Access 12: 174078–93. https://doi.org/10.1109/access.2024.3502688
Park, Pyung Koo, Seong Moon, Seungwoo Hong, and TaeYeon Kim. 2022b. “Experimental Study of Zero-Copy Performance for Immersive Streaming Service in Linux.” In 2022 13th International Conference on Information and Communication Technology Convergence (ICTC). IEEE. https://doi.org/10.1109/ictc55196.2022.9952985
Park, Sangcheol, Suhwan Park, Jin-Ku Kang, and Yongwoo Kim. 2025. “FPGA-Accelerated Neural Network Inference via a μkernel-Enabled Bytecode Interpreter.” In 2025 22nd International SoC Design Conference (ISOCC). IEEE. https://doi.org/10.1109/isocc66390.2025.11329603
Park, N., and V. K. Prasanna. 2004. “Dynamic Data Layouts for Cache-Conscious Implementation of a Class of Signal Transforms.” IEEE Transactions on Signal Processing 52 (7): 2120–34. https://doi.org/10.1109/tsp.2004.828946
Parnin, Chris, Christian Bird, and Emerson Murphy-Hill. 2012. “Adoption and Use of Java Generics.” Empirical Software Engineering 18 (6): 1047–89. https://doi.org/10.1007/s10664-012-9236-6
Parvez, Abu Wahid Md. Masud. 2013. “Efficiency Factor and Risk Factor Based User Case Point Test Effort Estimation Model Compatible with Agile Software Development.” In 2013 International Conference on Information Technology and Electrical Engineering (ICITEE). IEEE. https://doi.org/10.1109/iciteed.2013.6676222
PašaliΕ, Emir, Walid Taha, and Tim Sheard. 2002. “Tagless Staged Interpreters for Typed Languages.” ACM SIGPLAN Notices 37 (9): 218–29. https://doi.org/10.1145/583852.581499
Păsăreanu, Corina S., Willem Visser, David Bushnell, Jaco Geldenhuys, Peter Mehlitz, and Neha Rungta. 2013. “Symbolic PathFinder: Integrating Symbolic Execution with Model Checking for Java Bytecode Analysis.” Automated Software Engineering 20 (3): 391–425. https://doi.org/10.1007/s10515-013-0122-2
Pashchenko, Ivan, Stanislav Dashevskyi, and Fabio Massacci. 2017. “Delta-Bench: Differential Benchmark for Static Analysis Security Testing Tools.” In 2017 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). IEEE. https://doi.org/10.1109/esem.2017.24
Pasuksmit, Jirat, Patanamon Thongtanunam, and Shanika Karunasekera. 2021. “Towards Just-Enough Documentation for Agile Effort Estimation: What Information Should Be Documented?” In 2021 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE. https://doi.org/10.1109/icsme52107.2021.00017
Pathak, Pushparaj, Hong Zhao, Zhongcheng Gong, et al. 2010. “Real-Time Tagless Monitoring of Cell Viability Using Patch-Clamp Microdevices.” In 2010 IEEE Sensors. IEEE. https://doi.org/10.1109/icsens.2010.5690086
Patil, Arati, and S. S. Redekar. 2025. “Enhancing Neural Style Transfer for Multi-Style and Semantic Preservation.” In 2025 5th Asian Conference on Innovation in Technology (ASIANCON). IEEE. https://doi.org/10.1109/asiancon66527.2025.11280691
Patni, Sagar, Jobin George, Pratik Lahoti, and Jibi Abraham. 2015. “A Zero-Copy Fast Channel for Inter-Guest and Guest-Host Communication Using VirtIO-Serial.” In 2015 1st International Conference on Next Generation Computing Technologies (NGCT). IEEE. https://doi.org/10.1109/ngct.2015.7375072
Patros, Panagiotis, Kenneth B. Kent, and Michael Dawson. 2017. “Investigating the Effect of Garbage Collection on Service Level Objectives of Clouds.” In 2017 IEEE International Conference on Cluster Computing (CLUSTER). IEEE. https://doi.org/10.1109/cluster.2017.74
Patros, Panagiotis, Kenneth B. Kent, and Michael Dawson. 2018. “Mitigating Garbage Collection Interference on Containerized Clouds.” In 2018 IEEE 12th International Conference on Self-Adaptive and Self-Organizing Systems (SASO). IEEE. https://doi.org/10.1109/saso.2018.00029
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
Paulino, Hervé, and Nuno Delgado. 2016. “Cache-Conscious Run-Time Decomposition of Data Parallel Computations.” Journal of Supercomputing 73 (8): 3366–90. https://doi.org/10.1007/s11227-016-1721-z
Payet, Étienne, and Fausto Spoto. 2012. “Static Analysis of Android Programs.” Information and Software Technology 54 (11): 1192–1201. https://doi.org/10.1016/j.infsof.2012.05.003
Payrits, Szabolcs, Peter Dornbach, and Istvan Zolyomi. 2006. “Metadata-Based XML Serialization for Embedded C++.” In 2006 IEEE International Conference on Web Services (ICWS’06). IEEE. https://doi.org/10.1109/icws.2006.91
Paz, Harel, Erez Petrank, and Stephen M. Blackburn. 2005. “Age-Oriented Concurrent Garbage Collection.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-31985-6_9
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
Pedersen, Mathias V., and Aslan Askarov. 2017. “From Trash to Treasure: Timing-Sensitive Garbage Collection.” In 2017 IEEE Symposium on Security and Privacy (SP). IEEE. https://doi.org/10.1109/sp.2017.64
Peixoto, Carlos Eduardo Lima, Jorge Luis Nicolas Audy, and Rafael Prikladnicki. 2010. “Effort Estimation in Global Software Development Projects: Preliminary Results from a Survey.” In 2010 5th IEEE International Conference on Global Software Engineering. IEEE. https://doi.org/10.1109/icgse.2010.22
Peleato, Borja, Rajiv Agarwal, and John Cioffi. 2012. “On the Distribution of Valid Pages with Greedy Garbage Collection for NAND Flash.” In 2012 IEEE Statistical Signal Processing Workshop (SSP). IEEE. https://doi.org/10.1109/ssp.2012.6319743
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
Pendharkar, Parag C., and James A. Rodger. 2011. “A Distributed Problem-Solving Framework for Probabilistic Software Effort Estimation.” Expert Systems 29 (5): 492–505. https://doi.org/10.1111/j.1468-0394.2011.00607.x
Pendharkar, Parag C., James A. Rodger, and Girish H. Subramanian. 2008. “An Empirical Study of the Cobb–Douglas Production Function Properties of Software Development Effort.” Information and Software Technology 50 (12): 1181–88. https://doi.org/10.1016/j.infsof.2007.10.019
Pendharkar, Parag C., and Girish H. Subramanian. 2002. “Connectionist Models for Learning, Discovering, and Forecasting Software Effort: An Empirical Study.” Journal of Computer Information Systems 43 (1): 7–14. https://doi.org/10.1080/08874417.2002.11647064
Peng, Yun, Yu Zhang, and Mingzhe Hu. 2021. “An Empirical Study for Common Language Features Used in Python Projects.” In 2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner50967.2021.00012
Peng Li and Baojiang Cui. 2010. “A Comparative Study on Software Vulnerability Static Analysis Techniques and Tools.” In 2010 IEEE International Conference on Information Theory and Information Security. IEEE. https://doi.org/10.1109/icitis.2010.5689543
Penjam, Jaan. 1989. “Compiler Construction by Object-Oriented System Nut.” In Compiler Compilers and High Speed Compilation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-51364-7_5
Perarnau, Swann, Brice Videau, Nicolas Denoyelle, Florence Monna, Kamil Iskra, and Pete Beckman. 2019. “Explicit Data Layout Management for Autotuning Exploration on Complex Memory Topologies.” In 2019 IEEE/ACM Workshop on Memory Centric High Performance Computing (MCHPC). IEEE. https://doi.org/10.1109/mchpc49590.2019.00015
Percec, Virgil, and Dipankar Sahoo. 2022. “Discotic Liquid Crystals 45 Years Later. Dendronized Discs and Crowns Increase Liquid Crystal Complexity to Columnar from Spheres, Cubic Frank-Kasper, Liquid Quasicrystals and Memory-Effect Induced Columnar-Bundles.” Giant 12: 100127. https://doi.org/10.1016/j.giant.2022.100127
Pereira, Jose D’Abruzzo, Joao R. Campos, and Marco Vieira. 2021. “Machine Learning to Combine Static Analysis Alerts with Software Metrics to Detect Security Vulnerabilities: An Empirical Study.” In 2021 17th European Dependable Computing Conference (EDCC). IEEE. https://doi.org/10.1109/edcc53658.2021.00008
Perez, Taciano D., Marcelo V. Neves, Diego Medaglia, Pedro H. G. Monteiro, and César A. F. De Rose. 2019. “Orthogonal Persistence in Nonvolatile Memory Architectures: A Persistent Heap Design and Its Implementation for a Java Virtual Machine.” Software: Practice and Experience 50 (4): 368–87. https://doi.org/10.1002/spe.2781
Pérez-Piqueras, Víctor, Pablo Bermejo López, and José Gámez. 2025. “Agile Effort Estimation Improved by Feature Selection and Model Explainability.” In Proceedings of the 20th International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013229800003928
Periyasamy, Kasi, and Aditi Ghode. 2009. “Cost Estimation Using Extended Use Case Point (e-UCP) Model.” In 2009 International Conference on Computational Intelligence and Software Engineering. IEEE. https://doi.org/10.1109/cise.2009.5364515
Permandla, Pratibha, Michael Roberson, and Chandrasekhar Boyapati. 2007. “A Type System for Preventing Data Races and Deadlocks in the Java Virtual Machine Language: 1.” ACM SIGPLAN Notices 42 (7): 10. https://doi.org/10.1145/1273444.1254768
Persson, Patrik. 1999. “Live Memory Analysis for Garbage Collection in Embedded Systems.” ACM SIGPLAN Notices 34 (7): 45–54. https://doi.org/10.1145/315253.314440
Petek, Ana, Nikola Baketa, Anka Kekez, et al. 2021. “Unboxing the Vague Notion of Policy Goals: Comparison of Croatian Public Policies.” European Policy Analysis 7 (2): 451–69. https://doi.org/10.1002/epa2.1106
Peters, Randal J., and Ken Barker. 2001. “Change Propagation in an Axiomatic Model of Schema Evolution for Objectbase Management Systems.” In Database Schema Evolution and Meta-Modeling. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48196-6_9
Petersen, Leaf, and Neal Glew. 2010. “Functional Language Compiler Experiences at Intel.” In ACM SIGPLAN Commercial Users of Functional Programming. ACM. https://doi.org/10.1145/1900160.1900175
Petersen, Leaf, and Neal Glew. 2012. “GC-Safe Interprocedural Unboxing.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-28652-0_9
Petrank, Erez, and Dror Rawitz. 2002. “The Hardness of Cache Conscious Data Placement.” ACM SIGPLAN Notices 37 (1): 101–12. https://doi.org/10.1145/565816.503283
Petrogalli, Francesco, and Paul Walker. 2018. “LLVM and the Automatic Vectorization of Loops Invoking Math Routines: -FSIMDMATH.” In 2018 IEEE/ACM 5th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc.2018.8639354
Petry, Michael, Andreas Koch, and Martin Werner. 2024. “Zero-Copy AI-Augmented Signal Processing Pipeline on Heterogeneous Satellite Processors.” In 2024 58th Asilomar Conference on Signals, Systems, and Computers. IEEE. https://doi.org/10.1109/ieeeconf60004.2024.10943093
Pettersson, Mikael. 1996. “A Compiler for Natural Semantics.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-61053-7_61
Peyton Jones, Simon L., and John Launchbury. 1991. “Unboxed Values as First Class Citizens in a Non-Strict Functional Language.” In Functional Programming Languages and Computer Architecture. Springer Berlin Heidelberg. https://doi.org/10.1007/3540543961_30
Pham, Van Cam, Ansgar Radermacher, Sébastien Gérard, and Shuai Li. 2017. “Complete Code Generation from UML State Machine.” In Proceedings of the 5th International Conference on Model-Driven Engineering and Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006274502080219
Pham, Long, Feras A. Saad, and Jan Hoffmann. 2024. “Robust Resource Bounds with Static Analysis and Bayesian Inference.” Proceedings of the ACM on Programming Languages 8 (PLDI): 76–101. https://doi.org/10.1145/3656380
Phannachitta, Passakorn. 2017. “Robust Comparison of Similarity Measures in Analogy Based Software Effort Estimation.” In 2017 11th International Conference on Software, Knowledge, Information Management and Applications (SKIMA). IEEE. https://doi.org/10.1109/skima.2017.8294126
Phannachitta, Passakorn. 2020. “On an Optimal Analogy-Based Software Effort Estimation.” Information and Software Technology 125: 106330. https://doi.org/10.1016/j.infsof.2020.106330
Phannachitta, Passakorn. 2026. “Input Perturbation Robustness for Software Effort Estimation: An Empirical Evaluation of LP4EE Enhancement Strategies.” Software Quality Journal 34 (2): 30. https://doi.org/10.1007/s11219-026-09758-3
Phannachitta, Passakorn, Jacky Keung, Kwabena Ebo Bennin, Akito Monden, and Kenichi Matsumoto. 2016a. “Filter-INC: Handling Effort-Inconsistency in Software Effort Estimation Datasets.” In 2016 23rd Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2016.035
Phannachitta, Passakorn, Jacky Keung, Akito Monden, and Kenichi Matsumoto. 2016c. “A Stability Assessment of Solution Adaptation Techniques for Analogy-Based Software Effort Estimation.” Empirical Software Engineering 22 (1): 474–504. https://doi.org/10.1007/s10664-016-9434-8
Phongpaibul, Monvorath, and Pongtip Aroonvatanaporn. 2015. “Standardized Cost Estimation in Thai Government’s Software Development Projects.” In 2015 International Computer Science and Engineering Conference (ICSEC). IEEE. https://doi.org/10.1109/icsec.2015.7401449
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
Piccioni, Marco, Manuel Orioly, Bertrand Meyer, and Teseo Schneider. 2009. “An IDE-Based, Integrated Solution to Schema Evolution of Object-Oriented Software.” In 2009 IEEE/ACM International Conference on Automated Software Engineering. IEEE. https://doi.org/10.1109/ase.2009.100
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
Pickett, Christopher J. F., and Clark Verbrugge. 2006. “Software Thread Level Speculation for the Java Language and Virtual Machine Environment.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-69330-7_21
Pillai, S. K., and M. K. Jeyakumar. 2014b. “Extreme Learning Machine for Software Development Effort Estimation of Small Programs.” In 2014 International Conference on Circuits, Power and Computing Technologies [ICCPCT-2014]. IEEE. https://doi.org/10.1109/iccpct.2014.7054900
Pillai, Sreekumar P., S. D. Madhukumar, and T. Radharamanan. 2017. “Consolidating Evidence Based Studies in Software Cost/effort Estimation — A Tertiary Study.” In TENCON 2017 - 2017 IEEE Region 10 Conference. IEEE. https://doi.org/10.1109/tencon.2017.8227974
Pillai, K., and V. S. Sukumaran Nair. 1997. “A Model for Software Development Effort and Cost Estimation.” IEEE Transactions on Software Engineering 23 (8): 485–97. https://doi.org/10.1109/32.624305
Pinter, Shlomit S. 1993. “Register Allocation with Instruction Scheduling.” In Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/155090.155114
Pinto, Joylin Priya, Mohammed Aqib, Osama Shakeel, Emad Habibi, and S. Gagan. 2025. “Integrating Conversational AI, Image Generation, and Code Generation: A Unified Platform.” In Proceedings of the 3rd International Conference on Futuristic Technology. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013588800004664
Pinzger, Martin, and Sunghun Kim. 2016. “Guest Editorial: Mining Software Repositories.” Empirical Software Engineering 21 (5): 2033–34. https://doi.org/10.1007/s10664-016-9450-8
Pittman, T. 1987. “Two-Level Hybrid Interpreter/native Code Execution for Combined Space-Time Program Efficiency.” In Papers of the Symposium on Interpreters and interpretive techniques - SIGPLAN ‘87. ACM Press. https://doi.org/10.1145/29650.29666
Pixley, Carl. 1988. “An Incremental Garbage Collection Algorithm for Multi-Mutator Systems.” Distributed Computing 3 (1): 41–50. https://doi.org/10.1007/bf01788566
Pizzolotto, Davide, and Mariano Ceccato. 2018. “[Research Paper] Obfuscating Java Programs by Translating Selected Portions of Bytecode to Native Libraries.” In 2018 IEEE 18th International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE. https://doi.org/10.1109/scam.2018.00012
Plainfossé, David, and Marc Shapiro. 1995. “A Survey of Distributed Garbage Collection Techniques.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_26
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.” ACM SIGPLAN Notices 19 (6): 94–105. https://doi.org/10.1145/502949.502883
Pleban, U. F., and P. Lee. 1988. “An Automatically Generated, Realistic Compiler for Imperative Programming Language.” In Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/53990.54012
Plow, Ep. 1976. “Optimal Layout of Surfaces, MODFL, on Record Forms.” Journal of Dental Education 40 (2): 107–8. https://doi.org/10.1002/j.0022-0337.1976.40.2.tb00940.x
Plyukhin, Dan, and Gul Agha. 2018. “Concurrent Garbage Collection in the Actor Model.” In Proceedings of the 8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control. ACM. https://doi.org/10.1145/3281366.3281368
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
Poetzsch-Heffter, A. 1989. “Optimizing Implementation of Aggregates in the Compiler Specification System MAGIC.” In Compiler Compilers and High Speed Compilation. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-51364-7_15
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. 2022b. “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
Polkowski, Zdzislaw, Jayneel Vora, Sudeep Tanwar, Sudhanshu Tyagi, Pradeep Kumar Singh, and Yashwant Singh. 2019. “Machine Learning-Based Software Effort Estimation: An Analysis.” In 2019 11th International Conference on Electronics, Computers and Artificial Intelligence (ECAI). IEEE. https://doi.org/10.1109/ecai46879.2019.9042031
Pollet, Isabelle, and Baudouin Le Charlier. 2005. “Towards a Complete Static Analyser for Java: An Abstract Interpretation Framework and Its Implementation.” Electronic Notes in Theoretical Computer Science 131: 85–98. https://doi.org/10.1016/j.entcs.2005.01.025
Polys, Nicholas F., Seonho Kim, and Doug A. Bowman. 2006. “Effects of Information Layout, Screen Size, and Field of View on User Performance in Information-Rich Virtual Environments.” Computer Animation and Virtual Worlds 18 (1): 19–38. https://doi.org/10.1002/cav.159
Pommellet, Adrien, and Tayssir Touili. 2017. “Static Analysis of Multithreaded Recursive Programs Communicating via Rendez-Vous.” In Programming Languages and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-319-71237-6_12
Ponsini, Olivier, Claude Michel, and Michel Rueher. 2012. “Combining Constraint Programming and Abstract Interpretation for Value Analysis of Floating-Point Programs.” In 2012 IEEE Fifth International Conference on Software Testing, Verification and Validation. IEEE. https://doi.org/10.1109/icst.2012.175
Ponugoti, Kushal K. 2024. “Ensuring SFENCE Instruction Correctness: A Formal Verification Framework Based on Invariants.” In 2024 IEEE International Conference on Electro Information Technology (eIT). IEEE. https://doi.org/10.1109/eit60633.2024.10609914
Popli, Rashmi, and Naresh Chauhan. 2014. “Cost and Effort Estimation in Agile Software Development.” In 2014 International Conference on Reliability Optimization and Information Technology (ICROIT). IEEE. https://doi.org/10.1109/icroit.2014.6798284
Popov, Peter, Vladimir Stankovic, and Lorenzo Strigini. 2012. “An Empirical Study of the Effectiveness of ‘Forcing’ Diversity Based on a Large Population of Diverse Programs.” In 2012 IEEE 23rd International Symposium on Software Reliability Engineering. IEEE. https://doi.org/10.1109/issre.2012.27
Pottier, François. 2005. “From ML Type Inference to Stratified Type Inference.” ACM SIGPLAN Notices 40 (9): 1–1. https://doi.org/10.1145/1090189.1086367
Pow-Sang, José Antonio, and Ricardo Imbert. 2012. “Effort Estimation in Incremental Software Development Projects Using Function Points.” In Computer Applications for Software Engineering, Disaster Recovery, and Business Continuity. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-35267-6_61
Pow-Sang, Jose Antonio, and Enrique Jolay-Vasquez. 2006. “An Approach of a Technique for Effort Estimation of Iterations in Software Projects.” In 2006 13th Asia Pacific Software Engineering Conference (APSEC’06). IEEE. https://doi.org/10.1109/apsec.2006.20
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
Pracner, Doni, and Zoran Budimac. 2017. “Enabling Code Transformations with FermaT on Simplified Bytecode.” Journal of Software: Evolution and Process 29 (5): e1857. https://doi.org/10.1002/smr.1857
Prasad, M. Devi, and Banshi Dhar Chaudhary. 2004. “A Type System for an Aspect Oriented Programming Language.” In Distributed Computing and Internet Technology. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30555-2_31
Prasad Reddy, P. V. G. D., and Ch. V. M. K. Hari. 2011. “Fuzzy Based PSO for Software Effort Estimation.” In Information Technology and Mobile Communication. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-20573-6_36
Pratheek, B., Guilherme Cox, Jan Vesely, and Arkaprava Basu. 2024. “SUV: Static Analysis Guided Unified Virtual Memory.” In 2024 57th IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE. https://doi.org/10.1109/micro61859.2024.00030
Preetha Theresa Joy and K. Poulose Jacob. 2013. “A Coordinated Cache Data Placement Scheme for Mobile Ad Hoc Networks.” In 2013 Fifth International Conference on Advanced Computing (ICoAC). IEEE. https://doi.org/10.1109/icoac.2013.6921948
Prifti, Lejdi, Betim Cico, and Dimitrios Karras. 2024. “Smart Contract Vulnerability Detection Using Deep Learning Algorithms on EVM Bytecode.” In 2024 13th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco62516.2024.10577852
Printezis, Tony. 2006. “On Measuring Garbage Collection Responsiveness.” Science of Computer Programming 62 (2): 164–83. https://doi.org/10.1016/j.scico.2006.02.004
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
Proebsting, Todd A., and Charles N. Fischer. 1992. “Probabilistic Register Allocation.” In Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation - PLDI ‘92. ACM Press. https://doi.org/10.1145/143095.143142
Prokopec, Aleksandar, Gilles Duboscq, David Leopoldseder, and Thomas Wirthinger. 2019. “An Optimization-Driven Incremental Inline Substitution Algorithm for Just-in-Time Compilers.” In 2019 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2019.8661171
Pronina, V. A. 1979. “Program Analysis in the Compiler of a Parallel Computer.” Cybernetics 15 (1): 100–103. https://doi.org/10.1007/bf01072301
Proper, H. A. 1997. “Data Schema Design as a Schema Evolution Process.” Data & Knowledge Engineering 22 (2): 159–89. https://doi.org/10.1016/s0169-023x(96)00045-6
Puder, Arno, and Jessica Lee. 2009. “Towards an XML-Based Bytecode Level Transformation Framework.” Electronic Notes in Theoretical Computer Science 253 (5): 97–111. https://doi.org/10.1016/j.entcs.2009.11.017
Puebla, Germán, Elvira Albert, and Manuel Hermenegildo. 2006. “Abstract Interpretation with Specialized Definitions.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/11823230_8
Pufek, P., D. Beronic, B. Mihaljevic, and A. Radovan. 2020. “Achieving Efficient Structured Concurrency through Lightweight Fibers in Java Virtual Machine.” In 2020 43rd International Convention on Information, Communication and Electronic Technology (MIPRO). IEEE. https://doi.org/10.23919/mipro48935.2020.9245253
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
Pugh, William, and Grant Weddell. 1990. “Two-Directional Record Layout for Multiple Inheritance.” ACM SIGPLAN Notices 25 (6): 85–91. https://doi.org/10.1145/93548.93556
Pulakanam, Venkateswarlu. 2012. “Costs and Savings of Six Sigma Programs: An Empirical Study.” Quality Management Journal 19 (4): 39–54. https://doi.org/10.1080/10686967.2012.11918082
Purkayastha, Arnab A., Samuel Rogers, Suhas A. Shiddibhavi, and Hamed Tabkhi. 2020. “LLVM-Based Automation of Memory Decoupling for OpenCL Applications on FPGAs.” Microprocessors and Microsystems 72: 102909. https://doi.org/10.1016/j.micpro.2019.102909
Pusch, Cornelia. 1996. “Verification of Compiler Correctness for the WAM.” In Theorem Proving in Higher Order Logics. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0105415
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
Puschner, Peter, Daniel Prokesch, Benedikt Huber, Jens Knoop, Stefan Hepp, and Gernot Gebhard. 2013. “The T-CREST Approach of Compiler and WCET-Analysis Integration.” In 16th IEEE International Symposium on Object/component/service-oriented Real-time distributed Computing (ISORC 2013). IEEE. https://doi.org/10.1109/isorc.2013.6913220
Putatunda, R., D. Smith, S. McNeary, and J. Crabbe. 1986. “HAPPI: A Chip Compiler Based on Double-Level-Metal Technology.” In 23rd ACM/IEEE Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1986.1586172
Putra, Gilang Almaghribi Sarkara, and Rendra Agus Triyono. 2019. “Control Valve Cost Estimation Software Using Artificial Neural Network.” In 2019 International Conference on Sustainable Information Engineering and Technology (SIET). IEEE. https://doi.org/10.1109/siet48054.2019.8986033
Qasem, Apan, and Ken Kennedy. 2006. “A Cache-Conscious Profitability Model for Empirical Tuning of Loop Fusion.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-69330-7_8
Qawasmeh, Ahmad, Barbara Chapman, and Amrita Banerjee. 2012. “A Compiler-Based Tool for Array Analysis in HPC Applications.” In 2012 41st International Conference on Parallel Processing Workshops. IEEE. https://doi.org/10.1109/icppw.2012.63
Qi, Kan, and Barry W. Boehm. 2019. “Process-Driven Incremental Effort Estimation.” In 2019 IEEE/ACM International Conference on Software and System Processes (ICSSP). IEEE. https://doi.org/10.1109/icssp.2019.00030
Qi, Kan, and Barry Boehm. 2020. “Effort Estimation of Open Source Android Projects via Transaction Analysis.” Journal of Software: Evolution and Process 33 (1): e2253. https://doi.org/10.1002/smr.2253
Qi, Mingyao, Xinru Hao, and Meng Yuan. 2023. “An Optimal Layout Pattern-Based Solution Approach to the Extended Machine Layout Problem with Multirow Multicolumn Structure.” IEEE Transactions on Automation Science and Engineering 20 (2): 1408–28. https://doi.org/10.1109/tase.2022.3182031
Qi, Fumin, Xiao-Yuan Jing, Xiaoke Zhu, Xiaoyuan Xie, Baowen Xu, and Shi Ying. 2017. “Software Effort Estimation Based on Open Source Projects: Case Study of Github.” Information and Software Technology 92: 145–57. https://doi.org/10.1016/j.infsof.2017.07.015
Qian, Zhenyu. 1999. “A Formal Specification of Javaℳ Virtual Machine Instructions for Objects, Methods and Subroutines.” In Formal Syntax and Semantics of Java. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48737-9_8
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
Qiang Liu, George A. Constantinides, Konstantinos Masselos, and Peter Y. K. Cheung. 2008. “Combining Data Reuse Exploitationwith Data-Level Parallelization for FPGA Targeted Hardware Compilation: A Geometric Programming Framework.” In 2008 International Conference on Field Programmable Logic and Applications. IEEE. https://doi.org/10.1109/fpl.2008.4629928
Qin, Zhijie, Wei Zhong, Fei Hu, Xinyan Yang, Long Ye, and Qin Zhang. 2021. “Layout Structure Assisted Indoor Image Generation.” In 2021 IEEE 4th International Conference on Multimedia Information Processing and Retrieval (MIPR). IEEE. https://doi.org/10.1109/mipr51284.2021.00061
Qiu, Tianle, and Stephen M. Blackburn. 2025. “Iso: Request-Private Garbage Collection.” Proceedings of the ACM on Programming Languages 9 (PLDI): 874–96. https://doi.org/10.1145/3729285
Quantrill, Jason, Noura Khajehnouri, Zihan Guo, and Manar H. Alalfi. 2026. “Cracking IoT Security: Can LLMs Outsmart Static Analysis Tools?” Empirical Software Engineering 31 (5): 115. https://doi.org/10.1007/s10664-026-10849-9
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
Querin, Osvaldo M., Mariano Victoria, Concepción Díaz, and Pascual Martí. 2014. “Layout Optimization of Multi-Material Continuum Structures with the Isolines Topology Design Method.” Engineering Optimization 47 (2): 221–37. https://doi.org/10.1080/0305215x.2014.882332
Quillien, Tadeg, Neil Bramley, and Christopher G. Lucas. 2025. “Lossy Encoding of Distributions in Judgment under Uncertainty.” Cognitive Psychology 159: 101745. https://doi.org/10.1016/j.cogpsych.2025.101745
Quinlan, Dan, Shmuel Ur, and Richard Vuduc. 2006. “An Extensible Open-Source Compiler Infrastructure for Testing.” In Hardware and Software, Verification and Testing. Springer Berlin Heidelberg. https://doi.org/10.1007/11678779_9
Quiñones, Carlos García, Carlos Madriles, Jesús Sánchez, Pedro Marcuello, Antonio González, and Dean M. Tullsen. 2005. “Mitosis Compiler: An Infrastructure for Speculative Threading Based on Pre-Computation Slices.” ACM SIGPLAN Notices 40 (6): 269–79. https://doi.org/10.1145/1064978.1065043
Quintão Pereira, Fernando Magno, and Jens Palsberg. 2008. “Register Allocation by Puzzle Solving.” In Proceedings of the 29th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/1375581.1375609
Quintarelli, Elisa, Emanuele Rabosio, and Letizia Tanca. 2015. “A Principled Approach to Context Schema Evolution in a Data Management Perspective.” Information Systems 49: 65–101. https://doi.org/10.1016/j.is.2014.11.008
Ra, Young-Gook. 2004. “Relational Schema Evolution for Program Independency.” In Intelligent Information Technology. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30561-3_29
Rahiman, Amir Rizaan, and Putra Sumari. 2009. “Minimizing the Garbage Collection Time in Flash Memory Using Efficient Data Allocation Scheme.” In TENCON 2009 - 2009 IEEE Region 10 Conference. IEEE. https://doi.org/10.1109/tencon.2009.5396010
Rahman, Akond, Dibyendu Brinto Bose, Raunak Shakya, and Rahul Pandita. 2023. “Come for Syntax, Stay for Speed, Understand Defects: An Empirical Study of Defects in Julia Programs.” Empirical Software Engineering 28 (4): 93. https://doi.org/10.1007/s10664-023-10328-5
Rahman, Mizanur, Hasan Sarwar, Md. Abdul Kader, Teresa Gonçalves, and Ting Tin Tin. 2024. “Review and Empirical Analysis of Machine Learning-Based Software Effort Estimation.” IEEE Access 12: 85661–80. https://doi.org/10.1109/access.2024.3404879
Rais-Rohani, M., and J. Lokits. 2006b. “Reinforcement Layout and Sizing Optimization of Composite Submarine Sail Structures.” Structural and Multidisciplinary Optimization 34 (1): 75–90. https://doi.org/10.1007/s00158-006-0066-2
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
Rajaram, Prashant, and Puneet Manchanda. 2020. “Video Influencers: Unboxing the Mystique.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.3752107
Raji, Amine, Philippe Dhaussy, and Bruno Aizier. 2010. “Automating Context Description for Software Formal Verification.” In 2010 Workshop on Model-Driven Engineering, Verification, and Validation. IEEE. https://doi.org/10.1109/modevva.2010.13
Rak, Katija, Željka Car, and Ignac Lovrek. 2018. “Effort Estimation Model for Software Development Projects Based on Use Case Reuse.” Journal of Software: Evolution and Process 31 (2): e2119. https://doi.org/10.1002/smr.2119
Rama Sree P. 2015. “Analytical Structure of a Fuzzy Logic Controller for Software Development Effort Estimation.” In 2015 International Conference on Electrical, Electronics, Signals, Communication and Optimization (EESCO). IEEE. https://doi.org/10.1109/eesco.2015.7253928
Ramachandra, Karthik, Ravindra Guravannavar, and S. Sudarshan. 2012. “Program Analysis and Transformation for Holistic Optimization of Database Applications.” In Proceedings of the ACM SIGPLAN International Workshop on State of the Art in Java Program analysis. ACM. https://doi.org/10.1145/2259051.2259057
Raman, Easwaran, Robert Hundt, and Sandya Mannarswamy. 2007. “Structure Layout Optimization for Multithreaded Programs.” In International Symposium on Code Generation and Optimization (CGO’07). IEEE. https://doi.org/10.1109/cgo.2007.36
Ramananandro, Tahina, Gabriel Dos Reis, and Xavier Leroy. 2011. “Formal Verification of Object Layout for c++ Multiple Inheritance.” ACM SIGPLAN Notices 46 (1): 67–80. https://doi.org/10.1145/1925844.1926395
Ramasubbu, Narayan, and Rajesh Krishna Balan. 2012. “Overcoming the Challenges in Cost Estimation for Distributed Software Projects.” In 2012 34th International Conference on Software Engineering (ICSE). IEEE. https://doi.org/10.1109/icse.2012.6227203
Ramaswamy, Lakshmish, Arun Iyengar, and Jianxia Chen. 2006. “Cooperative Data Placement and Replication in Edge Cache Networks.” In 2006 International Conference on Collaborative Computing: Networking, Applications and Worksharing. IEEE. https://doi.org/10.1109/colcom.2006.361850
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
Ramezani Akhmareh, Alireza, Mihai Lazarescu, Osama Bin Tariq, and Luciano Lavagno. 2016. “A Tagless Indoor Localization System Based on Capacitive Sensing Technology.” Sensors 16 (9): 1448. https://doi.org/10.3390/s16091448
Ramirez, A., J. L. Larriba-Pey, and M. Valero. 2001. “Instruction Fetch Architectures and Code Layout Optimizations.” Proceedings of the IEEE 89 (11): 1588–1609. https://doi.org/10.1109/5.964440
Ramirez, Sergio, and Camilo Rocha. 2015. “Formal Verification of Safety Properties for a Cache Coherence Protocol.” In 2015 10th Computing Colombian Conference (10CCC). IEEE. https://doi.org/10.1109/columbiancc.2015.7333399
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
Ramsey, Norman, and João Dias. 2011. “Resourceable, Retargetable, Modular Instruction Selection Using a Machine-Independent, Type-Based Tiling of Low-Level Intermediate Code.” ACM SIGPLAN Notices 46 (1): 575–86. https://doi.org/10.1145/1925844.1926451
Ramsey, Norman, and Simon L. Peyton Jones. 2004. “The C—Compiler Infrastructure.” ACM SIGPLAN Notices 39 (9): 1–1. https://doi.org/10.1145/1016848.1016851
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. 2016. “Abstract Interpretation of Supermodular Games.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-53413-7_20
Rao, Vignesh S., Tarunkant Gupta, Saastha Vasan, and L. R. Deepthi. 2020. “PHPIL: Fuzzing the PHP Interpreter with Custom Bytecode.” In 2020 11th International Conference on Computing, Communication and Networking Technologies (ICCCNT). IEEE. https://doi.org/10.1109/icccnt49239.2020.9225578
Rasmussen, J., R. Ansola, J. Canales, and J. A. Tarrago. 2004. “Combined Shape and Reinforcement Layout Optimization of Shell Structures.” Structural and Multidisciplinary Optimization 27 (4): 219–27. https://doi.org/10.1007/s00158-004-0399-7
Raste, Aditi, Swati Jaiswal, and Uday Khedker. 2025. “SLIM: A Simplified LLVM IR Abstraction for Compiler Design Courses.” In Computing Education Research. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-14583-3_15
Rastogi, Himani, Swati Dhankhar, and Misha Kakkar. 2014. “A Survey on Software Effort Estimation Techniques.” In 2014 5th International Conference - Confluence The Next Generation Information Technology Summit (Confluence). IEEE. https://doi.org/10.1109/confluence.2014.6949367
Ratiu, Daniel, and Lars Heinemann. 2010. “Utilizing Web Search Engines for Program Analysis.” In 2010 IEEE 18th International Conference on Program Comprehension. IEEE. https://doi.org/10.1109/icpc.2010.26
Raubitzek, Sebastian, Patrick Felbauer, Kevin Mallinger, and Sebastian Schrittwieser. 2025. “Classification of Obfuscation Techniques in LLVM IR: Machine Learning on Vector Representations.” Machine Learning and Knowledge Extraction 7 (4): 125. https://doi.org/10.3390/make7040125
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
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
Regehr, John, Yang Chen, Pascal Cuoq, Eric Eide, Chucky Ellison, and Xuejun Yang. 2012. “Test-Case Reduction for C Compiler Bugs.” In Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2254064.2254104
Reid, Alastair. 1999. “Putting the Spine Back in the Spineless Tagless G-Machine: An Implementation of Resumable Black-Holes.” In Implementation of Functional Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48515-5_12
Reid, Brittany, Christoph Treude, and Markus Wagner. 2023. “Using the TypeScript Compiler to Fix Erroneous Node.js Snippets.” In 2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE. https://doi.org/10.1109/scam59687.2023.00031
Reif, Michael, Florian Kübler, Dominik Helm, Ben Hermann, Michael Eichberg, and Mira Mezini. 2020. “TACAI: An Intermediate Representation Based on Abstract Interpretation.” In Proceedings of the 9th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis. ACM. https://doi.org/10.1145/3394451.3397204
Reijers, Niels, and Chi-Sheng Shih. 2019. “Improved Ahead-of-Time Compilation of Stack-Based JVM Bytecode on Resource-Constrained Devices.” ACM Transactions on Sensor Networks 15 (3): 1–44. https://doi.org/10.1145/3341170
Reinhold, Mark B. 1994. “Cache Performance of Garbage-Collected Programs.” ACM SIGPLAN Notices 29 (6): 206–17. https://doi.org/10.1145/773473.178261
Reiser, Micha, and Luc Bläser. 2017. “Accelerate JavaScript Applications by Cross-Compiling to WebAssembly.” In Proceedings of the 9th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/3141871.3141873
Remil, Naïm Moussaoui, and Caterina Urban. 2026. “Termination Resilience Static Analysis.” In Verification, Model Checking, and Abstract Interpretation. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-15700-3_11
Rémy, Didier. 2005. “Simple, Partial Type-Inference for System F Based on Type-Containment.” In Proceedings of the tenth ACM SIGPLAN international conference on Functional programming. ACM. https://doi.org/10.1145/1086365.1086383
Ren, Brianna M., and Jeffrey S. Foster. 2016. “Just-in-Time Static Type Checking for Dynamic Languages.” In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2908080.2908127
Ren, Tong, Shuangbai Xue, Fei Peng, Qing Wang, and Xiang Gao. 2015. “Efficient Implementation of MIPS Code Generator for the IonMonkey JavaScript Compiler.” In Advanced Parallel Processing Technologies. Springer International Publishing. https://doi.org/10.1007/978-3-319-23216-4_6
Ren, Xin, and Ying Zhangxu. 2016. “Generational Garbage Collection Algorithm Based on Lifespan Prediction.” In 2016 IEEE 4th International Conference on Future Internet of Things and Cloud Workshops (FiCloudW). IEEE. https://doi.org/10.1109/w-ficloud.2016.47
Renardel de Lavalette, Gerard R. 1992. “Strictness Analysis via Abstract Interpretation for Recursively Defined Types.” Information and Computation 99 (2): 154–77. https://doi.org/10.1016/0890-5401(92)90028-e
Reps, Thomas, Gogul Balakrishnan, and Junghee Lim. 2006. “Intermediate-Representation Recovery from Low-Level Code.” In Proceedings of the 2006 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation. ACM. https://doi.org/10.1145/1111542.1111560
Requet, Antoine. 2003. “A B Model for Ensuring Soundness of a Large Subset of the Java Card Virtual Machine.” Science of Computer Programming 46 (3): 283–306. https://doi.org/10.1016/s0167-6423(02)00095-3
Reshniak, Viktor, Qian Gong, Rick Archibald, Scott Klasky, and Norbert Podhorszki. 2024. “A Framework for Compressing Unstructured Scientific Data via Serialization.” In 2024 IEEE International Conference on Big Data (BigData). IEEE. https://doi.org/10.1109/bigdata62323.2024.10825570
“Retracted: Research of Schema Evolution and Implementation Scheme Optimization in AI-Enabled Embedded Systems.” 2023. Wireless Communications and Mobile Computing 2023: 1–1. https://doi.org/10.1155/2023/9894875
Reynolds, Mark C. 2010. “Lightweight Modeling of Java Virtual Machine Security Constraints.” In Abstract State Machines, Alloy, B and Z. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-11811-1_12
Reynolds, Conor, and Rosemary Monahan. 2024. “Reasoning about Logical Systems in the Coq Proof Assistant.” Science of Computer Programming 233: 103054. https://doi.org/10.1016/j.scico.2023.103054
Rezaalipour, Mohammad, and Carlo A. Furia. 2024. “An Empirical Study of Fault Localization in Python Programs.” Empirical Software Engineering 29 (4): 92. https://doi.org/10.1007/s10664-024-10475-3
Rhein, Alexander Von, JöRG Liebig, Andreas Janker, Christian Kästner, and Sven Apel. 2018. “Variability-Aware Static Analysis at Scale: An Empirical Study.” ACM Transactions on Software Engineering and Methodology 27 (4): 1–33. https://doi.org/10.1145/3280986
Rhmann, Wasiur, Babita Pandey, and Gufran Ahmad Ansari. 2021. “Software Effort Estimation Using Ensemble of Hybrid Search-Based Algorithms Based on Metaheuristic Algorithms.” Innovations in Systems and Software Engineering 18 (2): 309–19. https://doi.org/10.1007/s11334-020-00377-0
Richards, Gregor, Sylvain Lebresne, Brian Burg, and Jan Vitek. 2010. “An Analysis of the Dynamic Behavior of JavaScript Programs.” In Proceedings of the 31st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/1806596.1806598
Richly, Keven. 2021. “Memory-Efficient Storing of Timestamps for Spatio-Temporal Data Management in Columnar in-Memory Databases.” In Database Systems for Advanced Applications. Springer International Publishing. https://doi.org/10.1007/978-3-030-73194-6_36
Richmond, Dustin, Jeremy Blackstone, Matthew Hogains, Kevin Thai, and Ryan Kastner. 2016. “Tinker: Generating Custom Memory Architectures for Altera’s OpenCL Compiler.” In 2016 IEEE 24th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm.2016.13
Ricov, Filip, and Kresimir Pripuzic. 2022. “Perfomance Evaluation of Java Serialization Frameworks on Geospatial Big Data.” In 2022 7th International Conference on Smart and Sustainable Technologies (SpliTech). IEEE. https://doi.org/10.23919/splitech55088.2022.9854334
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
Rinetzky, Noam, and Sharon Shoham. 2015. “Property Directed Abstract Interpretation.” In Verification, Model Checking, and Abstract Interpretation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-49122-5_5
Ringler, Thomas. 2000. “Static Worst-Case Execution Time Analysis of Synchronous Programs.” In Reliable Software Technologies Ada-Europe 2000. Springer Berlin Heidelberg. https://doi.org/10.1007/10722060_8
Ringström, Johan, Peter Fritzson, and Mikael Pettersson. 1994. “Generating an Efficient Compiler for a Data Parallel Language from a Denotational Specification.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57877-3_17
Ritu and Pankaj Bhambri. 2022. “A CAD System for Software Effort Estimation.” In 2022 2nd International Conference on Technological Advancements in Computational Sciences (ICTACS). IEEE. https://doi.org/10.1109/ictacs56270.2022.9988123
Ritu and Pankaj Bhambri. 2025. “Enhancing Software Development Effort Estimation with a Cloud-Based Data Framework Using Use Case Points, Fuzzy Logic, and Machine Learning.” Discover Computing 28 (1): 143. https://doi.org/10.1007/s10791-025-09668-1
Ritu, Pankaj Bhambri, Mudassir Khan, and Barga Mohammed Mujahid. 2026. “Advanced Effort Estimation in Software Projects Using Ensemble-Based Fusion Techniques.” Egyptian Informatics Journal 33: 100914. https://doi.org/10.1016/j.eij.2026.100914
Robbes, Romain, Emily Hill, and Christian Bird. 2018. “Guest Editorial: Special Section on Mining Software Repositories.” Empirical Software Engineering 23 (2): 833–34. https://doi.org/10.1007/s10664-018-9612-y
Robbes, Romain, Yasutaka Kamei, and Martin Pinzger. 2017. “Guest Editorial: Mining Software Repositories.” Empirical Software Engineering 22 (3): 1143–45. https://doi.org/10.1007/s10664-017-9527-z
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
Roberts, M. L., and P. D. Griffiths. 1985. “Design Considerations for IBM Personal Computer Professional FORTRAN, an Optimizing Compiler.” IBM Systems Journal 24 (1): 49–60. https://doi.org/10.1147/sj.241.0049
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
Robiolo, Gabriela, Cristina Badano, and Ricardo Orosco. 2009. “Transactions and Paths: Two Use Case Based Metrics Which Improve the Early Effort Estimation.” In 2009 3rd International Symposium on Empirical Software Engineering and Measurement. IEEE. https://doi.org/10.1109/esem.2009.5316021
Robiolo, Gabriela, and Ricardo Orosco. 2007. “An Alternative Method Employing Uses Cases for Early Effort Estimation.” In 31st IEEE Software Engineering Workshop (SEW 2007). IEEE. https://doi.org/10.1109/sew.2007.91
Robles, Gregorio. 2010. “Replicating MSR: A Study of the Potential Replicability of Papers Published in the Mining Software Repositories Proceedings.” In 2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010). IEEE. https://doi.org/10.1109/msr.2010.5463348
Robles, Gregorio, Andrea Capiluppi, Jesus M. Gonzalez-Barahona, Björn Lundell, and Jonas Gamalielsson. 2022. “Development Effort Estimation in Free/open Source Software from Activity in Version Control Systems.” Empirical Software Engineering 27 (6): 135. https://doi.org/10.1007/s10664-022-10166-x
Robson, D. J. 1982. “Pascal Implementation: The P4 Compiler, S. Pemberton and M. C. Danies. Ellis Horwood, Chichester. No. of Pages: 254. Price: £22.50.” Software: Practice and Experience 12 (12): 1167–1167. https://doi.org/10.1002/spe.4380121210
Ročkai, Petr, and Jiří Barnat. 2022. “DivSIM , an Interactive Simulator for LLVM Bitcode.” International Journal on Software Tools for Technology Transfer 24 (3): 493–510. https://doi.org/10.1007/s10009-022-00659-x
Rodrigues, Joao, and Jorge Barreiros. 2022. “Aspect-Oriented Webassembly Transformation.” In 2022 17th Iberian Conference on Information Systems and Technologies (CISTI). IEEE. https://doi.org/10.23919/cisti54924.2022.9820136
Rodrigues, Helena, and Richard Jones. 1998. “Cyclic Distributed Garbage Collection with Group Merger.” In ECOOP’98 — Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0054095
Rodrigues de Barros, Mateus, Felipe Rodrigo Evangelista Matilde, Wilbert Carpi Silva, and Cecilia de Azevedo Castro Cesar. 2022. “Optimizing Garbage Collection System.” In 2022 Symposium on Internet of Things (SIoT). IEEE. https://doi.org/10.1109/siot56383.2022.10069884
Rodriguez, Jonathan, and Ondřej Lhoták. 2011. “Actor-Based Parallel Dataflow Analysis.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-19861-8_11
Rodríguez, Gabriel, María J. Martín, Patricia González, Juan Touriño, and Ramón Doallo. 2012. “Compiler-Assisted Checkpointing of Parallel Codes: The Cetus and LLVM Experience.” International Journal of Parallel Programming 41 (6): 782–805. https://doi.org/10.1007/s10766-012-0231-8
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
Rodríguez Sánchez, Eduardo, Eduardo Filemón Vázquez Santacruz, and Humberto Cervantes Maceda. 2023. “Effort and Cost Estimation Using Decision Tree Techniques and Story Points in Agile Software Development.” Mathematics 11 (6): 1477. https://doi.org/10.3390/math11061477
Rodríguez-Carbonell, Enric, and Deepak Kapur. 2004. “An Abstract Interpretation Approach for Automatic Generation of Polynomial Invariants.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-27864-1_21
Rodriguez-Rivera, Gustavo. 2000. “Conservative Garbage Collection for General Memory Allocators.” ACM SIGPLAN Notices 36 (1): 71–79. https://doi.org/10.1145/362426.362464
Roe, Paul, and Clemens Szyperski. 2000. “Mianjin: A Parallel Language with a Type System That Governs Global System Behaviour.” In Modular Programming Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/10722581_4
Roger, C., S. Subramaniam, and A. Amri. 2011. “Dynamic Layout Algorithms for Wireless Field Hockey Strategy System.” In 2011 IEEE Conference on Open Systems. IEEE. https://doi.org/10.1109/icos.2011.6079263
Rogers, Timothy G., Mike O’Connor, and Tor M. Aamodt. 2012. “Cache-Conscious Wavefront Scheduling.” In 2012 45th Annual IEEE/ACM International Symposium on Microarchitecture. IEEE. https://doi.org/10.1109/micro.2012.16
Rogers, Timothy G., Mike O’Connor, and Tor M. Aamodt. 2013. “Cache-Conscious Thread Scheduling for Massively Multithreaded Processors.” IEEE Micro 33 (3): 78–85. https://doi.org/10.1109/mm.2013.24
Rogers, Samuel, Joshua Slycord, Ronak Raheja, and Hamed Tabkhi. 2019. “Scalable LLVM-Based Accelerator Modeling in gem5.” IEEE Computer Architecture Letters 18 (1): 18–21. https://doi.org/10.1109/lca.2019.2893932
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
Röjemo, Niklas. 1995. “Generational Garbage Collection without Temporary Space Leaks for Lazy Functional Languages.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_22
Rong, Kexin, Paul Liu, Sarah Ashok Sonje, and Moses Charikar. 2024. “Dynamic Data Layout Optimization with Worst-Case Guarantees.” In 2024 IEEE 40th International Conference on Data Engineering (ICDE). IEEE. https://doi.org/10.1109/icde60146.2024.00327
Rosà, Andrea, Matteo Basso, Leonardo Bohnhoff, and Walter Binder. 2023a. “Adaptive Thread Type Selection on the Java Virtual Machine.” In 2023 Eleventh International Symposium on Computing and Networking Workshops (CANDARW). IEEE. https://doi.org/10.1109/candarw60564.2023.00073
Rosà, Andrea, Matteo Basso, Leonardo Bohnhoff, and Walter Binder. 2023b. “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
Rosà, Andrea, and Walter Binder. 2020. “mathsfP^3: A Profiler Suite for Parallel Applications on the Java Virtual Machine.” In Programming Languages and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-64437-6_19
Rosa, Pasquale De, Pascal Felber, and Valerio Schiavoni. 2026. “Seeing through EVM Bytecode Obfuscation.” IEEE Access 14: 25515–36. https://doi.org/10.1109/access.2026.3662238
Rosa, Wilson, and Sara Jardine. 2025. “A Novel Method to Early Agile Effort Estimation through Functional Initiatives.” Journal of Systems and Software 223: 112302. https://doi.org/10.1016/j.jss.2024.112302
Rosà, Andrea, Eduardo Rosales, and Walter Binder. 2019. “Analysis and Optimization of Task Granularity on the Java Virtual Machine.” ACM Transactions on Programming Languages and Systems 41 (3): 1–47. https://doi.org/10.1145/3338497
Rosà, Andrea, Yudi Zheng, Haiyang Sun, Omar Javed, and Walter Binder. 2016. “Adaptable Runtime Monitoring for the Java Virtual Machine.” In Leveraging Applications of Formal Methods, Verification and Validation: Discussion, Dissemination, Applications. Springer International Publishing. https://doi.org/10.1007/978-3-319-47169-3_42
Rosales, Eduardo, Andrea Rosa, and Walter Binder. 2017. “Tgp: A Task-Granularity Profiler for the Java Virtual Machine.” In 2017 24th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2017.67
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
Ross, Charles, and Wim Bohm. 2006. “A Co-Verification Tool for a High Level Language Compiler for FPGAs.” In 2006 14th Annual IEEE Symposium on Field-Programmable Custom Computing Machines. IEEE. https://doi.org/10.1109/fccm.2006.6
Ross, Joe Cheri, and Priya Chandran. 2008. “Object Serialization Support for Object Oriented Java Processors.” In 2008 International Symposium on Information Technology. IEEE. https://doi.org/10.1109/itsim.2008.4632055
Rosselet, A. 1987. “Language Definition-Based Compiler Development.” Journal of Systems and Software 7 (2): 145–61. https://doi.org/10.1016/0164-1212(87)90019-7
Rossi, Bruno, and Lisandra Fontoura. 2025. “AI-Based Approaches for Software Tasks Effort Estimation: A Systematic Review of Methods and Trends.” In Proceedings of the 27th International Conference on Enterprise Information Systems. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013218200003929
Rostum, Hussam, and Jόzsef Vásárhelyi. 2026. “FPGA-Based ORB Accelerator: Effects of Compiler Optimization Levels.” In 2026 27th International Carpathian Control Conference (ICCC). IEEE. https://doi.org/10.1109/iccc71363.2026.11593248
Roth, Tobias. 2023. “Reusing Single-Language Analyses for Static Analysis of Multi-Language Programs.” 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.3623590
Roy, Peter. 1993. “Challenges in Developing Useful and Practical Static Analysis for Logic Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57264-3_33
Roy, Soumyaroop, Nagarajan Ranganathan, and Srinivas Katkoori. 2009. “Compiler-Directed Leakage Reduction in Embedded Microprocessors.” In 2009 IEEE International Conference on Computer Design. IEEE. https://doi.org/10.1109/iccd.2009.5413178
Roy, Pooja, Jianxing Wang, and Weng Fai Wong. 2015. “PAC: Program Analysis for Approximation-Aware Compilation.” In 2015 International Conference on Compilers, Architecture and Synthesis for Embedded Systems (CASES). IEEE. https://doi.org/10.1109/cases.2015.7324547
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
Rozi, Muhammad Fakhrur, Sangwook Kim, and Seiichi Ozawa. 2020. “Deep Neural Networks for Malicious JavaScript Detection Using Bytecode Sequences.” In 2020 International Joint Conference on Neural Networks (IJCNN). IEEE. https://doi.org/10.1109/ijcnn48605.2020.9207134
Rudi, Johann, Youngjun Lee, Aidan H. Chadha, et al. 2025. “CG-Kit: Code Generation Toolkit for Performant and Maintainable Variants of Source Code Applied to Flash-X Hydrodynamics Simulations.” Future Generation Computer Systems 163: 107511. https://doi.org/10.1016/j.future.2024.107511
Rudmik, A., and E. S. Lee. 1979. “Compiler Design for Efficient Code Generation and Program Optimization.” In Proceedings of the 1979 SIGPLAN symposium on Compiler construction - SIGPLAN ‘79. ACM Press. https://doi.org/10.1145/800229.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
Rudys, Algis, and Dan S. Wallach. 2003. “Enforcing Java Run-Time Properties Using Bytecode Rewriting.” In Software Security — Theories and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36532-x_12
Ruhela, Dhani. 2024. “Investigating the Performance of LLVM-Based Intel Fortran Compiler (Ifx).” In High Performance Computing. ISC High Performance 2024 International Workshops. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-73716-9_12
Ruirui Gu, Alessandro Forin, and Neil Pittman. 2010. “Path-Based Scheduling in a Hardware Compiler.” In 2010 Design, Automation & Test in Europe Conference & Exhibition (DATE 2010). IEEE. https://doi.org/10.1109/date.2010.5457011
Runeson, Johan, and Sven-Olof Nyström. 2003. “Retargetable Graph-Coloring Register Allocation for Irregular Architectures.” In Software and Compilers for Embedded Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39920-9_17
Ruospo, Annachiara, Ernesto Sanchez, Marcello Traiola, Ian O’Connor, and Alberto Bosio. 2021. “Investigating Data Representation for Efficient and Reliable Convolutional Neural Networks.” Microprocessors and Microsystems 86: 104318. https://doi.org/10.1016/j.micpro.2021.104318
Rusli, Ismail, Bambang R. Trilaksono, and Widyawardana Adiprawita. 2020. “RoomSLAM: Simultaneous Localization and Mapping with Objects and Indoor Layout Structure.” IEEE Access 8: 196992–197004. https://doi.org/10.1109/access.2020.3034537
Russell, David L., and Jeffrey V. Sue. 1976. “Implementation of a PASCAL Compiler for the IBM 360.” Software: Practice and Experience 6 (3): 371–76. https://doi.org/10.1002/spe.4380060309
Ruvald Pedersen, Mark, and J. Madsen. 2012. “Optimal Register Allocation by Augmented Left-Edge Algorithm on Arbitrary Control-Flow Structures.” In NORCHIP 2012. IEEE. https://doi.org/10.1109/norchp.2012.6403107
Rydhof Hansen, René, Jacob Grydholt Jensen, Flemming Nielson, and Hanne Riis Nielson. 1999. “Abstract Interpretation of Mobile Ambients.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48294-6_9
Saabas, Ando, and Tarmo Uustalu. 2007. “Type Systems for Optimizing Stack-Based Code.” Electronic Notes in Theoretical Computer Science 190 (1): 103–19. https://doi.org/10.1016/j.entcs.2007.02.063
Saabas, Ando, and Tarmo Uustalu. 2008. “Program and Proof Optimizations with Type Systems.” Journal of Logic and Algebraic Programming 77 (1–2): 131–54. https://doi.org/10.1016/j.jlap.2008.05.007
Saal, Harry J., and Zvi Weiss. 1977. “An Empirical Study of APL Programs.” Computer Languages 2 (3): 47–59. https://doi.org/10.1016/0096-0551(77)90007-8
Saballus, Bjoern, Johannes Eickhold, and Thomas Fuhrmann. 2008. “Global Accessible Objects (GAOs) in the Ambicomp Distributed Java Virtual Machine.” In 2008 Second International Conference on Sensor Technologies and Applications (sensorcomm 2008). IEEE. https://doi.org/10.1109/sensorcomm.2008.108
Sabeghi, Mojtaba, Vlad-Mihai Sima, and Koen Bertels. 2009. “Compiler Assisted Runtime Task Scheduling on a Reconfigurable Computer.” In 2009 International Conference on Field Programmable Logic and Applications. IEEE. https://doi.org/10.1109/fpl.2009.5272555
Sadeghi, Mohamad Mehdi, Somayeh Timarchi, and Mahmood Fazlali. 2023. “High-Performance Memory Allocation on FPGA with Reduced Internal Fragmentation.” IEEE Access 11: 66672–81. https://doi.org/10.1109/access.2023.3290100
Saeed, Syed Abu, Junaid Ali Khan, Saira Naeem, and Saif-Ur-Rehman Khan. 2021. “An Empirical Investigation on Cost Estimation Challenges in Agile Software Development (ASD) Context.” In 2021 International Conference on Frontiers of Information Technology (FIT). IEEE. https://doi.org/10.1109/fit53504.2021.00043
Saeedi, Payam, Mahsa Goodarzi, and M. Abdullah Canbaz. 2025. “Heuristics and Biases in AI Decision-Making: Implications for Responsible AGI.” In 2025 6th International Conference on Artificial Intelligence, Robotics and Control (AIRC). IEEE. https://doi.org/10.1109/airc64931.2025.11077505
Sagonas, Konstantinos. 2007. “Detecting Defects in Erlang Programs Using Static Analysis.” In Proceedings of the 9th ACM SIGPLAN international conference on Principles and practice of declarative programming. ACM. https://doi.org/10.1145/1273920.1273926
Saha, Sangeet, Shounak Chakraborty, Sukarn Agarwal, Rahul Gangopadhyay, Magnus Sjalander, and Klaus McDonald-Maier. 2023. “DELICIOUS: Deadline-Aware Approximate Computing in Cache-Conscious Multicore.” IEEE Transactions on Parallel and Distributed Systems 34 (2): 718–33. https://doi.org/10.1109/tpds.2022.3228751
Saha, Sangeet, Shounak Chakraborty, Sukarn Agarwal, Magnus Själander, and Klaus D. McDonald-Maier. 2024. “ARCTIC: Approximate Real-Time Computing in a Cache-Conscious Multicore Environment.” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 43 (10): 2944–57. https://doi.org/10.1109/tcad.2024.3384442
Sahasrabuddhe, Sameer, Hakim Raja, Kavi Arya, and Madhav Desai. 2007. “AHIR: A Hardware Intermediate Representation for Hardware Generation from High-Level Programs.” In 20th International Conference on VLSI Design held jointly with 6th International Conference on Embedded Systems (VLSID’07). IEEE. https://doi.org/10.1109/vlsid.2007.28
Sahoo, Pulak, Dayal Kumar Behera, J. R. Mohanty, and Ch. Sanjeev Kumar Dash. 2022. “Effort Estimation of Software Products by Using UML Sequence Models with Regression Analysis.” In 2022 OITS International Conference on Information Technology (OCIT). IEEE. https://doi.org/10.1109/ocit56763.2022.00028
Saito, Hideki, Nicholas Stavrakos, Steven Carroll, Constantine Polychronopoulos, and Alex Nicolau. 1999. “The Design of the PROMIS Compiler.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-49051-7_15
Sakai, Ryoji. 1988. “An Application of a Microcomputer Compiler Program to Multiple Logistic Regression Analysis.” Medical Informatics 13 (2): 127–31. https://doi.org/10.3109/14639238809010088
Sakhrawi, Zaineb, Asma Sellami, and Nadia Bouassida. 2021. “Software Enhancement Effort Estimation Using Correlation-Based Feature Selection and Stacking Ensemble Method.” Cluster Computing 25 (4): 2779–92. https://doi.org/10.1007/s10586-021-03447-5
Sakhrawi, Zaineb, Asma Sellami, and Nadia Bouassida. 2022. “Software Enhancement Effort Estimation Using Stacking Ensemble Model within the Scrum Projects: A Proposed Web Interface.” In Proceedings of the 17th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011321000003266
Salama, Heba, Sameh Alansary, and Amany Elshazly. 2022. “Morphological Analysis of Egyptian Children Corpus by KIDEVAL Program.” In 2022 20th International Conference on Language Engineering (ESOLEC). IEEE. https://doi.org/10.1109/esolec54569.2022.10009437
Salamy, Hassan, and J. Ramanujam. 2008. “Optimal Address Register Allocation for Arrays in DSP Applications.” In 2008 IEEE/ACM/IFIP Workshop on Embedded Systems for Real-Time Multimedia. IEEE. https://doi.org/10.1109/estmed.2008.4696998
Salehi, Mohammad Javad, Seyed Abolfazl Motahari, and Babak Hossein Khalaj. 2018. “On the Optimality of 0–1 Data Placement in Cache Networks.” IEEE Transactions on Communications 66 (3): 1053–63. https://doi.org/10.1109/tcomm.2017.2771377
Salinas, Diego, and Tomás Zegard. 2022. “Discontinuity Layout Optimization Using Unstructured Meshes and Material Layering in 2D.” Structural and Multidisciplinary Optimization 65 (5): 156. https://doi.org/10.1007/s00158-022-03245-6
Salm, Marie, Johanna Barzen, Frank Leymann, and Philipp Wundrack. 2023. “How to Select Quantum Compilers and Quantum Computers before Compilation.” In Proceedings of the 13th International Conference on Cloud Computing and Services Science. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011775300003488
Salvador Rohwedder, Caio, João P. L. De Carvalho, and José Nelson Amaral. 2024. “Region-Based Data Layout via Data Reuse Analysis.” In Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3640537.3641571
Sanchez, Eduardo Rodriguez, Humberto Cervantes Maceda, and Eduardo Vazquez Santacruz. 2022. “Software Effort Estimation for Agile Software Development Using a Strategy Based on k-Nearest Neighbors Algorithm.” In 2022 IEEE Mexican International Conference on Computer Science (ENC). IEEE. https://doi.org/10.1109/enc56672.2022.9882947
Sánchez, Roberto, and Diego P. Pinto-Roa. 2017. “Design of Software Effort Estimation Models an Approach Based on Linear Genetic Programming.” In 2017 XLIII Latin American Computer Conference (CLEI). IEEE. https://doi.org/10.1109/clei.2017.8226469
Sánchez, Eduardo Rodríguez, Eduardo Vázquez Santacruz, and Humberto Cervantes Maceda. 2023. “Effort Estimation in Agile Software Development Using Autoencoders.” In 2023 12th International Conference On Software Process Improvement (CIMPS). IEEE. https://doi.org/10.1109/cimps61323.2023.10528839
Sandeep, R. C., Mary Sánchez-Gordón, Ricardo Colomo-Palacios, and Monica Kristiansen. 2022. “Effort Estimation in Agile Software Development: A Exploratory Study of Practitioners’ Perspective.” In Lean and Agile Software Development. Springer International Publishing. https://doi.org/10.1007/978-3-030-94238-0_8
Sander, G. 1999. “Graph Layout for Applications in Compiler Construction.” Theoretical Computer Science 217 (2): 175–214. https://doi.org/10.1016/s0304-3975(98)00270-9
Sanfey, Alan G., and Reid Hastie. 2002. “Interevent Relationships and Judgment under Uncertainty: Structure Determines Strategy.” Memory & Cognition 30 (6): 921–33. https://doi.org/10.3758/bf03195777
Sankaran, Nandakumar. 1994. “A Bibliography on Garbage Collection and Related Topics.” ACM SIGPLAN Notices 29 (9): 149–58. https://doi.org/10.1145/185009.185040
Sankaranarayanan, Sriram, Aleksandar Chakarov, and Sumit Gulwani. 2013. “Static Analysis for Probabilistic Programs: Inferring Whole Program Properties from Finitely Many Paths.” ACM SIGPLAN Notices 48 (6): 447–58. https://doi.org/10.1145/2499370.2462179
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
Sanocki, Thomas, Eric Sellers, Jeff Mittelstadt, and Noah Sulman. 2010. “How High Is Visual Short-Term Memory Capacity for Object Layout?” Attention, Perception, & Psychophysics 72 (4): 1097–1109. https://doi.org/10.3758/app.72.4.1097
Santhanam, Vatsa, and Daryl Odnert. 1990. “Register Allocation across Procedure and Module Boundaries.” In Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation - PLDI ‘90. ACM Press. https://doi.org/10.1145/93542.93551
Santhanaraman, Gopalakrishnan, Jiesheng Wu, and Dhabaleswar K. Panda. 2004. “Zero-Copy MPI Derived Datatype Communication over InfiniBand.” In Recent Advances in Parallel Virtual Machine and Message Passing Interface. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30218-6_14
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
Santos, Tiago, and Joao M. P. Cardoso. 2020. “Automatic Selection and Insertion of HLS Directives via a Source-to-Source Compiler.” In 2020 International Conference on Field-Programmable Technology (ICFPT). IEEE. https://doi.org/10.1109/icfpt51103.2020.00039
Santos, Joanna C. S., Reese A. Jones, and Mehdi Mirakhorli. 2020. “Salsa: Static Analysis of Serialization Features.” In Proceedings of the 22nd ACM SIGPLAN International Workshop on Formal Techniques for Java-Like Programs. ACM. https://doi.org/10.1145/3427761.3428343
Saougkos, Dimitris, George Manis, Konstantinos Blekas, and Apostolos V. Zarras. 2007. “Revisiting Java Bytecode Compression for Embedded and Mobile Computing Environments.” IEEE Transactions on Software Engineering 33 (7): 478–95. https://doi.org/10.1109/tse.2007.1021
Sarac, Omer Faruk, and Nevcihan Duru. 2013. “A Novel Method for Software Effort Estimation: Estimating with Boundaries.” In 2013 IEEE Inista. IEEE. https://doi.org/10.1109/inista.2013.6577643
Saranam, S. R. Swamy, and Madhu Mutyam. 2018. “TDC: Tagless DRAM Cache.” In 2018 IEEE Computer Society Annual Symposium on VLSI (ISVLSI). IEEE. https://doi.org/10.1109/isvlsi.2018.00026
Sarcar, A., and Yoonsik Cheon. 2010. “A New Eclipse-Based JML Compiler Built Using AST Merging.” In 2010 Second World Congress on Software Engineering. IEEE. https://doi.org/10.1109/wcse.2010.92
Sarferaz, Siar, and Wolfgang Hesse. 2001. “CEOS: A Cost Estimation Method for Evolutionary, Object-Oriented Software Development.” In New Approaches in Software Measurement. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44704-0_3
Sari Dewi, Renny, and Riyanarto Sarno. 2020. “Software Effort Estimation Using Early COSMIC to Substitute Use Case Weight.” In 2020 International Seminar on Application for Technology of Information and Communication (iSemantic). IEEE. https://doi.org/10.1109/isemantic50169.2020.9234227
Sarimbekov, Aibek, Philippe Moret, Walter Binder, Andreas Sewe, and Mira Mezini. 2011a. “Complete and Platform-Independent Calling Context Profiling for the Java Virtual Machine.” Electronic Notes in Theoretical Computer Science 279 (1): 61–74. https://doi.org/10.1016/j.entcs.2011.11.006
Sarimbekov, Aibek, Andreas Sewe, Walter Binder, Philippe Moret, and Mira Mezini. 2014. “JP2: Call-Site Aware Calling Context Profiling for the Java Virtual Machine.” Science of Computer Programming 79: 146–57. https://doi.org/10.1016/j.scico.2011.11.003
Sarkar, Subhradyuti, and Dean M. Tullsen. 2011. “Data Layout for Cache Performance on a Multithreaded Architecture.” In Transactions on High-Performance Embedded Architectures and Compilers III. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-19448-1_3
Sarkar, Dipanwita, Oscar Waddell, and R. Kent Dybvig. 2004. “A Nanopass Infrastructure for Compiler Education.” ACM SIGPLAN Notices 39 (9): 201–12. https://doi.org/10.1145/1016848.1016878
Saroha, Meenakshi, and Shashank Sahu. 2015a. “Software Effort Estimation Using Enhanced Use Case Point Model.” In International Conference on Computing, Communication & Automation. IEEE. https://doi.org/10.1109/ccaa.2015.7148515
Saroha, Meenakshi, and Shashank Sahu. 2015b. “Tools & Methods for Software Effort Estimation Using Use Case Points Model — A Review.” In International Conference on Computing, Communication & Automation. IEEE. https://doi.org/10.1109/ccaa.2015.7148498
Sarpiri, Mona Najafi, Mohammadreza Soltan Aghaei, and Taghi Javdani Gandomani. 2023. “Towards Better Software Development Effort Estimation with Analogy-Based Approach and Nature-Based Algorithms.” In 2023 International Conference on Information Technology (ICIT). IEEE. https://doi.org/10.1109/icit58056.2023.10225939
Sassano, Giuseppe. 2025. “The Holistic View in Forecasting: A Conceptual Framework to Analyze and Mitigate Cost Underestimation Arising from Optimism Bias.” Project Leadership and Society 6: 100177. https://doi.org/10.1016/j.plas.2025.100177
Sathiyavathi, A., C. Gethara Gowri, R. Sundar, J. Arockia Theo, L. Poornimadevi, and Suberiya S. Begum. 2026. “Enhancing Code Generation Using Instruction-Tuned Transformer Models for Multi-Language Software Development.” In 2026 IEEE 2nd International Conference on Quantum Photonics, Artificial Intelligence & Networking (QPAIN). IEEE. https://doi.org/10.1109/qpain69676.2026.11546564
Saxena, Urvashi Rahul, and S. P. Singh. 2012. “Software Effort Estimation Using Neuro-Fuzzy Approach.” In 2012 CSI Sixth International Conference on Software Engineering (CONSEG). IEEE. https://doi.org/10.1109/conseg.2012.6349465
“A Scala-Based Domain Specific Language for Structured Data Representation.” 2010. In Proceedings of the 5th International Conference on Software and Data Technologies. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0003010502960299
Scavuzzo, Marco, Elisabetta Di Nitto, and Stefano Ceri. 2014. “Interoperable Data Migration between NoSQL Columnar Databases.” In 2014 IEEE 18th International Enterprise Distributed Object Computing Conference Workshops and Demonstrations. IEEE. https://doi.org/10.1109/edocw.2014.32
Schafer, Andre, Wolfram Amme, and Thomas S. Heinze. 2021. “Stubber: Compiling Source Code into Bytecode without Dependencies for Java Code Clone Detection.” In 2021 IEEE 15th International Workshop on Software Clones (IWSC). IEEE. https://doi.org/10.1109/iwsc53727.2021.00011
Schäfer, André, Thomas S. Heinze, and Wolfram Amme. 2023. “Finding Source Code Clones in Intermediate Representations of Java Bytecode.” In 2023 IEEE 17th International Workshop on Software Clones (IWSC). IEEE. https://doi.org/10.1109/iwsc60764.2023.00014
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
“Schema Evolution for Stars and Snowflakes.” 2004. In Proceedings of the 4th International Workshop on Pattern Recognition in Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002619704250433
“SCHEMA EVOLUTION IN WIKIPEDIA: Toward a Web Information System Benchmark.” 2008. In Proceedings of the Tenth International Conference on Enterprise Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0001713003230332
Scherzinger, Stefanie, Thomas Cerqueus, and Eduardo Cunha De Almeida. 2015. “ControVol: A Framework for Controlled Schema Evolution in NoSQL Application Development.” In 2015 IEEE 31st International Conference on Data Engineering. IEEE. https://doi.org/10.1109/icde.2015.7113402
Schinz, Michel, and Martin Odersky. 2001. “Tail Call Elimination on the Java Virtual Machine.” Electronic Notes in Theoretical Computer Science 59 (1): 158–71. https://doi.org/10.1016/s1571-0661(05)80459-1
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
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
Schmidt, David A. 1995. “Natural-Semantics-Based Abstract Interpretation (Preliminary Version).” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60360-3_28
Schmidt, E. 1997. “Eric Schmidt on the Intranet Wars: Can the Java Virtual Machine Really Challenge Microsoft?” IEEE Internet Computing 1 (5): 8–15. https://doi.org/10.1109/mic.1997.623963
Schmidt, David A. 2009. “Abstract Interpretation from a Topological Perspective.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-03237-0_20
Schmidt, Patrick, and Jürgen Becker. 2024. “Ph.D. Project: Compiler-Driven Hardware/Software Co- Design for Embedded AI.” In 2024 IEEE 32nd Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm60383.2024.00055
Schmidt, David, and Bernhard Steffen. 1998. “Program Analysis as Model Checking of Abstract Interpretations.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-49727-7_22
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. 1992b. “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, Ze’ev. 2022. “Situating the Problematics of Judgment-Based Deselection: A Heuristics and Biases Approach.” Collection Management 47 (4): 316–35. https://doi.org/10.1080/01462679.2022.2030840
Schneider, Jean-Guy, and Sung Une Lee. 2022. “An Experimental Comparison of Clone Detection Techniques Using Java Bytecode.” In 2022 29th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec57359.2022.00026
Schoeberl, Martin. 2010. “Scheduling of Hard Real-Time Garbage Collection.” Real-Time Systems 45 (3): 176–213. https://doi.org/10.1007/s11241-010-9095-4
Schroeder, T., and M. Hoffmann. 2006. “Flexible Automatic Converting of NC Programs. a Cross-Compiler for Structured Text.” International Journal of Production Research 44 (13): 2671–79. https://doi.org/10.1080/00207540500455841
Schubert, Aleksy. 1998. “Second-Order Unification and Type Inference for Church-Style Polymorphism.” In Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘98. ACM Press. https://doi.org/10.1145/268946.268969
Schuck, J., N. Wehn, and M. Glesner. 1989. “ALGIC — A Silicon Compiler System for Digital Signal Processing.” Computer-Aided Design 21 (3): 184. https://doi.org/10.1016/0010-4485(89)90080-8
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
Schukat, Sirkka, Louisa von Plettenberg, and Heinke Heise. 2020. “Animal Welfare Programs in Germany—an Empirical Study on the Attitudes of Pig Farmers.” Agriculture 10 (12): 609. https://doi.org/10.3390/agriculture10120609
Schwarz, Alexander, and Christian Hochberger. 2021. “Performance Gain of a Data Flow Oriented ISA as Replacement for Java Bytecode.” In Architecture of Computing Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-81682-7_7
Schwarz, Michael, Simmo Saan, Helmut Seidl, Kalmer Apinis, Julian Erhard, and Vesal Vojdani. 2021. “Improving Thread-Modular Abstract Interpretation.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-88806-0_18
Schwarz, Martin D., Helmut Seidl, Vesal Vojdani, Peter Lammich, and Markus Müller-Olm. 2011. “Static Analysis of Interrupt-Driven Programs Synchronized via the Priority Ceiling Protocol.” In Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/1926385.1926398
Seemann, Jochen. 1997. “Extending the Sugiyama Algorithm for Drawing UML Class Diagrams: Towards Automatic Layout of Object-Oriented Software Diagrams.” In Graph Drawing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-63938-1_86
Sehra, Sumeet Kaur, Yadwinder Singh Brar, Navdeep Kaur, and Sukhjit Singh Sehra. 2017b. “Research Patterns and Trends in Software Effort Estimation.” Information and Software Technology 91: 1–21. https://doi.org/10.1016/j.infsof.2017.06.002
Sehra, Sumeet Kaur, Jasneet Kaur, Yadwinder Singh Brar, and Navdeep Kaur. 2014. “Analysis of Data Mining Techniques for Software Effort Estimation.” In 2014 11th International Conference on Information Technology: New Generations. IEEE. https://doi.org/10.1109/itng.2014.116
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
Seifi, Payam, Boris Epel, Colin Mailer, and Howard J. Halpern. 2010. “Multiple-Stepped Zeeman Field Offset Method Applied in Acquiring Enhanced Resolution Spin-Echo Electron Paramagnetic Resonance Images.” Medical Physics 37 (10): 5412–20. https://doi.org/10.1118/1.3475936
Seigler, Adrian E., Gary A. Van Huben, and Hari Mony. 2007. “Formal Verification of Partial Good Self-Test Fencing Structures.” In Formal Methods in Computer Aided Design (FMCAD’07). IEEE. https://doi.org/10.1109/fmcad.2007.4401999
Seitz, Kerry A., Jr., and Mark C. Lewis. 2012. “Virtual Machine and Bytecode for Optimization on Heterogeneous Systems.” In 2012 Ninth International Conference on Information Technology - New Generations. IEEE. https://doi.org/10.1109/itng.2012.116
Seitzer, Maximilian, Michael Gruhn, and Tilo Müller. 2015. “A Bytecode Interpreter for Secure Program Execution in Untrusted Main Memory.” In Computer Security – ESORICS 2015. Springer International Publishing. https://doi.org/10.1007/978-3-319-24177-7_19
Sejans, Janis, and Oksana Nikiforova. 2011. “Practical Experiments with Code Generation from the UML Class Diagram.” In Proceedings of the 3rd International Workshop on Model-Driven Architecture and Modeling-Driven Software Development. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0003581300570067
Sekar, Thenmozhi, and Ruby ElKharboutly. 2026. “Assessing AI-Based Code Generation Using Code Comments.” In 2026 5th International Informatics and Software Engineering Conference (IISEC). IEEE. https://doi.org/10.1109/iisec69317.2026.11418477
Sekar, R. C., Prateek Mishra, and I. V. Ramakrishnan. 1991. “On the Power and Limitation of Strictness Analysis Based on Abstract Interpretation.” In Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ‘91. ACM Press. https://doi.org/10.1145/99583.99591
Selsam, Daniel, and Leonardo de Moura. 2016. “Congruence Closure in Intensional Type Theory.” In Automated Reasoning. Springer International Publishing. https://doi.org/10.1007/978-3-319-40229-1_8
Sembrant, Andreas, Erik Hagersten, and David Black-Schaffer. 2016. “Data Placement across the Cache Hierarchy: Minimizing Data Movement with Reuse-Aware Placement.” In 2016 IEEE 34th International Conference on Computer Design (ICCD). IEEE. https://doi.org/10.1109/iccd.2016.7753269
Sen, Rathijit, and Y. N. Srikant. 2007. “Executable Analysis Using Abstract Interpretation with Circular Linear Progressions.” In 2007 5th IEEE/ACM International Conference on Formal Methods and Models for Codesign (MEMOCODE 2007). IEEE. https://doi.org/10.1109/memcod.2007.371251
Senevirathne, Dharshitha Srimal, and Thareendhra Keerthi Wijayasiriwardhane. 2020. “Extending Use-Case Point-Based Software Effort Estimation for Open Source Freelance Software Development.” In 2020 International Research Conference on Smart Computing and Systems Engineering (SCSE). IEEE. https://doi.org/10.1109/scse49731.2020.9313007
Seo, Yeong-Seok, and Doo-Hwan Bae. 2012. “On the Value of Outlier Elimination on Software Effort Estimation Research.” Empirical Software Engineering 18 (4): 659–98. https://doi.org/10.1007/s10664-012-9207-y
Seo, Yeong-Seok, Doo-Hwan Bae, and Ross Jeffery. 2013. “AREION: Software Effort Estimation Based on Multiple Regressions with Adaptive Recursive Data Partitioning.” Information and Software Technology 55 (10): 1710–25. https://doi.org/10.1016/j.infsof.2013.03.007
Seo, Yeong-Seok, Kyung-A. Yoon, and Doo-Hwan Bae. 2009. “Improving the Accuracy of Software Effort Estimation Based on Multiple Least Square Regression Models by Estimation Error-Based Data Partitioning.” In 2009 16th Asia-Pacific Software Engineering Conference. IEEE. https://doi.org/10.1109/apsec.2009.57
Sepanski, Benjamin, Tuowen Zhao, Hans Johansen, and Samuel Williams. 2022. “Maximizing Performance through Memory Hierarchy-Driven Data Layout Transformations.” In 2022 IEEE/ACM Workshop on Memory Centric High Performance Computing (MCHPC). IEEE. https://doi.org/10.1109/mchpc56545.2022.00006
Serebryany, Konstantin, Alexander Potapenko, Timur Iskhodzhanov, and Dmitriy Vyukov. 2012. “Dynamic Race Detection with LLVM Compiler.” In Runtime Verification. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-29860-8_9
Serodio, Carlos M. J. A., Pedro M. Mestre A. Silva, and Joao L. Monteiro. 2007. “A Java Virtual Machine for Smart Sensors and Actuators.” In 2007 IEEE International Symposium on Industrial Electronics. IEEE. https://doi.org/10.1109/isie.2007.4374827
Serpette, Bernard Paul, and Manuel Serrano. 2002. “Compiling Scheme to JVM Bytecode:: A Performance Study.” ACM SIGPLAN Notices 37 (9): 259–70. https://doi.org/10.1145/583852.581503
Seshadri, V., S. Weber, D. B. Wortman, C. P. Yu, and I. Small. 1988. “Semantic Analysis in a Concurrent Compiler.” In Proceedings of the ACM SIGPLAN 1988 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/53990.54013
“Session 4: Formal Verification.” 2008. In 2008 IEEE International High Level Design Validation and Test Workshop. IEEE. https://doi.org/10.1109/hldvt.2008.4695872
“Session 6: Formal Verification.” 2007. In 2007 IEEE International High Level Design Validation and Test Workshop. IEEE. https://doi.org/10.1109/hldvt.2007.4392795
Setiawan, Aldi, and Dana Sulistiyo Kusumo. 2025. “Enhancing Python Object-Relational Mapping Performance Using Just-in-Time Compiler.” In 2025 International Conference on Advancement in Data Science, E-learning and Information System (ICADEIS). IEEE. https://doi.org/10.1109/icadeis65852.2025.10933413
Seunghan Lee, Kyungsu Kang, and Chong-Min Kyung. 2010. “Temperature- and Bus Traffic- Aware Data Placement in 3D-Stacked Cache.” In 2010 18th IEEE/IFIP International Conference on VLSI and System-on-Chip. IEEE. https://doi.org/10.1109/vlsisoc.2010.5642686
Ŝevčik, Jaroslav, Viktor Vafeiadis, Francesco Zappa Nardelli, Suresh Jagannathan, and Peter Sewell. 2011. “Relaxed-Memory Concurrency and Verified Compilation.” ACM SIGPLAN Notices 46 (1): 43–54. https://doi.org/10.1145/1925844.1926393
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
Seymour, Keith, and Jack Dongarra. 2003. “Automatic Translation of Fortran to JVM Bytecode.” Concurrency and Computation: Practice and Experience 15 (3–5): 207–22. https://doi.org/10.1002/cpe.657
Sha, Guoquan. 2010. “Using Google as a Super Corpus to Drive Written Language Learning: A Comparison with the British National Corpus.” Computer Assisted Language Learning 23 (5): 377–93. https://doi.org/10.1080/09588221.2010.514576
Sha, Zhiyu. 2021. “Research on Optimal Layout of Sensors in Civil Engineering Structure Based on GIS System.” In 2021 IEEE Conference on Telecommunications, Optics and Computer Science (TOCS). IEEE. https://doi.org/10.1109/tocs53301.2021.9688907
Shabeera, T. P., S. D. Madhu Kumar, Sameera M. Salam, and K. Murali Krishnan. 2017. “Optimizing VM Allocation and Data Placement for Data-Intensive Applications in Cloud Using ACO Metaheuristic Algorithm.” Engineering Science and Technology, an International Journal 20 (2): 616–28. https://doi.org/10.1016/j.jestch.2016.11.006
Shahpar, Zahra, Vahid Khatibi Bardsiri, and Amid Khatibi Bardsiri. 2021a. “An Evolutionary Ensemble Analogy-Based Software Effort Estimation.” Software: Practice and Experience 52 (4): 929–46. https://doi.org/10.1002/spe.3040
Shahpar, Zahra, Vahid Khatibi Bardsiri, and Amid Khatibi Bardsiri. 2021b. “Polynomial Analogy-Based Software Development Effort Estimation Using Combined Particle Swarm Optimization and Simulated Annealing.” Concurrency and Computation: Practice and Experience 33 (20): e6358. https://doi.org/10.1002/cpe.6358
Shahzad, Hafsah, Ahmed Sanaullah, Sanjay Arora, et al. 2022. “Reinforcement Learning Strategies for Compiler Optimization in High Level Synthesis.” In 2022 IEEE/ACM Eighth Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc56686.2022.00007
Shaikot, Shariful Hasan, and Min Sik Kim. 2012. “Efficient Memory Layout for Packet Classification System on Multi-Core Architecture.” In 2012 IEEE Global Communications Conference (GLOBECOM). IEEE. https://doi.org/10.1109/glocom.2012.6503501
Shamizi, Sevin, and Shahriar Lotfi. 2011. “Register Allocation via Graph Coloring Using an Evolutionary Algorithm.” In Swarm, Evolutionary, and Memetic Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-27242-4_1
Shamsi, Jafar, Karim Mohammadi, and Shahriar B. Shokouhi. 2017. “Columnar-Organized Memory (COM): Brain-Inspired Associative Memory with Large Capacity and Robust Retrieval.” Biologically Inspired Cognitive Architectures 20: 39–46. https://doi.org/10.1016/j.bica.2017.02.002
Shan, Yuxiang, Zhan Shi, Dan Feng, Ouyang Mengyun, and Fang Wang. 2018. “Cache-Friendly Data Layout for Massive Graph.” In 2018 IEEE International Conference on Networking, Architecture and Storage (NAS). IEEE. https://doi.org/10.1109/nas.2018.8515737
Shang, Weiyi, Bram Adams, and Ahmed E. Hassan. 2012. “Using Pig as a Data Preparation Language for Large-Scale Mining Software Repositories Studies: An Experience Report.” Journal of Systems and Software 85 (10): 2195–2204. https://doi.org/10.1016/j.jss.2011.07.034
Shang, Jiandong, Kunkun Xu, Lin Han, Hongsheng Wang, Yunda Chai, and Xiaoyi Yang. 2023. “Optimization of Access Address Calculation for LLVM.” In 2023 4th International Conference on Information Science, Parallel and Distributed Systems (ISPDS). IEEE. https://doi.org/10.1109/ispds58840.2023.10235678
Shao, Zhong. 1997. “Flexible Representation Analysis.” ACM SIGPLAN Notices 32 (8): 85–98. https://doi.org/10.1145/258949.258958
Shao, Zhong, and Andrew W. Appel. 1995. “A Type-Based Compiler for Standard ML.” In Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/207110.207123
Shao, Zhong, Christopher League, and Stefan Monnier. 1998. “Implementing Typed Intermediate Languages.” ACM SIGPLAN Notices 34 (1): 313–23. https://doi.org/10.1145/291251.289460
Shaoshan Liu, Ligang Wang, Xiao-Feng Li, and Jean-Luc Gaudiot. 2009. “Packer: An Innovative Space-Time-Efficient Parallel Garbage Collection Algorithm Based on Virtual Spaces.” In 2009 IEEE International Symposium on Parallel & Distributed Processing. IEEE. https://doi.org/10.1109/ipdps.2009.5160989
“Shape and Layout Optimization of Structural Systems.” 1990. Structural Optimization 2 (1): 64–64. https://doi.org/10.1007/bf01743523
Shapiro, Marc, Fabrice Le Fessant, and Paulo Ferreira. 2000. “Recent Advances in Distributed Garbage Collection.” In Advances in Distributed Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-46475-1_5
Sharada, H. N., Basavaraj Anami, and Shridhar Allagi. 2024. “An Optimized Deep Network-Based Intermediate Code Generation for the Mathematical Expression.” Multimedia Tools and Applications 84 (17): 18327–50. https://doi.org/10.1007/s11042-024-19730-7
Sharaf, Mohamed, Jie Huang, and Chin-Tser Huang. 2013. “Using Bytecode Instrumentation to Secure Information Flow in Multithreaded Java Applications.” In 2013 IEEE 33rd International Conference on Distributed Computing Systems Workshops. IEEE. https://doi.org/10.1109/icdcsw.2013.15
Sharif, Amir, Roberto Carbone, Silvio Ranise, and Giada Sciarretta. 2019. “A Wizard-Based Approach for Secure Code Generation of Single Sign-On and Access Delegation Solutions for Mobile Native Apps.” In Proceedings of the 16th International Joint Conference on e-Business and Telecommunications. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0007930502680275
Sharma, Yashvardhan. 2016. “Effort Estimation for Program Modification in Object Oriented Development.” In Computational Science and Its Applications – ICCSA 2016. Springer International Publishing. https://doi.org/10.1007/978-3-319-42089-9_24
Sharma, Amrita, and Neha Chaudhary. 2020. “Linear Regression Model for Agile Software Development Effort Estimation.” In 2020 5th IEEE International Conference on Recent Advances and Innovations in Engineering (ICRAIE). IEEE. https://doi.org/10.1109/icraie51050.2020.9358309
Sharma, Babita, S. D. Dhodapkar, and S. Ramesh. 2003. “Assertion Checking Environment (ACE) for Formal Verification of C Programs.” Reliability Engineering & System Safety 81 (3): 281–90. https://doi.org/10.1016/s0951-8320(03)00092-9
Sharma, Archana, and Dharmveer Singh Rajpoot. 2023. “A Memetic Approach for Optimizing Software Effort Estimation Using Anti-Predatory NIA.” International Journal of Information Technology 16 (2): 641–49. https://doi.org/10.1007/s41870-023-01652-6
Sharma, Archana, and Dharmveer Singh Rajpoot. 2025. “An Adaptive Anti-Predatory Algorithm-Based Model to Enhance the Efficiency of Software Effort Estimation.” Innovations in Systems and Software Engineering 21 (4): 1331–47. https://doi.org/10.1007/s11334-025-00599-0
Sharma, Pinkashia, and Jaiteg Singh. 2017. “Systematic Literature Review on Software Effort Estimation Using Machine Learning Approaches.” In 2017 International Conference on Next Generation Computing and Information Systems (ICNGCIS). IEEE. https://doi.org/10.1109/icngcis.2017.33
Sharma, Ravi, and Mary Lou Soffa. 1991. “Parallel Generational Garbage Collection.” ACM SIGPLAN Notices 26 (11): 16–32. https://doi.org/10.1145/118014.117956
Shatnawi, Anas, Adem Bahri, Boubou Niang, and Benoit Verhaeghe. 2025. “Enhancing Data Serialization Efficiency in REST Services: Migrating from JSON to Protocol Buffers.” In Proceedings of the 20th International Conference on Software Technologies. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013459500003964
Shaylor, Nik, Douglas N. Simon, and William R. Bush. 2003. “A Java Virtual Machine Architecture for Very Small Devices.” ACM SIGPLAN Notices 38 (7): 34–41. https://doi.org/10.1145/780731.780738
Shen, Xiaoning, Jiaqi Lu, Shuxian Li, and Liyan Song. 2024. “Feature Mapping Based on Heterogeneous Cross-Company Effort Estimation.” Software Quality Journal 32 (4): 1717–61. https://doi.org/10.1007/s11219-024-09697-x
Shen, Bor-Yeh, Jyun-Yan You, Wuu Yang, and Wei-Chung Hsu. 2012. “An LLVM-Based Hybrid Binary Translation System.” In 7th IEEE International Symposium on Industrial Embedded Systems (SIES’12). IEEE. https://doi.org/10.1109/sies.2012.6356589
Shen, Zhiming, Christopher C. Young, Sai Zeng, Karin Murthy, and Kun Bai. 2016. “Identifying Resources for Cloud Garbage Collection.” In 2016 12th International Conference on Network and Service Management (CNSM). IEEE. https://doi.org/10.1109/cnsm.2016.7818426
Sheng, Weihua, Stefan Schürmans, Maximilian Odendahl, et al. 2014. “A Compiler Infrastructure for Embedded Heterogeneous MPSoCs.” Parallel Computing 40 (2): 51–68. https://doi.org/10.1016/j.parco.2013.11.007
Shengqi, Wu, Zhang Shidong, and Kong Lanju. 2012. “Schema Evolution via Multi-Version Metadata in SaaS.” Procedia Engineering 29: 1107–12. https://doi.org/10.1016/j.proeng.2012.01.096
Shepperd, M., and C. Schofield. 1997. “Estimating Software Project Effort Using Analogies.” IEEE Transactions on Software Engineering 23 (11): 736–43. https://doi.org/10.1109/32.637387
Sheta, A. 2006. “Software Effort Estimation and Stock Market Prediction Using Takagi-Sugeno Fuzzy Models.” In 2006 IEEE International Conference on Fuzzy Systems. IEEE. https://doi.org/10.1109/fuzzy.2006.1681711
Shi, Zhongyi, Fuzhang Wu, Weibin Zeng, Yan Kong, Sicheng Shen, and Yanjun Wu. 2025. “Algorithmic Inversion: A Learnable Algorithm Representation for Code Generation.” In 2025 IEEE/ACM 33rd International Conference on Program Comprehension (ICPC). IEEE. https://doi.org/10.1109/icpc66645.2025.00054
Shi, Rui, and Hongwei Xi. 2013. “A Linear Type System for Multicore Programming in ATS.” Science of Computer Programming 78 (8): 1176–92. https://doi.org/10.1016/j.scico.2012.09.005
Shiba, Masahito. 2018. “Controlling the Priority of Garbage Collection Based on the Value of Objects.” In 2018 IEEE 7th Global Conference on Consumer Electronics (GCCE). IEEE. https://doi.org/10.1109/gcce.2018.8574741
Shibata, Ryoichi, Atsuya Sonoyama, Masato Oguchi, Takeshi Kamiyama, Akira Fukuda, and Saneyasu Yamaguchi. 2020. “Java Android Application Performance Improvement by Kotlin DEX Bytecode Analysis without JIT Compiler.” In 2020 IEEE International Conference on Consumer Electronics - Taiwan (ICCE-Taiwan). IEEE. https://doi.org/10.1109/icce-taiwan49838.2020.9258095
Shiel, Sam, and Ian Bayley. 2005. “A Translation-Facilitated Comparison between the Common Language Runtime and the Java Virtual Machine.” Electronic Notes in Theoretical Computer Science 141 (1): 35–52. https://doi.org/10.1016/j.entcs.2005.02.039
Shim, Jeong Min, Seok Il Song, Jae Soo Yoo, and Young Soo Min. 2004. “An Efficient Cache Conscious Multi-Dimensional Index Structure.” Information Processing Letters 92 (3): 133–42. https://doi.org/10.1016/j.ipl.2004.06.017
Shimmi, Samiha S., Gokila Dorai, Umit Karabiyik, and Sudhir Aggarwal. 2020. “Analysis of iOS SQLite Schema Evolution for Updating Forensic Data Extraction Tools.” In 2020 8th International Symposium on Digital Forensics and Security (ISDFS). IEEE. https://doi.org/10.1109/isdfs49300.2020.9116208
Shin, MinSeung, Jongbeom Kim, Yunjeong Shin, and Taigon Song. 2023. “A Compact Q-Learning-Based Standard Cell Layout Compiler for 3nm GAAFET and Beyond.” In 2023 20th International SoC Design Conference (ISOCC). IEEE. https://doi.org/10.1109/isocc59558.2023.10396096
Shinohara, H., N. Matsumoto, K. Fujimori, et al. 1991. “A Flexible Multiport RAM Compiler for Data Path.” IEEE Journal of Solid-State Circuits 26 (3): 343–49. https://doi.org/10.1109/4.75013
Shiraishi, Kenjiro. 2025. “Clarifying the Gateway Hypothesis and Conflict of Interest in Cannabis Research.” Neuropsychopharmacology Reports 45 (3): e70056. https://doi.org/10.1002/npr2.70056
Shoroye, Zakariyah, Waheeb Yaqub, Azhar Ahmed Mohammed, Zeyar Aung, and Davor Svetinovic. 2015. “Exploring Social Contagion in Open-Source Communities by Mining Software Repositories.” In Neural Information Processing. Springer International Publishing. https://doi.org/10.1007/978-3-319-26561-2_15
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
Shrivastava, Aviral, Ilya Issenin, and Nikil Dutt. 2008. “A Compiler-in-the-Loop Framework to Explore Horizontally Partitioned Cache Architectures.” In 2008 Asia and South Pacific Design Automation Conference. IEEE. https://doi.org/10.1109/aspdac.2008.4483968
Shudo, Kazuyuki, Satoshi Sekiguchi, and Yoichi Muraoka. 2004. “Cost-Effective Compilation Techniques for Java Just-in-Time Compilers.” Systems and Computers in Japan 35 (12): 10–24. https://doi.org/10.1002/scj.10564
Shukla, Suyash, and Sandeep Kumar. 2019. “Applicability of Neural Network Based Models for Software Effort Estimation.” In 2019 IEEE World Congress on Services (SERVICES). IEEE. https://doi.org/10.1109/services.2019.00094
Shukla, Suyash, and Sandeep Kumar. 2021a. “An Extreme Learning Machine Based Approach for Software Effort Estimation.” In Proceedings of the 16th International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010397700470057
Shukla, Suyash, and Sandeep Kumar. 2021b. “A Stacking Ensemble-Based Approach for Software Effort Estimation.” In Proceedings of the 16th International Conference on Evaluation of Novel Approaches to Software Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0010405002050212
Shukla, Suyash, and Sandeep Kumar. 2023. “Self-Adaptive Ensemble-Based Approach for Software Effort Estimation.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00060
Shukla, Suyash, and Sandeep Kumar. 2026. “Locality-Based Self-Adjustable Ensemble Approach for Effort Estimation.” Journal of Software: Evolution and Process 38 (4): e70109. https://doi.org/10.1002/smr.70109
Shukla, Suyash, Sandeep Kumar, and Pravas Ranjan Bal. 2019. “Analyzing Effect of Ensemble Models on Multi-Layer Perceptron Network for Software Effort Estimation.” In 2019 IEEE World Congress on Services (SERVICES). IEEE. https://doi.org/10.1109/services.2019.00116
Shukla, R., and A. K. Misra. 2009. “AI Based Framework for Dynamic Modeling of Software Maintenance Effort Estimation.” In 2009 International Conference on Computer and Automation Engineering. IEEE. https://doi.org/10.1109/iccae.2009.47
Shukla, Ruchi, Mukul Shukla, A. K. Misra, T. Marwala, and W. A. Clarke. 2012. “Dynamic Software Maintenance Effort Estimation Modeling Using Neural Network, Rule Engine and Multi-Regression Approach.” In Computational Science and Its Applications – ICCSA 2012. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-31128-4_12
Shuyi Shao, A. K. Jones, and R. Melhem. 2006. “A Compiler-Based Communication Analysis Approach for Multiprocessor Systems.” In Proceedings 20th IEEE International Parallel & Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2006.1639322
Sidiropoulos, Harry, Kostas Siozios, Peter Figuli, Dimitrios Soudris, and Michael Hubner. 2012. “On Supporting Efficient Partial Reconfiguration with Just-In-Time Compilation.” In 2012 IEEE 26th International Parallel and Distributed Processing Symposium Workshops & PhD Forum. IEEE. https://doi.org/10.1109/ipdpsw.2012.40
Siebel, Nils T., Andreas Jordt, and Gerald Sommer. 2010. “Accelerating Neuro-Evolution by Compilation to Native Machine Code.” In The 2010 International Joint Conference on Neural Networks (IJCNN). IEEE. https://doi.org/10.1109/ijcnn.2010.5596296
Siebert, Fridtjof. 2001. “Constant-Time Root Scanning for Deterministic Garbage Collection.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45306-7_21
Siebert, Fridtjof. 2010. “Concurrent, Parallel, Real-Time Garbage-Collection.” ACM SIGPLAN Notices 45 (8): 11–20. https://doi.org/10.1145/1837855.1806654
Sieh, Volkmar, Robert Burlacu, Timo Honig, et al. 2019. “Combining Automated Measurement-Based Cost Modeling with Static Worst-Case Execution-Time and Energy-Consumption Analyses.” IEEE Embedded Systems Letters 11 (2): 38–41. https://doi.org/10.1109/les.2018.2868823
Silhavy, Petr, Radek Silhavy, and Zdenka Prokopova. 2019a. “Categorical Variable Segmentation Model for Software Development Effort Estimation.” IEEE Access 7: 9618–26. https://doi.org/10.1109/access.2019.2891878
Silhavy, Petr, Radek Silhavy, and Zdenka Prokopova. 2021. “Spectral Clustering Effect in Software Development Effort Estimation.” Symmetry 13 (11): 2119. https://doi.org/10.3390/sym13112119
Silva, Stallin E. F., and Mario L. Cortes. 2017. “Use of Non-Functional Requirements in Software Effort Estimation: Systematic Review and Experimental Results.” In 2017 5th International Conference in Software Engineering Research and Innovation (CONISOFT). IEEE. https://doi.org/10.1109/conisoft.2017.00008
Silva, Wilamis, Bernan Nascimento, Péricles Miranda, and Emanuel Vicente. 2025. “Predictive Regression Models of Machine Learning for Effort Estimation in Software Teams: An Experimental Study.” In Proceedings of the 27th International Conference on Enterprise Information Systems. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013284800003929
Silva, Pedro Zaffalon da, Helen Cristina de Mattos Senefonte, and Wesley Attrot. 2024. “Interference Graph Dataset for Machine Learning-Based Register Allocation.” IEEE Access 12: 157574–86. https://doi.org/10.1109/access.2024.3481358
Silvestru, Claudiu, and Tu Wien. 2013. “The Late Medieval Street Layout of Vienna: Digital 2D Reconstruction and Space Syntax Analysis of the Public Space.” In 2013 Digital Heritage International Congress (DigitalHeritage). IEEE. https://doi.org/10.1109/digitalheritage.2013.6743820
Simão, José, Tiago Garrochinho, and Luís Veiga. 2011. “A Checkpointing-Enabled and Resource-Aware Java Virtual Machine for Efficient and Robust e-Science Applications in Grid Environments.” Concurrency and Computation: Practice and Experience 24 (13): 1421–42. https://doi.org/10.1002/cpe.1879
Simaremare, Mario, and Henry Edison. 2024. “The State of Generative AI Adoption from Software Practitioners’ Perspective: An Empirical Study.” In 2024 50th Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa64295.2024.00024
Simon, Gábor. 1993. “Design and Implementation of a Retargetable ALDES Compiler.” In Design and Implementation of Symbolic Computation Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-57272-4_33
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
Simumba, Naomi, Daiki Kimura, and Michiaki Tatsubori. 2024. “Towards Efficient Satellite Data Representation Learning with Consistency Loss.” In IGARSS 2024 - 2024 IEEE International Geoscience and Remote Sensing Symposium. IEEE. https://doi.org/10.1109/igarss53475.2024.10640402
Sinai, Gideon. 2011. “Layout Structure of Multi-Quality Irrigation Networks: I—Introduction and Layout Types.” Irrigation and Drainage Systems 25 (4): 179–95. https://doi.org/10.1007/s10795-011-9109-y
Singapura, Shreyas G., Rajgopal Kannan, and Viktor K. Prasanna. 2016. “On-Chip Memory Efficient Data Layout for 2D FFT on 3D Memory Integrated FPGA.” In 2016 IEEE High Performance Extreme Computing Conference (HPEC). IEEE. https://doi.org/10.1109/hpec.2016.7761606
Singh, Gagandeep. 2023. “Building Trust and Safety in Artificial Intelligence with Abstract Interpretation.” In Static Analysis. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-44245-2_3
Singh, V. K., S. H. Ankadi, and D. Das. 2011. “Study of Combined Effects of Zero Copy and Pre-Processing on Input/Output Performance of Multimedia on Demand Streaming Server.” In 2011 Third International Conference on Communication Systems and Networks (COMSNETS 2011). IEEE. https://doi.org/10.1109/comsnets.2011.5716477
Singh, Siddhartha, Parikhit Baruah, Sachin Rai, and Ram Kumar Karsh. 2020. “Solar Powered IoT Based Garbage Collection System.” In 2020 International Conference on Communication and Signal Processing (ICCSP). IEEE. https://doi.org/10.1109/iccsp48568.2020.9182257
Singh, Mahesh Bahadur, and Asif Khan. 2025. “Evaluation of Software Development Effort Estimation via Computational Intelligence.” In 2025 International Conference on Cognitive Computing in Engineering, Communications, Sciences and Biomedical Health Informatics (IC3ECSBHI). IEEE. https://doi.org/10.1109/ic3ecsbhi63591.2025.10991190
Sinha, Ranjan, and Justin Zobel. 2004. “Cache-Conscious Sorting of Large Sets of Strings with Dynamic Tries.” ACM Journal of Experimental Algorithmics 9. https://doi.org/10.1145/1005813.1041517
Sinharoy, Balaram. 1999. “Compiler Optimization to Improve Data Locality for Processor Multithreading.” Scientific Programming 7 (1): 21–37. https://doi.org/10.1155/1999/235625
Sinn, Moritz, Florian Zuleger, and Helmut Veith. 2017. “Complexity and Resource Bound Analysis of Imperative Programs Using Difference Constraints.” Journal of Automated Reasoning 59 (1): 3–45. https://doi.org/10.1007/s10817-016-9402-4
Sîrbu, Alexandru-Gabriel, and Gabriela Czibula. 2025. “Automatic Code Generation Based on Abstract Syntax-Based Encoding. Application on Malware Detection Code Generation Based on MITRE ATT&CK Techniques.” Expert Systems with Applications 264: 125821. https://doi.org/10.1016/j.eswa.2024.125821
Sites, Richard L. 1979. “Machine-Independent Register Allocation.” ACM SIGPLAN Notices 14 (8): 221–25. https://doi.org/10.1145/872732.806973
Situ, Ping, and Jeanne F. Voyles. 2008. “Collecting Forever or Just-In-Time: An Alternative to Enhance Customers’ Access to Chinese Language Materials through Resource Sharing.” Resource Sharing & Information Networks 19 (1–2): 39–50. https://doi.org/10.1080/07377790802421384
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
Sjøberg, D. 1993. “Quantifying Schema Evolution.” Information and Software Technology 35 (1): 35–44. https://doi.org/10.1016/0950-5849(93)90027-z
Skalistis, Stefanos, and Alena Simalatsar. 2016. “Worst-Case Execution Time Analysis for Many-Core Architectures with NoC.” In Formal Modeling and Analysis of Timed Systems. Springer International Publishing. https://doi.org/10.1007/978-3-319-44878-7_13
Skalka, Christian, David Darais, Trent Jaeger, and Frank Capobianco. 2020. “Types and Abstract Interpretation for Authorization Hook Advice.” In 2020 IEEE 33rd Computer Security Foundations Symposium (CSF). IEEE. https://doi.org/10.1109/csf49147.2020.00018
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
Skeppstedt, Jonas, and Per Stenström. 1994. “Simple Compiler Algorithms to Reduce Ownership Overhead in Cache Coherence Protocols.” ACM SIGPLAN Notices 29 (11): 286–96. https://doi.org/10.1145/195470.195572
Slobodova, Anna. 2008. “Formal Verification of Hardware Support for Advanced Encryption Standard.” In 2008 Formal Methods in Computer-Aided Design. IEEE. https://doi.org/10.1109/fmcad.2008.ecp.12
Sluzenski, Julia, and Timothy P. McNamara. 2011. “The Organization of Room Geometry and Object Layout Geometry in Human Memory.” Psychonomic Bulletin & Review 18 (4): 758–66. https://doi.org/10.3758/s13423-011-0098-5
Smith, Eric, and David L. Dill. 2008. “Automatic Formal Verification of Block Cipher Implementations.” In 2008 Formal Methods in Computer-Aided Design. IEEE. https://doi.org/10.1109/fmcad.2008.ecp.10
Smith, R. K., J. E. Hale, and A. S. Parrish. 2001. “An Empirical Study Using Task Assignment Patterns to Improve the Accuracy of Software Effort Estimation.” IEEE Transactions on Software Engineering 27 (3): 264–71. https://doi.org/10.1109/32.910861
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, T., S. Srinivas, P. Tomsich, and Jinpyo Park. 2002. “Experiences with Retargeting the Java HotSpot Virtual Machine.” In Proceedings 16th International Parallel and Distributed Processing Symposium. IEEE. https://doi.org/10.1109/ipdps.2002.1016507
Smith, Geoffrey, and Dennis Volpano. 1998. “A Sound Polymorphic Type System for a Dialect of C.” Science of Computer Programming 32 (1–3): 49–72. https://doi.org/10.1016/s0167-6423(97)00030-0
So, Sunbeom, and Hakjoo Oh. 2017. “Synthesizing Imperative Programs from Examples Guided by Static Analysis.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-66706-5_18
“Software Effort Estimation as a Classification Problem.” 2008. In Proceedings of the Third International Conference on Software and Data Technologies Special Session on Applications in Banking and Finance. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0001877802740277
Soliman, Mohamed, Michel Albonico, Ivano Malavolta, and Andreas Wortmann. 2025. “Mining Software Repositories for Software Architecture — A Systematic Mapping Study.” Information and Software Technology 181: 107677. https://doi.org/10.1016/j.infsof.2025.107677
Soltani Siapoush, Mina, and Jim Alves-Foss. 2025. “Zero-Copy Messaging: Low-Latency Inter-Task Communication in CHERI-Enabled RTOS.” Future Internet 17 (11): 506. https://doi.org/10.3390/fi17110506
Solworth, J. A. 1986. “GENERIC: A Silicon Compiler Support Language.” In 23rd ACM/IEEE Design Automation Conference. IEEE. https://doi.org/10.1109/dac.1986.1586138
Somani, Antariksh, and Swati Srivastava. 2019. “Implementation of SAAS Intranet Compiler in PHP.” SSRN Electronic Journal. https://doi.org/10.2139/ssrn.3366275
Somogyi, Norbert, and Gergely Mezei. 2023. “Verifying Static Constraints on Models Using General Formal Verification Methods.” In Proceedings of the 11th International Conference on Model-Based Software and Systems Engineering. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0011796500003402
Son, S. W., G. Chen, M. Kandemir, and A. Choudhary. 2005. “Exposing Disk Layout to Compiler for Reducing Energy Consumption of Parallel Disk Based Systems.” In Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming. ACM. https://doi.org/10.1145/1065944.1065968
Son, YunSik, and YangSun Lee. 2012. “A Study on the Java Compiler for the Smart Virtual Machine Platform.” In Computer Applications for Bio-technology, Multimedia, and Ubiquitous City. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-35521-9_17
Song, Dawn. 2016. “Formal Verification for Computer Security: Lessons Learned and Future Directions.” In 2016 Formal Methods in Computer-Aided Design (FMCAD). IEEE. https://doi.org/10.1109/fmcad.2016.7886647
Song, Junsup, and Dongkun Shin. 2014. “Performance Improvement with Zero Copy Technique on FUSE-Based Consumer Devices.” In 2014 IEEE International Conference on Consumer Electronics (ICCE). IEEE. https://doi.org/10.1109/icce.2014.6776074
Song, Zihua, Junfeng Wang, Shengli Liu, Zhiyang Fang, and Kaiyuan Yang. 2022. “HGVul: A Code Vulnerability Detection Method Based on Heterogeneous Source-Level Intermediate Representation.” Security and Communication Networks 2022: 1–13. https://doi.org/10.1155/2022/1919907
Song, Ziyu, Shan Wu, and Yuqin Zhou. 2025. “Code like an Economist: Analyzing LLMs’ Code Generation Capabilities in Economics and Finance.” Finance Research Letters 86: 108540. https://doi.org/10.1016/j.frl.2025.108540
Song, Huaiming, Yanlong Yin, Yong Chen, and Xian-He Sun. 2012. “Cost-Intelligent Application-Specific Data Layout Optimization for Parallel File Systems.” Cluster Computing 16 (2): 285–98. https://doi.org/10.1007/s10586-012-0200-4
Song, Tae-Hoon, Kyung-A. Yoon, and Doo-Hwan Bae. 2007. “An Approach to Probabilistic Effort Estimation for Military Avionics Software Maintenance by Considering Structural Characteristics.” In 14th Asia-Pacific Software Engineering Conference (APSEC’07). IEEE. https://doi.org/10.1109/apsec.2007.19
Sonnleitner, Erik, Marc Kurz, and Alexander Palmanshofer. 2019. “Indirect Data Representation via Offset Vectoring: A Code-Integrity-Driven in-Memory Data Regeneration Scheme.” In Proceedings of the 16th International Joint Conference on e-Business and Telecommunications. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0007786703330340
Sonoyama, Atsuya, Takeshi Kamiyama, Masato Oguchi, and Saneyasu Yamaguchi. 2021. “Performance Study of Kotlin and Java Program Considering Bytecode Instructions and JVM JIT Compiler.” In 2021 Ninth International Symposium on Computing and Networking Workshops (CANDARW). IEEE. https://doi.org/10.1109/candarw53999.2021.00028
Soomro, Safeeullah, Mohammad Riyaz Belgaum, Zainab Alansari, and Mahdi H. Miraz. 2018. “A Framework for Debugging Java Programs in a Bytecode.” In 2018 International Conference on Computing, Electronics & Communications Engineering (iCCECE). IEEE. https://doi.org/10.1109/iccecome.2018.8658589
Soueidi, Chukri, Ali Kassem, and Yliès Falcone. 2020. “BISM: Bytecode-Level Instrumentation for Software Monitoring.” In Runtime Verification. Springer International Publishing. https://doi.org/10.1007/978-3-030-60508-7_18
Spector, David. 1982. “Minimal Overhead Garbage Collection of Complex List Structure.” ACM SIGPLAN Notices 17 (3): 80–82. https://doi.org/10.1145/947912.947919
Spezialetti, Madalene, and Rajiv Gupta. 1994. “Perturbation Analysis: A Static Analysis Approach for the Non-Intrusive Monitoring of Distributed Programs.” In 1994 International Conference on Parallel Processing (ICPP’94). IEEE. https://doi.org/10.1109/icpp.1994.162
Spoto, Fausto, Fred Mesnard, and Étienne Payet. 2010. “A Termination Analyzer for Java Bytecode Based on Path-Length.” ACM Transactions on Programming Languages and Systems 32 (3): 1–70. https://doi.org/10.1145/1709093.1709095
Spoto, Fausto, and Étienne Payet. 2010. “Magic-Sets for Localised Analysis of Java Bytecode.” Higher-Order and Symbolic Computation 23 (1): 29–86. https://doi.org/10.1007/s10990-010-9063-7
Springer, Matthias, Yaozhu Sun, and Hidehiko Masuhara. 2018. “Inner Array Inlining for Structure of Arrays Layout.” In Proceedings of the 5th ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming. ACM. https://doi.org/10.1145/3219753.3219760
Sridhar, Sashank, and Sowmya Sanagavarapu. 2020. “A Compiler-Based Approach for Natural Language to Code Conversion.” In 2020 3rd International Conference on Computer and Informatics Engineering (IC2IE). IEEE. https://doi.org/10.1109/ic2ie50715.2020.9274674
Sridhar, Swaroop, Jonathan S. Shapiro, and Scott F. Smith. 2008. “Sound and Complete Type Inference for a Systems Programming Language.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-89330-1_21
Sridi, Marwa, Bruno Raffin, and Vincent Faucher. 2016. “Cache Aware Dynamics Data Layout for Efficient Shared Memory Parallelisation of EUROPLEXUS.” Procedia Computer Science 80: 1083–92. https://doi.org/10.1016/j.procs.2016.05.413
Srinivasan, S. 1990. “Compiler Design for Sets in Pascal.” ACM SIGPLAN Notices 25 (1): 23–24. https://doi.org/10.1145/74105.74107
Srivastava, Garima, Yeshwant More, and Jenifer Sam. 2020. “Effort Estimation Model for an Enterprise Software Upgrade.” In 2020 International Conference for Emerging Technology (INCET). IEEE. https://doi.org/10.1109/incet49848.2020.9154073
Srivastava, Devesh Kumar, Akhilesh Kumar Sharma, and Deevesh Choudhary. 2021. “Software Development Effort Estimation Using Machine Learning Techniques: Multi-Linear Regression versus Random Forest.” In 2021 International Conference on Computing, Communication and Green Engineering (CCGE). IEEE. https://doi.org/10.1109/ccge50943.2021.9776394
Staiger, Stefan. 2007. “Static Analysis of Programs with Graphical User Interface.” In 11th European Conference on Software Maintenance and Reengineering (CSMR’07). IEEE. https://doi.org/10.1109/csmr.2007.44
Stamelos, Ioannis, and Lefteris Angelis. 2001. “Managing Uncertainty in Project Portfolio Cost Estimation.” Information and Software Technology 43 (13): 759–68. https://doi.org/10.1016/s0950-5849(01)00183-5
Standish, Thomas A. 1969. “Some Compiler-Compiler Techniques for Use in Extensible Languages.” ACM SIGPLAN Notices 4 (8): 55–62. https://doi.org/10.1145/1115858.1115872
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
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
Steele, Guy L. 1975. “Multiprocessing Compactifying Garbage Collection.” Communications of the ACM 18 (9): 495–508. https://doi.org/10.1145/361002.361005
Stefanović, Darko, Matthew Hertz, Stephen M. Blackburn, Kathryn S. McKinley, and J. Eliot B. Moss. 2002. “Older-First Garbage Collection in Practice: Evaluation in a Java Virtual Machine.” ACM SIGPLAN Notices 38 (2 supplement): 25–36. https://doi.org/10.1145/773039.773042
Steger, N., H. Schmidt, U. Guntzer, and W. Kiessling. 1989. “Semantics and Efficient Compilation for Quantitative Deductive Databases.” In [1989] Proceedings. Fifth International Conference on Data Engineering. IEEE. https://doi.org/10.1109/icde.1989.47274
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
Stell, Lance K. 2010. “Conflict of Interest in Diabetes Research.” Journal of Diabetes 2 (1): 5–6. https://doi.org/10.1111/j.1753-0407.2009.00061.x
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
Stephenson, K. 1998. “Towards an Algebraic Specification of the Java Virtual Machine.” In Prospects for Hardware Foundations. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-49254-2_7
Stepp, Michael, Ross Tate, and Sorin Lerner. 2011. “Equality-Based Translation Validator for LLVM.” In Computer Aided Verification. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-22110-1_59
Steuwer, Michel, Toomas Remmelg, and Christophe Dubach. 2017. “LIFT: A Functional Data-Parallel IR for High-Performance GPU Code Generation.” In 2017 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2017.7863730
Stevens, Jim. 2007. “Hybridthreads Compiler: Generation of Application Specific Hardware Thread Cores from C.” In 2007 International Conference on Field Programmable Logic and Applications. IEEE. https://doi.org/10.1109/fpl.2007.4380704
Stichnoth, James M., Guei-Yuan Lueh, and Michał Cierniak. 1999. “Support for Garbage Collection at Every Instruction in a Java Compiler.” In Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/301618.301652
Stickel, Mark E. 1988. “A Prolog Technology Theorem Prover: Implementation by an Extended Prolog Compiler.” Journal of Automated Reasoning 4 (4): 353–80. https://doi.org/10.1007/bf00297245
Stievenart, Quentin, Jens Nicolay, Wolfgang De Meuter, and Coen De Roover. 2015. “Poster: Static Analysis of Concurrent Higher-Order Programs.” In 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering. IEEE. https://doi.org/10.1109/icse.2015.265
Štill, Vladimír, Petr Ročkai, and Jiří Barnat. 2016. “Weak Memory Models as LLVM-to-LLVM Transformations.” In Mathematical and Engineering Methods in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-29817-7_13
Stinnett, J. Ryan, and Stephen Kell. 2024. “Accurate Coverage Metrics for Compiler-Generated Debugging Information.” In Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3640537.3641578
Stockhausen, Peter F. 1973. “Adapting Optimal Code Generation for Arithmetic Expressions to the Instruction Sets Available on Present-Day Computers.” Communications of the ACM 16 (6): 353–54. https://doi.org/10.1145/362248.362260
Stoica, Florin, and Laura Florentina Stoica. 2024. “Formal Verification of Business Constraints in Workflow-Based Applications.” Information 15 (12): 778. https://doi.org/10.3390/info15120778
Strecker, Martin. 2002. “Formal Verification of a Java Compiler in Isabelle.” In Automated Deduction—CADE-18. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45620-1_5
Strolenberg, Chris W. H. 1992. “Technology-Independent Design Using the ASA Silicon Compiler.” Microelectronics Journal 23 (8): 651–64. https://doi.org/10.1016/0026-2692(92)90132-k
Strout, Michelle Mills, John Mellor-Crummey, and Paul Hovland. 2005. “Representation-Independent Program Analysis.” In Proceedings of the 6th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering. ACM. https://doi.org/10.1145/1108792.1108810
Strzodka, Robert. 2012. “Data Layout Optimization for Multi-Valued Containers in OpenCL.” Journal of Parallel and Distributed Computing 72 (9): 1073–82. https://doi.org/10.1016/j.jpdc.2011.10.012
Stuchlik, Andreas, and Stefan Hanenberg. 2011. “Static vs. Dynamic Type Systems: An Empirical Study about the Relationship between Type Casts and Development Time.” ACM SIGPLAN Notices 47 (2): 97–106. https://doi.org/10.1145/2168696.2047861
Su, ChiaHui, Chia-Hua Ku, Jenq Kuen Lee, and Kuan-Hsun Chen. 2024. “TreeHouse: An MLIR-Based Compilation Flow for Real-Time Tree-Based Inference.” ACM Transactions on Embedded Computing Systems: 3704727. https://doi.org/10.1145/3704727
Su, Chia-Yi, and Collin McMillan. 2026. “Do Code LLMs Do Static Analysis?” Empirical Software Engineering 31 (5): 116. https://doi.org/10.1007/s10664-026-10853-z
Su, Yu, and Junyi Zhang. 2026. “A Zero-Copy Lock-Free Data Pipeline for Edge Streaming.” Information Sciences 739: 123171. https://doi.org/10.1016/j.ins.2026.123171
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
Subhameena, M., A. Rajesh, A. Packialatha, P. Thilakavathy, and A. Banushri. 2025. “LSTM-Based Malware Classification Using Bytecode and Opcode Features for IoT Security.” In 2025 8th International Conference on Computing Methodologies and Communication (ICCMC). IEEE. https://doi.org/10.1109/iccmc65190.2025.11140834
Subramani, Raja, Haritima Swapnil, Niharika Thakur, Bharath Radhakrishnan, and Krishnamurthy Puttaiah. 2013. “Garbage Collection Algorithms for NAND Flash Memory Devices – an Overview.” In 2013 European Modelling Symposium. IEEE. https://doi.org/10.1109/ems.2013.14
Subramanian, Girish H., and Steven Breslawski. 1993. “Dimensionality Reduction in Software Development Effort Estimation.” Journal of Systems and Software 21 (2): 187–96. https://doi.org/10.1016/0164-1212(93)90041-u
Subramanian, Ram, and Santosh Pande. 2001. “A Data Re-Use Based Compiler Optimization for FPGAs.” In Field-Programmable Logic and Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-44687-7_72
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
Suganuma, Toshio, Toshiaki Yasue, Motohiro Kawahito, Hideaki Komatsu, and Toshio Nakatani. 2001. “A Dynamic Optimization Framework for a Java Just-in-Time Compiler.” In Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications. ACM. https://doi.org/10.1145/504282.504296
Suganuma, Toshio, Toshiaki Yasue, and Toshio Nakatani. 2003. “A Region-Based Compilation Technique for a Java Just-in-Time Compiler.” ACM SIGPLAN Notices 38 (5): 312–23. https://doi.org/10.1145/780822.781166
Suharjito, Saka Nanda, and Benfano Soewito. 2016. “Modeling Software Effort Estimation Using Hybrid PSO-ANFIS.” In 2016 International Seminar on Intelligent Technology and Its Applications (ISITIA). IEEE. https://doi.org/10.1109/isitia.2016.7828661
Sukri, Hanifudin, Ach. Dafid, and Ari Basuki. 2022. “Design of Garbage Collection Robots in Tourism Area (Beach) with Artificial Neural Network Method.” In 2022 IEEE 8th Information Technology International Seminar (ITIS). IEEE. https://doi.org/10.1109/itis57155.2022.10010038
Sulzmann, Martin, and Stefan Wehr. 2022. “Semantic Preservation for a Type Directed Translation Scheme of Featherweight Go.” In Mathematics of Program Construction. Springer International Publishing. https://doi.org/10.1007/978-3-031-16912-0_7
Sun, Chengnian, Vu Le, and Zhendong Su. 2016a. “Finding Compiler Bugs via Live Code Mutation.” In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications. ACM. https://doi.org/10.1145/2983990.2984038
Sun, Lijun, and Dan Li. 2025. “Application of Multi-Objective Optimization Algorithm in Urban Infrastructure Layout.” In 2025 3rd International Conference on Data Science and Information System (ICDSIS). IEEE. https://doi.org/10.1109/icdsis65355.2025.11070770
Sun, Xiaobing, Bin Li, Yucong Duan, Wei Shi, and Xiangyue Liu. 2016b. “Mining Software Repositories for Automatic Interface Recommendation.” Scientific Programming 2016: 1–11. https://doi.org/10.1155/2016/5475964
Sun, Xiaobing, Bixin Li, Hareton Leung, Bin Li, and Yun Li. 2015. “MSR4SM: Using Topic Models to Effectively Mining Software Repositories for Software Maintenance Tasks.” Information and Software Technology 66: 1–12. https://doi.org/10.1016/j.infsof.2015.05.003
Sun, Qingyue, Xiaohua Shi, and Junru Xie. 2012. “Profiling Object Life Ranges for Detecting Memory Leaks in Java Virtual Machine.” In 2012 13th International Conference on Parallel and Distributed Computing, Applications and Technologies. IEEE. https://doi.org/10.1109/pdcat.2012.114
Sun, Tianyu, and Wensheng Yu. 2020. “A Formal Verification Framework for Security Issues of Blockchain Smart Contracts.” Electronics 9 (2): 255. https://doi.org/10.3390/electronics9020255
Sun, Xin, Ming Zhong, Lulin Wang, Fang Lv, and Xianbo He. 2025a. “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
Sun, Xiaobing, Tianchi Zhou, Gengjie Li, Jiajun Hu, Hui Yang, and Bin Li. 2017. “An Empirical Study on Real Bugs for Machine Learning Programs.” In 2017 24th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2017.41
Sunda, Neelam, and Ripu Ranjan Sinha. 2023. “Optimizing Effort Estimation in Agile Software Development: Traditional vs. Advanced ML Methods.” In 2023 International Conference on Communication, Security and Artificial Intelligence (ICCSAI). IEEE. https://doi.org/10.1109/iccsai59793.2023.10421235
Sundararajan, Renganathan, and John S. Conery. 1992. “An Abstract Interpretation Scheme for Groundness, Freeness, and Sharing Analysis of Logic Programs.” In Foundations of Software Technology and Theoretical Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-56287-7_106
Sung, I-Jui, Nasser Anssari, John A. Stratton, and Wen-Mei W. Hwu. 2011. “Data Layout Transformation Exploiting Memory-Level Parallelism in Structured Grid Many-Core Applications.” International Journal of Parallel Programming 40 (1): 4–24. https://doi.org/10.1007/s10766-011-0182-5
Sung, Dong Kyu, Sunggon Kim, Sangjin Lee, et al. 2025. “Regen: An Object Layout Regenerator on Large-Scale Production HPC Systems.” Future Generation Computer Systems 171: 107830. https://doi.org/10.1016/j.future.2025.107830
Sung, I-Jui, Geng Daniel Liu, and Wen-Mei W. Hwu. 2012. “DL: A Data Layout Transformation System for Heterogeneous Computing.” In 2012 Innovative Parallel Computing (InPar). IEEE. https://doi.org/10.1109/inpar.2012.6339606
Sunkle, Sagar, and Vinay Kulkarni. 2012. “Cost Estimation for Model-Driven Engineering.” In Model Driven Engineering Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-33666-9_42
Suo, Chenyao, Jianrong Wang, Yongjia Wang, Jiajun Jiang, Qingchao Shen, and Junjie Chen. 2025. “DESIL: Detecting Silent Bugs in MLIR Compiler Infrastructure.” Proceedings of the ACM on Programming Languages 9 (OOPSLA2): 3093–3119. https://doi.org/10.1145/3763161
Surantha, Nico, Wincent, and Sani Muhamad Isa. 2021. “Real-Time Monitoring System for Sudden Cardiac Death Based on Container Orchestration and Binary Serialization.” In 2021 International Symposium on Electronics and Smart Devices (ISESD). IEEE. https://doi.org/10.1109/isesd53023.2021.9501536
Surdeanu, M., and D. Moldovan. 2002. “Design and Performance Analysis of a Distributed Java Virtual Machine.” IEEE Transactions on Parallel and Distributed Systems 13 (6): 611–27. https://doi.org/10.1109/tpds.2002.1011415
Suzanne, Thibault, and Antoine Miné. 2016. “From Array Domains to Abstract Interpretation under Store-Buffer-Based Memory Models.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-53413-7_23
Swan, C. C., and J. S. Arora. 1997. “Topology Design of Material Layout in Structured Composites of High Stiffness and Strength.” Structural Optimization 13 (1): 45–59. https://doi.org/10.1007/bf01198375
Swandari, Yulia, Ridi Ferdiana, and Adhistya Erna Permanasari. 2023. “Research Trends in Software Development Effort Estimation.” In 2023 10th International Conference on Electrical Engineering, Computer Science and Informatics (EECSI). IEEE. https://doi.org/10.1109/eecsi59885.2023.10295716
Swarup Kumar, J. N. V. R., T. Govinda Rao, M. Vishnu Chaitanya, and A. Tejaswi. 2011. “A Novel Model for Software Effort Estimation Using Exponential Regression as Firing Interval in Fuzzy Logic.” In Computer Networks and Information Technologies. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-19542-6_19
Sweeney, Peter F., and Joseph (Yossi) Gil. 1999. “Space and Time-Efficient Memory Layout for Multiple Inheritance.” ACM SIGPLAN Notices 34 (10): 256–75. https://doi.org/10.1145/320385.320408
Swenson, Brian Paul, and George F. Riley. 2012. “A New Approach to Zero-Copy Message Passing with Reversible Memory Allocation in Multi-Core Architectures.” In 2012 ACM/IEEE/SCS 26th Workshop on Principles of Advanced and Distributed Simulation. IEEE. https://doi.org/10.1109/pads.2012.3
Szafarczyk, Robert, Syed Waqar Nabi, and Wim Vanderbauwhede. 2023. “Compiler Discovered Dynamic Scheduling of Irregular Code in High-Level Synthesis.” In 2023 33rd International Conference on Field-Programmable Logic and Applications (FPL). IEEE. https://doi.org/10.1109/fpl60245.2023.00009
Szafarczyk, Robert, Syed Waqar Nabi, and Wim Vanderbauwhede. 2025. “Compiler Support for Speculation in Decoupled Access/Execute Architectures.” In Proceedings of the 34th ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3708493.3712695
Szöke, Péter. 1977. “Some Remarks on New Instances and Garbage Collection.” ACM SIGPLAN Notices 12 (6): 42–48. https://doi.org/10.1145/872738.807141
Taha, Walid, Zine-El-Abidine Benaissa, and Tim Sheard. 1998. “Multi-Stage Programming: Axiomatization and Type Safety.” In Automata, Languages and Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0055113
Tahar, Sofiéne, and Ramayya Kumar. 1998. “A Practical Methodology for the Formal Verification of RISC Processors.” Formal Methods in System Design 13 (2): 159–225. https://doi.org/10.1023/a:1008622002590
Tahir, Amjed, Rodina Ahmad, and Zarinah Mohd Kasirun. 2010. “An Empirical Study on the Use of Standards and Procedures in Software Development Projects.” In 2010 2nd International Conference on Software Technology and Engineering. IEEE. https://doi.org/10.1109/icste.2010.5608844
Takase, T., and M. Tatsubori. 2004. “Efficient Web Services Response Caching by Selecting Optimal Data Representation.” In 24th International Conference on Distributed Computing Systems, 2004. Proceedings.. IEEE. https://doi.org/10.1109/icdcs.2004.1281583
Takayama, Yukihide. 1988. “QPC: QJ-Based Proof Compiler -Simple Examples and Analysis-.” In ESOP ‘88. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-19027-9_4
Tallam, Sriraman, and Rajiv Gupta. 2003. “Bitwidth Aware Global Register Allocation.” In Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/604131.604139
Tamboli, Teja, Thomas H. Austin, and Mark Stamp. 2013. “Metamorphic Code Generation from LLVM Bytecode.” Journal of Computer Virology and Hacking Techniques 10 (3): 177–87. https://doi.org/10.1007/s11416-013-0194-3
Tan, Zi. 2025. “A Multi-Source Data Privacy Collaborative Optimization Model for Engineering Cost Estimation Based on Federated Learning and Blockchain.” In 2025 2nd International Conference on Software, Systems and Information Technology (SSITCON). IEEE. https://doi.org/10.1109/ssitcon66133.2025.11342099
Tan, Alvin Jian Jia, Chun Yong Chong, and Aldeida Aleti. 2023. “Closing the Loop for Software Remodularisation: REARRANGE: An Effort Estimation Approach for Software Clustering-Based Remodularisation.” In 2023 IEEE/ACM 45th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). IEEE. https://doi.org/10.1109/icse-companion58688.2023.00090
Tan, Alvin Jian Jia, Chun Yong Chong, and Aldeida Aleti. 2024. “REARRANGE: Effort Estimation Approach for Software Clustering-Based Remodularisation.” Information and Software Technology 176: 107567. https://doi.org/10.1016/j.infsof.2024.107567
Tan, Lin, and Abram Hindle. 2019. “Guest Editorial: Special Section on Mining Software Repositories.” Empirical Software Engineering 24 (3): 1458–60. https://doi.org/10.1007/s10664-019-09724-7
Tan, Jiaqi, Fangyu Li, and Yang Liu. 2026. “Instruction Guided Multi Object Image Editing with Quantity and Layout Consistency.” In ICASSP 2026 - 2026 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE. https://doi.org/10.1109/icassp55912.2026.11461854
Tan, Jichang, and I-Peng Lin. 1992. “Compiling Dataflow Analysis of Logic Programs.” ACM SIGPLAN Notices 27 (7): 106–15. https://doi.org/10.1145/143103.143123
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, Xun, Maha Alabduljalil, Xin Jin, and Tao Yang. 2017. “Partitioned Similarity Search with Cache-Conscious Data Traversal.” ACM Transactions on Knowledge Discovery from Data 11 (3): 1–38. https://doi.org/10.1145/3014060
Tang, Ke, Zheng Shan, Chunyan Zhang, Lianqiu Xu, Meng Qiao, and Fudong Liu. 2022. “DFSGraph: Data Flow Semantic Model for Intermediate Representation Programs Based on Graph Network.” Electronics 11 (19): 3230. https://doi.org/10.3390/electronics11193230
Tang, Yuxian, Hongxing Xu, and Shaowen Yao. 2026. “S2GNN: Topology and Sequence-Aware Graph Learning for Smart Contract Bytecode Security.” In 2026 5th International Conference on Electronics Technology and Artificial Intelligence (ETAI). IEEE. https://doi.org/10.1109/etai68332.2026.11485271
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 Wei Hong and Mohd Amaluddin Yusoff. 2008. “Speech Processing in FPGA with C-to-RTL Compiler Technology.” In 2008 International Conference on Electronic Design. IEEE. https://doi.org/10.1109/iced.2008.4786677
Tanriverdi, Muhammed, and O. Ozgur Tanriover. 2017. “An Experimental Comparison of Software Effort Estimation Methods of ORM Based 4GL Software Applications.” In 2017 International Conference on Computer Science and Engineering (UBMK). IEEE. https://doi.org/10.1109/ubmk.2017.8093382
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
Tanveer, Binish. 2016. “Hybrid Effort Estimation of Changes in Agile Software Development.” In Agile Processes, in Software Engineering, and Extreme Programming. Springer International Publishing. https://doi.org/10.1007/978-3-319-33515-5_33
Tanveer, Binish, Liliana Guzmán, and Ulf Martin Engel. 2017a. “Effort Estimation in Agile Software Development: Case Study and Improvement Framework.” Journal of Software: Evolution and Process 29 (11): e1862. https://doi.org/10.1002/smr.1862
Tanveer, Binish, Anna Maria Vollmer, Stefan Braun, and Nauman bin Ali. 2019. “An Evaluation of Effort Estimation Supported by Change Impact Analysis in Agile Software Development.” Journal of Software: Evolution and Process 31 (5): e2165. https://doi.org/10.1002/smr.2165
Tanveer, Binish, Anna Maria Vollmer, and Ulf Martin Engel. 2017b. “Utilizing Change Impact Analysis for Effort Estimation in Agile Development.” In 2017 43rd Euromicro Conference on Software Engineering and Advanced Applications (SEAA). IEEE. https://doi.org/10.1109/seaa.2017.64
Tao, Xiaohan, Jianmin Pang, Jinlong Xu, and Yu Zhu. 2021. “Compiler-Directed Scratchpad Memory Data Transfer Optimization for Multithreaded Applications on a Heterogeneous Many-Core Architecture.” Journal of Supercomputing 77 (12): 14502–24. https://doi.org/10.1007/s11227-021-03853-x
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
Tarditi, David. 2000. “Compact Garbage Collection Tables.” ACM SIGPLAN Notices 36 (1): 50–58. https://doi.org/10.1145/362426.362437
Tarditi, D., G. Morrisett, P. Cheng, C. Stone, R. Harper, and P. Lee. 1996. “TIL: A Type-Directed Optimizing Compiler for ML.” In Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/231379.231414
Tariq, Sidra, Muhammad Usman, and Alvis C. M. Fong. 2020. “Selecting Best Predictors from Large Software Repositories for Highly Accurate Software Effort Estimation.” Journal of Software: Evolution and Process 32 (10): e2271. https://doi.org/10.1002/smr.2271
Tassarotti, Joseph, and Jean-Baptiste Tristan. 2023. “Verified Density Compilation for a Probabilistic Programming Language.” Proceedings of the ACM on Programming Languages 7 (PLDI): 615–37. https://doi.org/10.1145/3591245
Tate, Ross, Alan Leung, and Sorin Lerner. 2011. “Taming Wildcards in Java’s Type System.” In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/1993498.1993570
Taura, Kenjiro, and Akinori Yonezawa. 1997. “Fine-Grain Multithreading with Minimal Compiler Support—a Cost Effective Approach to Implementing Efficient Multithreading Languages.” In Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation. ACM. https://doi.org/10.1145/258915.258944
Tavakkoli, Amir Mohammad, Cosmin E. Oancea, and Mary Hall. 2026. “LEGO: A Layout Expression Language for Code Generation of Hierarchical Mapping.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11394846
Tavarageri, Sanket, Wooil Kim, Josep Torrellas, and P. Sadayappan. 2016. “Compiler Support for Software Cache Coherence.” In 2016 IEEE 23rd International Conference on High Performance Computing (HiPC). IEEE. https://doi.org/10.1109/hipc.2016.047
Tavarageri, Sanket, Sriram Krishnamoorthy, and P. Sadayappan. 2014. “Compiler-Assisted Detection of Transient Memory Errors.” In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/2594291.2594298
Tavarageri, Sanket, and P. Sadayappan. 2013. “A Compiler Analysis to Determine Useful Cache Size for Energy Efficiency.” In 2013 IEEE International Symposium on Parallel & Distributed Processing, Workshops and Phd Forum. IEEE. https://doi.org/10.1109/ipdpsw.2013.268
Tawosi, Vali, Federica Sarro, Alessio Petrozziello, and Mark Harman. 2022. “Multi-Objective Software Effort Estimation: A Replication Study.” IEEE Transactions on Software Engineering 48 (8): 3185–3205. https://doi.org/10.1109/tse.2021.3083360
Tayeb, Hayfa, Ludovic Paillat, and Bérenger Bramas. 2023. “Autovesk: Automatic Vectorized Code Generation from Unstructured Static Kernels Using Graph Transformations.” ACM Transactions on Architecture and Code Optimization 21 (1): 1–25. https://doi.org/10.1145/3631709
Taylan Kandemir, Mahmut. 2000. “A Collective I/O Scheme Based on Compiler Analysis.” In Languages, Compilers, and Run-Time Systems for Scalable Computers. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-40889-4_1
Tempero, Ewan. 2008. “An Empirical Study of Unused Design Decisions in Open Source Java Software.” In 2008 15th Asia-Pacific Software Engineering Conference. IEEE. https://doi.org/10.1109/apsec.2008.30
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
Tengeri, David, Ferenc Horvath, Arpad Beszedes, Tamas Gergely, and Tibor Gyimothy. 2016. “Negative Effects of Bytecode Instrumentation on Java Source Code Coverage.” In 2016 IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner.2016.61
Teodorescu, Lucian, and Rodica Potolea. 2013. “Compiler Design for Hyper-Metaprogramming.” In 2013 15th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing. IEEE. https://doi.org/10.1109/synasc.2013.34
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
Terei, David A., and Manuel M. T. Chakravarty. 2010. “An llVM Backend for GHC.” ACM SIGPLAN Notices 45 (11): 109–20. https://doi.org/10.1145/2088456.1863538
Tetelbaum, A. Y. 1996. “Prediction of Structure and Layout Parameters for a Hierarchical System.” Computers & Structures 58 (4): 809–24. https://doi.org/10.1016/0045-7949(95)00188-m
Thakur, Vaishali, and Kamlesh Dutta. 2025. “Machine Learning Based Effort Estimation Models for Software Development Projects Related Datasets with Diverse Features.” In 2025 2nd International Conference on Computational Intelligence, Communication Technology and Networking (CICTN). IEEE. https://doi.org/10.1109/cictn64563.2025.10932601
Thatte, Satish. 1991. “A Type System for Implicit Scaling.” Science of Computer Programming 17 (1–3): 217–45. https://doi.org/10.1016/0167-6423(91)90040-5
Theocharis, Stamatios, and George Tsihrintzis. 2016. “Rdf Serialization from JSON Data: The Case of JSON Data in Diavgeia.gov.gr.” In 2016 7th International Conference on Information, Intelligence, Systems & Applications (IISA). IEEE. https://doi.org/10.1109/iisa.2016.7785386
Thethi, Sukhmani Kaur, and Ravi Kumar. 2017. “Area and Power Efficient Register Allocation Technique for the Implementation of PCA.” In 2017 4th International Conference on Signal Processing, Computing and Control (ISPCC). IEEE. https://doi.org/10.1109/ispcc.2017.8269684
Thirunarayan, Krishnaprasad, and Robert L. Ewing. 2001. “Structural Operational Semantics for a Portable Subset of Behavioral VHDL-93.” Formal Methods in System Design 18 (1): 69–88. https://doi.org/10.1023/a:1008786720393
Thompson, Sarah, and Alan Mycroft. 2004. “Abstract Interpretation of Combinational Asynchronous Circuits.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-27864-1_15
Thongkaew, Surachai, Tsuyoshi Isshiki, Dongju Li, and Hiroaki Kunieda. 2014. “Dalvik Bytecode Acceleration Using Fetch/Decode Hardware Extension with Hybrid Execution.” In 2014 IEEE Asia Pacific Conference on Circuits and Systems (APCCAS). IEEE. https://doi.org/10.1109/apccas.2014.7032798
Thorup, Mikkel. 1997. “Structured Programs Have Small Tree-Width and Good Register Allocation: Extended Abstract.” In Graph-Theoretic Concepts in Computer Science. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0024507
Tian, Zhenzhou, Yuchen Gong, Chenhao Chang, Jiaze Sun, Yanping Chen, and Lingwei Chen. 2024. “An Empirical Study on Divergence of Differently-Sourced LLVM IRs.” Journal of Computer Languages 81: 101289. https://doi.org/10.1016/j.cola.2024.101289
Tian, Ruiqin, Luanzheng Guo, Jiajia Li, Bin Ren, and Gokcen Kestor. 2021. “A High Performance Sparse Tensor Algebra Compiler in MLIR.” In 2021 IEEE/ACM 7th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvmhpc54804.2021.00009
Tian, Shilei, Joseph Huber, John Tramm, Barbara Chapman, and Johannes Doerfert. 2022. “Just-in-Time Compilation and Link-Time Optimization for OpenMP Target Offloading.” In OpenMP in a Modern World: From Multi-device Support to Meta Programming. Springer International Publishing. https://doi.org/10.1007/978-3-031-15922-0_10
Tian, Xinmin, Hideki Saito, Ernesto Su, et al. 2016. “LLVM Framework and IR Extensions for Parallelization, SIMD Vectorization and Offloading.” In 2016 Third Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC). IEEE. https://doi.org/10.1109/llvm-hpc.2016.008
Tian, Yi, Guangping Xu, Hongzhang Yang, Yue Ni, JiaXin Cao, and Lei Yang. 2023. “Discrete Geometric Coded Data Layout for Large-Scale Object Storage Systems.” In 2023 IEEE Intl Conf on Parallel & Distributed Processing with Applications, Big Data & Cloud Computing, Sustainable Computing & Communications, Social Computing & Networking (ISPA/BDCloud/SocialCom/SustainCom). IEEE. https://doi.org/10.1109/ispa-bdcloud-socialcom-sustaincom59178.2023.00067
Tian, Xingyan, Kejia Zhao, Huowang Chen, and Hongyan Du. 2004. “Cache Behavior Analysis of a Compiler-Assisted Cache Replacement Policy.” In Advances in Computer Systems Architecture. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30102-8_4
Tianhua, Liu, Zhu Hongfeng, Chang Guira, and Zhou Chuansheng. 2006. “Research and Implementation of Zero-Copy Technology in Linux.” In 2006 IEEE Sarnoff Symposium. IEEE. https://doi.org/10.1109/sarnof.2006.4534808
Tianhua, Liu, Zhu Hongfeng, Chang Guiran, and Zhou Chuansheng. 2008. “The Design and Implementation of Zero-Copy for Linux.” In 2008 Eighth International Conference on Intelligent Systems Design and Applications. IEEE. https://doi.org/10.1109/isda.2008.102
Tiganourias, Efstratios, Michail Mavropoulos, Georgios Keramidas, Vasilios Kelefouras, Christos P. Antonopoulos, and Nikolaos Voros. 2021. “A Hierarchical Profiler of Intermediate Representation Code Based on LLVM.” In 2021 10th Mediterranean Conference on Embedded Computing (MECO). IEEE. https://doi.org/10.1109/meco52532.2021.9460203
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
Tirpankar, Tanmay, Artem Yadrov, Pavel Panchekha, and Ganesh Gopalakrishnan. 2025. “FpGuard: Static-Analysis Guided Domain Exclusions for Robust Floating-Point Error Analysis.” In 2025 IEEE/ACM 1st International Workshop on Advancing Static Analysis for Researchers and Industry Practitioners in Software Engineering (STATIC). IEEE. https://doi.org/10.1109/static66697.2025.00006
Tischler, Ron, Robin Schaufler, and Charlotte Payne. 1983. “Static Analysis of Programs as an Aid to Debugging.” ACM SIGPLAN Notices 18 (8): 155–58. https://doi.org/10.1145/1006142.1006182
Titolo, Laura, Marco A. Feliú, Mariano Moscato, and César A. Muñoz. 2017. “An Abstract Interpretation Framework for the Round-Off Error Analysis of Floating-Point Programs.” In Verification, Model Checking, and Abstract Interpretation. Springer International Publishing. https://doi.org/10.1007/978-3-319-73721-8_24
Titzer, Ben L., and Jens Palsberg. 2009. “Vertical Object Layout and Compression for Fixed Heaps.” In Semantics and Algebraic Specification. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-04164-8_18
Tiwari, Nitin M., Ganesha Upadhyaya, Hoan Anh Nguyen, and Hridesh Rajan. 2017. “Candoia: A Platform for Building and Sharing Mining Software Repositories Tools as Apps.” In 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR). IEEE. https://doi.org/10.1109/msr.2017.56
Tjioe, Jonathan, Andres Blanco, Tao Xie, and Yiming Ouyang. 2012. “Making Garbage Collection Wear Conscious for Flash SSD.” In 2012 IEEE Seventh International Conference on Networking, Architecture, and Storage. IEEE. https://doi.org/10.1109/nas.2012.20
Tobisch, Franziska, Karla Weigelt, Pascal Philipp, and Florian Matthes. 2024. “Investigating Effort Estimation in a Large-Scale Agile ERP Transformation Program.” In Agile Processes in Software Engineering and Extreme Programming. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-61154-4_5
Toccaceli, Roberto, and Francesco Quaglia. 2008. “DyMeLoR: Dynamic Memory Logger and Restorer Library for Optimistic Simulation Objects with Generic Memory Layout.” In 2008 22nd Workshop on Principles of Advanced and Distributed Simulation. IEEE. https://doi.org/10.1109/pads.2008.23
Tolmach, Andrew. 1994. “Tag-Free Garbage Collection Using Explicit Type Parameters.” ACM SIGPLAN Lisp Pointers VII (3): 1–11. https://doi.org/10.1145/182590.182411
Tong, Liangliang, and Francis C. M. Lau. 2013. “Skew-Space Garbage Collection.” Science of Computer Programming 78 (5): 445–57. https://doi.org/10.1016/j.scico.2011.06.003
Tosun, Ayse, Burak Turhan, and Ayse Basar Bener. 2009. “Feature Weighting Heuristics for Analogy-Based Effort Estimation Models.” Expert Systems with Applications 36 (7): 10325–33. https://doi.org/10.1016/j.eswa.2009.01.079
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
Touzeau, Valentin, and Jan Reineke. 2023. “Leveraging LLVM’s ScalarEvolution for Symbolic Data Cache Analysis.” In 2023 IEEE Real-Time Systems Symposium (RTSS). IEEE. https://doi.org/10.1109/rtss59052.2023.00029
Trautsch, Alexander, Johannes Erbel, Steffen Herbold, and Jens Grabowski. 2023. “What Really Changes When Developers Intend to Improve Their Source Code: A Commit-Level Study of Static Metric Value and Static Analysis Warning Changes.” Empirical Software Engineering 28 (2): 30. https://doi.org/10.1007/s10664-022-10257-9
Trautsch, Alexander, Steffen Herbold, and Jens Grabowski. 2020. “A Longitudinal Study of Static Analysis Warning Evolution and the Effects of PMD on Software Quality in Apache Open Source Projects.” Empirical Software Engineering 25 (6): 5137–92. https://doi.org/10.1007/s10664-020-09880-1
Trendowicz, Adam, Jürgen Münch, and Ross Jeffery. 2011. “State of the Practice in Software Effort Estimation: A Survey and Literature Review.” In Software Engineering Techniques. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-22386-0_18
Trifonov, Valery, Bratin Saha, and Zhong Shao. 2000. “Fully Reflexive Intensional Type Analysis.” ACM SIGPLAN Notices 35 (9): 82–93. https://doi.org/10.1145/357766.351248
Trindade, Alessandro, and Lucas Cordeiro. 2019. “Automated Formal Verification of Stand-Alone Solar Photovoltaic Systems.” Solar Energy 193: 684–91. https://doi.org/10.1016/j.solener.2019.09.093
Tristan, Jean-Baptiste, Paul Govereau, and Greg Morrisett. 2011. “Evaluating Value-Graph Translation Validation for LLVM.” ACM SIGPLAN Notices 46 (6): 295–305. https://doi.org/10.1145/1993316.1993533
Tristan, Jean-Baptiste, Paul Govereau, and Greg Morrisett. 2012. “Evaluating Value-Graph Translation Validation for LLVM.” ACM SIGPLAN Notices 47 (6): 295. https://doi.org/10.1145/2345156.1993533
Trushkina, Julia. 2006. “The North-West University Bible Corpus: A Multilingual Parallel Corpus for South African Languages.” Language Matters 37 (2): 227–45. https://doi.org/10.1080/10228190608566262
Tsai, Yu-Hsin, I-Wei Wu, I-Chun Liu, and Jean Jyh-Jiun Shann. 2013. “Improving Performance of JNA by Using LLVM JIT Compiler.” In 2013 IEEE/ACIS 12th International Conference on Computer and Information Science (ICIS). IEEE. https://doi.org/10.1109/icis.2013.6607886
Tsou, Benjamin K., and Andy C. Chin. 2010. “A Large Synchronous Corpus as Monitoring Corpus: Some Comparative Content Analysis of Chinese and Japanese Language Developments.” In 2010 4th International Universal Communication Symposium. IEEE. https://doi.org/10.1109/iucs.2010.5666763
Tsuji, Yoshishige, Hideyuki Kawashima, and Ikuo Takeuchi. 2010. “Optimization of Query Processing with Cache Conscious Buffering Operator.” In Databases in Networked Information Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-12038-1_6
Tsunoda, Masateru, Yasutaka Kamei, Koji Toda, Meiyappan Nagappan, Kyohei Fushida, and Naoyasu Ubayashi. 2013b. “Revisiting Software Development Effort Estimation Based on Early Phase Development Activities.” In 2013 10th Working Conference on Mining Software Repositories (MSR). IEEE. https://doi.org/10.1109/msr.2013.6624059
Tsunoda, Masateru, Akito Monden, Jacky Keung, and Kenichi Matsumoto. 2012. “Incorporating Expert Judgment into Regression Models of Software Effort Estimation.” In 2012 19th Asia-Pacific Software Engineering Conference. IEEE. https://doi.org/10.1109/apsec.2012.58
Tun, Ye Lin, Chu Myaet Thwal, Yu Min Park, Seong-Bae Park, and Choong Seon Hong. 2023. “Federated Learning with Intermediate Representation Regularization.” In 2023 IEEE International Conference on Big Data and Smart Computing (BigComp). IEEE. https://doi.org/10.1109/bigcomp57234.2023.00017
Tunalilar, Seckin, and Onur Demirors. 2012. “EFES: An Effort Estimation Methodology.” In 2012 Joint Conference of the 22nd International Workshop on Software Measurement and the 2012 Seventh International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm-mensura.2012.37
Turic, Mili, Stipe Celar, Srdjana Dragicevic, and Linda Vickovic. 2023. “Advanced Bayesian Network for Task Effort Estimation in Agile Software Development.” Applied Sciences 13 (16): 9465. https://doi.org/10.3390/app13169465
Türker, Can. 2001. “Schema Evolution in SQL-99 and Commercial (Object-)Relational DBMS.” In Database Schema Evolution and Meta-Modeling. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48196-6_1
“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
“Tutorial: Array Building Blocks: A Dynamic Compiler for Data-Parallel Heterogeneous Systems.” 2011a. In International Symposium on Code Generation and Optimization (CGO 2011). IEEE. https://doi.org/10.1109/cgo.2011.5764657
“Tutorial: Essential Abstractions in GCC.” 2011b. In International Symposium on Code Generation and Optimization (CGO 2011). IEEE. https://doi.org/10.1109/cgo.2011.5764659
“Tutorial: PIPS: An Interprocedural Extensible Source-to-Source Compiler Infrastructure for Code/application Transformations and Instrumentations.” 2011c. In International Symposium on Code Generation and Optimization (CGO 2011). IEEE. https://doi.org/10.1109/cgo.2011.5764662
Týma, Paul. 1999. “Transient Variable Caching in Java’s Stack-Based Intermediate Representation.” Scientific Programming 7 (2): 157–66. https://doi.org/10.1155/1999/501879
Tyystjarvi, Joonas, Tero Santti, and Juha Plosila. 2010a. “Efficient Bytecode Optimizations for a Multicore Java Co-Processor System.” In 2010 12th Biennial Baltic Electronics Conference. IEEE. https://doi.org/10.1109/bec.2010.5631144
Tyystjarvi, Joonas, Tero Santti, and Juha Plosila. 2010b. “Heap Access Optimizations for a Hardware-Accelerated Java Virtual Machine.” In 2010 International Symposium on System on Chip. IEEE. https://doi.org/10.1109/issoc.2010.5625548
Tzong-Yen Lin, Cheng-Yu L, and Rong-Guey Chang. 2010. “Thermal-Aware Register Allocation with Loop-Unrolling.” In 2010 International Conference On Computer Design and Applications. IEEE. https://doi.org/10.1109/iccda.2010.5541485
Tzouros, Giannis, Michail Tsenos, and Vana Kalogeraki. 2021. “Portable Intermediate Representation for Efficient Big Data Analytics.” In Distributed Applications and Interoperable Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-78198-9_5
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
ul Huque, Md Tanvir Ishtaique, Guillaume Jourjon, and Vincent Gramoli. 2017. “Garbage Collection of Forwarding Rules in Software Defined Networks.” IEEE Communications Magazine 55 (6): 39–45. https://doi.org/10.1109/mcom.2017.1601051
Ungan, Erdir, Numan Cizmeli, and Onur Demirors. 2014. “Comparison of Functional Size Based Estimation and Story Points, Based on Effort Estimation Effectiveness in SCRUM Projects.” In 2014 40th EUROMICRO Conference on Software Engineering and Advanced Applications. IEEE. https://doi.org/10.1109/seaa.2014.83
Unnikrishnan, Supriya, and G. Sreelekha. 2022. “Performance Analysis of Memory Data Layout for Sub-Block Data Access.” Multimedia Tools and Applications 82 (5): 7229–45. https://doi.org/10.1007/s11042-022-13564-x
Upadhyaya, Ganesha, and Hridesh Rajan. 2015. “Effectively Mapping Linguistic Abstractions for Message-Passing Concurrency to Threads on the Java Virtual Machine.” ACM SIGPLAN Notices 50 (10): 840–59. https://doi.org/10.1145/2858965.2814289
Ur Rehman Khan, Saif, Syed Abu Saeed, Habib Un Nisa, Muhammad Javed, and Kashif Manzer. 2026. “Effort Estimation in Agile Software Development Context: A Systematic Mapping Study.” In SEET—Software Engineering for Emerging Technologies. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-08977-9_19
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
Urban, Caterina, Samuel Ueltschi, and Peter Müller. 2018. “Abstract Interpretation of CTL Properties.” In Static Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-319-99725-4_24
Usharani, K., V. Vignaraj Ananth, and D. Velmurugan. 2016. “A Survey on Software Effort Estimation.” In 2016 International Conference on Electrical, Electronics, and Optimization Techniques (ICEEOT). IEEE. https://doi.org/10.1109/iceeot.2016.7755665
Usman, Muhammad, and Ricardo Britto. 2016. “Effort Estimation in Co-Located and Globally Distributed Agile Software Development: A Comparative Study.” In 2016 Joint Conference of the International Workshop on Software Measurement and the International Conference on Software Process and Product Measurement (IWSM-MENSURA). IEEE. https://doi.org/10.1109/iwsm-mensura.2016.042
Usman, Muhammad, Ricardo Britto, Lars-Ola Damm, and Jürgen Börstler. 2018b. “Effort Estimation in Large-Scale Software Development: An Industrial Case Study.” Information and Software Technology 99: 21–40. https://doi.org/10.1016/j.infsof.2018.02.009
Usman, Muhammad, Kai Petersen, Jürgen Börstler, and Pedro Santos Neto. 2018a. “Developing and Using Checklists to Improve Software Effort Estimation: A Multi-Case Study.” Journal of Systems and Software 146: 286–309. https://doi.org/10.1016/j.jss.2018.09.054
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
Vacari, Isaque, and Rafael Prikladnicki. 2017. “An Empirical Study on the Adoption of Agile Software Development in Public Organizations.” In Agile Methods. Springer International Publishing. https://doi.org/10.1007/978-3-319-55907-0_1
Vallis, P., and J. S. Colton. 1996. “A Method of Object-Oriented Information Management for Layout Design.” Engineering with Computers 12 (1): 34–45. https://doi.org/10.1007/bf01200260
Van De Snepscheut, Jan L. A. 1987. ““Algorithms for on-the-Fly Garbage Collection” Revisited.” Information Processing Letters 24 (4): 211–16. https://doi.org/10.1016/0020-0190(87)90135-9
van den Berg, Kg, and Pm van den Broek. 1995. “Static Analysis of Functional Programs.” Information and Software Technology 37 (4): 213–24. https://doi.org/10.1016/0950-5849(95)90813-a
van der Poel, Klaas G., and Stephen R. Schach. 1983. “A Software Metric for Cost Estimation and Efficiency Measurement in Data Processing System Development.” Journal of Systems and Software 3 (3): 187–91. https://doi.org/10.1016/0164-1212(83)90033-x
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 Houdt, B. 2016. “On the Power of Asymmetry and Memory in Flash-Based SSD Garbage Collection.” Performance Evaluation 97: 1–15. https://doi.org/10.1016/j.peva.2015.11.002
van Reeuwijk, C. 2003. “Rapid and Robust Compiler Construction Using Template-Based Metacompilation.” In Compiler Construction. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36579-6_18
Van Strydonck, Thomas, Frank Piessens, and Dominique Devriese. 2019. “Linear Capabilities for Fully Abstract Compilation of Separation-Logic-Verified Code.” Proceedings of the ACM on Programming Languages 3 (ICFP): 1–29. https://doi.org/10.1145/3341688
Vandecruys, Olivier, David Martens, Bart Baesens, Christophe Mues, Manu De Backer, and Raf Haesen. 2008. “Mining Software Repositories for Comprehensible Software Fault Prediction Models.” Journal of Systems and Software 81 (5): 823–39. https://doi.org/10.1016/j.jss.2007.07.034
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
Vanderwaart, Joseph C., and Karl Crary. 2003. “A Typed Interface for Garbage Collection.” ACM SIGPLAN Notices 38 (3): 109–22. https://doi.org/10.1145/640136.604189
Vanura, Jan, and Pavel Kriz. 2018. “Perfomance Evaluation of Java, JavaScript and PHP Serialization Libraries for XML, JSON and Binary Formats.” In Services Computing – SCC 2018. Springer International Publishing. https://doi.org/10.1007/978-3-319-94376-3_11
Vardhan, Abhay, and Gul Agha. 2002. “Using Passive Object Garbage Collection Algorithms for Garbage Collection of Active Objects.” ACM SIGPLAN Notices 38 (2 supplement): 106–13. https://doi.org/10.1145/773039.512443
Vassallo, Carmine, Sebastiano Panichella, Fabio Palomba, Sebastian Proksch, Andy Zaidman, and Harald C. Gall. 2018. “Context Is King: The Developer Perspective on the Usage of Static Analysis Tools.” In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner.2018.8330195
Vassiliadis, Panos. 2021. “Profiles of Schema Evolution in Free Open Source Software Projects.” In 2021 IEEE 37th International Conference on Data Engineering (ICDE). IEEE. https://doi.org/10.1109/icde51399.2021.00008
Vassiliadis, Panos, and George Kalampokis. 2022. “Taxa and Super Taxa of Schema Evolution and Their Relationship to Activity, Heartbeat and Duration.” Information Systems 110: 102109. https://doi.org/10.1016/j.is.2022.102109
Vassiliadis, Panos, Apostolos V. Zarras, and Ioannis Skoulis. 2017. “Gravitating to Rigidity: Patterns of Schema Evolution – and Its Absence – in the Lives of Tables.” Information Systems 63: 24–46. https://doi.org/10.1016/j.is.2016.06.010
Vasumathi, K. Narayanan. 2010. “Formal Verification of Robotic and Automation Tasks.” In Interact-2010. IEEE. https://doi.org/10.1109/interact.2010.5706214
Vaucheret, Claudio, and Francisco Bueno. 2002. “More Precise Yet Efficient Type Inference for Logic Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45789-5_10
Védrine, Franck. 1995. “Binding-Time Analysis and Strictness Analysis by Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60360-3_52
Velarde, Hector, Cosme Santiesteban, Ana Garcia, and Jorge Casillas. 2016. “Analyzing the Effect of Variables in the Software Development Effort Estimation.” IEEE Latin America Transactions 14 (8): 3797–3803. https://doi.org/10.1109/tla.2016.7786366
Velev, Miroslav N., and Ping Gao. 2014. “Formal Verification of Safety of Polymorphic Heterogeneous Multi-Core Architectures.” In Fifteenth International Symposium on Quality Electronic Design. IEEE. https://doi.org/10.1109/isqed.2014.6783383
Venelle, Benjamin, Jeremy Briffaut, Laurent Clevy, and Christian Toinard. 2013. “Security Enhanced Java: Mandatory Access Control for the Java Virtual Machine.” In 16th IEEE International Symposium on Object/component/service-oriented Real-time distributed Computing (ISORC 2013). IEEE. https://doi.org/10.1109/isorc.2013.6913208
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
Venkatraman, K., M. Akashvarma, and S. Siddharth. 2024. “Enhancing Software Test Effort Estimation Using Ensemble Learning Algorithms.” In 2024 4th International Conference on Intelligent Technologies (CONIT). IEEE. https://doi.org/10.1109/conit61985.2024.10626442
Vera, Tomas, Sergio F. Ochoa, and Daniel Perovich. 2020. “Development Effort Estimation Practices in Small Software Companies: An Exploratory Study.” In 2020 39th International Conference of the Chilean Computer Science Society (SCCC). IEEE. https://doi.org/10.1109/sccc51225.2020.9281161
Verdonik, Darinka, Iztok Kosem, Ana Zwitter Vitez, Simon Krek, and Marko Stabej. 2013. “Compilation, Transcription and Usage of a Reference Speech Corpus: The Case of the Slovene Corpus GOS.” Language Resources and Evaluation 47 (4): 1031–48. https://doi.org/10.1007/s10579-013-9216-5
Verdoolaege, Sven, Juan Carlos Juega, Albert Cohen, José Ignacio Gómez, Christian Tenllado, and Francky Catthoor. 2013. “Polyhedral Parallel Code Generation for CUDA.” ACM Transactions on Architecture and Code Optimization 9 (4): 1–23. https://doi.org/10.1145/2400682.2400713
Vergnaud, Thomas, David Pardessus, and Pascal Guerin. 2014. “Assessing the Overhead of Automatic Code Generation for a Component Approach Compared with Hand-Written Code: Experiments with the MyCCM Code Generation Tool Chain.” In 2014 40th EUROMICRO Conference on Software Engineering and Advanced Applications. IEEE. https://doi.org/10.1109/seaa.2014.46
Vidoni, M. 2022. “A Systematic Process for Mining Software Repositories: Results from a Systematic Literature Review.” Information and Software Technology 144: 106791. https://doi.org/10.1016/j.infsof.2021.106791
Vieira, Marcia Damaso, and Estefanía Baranger. 2021. “Object Sharing in Mbya Guarani: A Case of Asymmetrical Verbal Serialization?” Languages 6 (1): 45. https://doi.org/10.3390/languages6010045
Viglas, Stratis D. 2014. “Just-in-Time Compilation for SQL Query Processing.” In 2014 IEEE 30th International Conference on Data Engineering. IEEE. https://doi.org/10.1109/icde.2014.6816765
Vilela, Giuliano, Edgard Correa, and Marcio Kreutz. 2012. “A LLVM Based Development Environment for Embedded Systems Software Targeting the RISCO Processor.” In 2012 Brazilian Symposium on Computing System Engineering. IEEE. https://doi.org/10.1109/sbesc.2012.23
Villalobos-Arias, Leonardo, Christian Quesada-Lopez, Marcelo Jenkins, and Juan Murillo-Morera. 2021b. “Hyper-Parameter Tuning Using Genetic Algorithms for Software Effort Estimation.” In 2021 16th Iberian Conference on Information Systems and Technologies (CISTI). IEEE. https://doi.org/10.23919/cisti52073.2021.9476459
“Visualizing Software Project Analogies to Support Cost Estimation.” 2004. In Proceedings of the 4th International Workshop on Pattern Recognition in Information Systems. SciTePress - Science and and Technology Publications. https://doi.org/10.5220/0002651200610068
Viswanathan, D., and S. Liang. 2000. “Java Virtual Machine Profiler Interface.” IBM Systems Journal 39 (1): 82–95. https://doi.org/10.1147/sj.391.0082
Vivekanandan, Abhishek, and J. Marius Zöllner. 2025. “Efficient Data Representation for Motion Forecasting: A Scene-Specific Trajectory Set Approach.” In 2025 IEEE Intelligent Vehicles Symposium (IV). IEEE. https://doi.org/10.1109/iv64158.2025.11097487
“VLSI Design Station Has CAE and Silicon Compiler.” 1986. Microprocessors and Microsystems 10 (1): 43. https://doi.org/10.1016/0141-9331(86)90018-9
Vogel, Pirmin, Andrea Marongiu, and Luca Benini. 2017. “Lightweight Virtual Memory Support for Zero-Copy Sharing of Pointer-Rich Data Structures in Heterogeneous Embedded SoCs.” IEEE Transactions on Parallel and Distributed Systems 28 (7): 1947–59. https://doi.org/10.1109/tpds.2016.2645219
von Oheimb, David, and Tobias Nipkow. 1999. “Machine-Checking the Java Specification: Proving Type-Safety.” In Formal Syntax and Semantics of Java. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48737-9_4
Vuong, S. T., A. C. Lau, and R. I. Chan. 1988. “Semiautomatic Implementation of Protocols Using an Estelle-C Compiler.” IEEE Transactions on Software Engineering 14 (3): 384–93. https://doi.org/10.1109/32.4658
Wadler, Philip. 1995. “Static Analysis Refuses to Stay Still: Prospects of Static Analyis for Dynamic Allocation.” In Memory Management. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-60368-9_20
Wagner, Gregor, Andreas Gal, and Michael Franz. 2011. ““Slimming” a Java Virtual Machine by Way of Cold Code Removal and Optimistic Partial Program Loading.” Science of Computer Programming 76 (11): 1037–53. https://doi.org/10.1016/j.scico.2010.04.008
Wagner, J., and R. Leupers. 2001a. “C Compiler Design for a Network Processor.” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 20 (11): 1302–8. https://doi.org/10.1109/43.959859
Wagner, Jens, and Rainer Leupers. 2001b. “C Compiler Design for an Industrial Network Processor.” ACM SIGPLAN Notices 36 (8): 155–64. https://doi.org/10.1145/384196.384218
Wagner, Michael J., and Tim Wendelin. 2018. “SolarPILOT: A Power Tower Solar Field Layout and Characterization Tool.” Solar Energy 171: 185–96. https://doi.org/10.1016/j.solener.2018.06.063
Wakabayashi, Kazutoshi. 2013. “Reconfigurable Chip Advantage Compared with GPGPU from the Compiler Perspective.” In 2013 International Conference on Field-Programmable Technology (FPT). IEEE. https://doi.org/10.1109/fpt.2013.6718319
Wakeling, David. 1998a. “A Haskell to Java Virtual Machine Code Compiler.” In Implementation of Functional Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0055423
Wakeling, David. 1998b. “Mobile Haskell: Compiling Lazy Functional Programs for the Java Virtual Machine.” In Principles of Declarative Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0056624
Walkerden, Fiona, and Ross Jeffery. 1999. “An Empirical Study of Analogy-Based Software Effort Estimation.” Empirical Software Engineering 4 (2): 135–58. https://doi.org/10.1023/a:1009872202035
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
Walshe, Thomas, and Andrew Simpson. 2020. “An Empirical Study of Bug Bounty Programs.” In 2020 IEEE 2nd International Workshop on Intelligent Bug Fixing (IBF). IEEE. https://doi.org/10.1109/ibf50092.2020.9034828
Walter, Kenneth G. 1976. “Recursion Analysis for Compiler Optimization.” Communications of the ACM 19 (9): 514–16. https://doi.org/10.1145/360336.360341
Wams, Nanne, and Frank Vogelezang. 2014. “Cost Estimation of Transition Projects in Application Outsourcing: An Empirical Model.” In 2014 Joint Conference of the International Workshop on Software Measurement and the International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm.mensura.2014.17
Wan, Jiacheng. 2025. “LayoutFusion: A Data-Layout-Focused Operator Fusion Framework.” In 2025 6th International Conference on Computer Engineering and Application (ICCEA). IEEE. https://doi.org/10.1109/iccea65460.2025.11103433
Wan, Bangrui, Shuang Dong, Jianjun Zhou, and Ying Qian. 2023. “SJBCD: A Java Code Clone Detection Method Based on Bytecode Using Siamese Neural Network.” Applied Sciences 13 (17): 9580. https://doi.org/10.3390/app13179580
Wan, Han, Wenhao Nie, Shiyang Yue, and Xiaoyan Luo. 2024. “Fault Localization for Novice Programs Combining Static Analysis and Dynamic Detection.” In 2024 IEEE 48th Annual Computers, Software, and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac61105.2024.00023
Wan, Chengyu, Siqian Zhang, Lingjun Zhao, Tao Tang, and Gangyao Kuang. 2026. “Task-Oriented Unsupervised SAR Image Enhancement with Semantic Preservation for Robust Target Recognition.” Remote Sensing 18 (6): 930. https://doi.org/10.3390/rs18060930
Wand, Mitchell. 1991. “Type Inference for Record Concatenation and Multiple Inheritance.” Information and Computation 93 (1): 1–15. https://doi.org/10.1016/0890-5401(91)90050-c
Wang, Pei. 1996. “Heuristics and Normative Models of Judgment under Uncertainty.” International Journal of Approximate Reasoning 14 (4): 221–35. https://doi.org/10.1016/0888-613x(95)00091-t
Wang, Farn. 2006. “REDLIB for the Formal Verification of Embedded Systems.” In Second International Symposium on Leveraging Applications of Formal Methods, Verification and Validation (isola 2006). IEEE. https://doi.org/10.1109/isola.2006.68
Wang, Wei-Jen. 2011. “Conservative Snapshot-Based Actor Garbage Collection for Distributed Mobile Actor Systems.” Telecommunication Systems. https://doi.org/10.1007/s11235-011-9509-1
Wang, Aiqing. 2022. “Development of Language Feature Analysis System for Mineral Engineering English Corpus Based on Web.” In 2022 IEEE 2nd International Conference on Computer Systems (ICCS). IEEE. https://doi.org/10.1109/iccs56273.2022.9988369
Wang, Zheer. 2024a. “Advancements and Challenges of Large Language Model-Based Code Generation and Completion.” In Proceedings of the 1st International Conference on Modern Logistics and Supply Chain Management. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013271800004558
Wang, Chong. 2024b. “Research on the Application of Smart Tourism Management System Based on Java Enterprise Edition and Ethereum Virtual Machine.” In 2024 International Conference on Integrated Intelligence and Communication Systems (ICIICS). IEEE. https://doi.org/10.1109/iciics63763.2024.10859371
Wang, Wenhao. 2025a. “Multi-Corpus Alignment and Cross-Language Semantic Analysis for Chinese-English Machine Translation.” In 2025 3rd International Conference on Inventive Computing and Informatics (ICICI). IEEE. https://doi.org/10.1109/icici65870.2025.11069758
Wang, Taogong. 2025c. “VLTSR: Visual-Layout Multi-Modal Fusion for Table Structure Recognition.” In 2025 5th International Conference on Electronic Information Engineering and Computer Science (EIECS). IEEE. https://doi.org/10.1109/eiecs67708.2025.11283277
Wang, Cheng, Wei-Yu Chen, Youfeng Wu, Bratin Saha, and Ali-Reza Adl-Tabatabai. 2007a. “Code Generation and Optimization for Transactional Memory Constructs in an Unmanaged Language.” In International Symposium on Code Generation and Optimization (CGO’07). IEEE. https://doi.org/10.1109/cgo.2007.4
Wang, Sheng-Hong, Hunter James Coffman, Kenneth Mayer, Sakshi Garg, and Jose Renau. 2023d. “A Multi-Threaded Fast Hardware Compiler for HDLs.” In Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3578360.3580254
Wang, Siao, Chenglie Du, Jinchao Chen, Zuo Zhao, and Ying Zhang. 2021a. “A Bytecode Service Composition Engine for Embedded Services.” In 2021 IEEE International Conference on Progress in Informatics and Computing (PIC). IEEE. https://doi.org/10.1109/pic53636.2021.9687016
Wang, Panfeng, Yunfei Du, Hongyi Fu, Xuejun Yang, and Haifang Zhou. 2008. “Static Analysis for Application-Level Checkpointing of MPI Programs.” In 2008 10th IEEE International Conference on High Performance Computing and Communications. IEEE. https://doi.org/10.1109/hpcc.2008.39
Wang, Baokang, Yuki Fukazawa, Toshio Kondo, and Takahiro Sasaki. 2017b. “Tile/line Access Cache Memory Based on a Multi-Level Z-Order Tiling Data Layout.” Concurrency and Computation: Practice and Experience 30 (9): e4375. https://doi.org/10.1002/cpe.4375
Wang, Di, Jan Hoffmann, and Thomas Reps. 2018b. “PMAF: An Algebraic Framework for Static Analysis of Probabilistic Programs.” ACM SIGPLAN Notices 53 (4): 513–28. https://doi.org/10.1145/3296979.3192408
Wang, Ge, Ziyuan Hu, Zechuan Hu, and Kewei Tu. 2020b. “An Empirical Study of Encoders and Decoders in Graph-Based Dependency Parsing.” IEEE Access 8: 35770–76. https://doi.org/10.1109/access.2020.2974109
Wang, Yiqun, Hongyang Jia, Yongpan Liu, Qing’an Li, Chun Jason Xue, and Huazhong Yang. 2014c. “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, Zhuangzhuang, Chengze Jiang, Jie Gui, Xinli Shi, and Yuan Yan Tang. 2026b. “Revisiting the Adversarial Transferability: Toward a Perspective of Semantic Preservation.” IEEE Transactions on Multimedia 28: 7773–86. https://doi.org/10.1109/tmm.2026.3673547
Wang, Chaoming, Yingqian Jiang, Xinyu Liu, et al. 2021c. “A Just-In-Time Compilation Approach for Neural Dynamics Simulation.” In Neural Information Processing. Springer International Publishing. https://doi.org/10.1007/978-3-030-92238-2_2
Wang, Jing, and Eunyoung Kim. 2026. “An Empirical Study of TPACK Development through Transnational Online Continuing Professional Development Programs.” Sustainability 18 (8): 3682. https://doi.org/10.3390/su18083682
Wang, Zi, Yuqing Lan, Xinlei He, and Jianghua Lv. 2024a. “A Formal Verification Approach for Linux Kernel Designing.” Technologies 12 (8): 132. https://doi.org/10.3390/technologies12080132
Wang, Tuo, Peixuan Li, Ping Xie, and Xiaofei Wang. 2023e. “SSD Multi-Level Parallel Garbage Collection.” In 2023 4th International Conference on Information Science, Parallel and Distributed Systems (ISPDS). IEEE. https://doi.org/10.1109/ispds58840.2023.10235643
Wang, Fengqin, Ying Li, and Zhengxia Zhang. 2009b. “A Register Allocation Algorithm Based on Predicate Analysis System.” In 2009 WASE International Conference on Information Engineering. IEEE. https://doi.org/10.1109/icie.2009.259
Wang, Lantao, Yun Li, Haitao Zhang, Qigu Han, and Lirong Chen. 2021b. “An Efficient Control-Flow Based Obfuscator for Micropython Bytecode.” In 2021 7th International Symposium on System and Software Reliability (ISSSR). IEEE. https://doi.org/10.1109/isssr53171.2021.00028
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, Jie, Yuetong Luo, and Juan Han. 2013c. “Skeleton-Based Structure-Preserving Focus + Context Layout Method of Large Tree.” In 2013 International Conference on Computational and Information Sciences. IEEE. https://doi.org/10.1109/iccis.2013.464
Wang, Jichang, Gaofeng Lv, Zhongpei Liu, and Xiangrui Yang. 2022a. “Programmable Deterministic Zero-Copy DMA Mechanism for FPGA Accelerator.” Applied Sciences 12 (19): 9581. https://doi.org/10.3390/app12199581
Wang, Shuyi, Seonghyeon Moon, Yuguang Fu, and Jinwoo Kim. 2025c. “Construction Regulatory Document Digitalization with Layout Knowledge-Informed Object Detection and Semantic Text Recognition.” Advanced Engineering Informatics 65: 103278. https://doi.org/10.1016/j.aei.2025.103278
Wang, Xiaoran, Lori Pollock, and K. Vijay-Shanker. 2015c. “Developing a Model of Loop Actions by Mining Loop Characteristics from a Large Code Corpus.” In 2015 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE. https://doi.org/10.1109/icsm.2015.7332451
Wang, Shengyi, Zongyan Qiu, Shengchao Qin, and Wei-Ngan Chin. 2010b. “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, Tongyao, Donghui Shi, Jose Aguilar, and Jozef Zurada. 2026a. “DSE-RE: Dynamic Schema Evolution with LLM for Iterative Relation Extraction.” Human-Centric Intelligent Systems. https://doi.org/10.1007/s44230-026-00158-1
Wang, Yong, Qin-Bao Song, and Jun-Yi Shen. 2007b. “Grey Learning Based Software Stage-Effort Estimation.” In 2007 International Conference on Machine Learning and Cybernetics. IEEE. https://doi.org/10.1109/icmlc.2007.4370377
Wang, Liqiang, and Scott D. Stoller. 2005. “Static Analysis of Atomicity for Programs with Non-Blocking Synchronization.” In Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming. ACM. https://doi.org/10.1145/1065944.1065953
Wang, Keyu, Huailiang Tan, Zaihong He, Jinyou Li, and Keqin Li. 2025b. “CDA-GC: An Effective Cache Data Allocation for Garbage Collection in Flash-Based Solid-State Drives.” Integration 102: 102359. https://doi.org/10.1016/j.vlsi.2025.102359
Wang, Chundong, Qingsong Wei, Mingdi Xue, Jun Yang, and Cheng Chen. 2015a. “Data-Centric Garbage Collection for NAND Flash Devices.” In 2015 IEEE Non-Volatile Memory System and Applications Symposium (NVMSA). IEEE. https://doi.org/10.1109/nvmsa.2015.7304360
Wang, Yuting, Pierre Wilke, and Zhong Shao. 2019. “An Abstract Stack Based Approach to Verified Compositional Compilation to Machine Code.” Proceedings of the ACM on Programming Languages 3 (POPL): 1–30. https://doi.org/10.1145/3290375
Wang, Jyh-Shian, I-Wei Wu, Yu-Sheng Chen, Jean Jyh-Jiun Shann, and Wei-Chung Hsu. 2009a. “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, Cheng, Youfeng Wu, and Marcelo Cintra. 2013a. “Acceldroid: Co-Designed Acceleration of Android Bytecode.” In Proceedings of the 2013 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo.2013.6494980
Wang, Zhenjiang, Chenggang Wu, Pen-Chung Yew, Jianjun Li, and Di Xu. 2012. “On-the-Fly Structure Splitting for Heap Objects.” ACM Transactions on Architecture and Code Optimization 8 (4): 1–20. https://doi.org/10.1145/2086696.2086705
Wang, Jing, Zhiwei Xu, Siyuan Liu, Ye Lu, and Tao Li. 2026c. “Towards Efficient Graph-RAG via Structure-Aware Intermediate Representation: Incremental Collaborative Exploration on Knowledge Graph.” Knowledge-Based Systems 342: 115884. https://doi.org/10.1016/j.knosys.2026.115884
Wang, Yuting, Xiangzhe Xu, Pierre Wilke, and Zhong Shao. 2020a. “CompCertELF: Verified Separate Compilation of C Programs into ELF Object Files.” Proceedings of the ACM on Programming Languages 4 (OOPSLA): 1–28. https://doi.org/10.1145/3428265
Wang, Taizheng, Chunyang Ye, Hui Zhou, Wei Chang, and Chaoyi Li. 2025d. “Enhancing Service Observability through Bytecode-Level Variable Monitoring.” In 2025 IEEE International Conference on Web Services (ICWS). IEEE. https://doi.org/10.1109/icws67624.2025.00114
Wang, Peng, and Zhi-Bin Yu. 2023. “LLVM RISC-V RV32X Graphics Extension Support and Characteristics Analysis of Graphics Programs.” IEEE Access 11: 67285–97. https://doi.org/10.1109/access.2023.3291920
Wang, Yuting, Ling Zhang, Zhong Shao, and Jérémie Koenig. 2022b. “Verified Compilation of C Programs with a Nominal Memory Model.” Proceedings of the ACM on Programming Languages 6 (POPL): 1–31. https://doi.org/10.1145/3498686
Wang, Yu-Ying, and Xing-She Zhou. 2007. “Mutual Effect of Instruction Layout Optimization and Instruction Memory Hierarchy.” In 2007 International Conference on Parallel Processing Workshops (ICPPW 2007). IEEE. https://doi.org/10.1109/icppw.2007.57
Wang, Leiquan, Jialiang Zhou, Zhongwei Li, Xin Zhao, Chunlei Wu, and Mingming Xu. 2023a. “Adversarial MixUp with Implicit Semantic Preservation for Semi-Supervised Hyperspectral Image Classification.” Signal Processing 211: 109116. https://doi.org/10.1016/j.sigpro.2023.109116
Wang Shu-qin and Liu Wei. 2008. “Layout Planning with a Controlling Structure to Logistics Parks.” In 2008 IEEE International Conference on Automation and Logistics. IEEE. https://doi.org/10.1109/ical.2008.4636498
Washabaugh, D. M., and D. Kafura. 1990. “Incremental Garbage Collection of Concurrent Objects for Real-Time Applications.” In [1990] Proceedings 11th Real-Time Systems Symposium. IEEE. https://doi.org/10.1109/real.1990.128723
Wasserrab, Daniel, Tobias Nipkow, Gregor Snelting, and Frank Tip. 2006. “An Operational Semantics and Type Safety Prooffor Multiple Inheritance in C++.” In Proceedings of the 21st annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications. ACM. https://doi.org/10.1145/1167473.1167503
Watanabe, Tan, Tetsuro Fujise, Koichiro Mori, Kyoko Iwasawa, and Ikuo Nakata. 2007. “Design Assists for Embedded Systems in the COINS Compiler Infrastructure.” In Innovative Architecture for Future Generation High-Performance Processors and Systems (IWIA 2007). IEEE. https://doi.org/10.1109/iwia.2007.13
Watanabe, Osamu, Yuta Hougi, Kazuhiko Komatsu, Masayuki Sato, Akihiro Musa, and Hiroaki Kobayashi. 2019. “Optimizing Memory Layout of Hyperplane Ordering for Vector Supercomputer SX-Aurora TSUBASA.” In 2019 IEEE/ACM Workshop on Memory Centric High Performance Computing (MCHPC). IEEE. https://doi.org/10.1109/mchpc49590.2019.00011
Watanabe, Soma, and Yoshinari Kameda. 2024. “Punch Type Classification and Hit Judgement Using Estimated Skeletal Model in Boxing Match Videos.” In Proceedings of the 12th International Conference on Sport Sciences Research and Technology Support. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0013018400003828
Watt, Conrad, Xiaojia Rao, Jean Pichon-Pharabod, Martin Bodin, and Philippa Gardner. 2021. “Two Mechanisations of WebAssembly 1.0.” In Formal Methods. Springer International Publishing. https://doi.org/10.1007/978-3-030-90870-6_4
Weber, Manfred, and Susan L. Bernstein. 1980. “Global Register Allocation for Non-Equivalent Register Sets.” ACM SIGPLAN Notices 15 (2): 74–81. https://doi.org/10.1145/947586.947594
Wedemeijer, Lex. 2001. “Defining Metrics for Conceptual Schema Evolution.” In Database Schema Evolution and Meta-Modeling. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48196-6_13
Wei, Yihua, Lihan Hu, and Peng Jiang. 2025a. “Matcha: A Language and Compiler for Backtracking-Based Subgraph Matching.” In 2025 IEEE International Parallel and Distributed Processing Symposium (IPDPS). IEEE. https://doi.org/10.1109/ipdps64566.2025.00105
Wei, Jianhao, Qian Zhang, Yiwen Xiang, and Xueqing Gong. 2025b. “TB-Collect: Efficient Garbage Collection for Non-Volatile Memory Online Transaction Processing Engines.” Electronics 14 (10): 2080. https://doi.org/10.3390/electronics14102080
Weimin Wu, Yongfeng Cao, Qing Su, Yonghe Zhang, and Kailun Li. 2009. “Venus: A Visual Java Virtual Machine Framework.” In 2009 4th International Conference on Computer Science & Education. IEEE. https://doi.org/10.1109/iccse.2009.5228212
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
Weirich, Stephanie. 2001. “Encoding Intensional Type Analysis.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45309-1_7
Weirich, Stephanie. 2002. “Higher-Order Intensional Type Analysis.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45927-8_8
Weise, Daniel. 1999. “Static Analysis of Mega-Programs: (Invited Paper).” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-48294-6_19
Weiss, Michael, François de Ferrière, Bertrand Delsart, et al. 1998. “TurboJ, a Java Bytecode-to-Native Compiler.” In Languages, Compilers, and Tools for Embedded Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0057785
Weiyi Shang, Zhen Ming Jiang, Bram Adams, and Ahmed E. Hassan. 2009. “MapReduce as a General Framework to Support Research in Mining Software Repositories (MSR).” In 2009 6th IEEE International Working Conference on Mining Software Repositories. IEEE. https://doi.org/10.1109/msr.2009.5069477
Welch, Ian, and Robert J. Stroud. 2000. “Kava: A Reflective Java Based on Bytecode Rewriting.” In Reflection and Software Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45046-7_9
Wells, Paul Damian. 2004. “A Universal Intermediate Representation for Massively Parallel Software Development.” ACM SIGPLAN Notices 39 (5): 48–57. https://doi.org/10.1145/997140.997145
Wells, J. B., Allyn Dimock, Robert Muller, and Franklyn Turbak. 1997. “A Typed Intermediate Language for Flow-Directed Compilation.” In TAPSOFT ‘97: Theory and Practice of Software Development. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0030639
Wen, Elliott, and Jens Dietrich. 2023. “WasmSlim: Optimizing WebAssembly Binary Distribution via Automatic Module Splitting.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00069
Wen, Jianfeng, Shixian Li, Zhiyong Lin, Yong Hu, and Changqin Huang. 2012. “Systematic Literature Review of Machine Learning Based Software Development Effort Estimation Models.” Information and Software Technology 54 (1): 41–59. https://doi.org/10.1016/j.infsof.2011.09.002
Wen, Jianfeng, Shixian Li, and Linyan Tang. 2009. “Improve Analogy-Based Software Effort Estimation Using Principal Components Analysis and Correlation Weighting.” In 2009 16th Asia-Pacific Software Engineering Conference. IEEE. https://doi.org/10.1109/apsec.2009.40
Wen, Fengcai, Csaba Nagy, Michele Lanza, and Gabriele Bavota. 2021. “Quick Remedy Commits and Their Impact on Mining Software Repositories.” Empirical Software Engineering 27 (1): 14. https://doi.org/10.1007/s10664-021-10051-z
Weng, Bingjie, and Jianhui Ma. 2024. “Semantic-Based Detection of Ponzi Smart Contracts: Enhancing Bytecode Analysis with Source Code.” In 2024 4th International Conference on Electronic Information Engineering and Computer (EIECT). IEEE. https://doi.org/10.1109/eiect64462.2024.10866315
Weng, Min-Hsien, Robi Malik, and Mark Utting. 2021. “Automatic Proofs of Memory Deallocation for a Whiley-to-C Compiler.” Formal Methods in System Design 57 (3): 429–72. https://doi.org/10.1007/s10703-021-00378-0
Wenjun, Liu. 2011. “Performance Study for Java Virtual Machine in Embedded Systems.” In 2011 International Conference on Internet Computing and Information Services. IEEE. https://doi.org/10.1109/icicis.2011.31
Wentworth, E. P. 1990. “Pitfalls of Conservative Garbage Collection.” Software: Practice and Experience 20 (7): 719–27. https://doi.org/10.1002/spe.4380200707
Whaley, John. 2005. “Joeq: A Virtual Machine and Compiler Infrastructure.” Science of Computer Programming 57 (3): 339–56. https://doi.org/10.1016/j.scico.2004.08.006
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
Whigham, Peter A., and Caitlin Owen. 2014. “Multi-Objective Optimisation, Software Effort Estimation and Linear Models.” In Simulated Evolution and Learning. Springer International Publishing. https://doi.org/10.1007/978-3-319-13563-2_23
Whitehead, Jim, and Thomas Zimmermann. 2012. “Introduction to the Special Issue on Mining Software Repositories in 2010.” Empirical Software Engineering 17 (4–5): 500–502. https://doi.org/10.1007/s10664-012-9206-z
Wickramasinghe, Udayanga, Andrew Lumsdaine, Saliya Ekanayake, and Martin Swany. 2019. “RDMA Managed Buffers: A Case for Accelerating Communication Bound Processes via Fine-Grained Events for Zero-Copy Message Passing.” In 2019 18th International Symposium on Parallel and Distributed Computing (ISPDC). IEEE. https://doi.org/10.1109/ispdc.2019.00025
Wiecek, Cheryl A. 1982. “A Case Study of VAX-11 Instruction Set Usage for Compiler Execution.” ACM SIGPLAN Notices 17 (4): 177–84. https://doi.org/10.1145/960120.801841
Wieclawski, A., and M. Perkowski. 1984. “Optimization of Negative Gate Networks Realized in Weinberger-Likf Layout in a Boolean Level Silicon Compiler.” In 21st Design Automation Conference Proceedings. IEEE. https://doi.org/10.1109/dac.1984.1585888
Wiedenbeck, Susan, Vikki Fix, and Jean Scholtz. 1993. “Characteristics of the Mental Representations of Novice and Expert Programmers: An Empirical Study.” International Journal of Man-Machine Studies 39 (5): 793–812. https://doi.org/10.1006/imms.1993.1084
Wilder, Michael D. 2006. “The Uniconc Optimizing Unicon Compiler.” In Companion to the 21st ACM SIGPLAN symposium on Object-oriented programming systems, languages, and applications. ACM. https://doi.org/10.1145/1176617.1176710
Wildmoser, Martin, Amine Chaieb, and Tobias Nipkow. 2005. “Bytecode Analysis for Proof Carrying Code.” Electronic Notes in Theoretical Computer Science 141 (1): 19–34. https://doi.org/10.1016/j.entcs.2005.02.040
Wildmoser, Martin, and Tobias Nipkow. 2005. “Asserting Bytecode Safety.” In Programming Languages and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-31987-0_23
Wille, Cornelius, Anja Fiegler, Robert Neumann, and Reiner R. Dumke. 2011. “Evidence-Based Evaluation of Effort Estimation Methods.” In 2011 Joint Conference of the 21st International Workshop on Software Measurement and the 6th International Conference on Software Process and Product Measurement. IEEE. https://doi.org/10.1109/iwsm-mensura.2011.17
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, Kevin, Jason McCandless, and David Gregg. 2010. “Portable Just-in-Time Specialization of Dynamically Typed Scripting Languages.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-13374-9_27
Wilson, P. R. 1988. “Opportunistic Garbage Collection.” ACM SIGPLAN Notices 23 (12): 98–102. https://doi.org/10.1145/57669.57679
Wilson, Paul R., and Barry Hayes. 1991. “Garbage Collection in Object Oriented Systems.” ACM SIGPLAN OOPS Messenger 3 (4): 63–71. https://doi.org/10.1145/143776.143792
Winne, Olaf, and Helmut Beikirch. 2013. “Software Development Effort Estimation for Distributed Embedded-Systems.” In Eurocon 2013. IEEE. https://doi.org/10.1109/eurocon.2013.6625046
Wirth, N. 1971. “The Design of a Pascal Compiler.” Software: Practice and Experience 1 (4): 309–33. https://doi.org/10.1002/spe.4380010403
Wojcicki, Margaret A., and Paul Strooper. 2007. “Maximising the Information Gained from a Study of Static Analysis Technologies for Concurrent Software.” Empirical Software Engineering 12 (6): 617–45. https://doi.org/10.1007/s10664-007-9044-6
Wolfengagen, V. E., S. V. Kosikov, and I. O. Slieptsov. 2018. “A Cognitive Type System Simulation by a Dynamically Typed Language.” Procedia Computer Science 145: 641–45. https://doi.org/10.1016/j.procs.2018.11.069
Wolski, Rich, and David Cann. 1995. “Compiler-Enforced Cache Coherence Using a Functional Language.” Scientific Programming 5 (2): 161–71. https://doi.org/10.1155/1996/537293
Wong, KokSheik, Kiyoshi Tanaka, Koichi Takagi, and Yasuyuki Nakajima. 2008. “An Efficient Data Representation Scheme for Complete Video Quality Preserving Data Hiding.” In 2008 IEEE International Conference on Multimedia and Expo. IEEE. https://doi.org/10.1109/icme.2008.4607584
Wood, Ryan, Joseph C. Libby, and Kenneth B. Kent. 2008. “Application Specific Instruction Sets and Their Impact on the Design Space Requirements of a Hardware Java Virtual Machine.” In 2008 The 19th IEEE/IFIP International Symposium on Rapid System Prototyping. IEEE. https://doi.org/10.1109/rsp.2008.10
Wortman, David B., and Michael D. Junkin. 1992. “A Concurrent Compiler for Modula-2+.” In Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation - PLDI ‘92. ACM Press. https://doi.org/10.1145/143095.120025
Wu, Youfeng. 2002. “Efficient Discovery of Regular Stride Patterns in Irregular Programs and Its Use in Compiler Prefetching.” In Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation - PLDI ‘02. ACM Press. https://doi.org/10.1145/512553.512555
Wu, Jiahui. 2025. “A Study on Framework for Adaptive Code Generation and Performance Optimization Based on Qwen.” In Proceedings of the 3rd International Conference on Computer Science and Mechatronics. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0014021500004918
Wu, Wenzhi. 2026. “Cantonese Spoken Corpus Construction for Deep Learning: Bibliometric Analysis and Low-Resource Strategy.” In 2026 8th International Conference on Natural Language Processing (ICNLP). IEEE. https://doi.org/10.1109/icnlp69856.2026.11528002
Wu, Aiqing, Mengni Bie, Longmei Nan, and Wei Li. 2021b. “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, On Tai, Frodo Kin Sun Chan, and Yan Nei Law. 2024. “Improving Few-Shot Code Generation with Prompt Selection and Augmentation Techniques in Large Language Models.” In 2024 5th International Conference on Computers and Artificial Intelligence Technology (CAIT). IEEE. https://doi.org/10.1109/cait64506.2024.10963264
Wu, Tianze, Zezhi Chen, Chenkai Chai, et al. 2025. “AutoRRAM: An Agile RRAM Compiler Featuring Simultaneous Layout/Netlist Generation and Cross-Technology Migration.” In 2025 International Symposium of Electronics Design Automation (ISEDA). IEEE. https://doi.org/10.1109/iseda65950.2025.11101707
Wu, Xueguang, Liqian Chen, Antoine Mine, Wei Dong, and Ji Wang. 2015. “Numerical Static Analysis of Interrupt-Driven Programs via Sequentialization.” In 2015 International Conference on Embedded Software (EMSOFT). IEEE. https://doi.org/10.1109/emsoft.2015.7318260
Wu, Hao, and Zhenzhou Ji. 2015. “Improving Trace Precision for Concurrent Garbage Collection on Multicore Platform.” In 2015 Fifth International Conference on Instrumentation and Measurement, Computer, Communication and Control (IMCCC). IEEE. https://doi.org/10.1109/imccc.2015.316
Wu, Jack H. C., and Jacky W. Keung. 2017. “Utilizing Cluster Quality in Hierarchical Clustering for Analogy-Based Software Effort Estimation.” In 2017 8th IEEE International Conference on Software Engineering and Service Science (ICSESS). IEEE. https://doi.org/10.1109/icsess.2017.8342851
Wu, Xingfu, Michael Kruse, Prasanna Balaprakash, et al. 2021a. “Autotuning PolyBench Benchmarks with LLVM Clang/Polly Loop Optimization Pragmas Using Bayesian Optimization.” Concurrency and Computation: Practice and Experience 34 (20): e6683. https://doi.org/10.1002/cpe.6683
Wu, Jian-Zhi, and Jenq Kuen Lee. 2001. “A Bytecode Otimizer to Engineer Bytecodes for Performance.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45574-4_28
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, Shengfeng, and Iulian Neamtiu. 2011. “Schema Evolution Analysis for Embedded Databases.” In 2011 IEEE 27th International Conference on Data Engineering Workshops. IEEE. https://doi.org/10.1109/icdew.2011.5767627
Wu, Hong, Lin Shi, Celia Chen, Qing Wang, and Barry Boehm. 2016. “Maintenance Effort Estimation for Open Source Software: A Systematic Literature Review.” In 2016 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE. https://doi.org/10.1109/icsme.2016.87
Wu, Pei-Chi, and Feng-Jian Wang. 1992. “An Object-Oriented Specification for Compiler.” ACM SIGPLAN Notices 27 (1): 85–94. https://doi.org/10.1145/130722.130733
Wu, Chin-Hsien, and Ting-Wei Wang. 2017. “A Demand-Based Caching Method for Garbage Collection in Flash-Memory Embedded Systems.” In 2017 IEEE 6th Global Conference on Consumer Electronics (GCCE). IEEE. https://doi.org/10.1109/gcce.2017.8229472
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 Chengyong, Hu Weiping, Zhang Zhaoqing, and Qiao Ruliang. 2000. “Multi-View Intermediate Representation Based on Algebraic Data Type.” In Proceedings Fourth International Conference/Exhibition on High Performance Computing in the Asia-Pacific Region. IEEE. https://doi.org/10.1109/hpc.2000.846559
Würthinger, Thomas, Michael L. Van De Vanter, and Doug Simon. 2010b. “Multi-Level Virtual Machine Debugging Using the Java Platform Debugger Architecture.” In Perspectives of Systems Informatics. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-11486-1_34
Xi, Fang, Takeshi Mishima, and Haruo Yokota. 2014. “CARIC-DA: Core Affinity with a Range Index for Cache-Conscious Data Access in a Multicore Environment.” In Database Systems for Advanced Applications. Springer International Publishing. https://doi.org/10.1007/978-3-319-05810-8_19
Xia, Tianpei, Rui Shu, Xipeng Shen, and Tim Menzies. 2022. “Sequential Model Optimization for Software Effort Estimation.” IEEE Transactions on Software Engineering 48 (6): 1994–2009. https://doi.org/10.1109/tse.2020.3047072
Xiang, Xiaoya, Bin Bao, Chen Ding, and Kai Shen. 2012. “Cache Conscious Task Regrouping on Multicore Processors.” In 2012 12th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing (ccgrid 2012). IEEE. https://doi.org/10.1109/ccgrid.2012.139
Xiang, Jiajun, Xiaojian Pi, Shilun Feng, and Chen Bian. 2016. “Research on the Layout Plan of Tether-Typed Submerged Floating Tunnel.” Procedia Engineering 166: 69–75. https://doi.org/10.1016/j.proeng.2016.11.565
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
Xiao, Fengwei. 2024. “Design of Chinese Programming Language Compiler Based on LLVM Framework.” In 2024 IEEE 2nd International Conference on Image Processing and Computer Applications (ICIPCA), vol. 5. IEEE. https://doi.org/10.1109/icipca61593.2024.10709069
Xiao, Yuanlong, Dongjoon Park, Andrew Butt, et al. 2019. “Reducing FPGA Compile Time with Separate Compilation for FPGA Building Blocks.” In 2019 International Conference on Field-Programmable Technology (ICFPT). IEEE. https://doi.org/10.1109/icfpt47387.2019.00026
Xiao, Ayang, Benli Wang, and Yaochu Jin. 2013. “Evolutionary Truss Layout Optimization Using the Vectorized Structure Approach.” In 2013 IEEE Congress on Evolutionary Computation. IEEE. https://doi.org/10.1109/cec.2013.6557919
Xiaobo, Yan, Liu Bin, and Li Jianxing. 2017. “The Failure Behaviors of Multi-Faults Programs: An Empirical Study.” In 2017 IEEE International Conference on Software Quality, Reliability and Security Companion (QRS-C). IEEE. https://doi.org/10.1109/qrs-c.2017.11
XiaoCheng, Lu, and Chen Zhiming. 2010. “Software Watermarking Algorithm Based on Register Allocation.” In 2010 Ninth International Symposium on Distributed Computing and Applications to Business, Engineering and Science. IEEE. https://doi.org/10.1109/dcabes.2010.114
Xiaocong Wang, Fei Yan, and Fan He. 2011. “Automatic Vulnerability Mining with Abstract Interpretation and Static Taint Trace.” In 2011 2nd International Conference on Control, Instrumentation and Automation (ICCIA). IEEE. https://doi.org/10.1109/icciautom.2011.6183972
Xiaoliang Xu and Jiang Shen. 2010. “Research on Stack-Allocation Based JVM Garbage Collection.” In 2010 3rd International Conference on Advanced Computer Theory and Engineering(ICACTE). IEEE. https://doi.org/10.1109/icacte.2010.5579281
Xiaoping Zhu and T. T. Tay. 2005. “A Compiler-Controlled Instruction Cache Architecture for an Embedded Low Power Microprocessor.” In The Fifth International Conference on Computer and Information Technology (CIT’05). IEEE. https://doi.org/10.1109/cit.2005.3
Xiaozhen Mi, Xiaodong Zhao, Wenzhong Zhao, and Wenhui Fan. 2008. “Application of Genetic Algorithm for Rectangular Object Layout Optimization.” In 2008 12th International Conference on Computer Supported Cooperative Work in Design. IEEE. https://doi.org/10.1109/cscwd.2008.4536986
Xie, Wei, and Yong Chen. 2015. “A Cache Management Scheme for Hiding Garbage Collection Latency in Flash-Based Solid State Drives.” In 2015 IEEE International Conference on Cluster Computing. IEEE. https://doi.org/10.1109/cluster.2015.75
Xie, Anxing, Yonghua Hu, Zhe Li, and Yaohua Wang. 2024b. “SORA: Rapid Software Pipelining Optimization after Register Allocation for Vector-DSPs.” In 2024 IEEE International Symposium on Parallel and Distributed Processing with Applications (ISPA). IEEE. https://doi.org/10.1109/ispa63168.2024.00173
Xie, Xiaolong, Yun Liang, Guangyu Sun, and Deming Chen. 2013a. “An Efficient Compiler Framework for Cache Bypassing on GPUs.” In 2013 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE. https://doi.org/10.1109/iccad.2013.6691165
Xie, Yusheng, Diana Palsetia, Goce Trajcevski, Ankit Agrawal, and Alok Choudhary. 2014. “SILVERBACK: Scalable Association Mining for Temporal Data in Columnar Probabilistic Databases.” In 2014 IEEE 30th International Conference on Data Engineering. IEEE. https://doi.org/10.1109/icde.2014.6816724
Xie, Xiaoyuan, Haolin Yang, Qiang He, and Lin Chen. 2021. “Towards Understanding Tool-Chain Bugs in the LLVM Compiler Infrastructure.” In 2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner50967.2021.00010
Xie, Yuqin, Yuan Zhang, Daofeng Li, and Guoren Xiong. 2025a. “ATBShellFinder: A Bytecode-Level Webshell Detector Based on Adversarial Training.” IEEE Access 13: 98133–43. https://doi.org/10.1109/access.2025.3575263
Xie, Tao, Thomas Zimmermann, and Arie van Deursen. 2013b. “Introduction to the Special Issue on Mining Software Repositories.” Empirical Software Engineering 18 (6): 1043–46. https://doi.org/10.1007/s10664-013-9273-9
Xin, Rui, Zhengwei Qi, Shiqiu Huang, et al. 2013. “An Automation-Assisted Empirical Study on Lock Usage for Concurrent Programs.” In 2013 IEEE International Conference on Software Maintenance. IEEE. https://doi.org/10.1109/icsm.2013.21
Xinda Lu and Jie Chen. 2000. “Eliminate Self-Interference Misses of Cache through Modifying Data Layout of Arrays.” In Proceedings Fourth International Conference/Exhibition on High Performance Computing in the Asia-Pacific Region. IEEE. https://doi.org/10.1109/hpc.2000.846557
Xiong, Xin, and Zulkefli Mansor. 2025. “A Lifelong Learning Algorithm in Software Effort Estimation.” In 2025 International Conference on Electrical Engineering and Informatics (ICEEI). IEEE. https://doi.org/10.1109/iceei68459.2025.11330847
Xiuli Sun and J. Wu. 2005. “Operational Semantics for Real-Time Processes with Action Refinement.” In Third IEEE International Conference on Software Engineering and Formal Methods (SEFM’05). IEEE. https://doi.org/10.1109/sefm.2005.32
Xu, Yeqing. 2025b. “A Corpus-Based Analysis of ChatGPT English Translation of Terms in the Civil Code of the People’s Republic of China (Contract) from the Perspective of Functional Theories of Translation.” International Journal for the Semiotics of Law - Revue internationale de Sémiotique juridique 39 (6): 1917–36. https://doi.org/10.1007/s11196-025-10394-6
Xu, Weifeng, Tao Ding, Hanlin Wang, and Dianxiang Xu. 2013. “Mining Test Oracles for Test Inputs Generated from Java Bytecode.” In 2013 IEEE 37th Annual Computer Software and Applications Conference. IEEE. https://doi.org/10.1109/compsac.2013.8
Xu, Weifeng, Tao Ding, and Dianxiang Xu. 2014. “Rule-Based Test Input Generation from Bytecode.” In 2014 Eighth International Conference on Software Security and Reliability. IEEE. https://doi.org/10.1109/sere.2014.24
Xu, Yi, Zhiqiang Gao, and Xiangqing He. 2007. “A Flexible Embedded SRAM IP Compiler.” In 2007 IEEE International Symposium on Circuits and Systems (ISCAS). IEEE. https://doi.org/10.1109/iscas.2007.378778
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, Xiaochen, and Zhongwen Li. 2009. “High-Speed Packet Capture Mechanism Based on Zero-Copy in Linux.” In 2009 2nd International Conference on Biomedical Engineering and Informatics. IEEE. https://doi.org/10.1109/bmei.2009.5305585
Xu, Wenchu, and Yanran Ma. 2021. “A Static Analysis Framework for Detecting Bugs in Introductory Programs.” In 2021 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW). IEEE. https://doi.org/10.1109/issrew53611.2021.00078
Xu, Qiyuan, Renxi Wang, Peixin Wang, Haonan Li, and Conrad Watt. 2026. “A Minimalist Proof Language for Neural Theorem Proving over Isabelle/HOL.” Proceedings of the ACM on Programming Languages 10 (OOPSLA1): 2073–98. https://doi.org/10.1145/3798275
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, Chen, Minqi Zhou, and Weining Qian. 2010. “Materialized View Maintenance in Columnar Storage for Massive Data Analysis.” In 2010 4th International Universal Communication Symposium. IEEE. https://doi.org/10.1109/iucs.2010.5666768
Ya-Hui Tung, Hung-Cheng Lo, Vince Lo, and Sheng-Jer Kuo. 2010. “Platform-Based Design Automation: Platform Core Compiler.” In Proceedings of 2010 International Symposium on VLSI Design, Automation and Test. IEEE. https://doi.org/10.1109/vdat.2010.5496685
Yacci, M. 1997. “Object-Oriented Compiler Construction [Book Review].” IEEE Software 14 (5): 117–18. https://doi.org/10.1109/ms.1997.605944
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
Yaffey, Michael. 1988. “Layout and Structure of Computer Spreadsheets for Project Planning.” Project Appraisal 3 (2): 105–10. https://doi.org/10.1080/02688867.1988.9726665
Yamada, Tomoaki, Chao Sun, and Ken Takeuchi. 2014. “A High-Performance Solid-State Drive by Garbage Collection Overhead Suppression.” In 2014 14th Annual Non-Volatile Memory Technology Symposium (NVMTS). IEEE. https://doi.org/10.1109/nvmts.2014.7060855
Yamamoto, Tetsuo. 2017. “Code Suggestion of Method Call Statements Using a Source Code Corpus.” In 2017 24th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2017.82
Yamamoto, Shintaro, and Kazuhiko Ohno. 2025. “Performance Estimation Using Both Source and Assembly Code for Data Layout Optimization on GPU.” In 2025 Thirteenth International Symposium on Computing and Networking Workshops (CANDARW). IEEE. https://doi.org/10.1109/candarw68385.2025.00027
Yamamoto, Tetsuo, Norihiro Yoshida, and Yoshiki Higo. 2013. “Seamless Code Reuse with Source Code Corpus.” In 2013 20th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec.2013.108
Yamini, S., and Rahul R. Marathe. 2018. “Mathematical Model to Mitigate Planning Fallacy and to Determine Realistic Delivery Time.” IIMB Management Review 30 (3): 242–57. https://doi.org/10.1016/j.iimb.2018.05.003
Yan, Yan, Yahong Han, Petia Radeva, and Qi Tian. 2017. “Guest Editorial: Intermediate Representation for Vision and Multimedia Applications.” Journal of Visual Communication and Image Representation 44: 227–28. https://doi.org/10.1016/j.jvcir.2017.01.023
Yan, Fang, Yu’an Tan, Quanxin Zhang, Fei Wu, Zijing Cheng, and Jun Zheng. 2016. “An Effective RAID Data Layout for Object-Based De-Duplication Backup System.” Chinese Journal of Electronics 25 (5): 832–40. https://doi.org/10.1049/cje.2016.06.021
Yan, Da, Wei Wang, and Xiaowen Chu. 2022. “An LLVM-Based Open-Source Compiler for NVIDIA GPUs.” In Proceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. ACM. https://doi.org/10.1145/3503221.3508428
Yan, Dacong, Guoqing Xu, and Atanas Rountev. 2012. “Rethinking Soot for Summary-Based Whole-Program Analysis.” In Proceedings of the ACM SIGPLAN International Workshop on State of the Art in Java Program analysis. ACM. https://doi.org/10.1145/2259051.2259053
Yan, Jianfeng, and Bo Zhang. 2009. “Support Multi-Version Applications in SaaS via Progressive Schema Evolution.” In 2009 IEEE 25th International Conference on Data Engineering. IEEE. https://doi.org/10.1109/icde.2009.167
Yan, Aoyang, Hao Zhong, Daohan Song, and Li Jia. 2023. “How Do Programmers Fix Bugs as Workarounds? An Empirical Study on Apache Projects.” Empirical Software Engineering 28 (4): 96. https://doi.org/10.1007/s10664-023-10318-7
Yang, Zhenkun, Suvadeep Banerjee, Jeremy Casas, and Jin Yang. 2025c. “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, Heng-Li, and Hsiu-Hua Cheng. 2009. “Creative Self-Efficacy and Its Factors: An Empirical Study of Information System Analysts and Programmers.” Computers in Human Behavior 25 (2): 429–38. https://doi.org/10.1016/j.chb.2008.10.005
Yang, Hongbo, R. Govindarajan, Guang R. Gao, and Ziang Hu. 2004. “Compiler-Assisted Cache Replacement: Problem Formulation and Performance Evaluation.” In Languages and Compilers for Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-24644-2_6
Yang, Peilin, Yijun Gu, and Taiyu Wong. 2026a. “ContractFull: A Rapid and Comprehensive Static Analysis Tool for Ethereum Smart Contracts.” Empirical Software Engineering 31 (5): 125. https://doi.org/10.1007/s10664-026-10863-x
Yang, Xu, and Hu He. 2012a. “An Advanced Compiler Designed for a VLIW DSP for Sensors-Based Systems.” Sensors 12 (4): 4466–78. https://doi.org/10.3390/s120404466
Yang, Le, and Huo-jiao He. 2012b. “Research on Java Bytecode Parse and Obfuscate Tool.” In 2012 International Conference on Computer Science and Service System. IEEE. https://doi.org/10.1109/csss.2012.21
Yang, Seonghyeok, Kyungeun Lee, and Ikjin Lee. 2020. “Pattern-Free Heliostat Field Layout Optimization Using Physics-Based Gradient.” Solar Energy 206: 722–31. https://doi.org/10.1016/j.solener.2020.06.029
Yang, Zhihu, and Dan Li. 2020. “WasNet: A Neural Network-Based Garbage Collection Management System.” IEEE Access 8: 103984–93. https://doi.org/10.1109/access.2020.2999678
Yang, Byung-Sun, Soo-Mook Moon, and Kemal Ebcio?lu. 2005b. “Lightweight Monitors for the Java Virtual Machine.” Software: Practice and Experience 35 (3): 281–99. https://doi.org/10.1002/spe.635
Yang, Yuanzhe, Zhiyi Niu, Yuying Qiu, Biao Song, Xinchang Zhang, and Yuan Tian. 2023a. “A Multi-Input Fusion Model for Privacy and Semantic Preservation in Facial Image Datasets.” Applied Sciences 13 (11): 6799. https://doi.org/10.3390/app13116799
Yang, Jing, and Shuyi Pei. 2019. “Thermo-GC: Reducing Write Amplification by Tagging Migrated Pages during Garbage Collection.” In 2019 IEEE International Conference on Networking, Architecture and Storage (NAS). IEEE. https://doi.org/10.1109/nas.2019.8834722
Yang, Qibo, Jin Tian, and Tingdi Zhao. 2017b. “Safety Is an Emergent Property: Illustrating Functional Resonance in Air Traffic Management with Formal Verification.” Safety Science 93: 162–77. https://doi.org/10.1016/j.ssci.2016.12.006
Yang, Chun-Chieh, Shao-Chung Wang, Min-Yi Hsu, Yuan-Ming Chang, Yuan-Shin Hwang, and Jenq-Kuen Lee. 2017a. “OpenCL 2.0 Compiler Adaptation on LLVM for PTX Simulators.” In 2017 46th International Conference on Parallel Processing Workshops (ICPPW). IEEE. https://doi.org/10.1109/icppw.2017.21
Yang, Chun-Chieh, Shao-Chung Wang, Min-Yi Hsu, Yuan-Ming Chang, Yuan-Shin Hwang, and Jenq-Kuen Lee. 2018. “Support OpenCL 2.0 Compiler on LLVM for PTX Simulators.” Journal of Signal Processing Systems 91 (3–4): 261–71. https://doi.org/10.1007/s11265-018-1377-4
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
Yang, Albert Mingkun, and Tobias Wrigstad. 2017. “Type-Assisted Automatic Garbage Collection for Lock-Free Data Structures.” ACM SIGPLAN Notices 52 (9): 14–24. https://doi.org/10.1145/3156685.3092274
Yang, Yi, Ping Xiang, Jingfei Kong, and Huiyang Zhou. 2010. “A GPGPU Compiler for Memory Optimization and Parallelism Management.” In Proceedings of the 31st ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM. https://doi.org/10.1145/1806596.1806606
Yang, Yi, Ping Xiang, Mike Mantor, and Huiyang Zhou. 2012. “Fixing Performance Bugs: An Empirical Study of Open-Source GPGPU Programs.” In 2012 41st International Conference on Parallel Processing. IEEE. https://doi.org/10.1109/icpp.2012.30
Yang, Xiao, Yu Xiao, Liangcai Shu, Ward Taborsky, and Dongsheng Yang. 2025a. “Automatic Power Electronic PCB Layout Design Based on Generative AI: The Pathway towards Next-Generation Hardware Compiler.” In 2025 Energy Conversion Congress & Expo Europe (ECCE Europe). IEEE. https://doi.org/10.1109/ecce-europe62795.2025.11238791
Yang, Bailin, Lu Ye, Zhigeng Pan, and Guilin Xu. 2005c. “An Optimized Soft 3D Mobile Graphics Library Based on JIT Backend Compiler.” In Entertainment Computing - ICEC 2005. Springer Berlin Heidelberg. https://doi.org/10.1007/11558651_7
Yang, Jiahui, Xiangfu Zhao, Hanfeng Zhang, Long He, Shiji Wang, and Naixiang Gou. 2025b. “CSAFuzzer: Fuzzing Smart Contracts Combining with Static Analysis.” Empirical Software Engineering 30 (3): 62. https://doi.org/10.1007/s10664-025-10623-3
Yang, Yi, and Huiyang Zhou. 2012. “The Implementation of a High Performance GPGPU Compiler.” International Journal of Parallel Programming 41 (6): 768–81. https://doi.org/10.1007/s10766-012-0228-3
Yang, Guang, Yanlin Zhou, Xiang Chen, and Chi Yu. 2021. “Fine-Grained Pseudo-Code Generation Method via Code Feature Extraction and Transformer.” In 2021 28th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec53868.2021.00029
Yang Chen, Bin Fan, Lujie Zhong, and Chengyong Wu. 2008. “Diva: A Dataflow Programming Model and Its Runtime Support in Java Virtual Machine.” In 2008 13th Asia-Pacific Computer Systems Architecture Conference. IEEE. https://doi.org/10.1109/apcsac.2008.4625447
YanJia Zhang, WeiTao Du, and YaHui Hou. 2011. “Design of CORDIC IP Compiler.” In 2011 International Conference on Electric Information and Control Engineering. IEEE. https://doi.org/10.1109/iceice.2011.5778159
Yaqub, Waheeb, Ibrahim Kamel, and Zeyar Aung. 2018. “Distortion-Free Watermarking Scheme for Compressed Data in Columnar Database.” In Proceedings of the 15th International Joint Conference on e-Business and Telecommunications. SCITEPRESS - Science and Technology Publications. https://doi.org/10.5220/0006857203430353
Yardeni, Eyal, and Ehud Shapiro. 1991. “A Type System for Logic Programs.” Journal of Logic Programming 10 (2): 125–53. https://doi.org/10.1016/0743-1066(91)80002-u
Yassa, F. F., J. R. Jasica, R. I. Hartley, and S. E. Noujaim. 1987. “A Silicon Compiler for Digital Signal Processing: Methodology, Implementation, and Applications.” Proceedings of the IEEE 75 (9): 1272–82. https://doi.org/10.1109/proc.1987.13879
Yasuhiro Ito, Yutaka Sugawara, Mary Inaba, and Kei Hiraki. 2008. “CVC: The C to RTL Compiler for Callback-Based Verification Model.” In 2008 International Conference on Field Programmable Logic and Applications. IEEE. https://doi.org/10.1109/fpl.2008.4629993
Yates, J. S., and R. A. Schwartz. 1988. “Dynamic Programming and Industrial-Strength Instruction Selection: Code Generation by Tiring, but Not Exhaustive, Search.” ACM SIGPLAN Notices 23 (10): 131–40. https://doi.org/10.1145/51607.51618
Yau Chi Hang, Tan Yiyu, and S. F. Anthony. 2005. “A Novel Just-in-Time Compiler on an Embedded Object-Oriented Processor.” In The Fifth International Conference on Computer and Information Technology (CIT’05). IEEE. https://doi.org/10.1109/cit.2005.32
Yavari, Yaeghoob, Mohsen Afsharchi, and Mojtaba Karami. 2011. “Software Complexity Level Determination Using Software Effort Estimation Use Case Points Metrics.” In 2011 Malaysian Conference in Software Engineering. IEEE. https://doi.org/10.1109/mysec.2011.6140680
Yavas, Demir Y. 2022. “Zero-Copy Approach to Enhance SIP Parsing Performance.” In 2022 7th International Conference on Computer Science and Engineering (UBMK). IEEE. https://doi.org/10.1109/ubmk55850.2022.9919566
Ye, Fan, Qing Li, and Enhong Chen. 2010. “Benefit Based Cache Data Placement and Update for Mobile Peer to Peer Networks.” World Wide Web 14 (3): 243–59. https://doi.org/10.1007/s11280-010-0103-3
Ye, Liwei, Yuge Nie, Yufei Zhou, et al. 2026. “Line-Level Bug-Finding Power of Static Analysis Rules: A Case Study of Teamscale.” Empirical Software Engineering 31 (6): 164. https://doi.org/10.1007/s10664-026-10895-3
Ye Hua, Tong WeiQin, and Yao WenSheng. 2000. “Platform Independence Issues in Compiling Java Bytecode to Native Code.” In Proceedings Fourth International Conference/Exhibition on High Performance Computing in the Asia-Pacific Region. IEEE. https://doi.org/10.1109/hpc.2000.846610
Yeboah-Antwi, Kwaku, and Benoit Baudry. 2016. “Online Genetic Improvement on the Java Virtual Machine with ECSELR.” Genetic Programming and Evolvable Machines 18 (1): 83–109. https://doi.org/10.1007/s10710-016-9278-4
Yeh, Ming-Feng, Ching-Chuan Luo, and Cheng-Lin Lu. 2026. “Multi-Hardware Benchmarking of Open-Source Large Language Models with Retrieval-Augmented Generation for Mitsubishi FX-Series PLC Instruction List Code Generation.” Sensors 26 (11): 3602. https://doi.org/10.3390/s26113602
Yelland, Phillip M. 1999. “A Compositional Account of the Java Virtual Machine.” In Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM. https://doi.org/10.1145/292540.292548
Yerramreddy, Sai, Austin Mordahl, Ugur Koc, et al. 2023. “An Empirical Assessment of Machine Learning Approaches for Triaging Reports of Static Analysis Tools.” Empirical Software Engineering 28 (2): 28. https://doi.org/10.1007/s10664-022-10253-z
Yi, He, Narayanaswamy Balakrishnan, and Xiang Li. 2023. “Reliability of Three-Dimensional Consecutive k-Type Systems.” Reliability Engineering & System Safety 233: 109131. https://doi.org/10.1016/j.ress.2023.109131
Yi, He, Narayanaswamy Balakrishnan, and Xiang Li. 2026. “Linear Two-Dimensional Consecutive k-Type Systems in Multi-State Case.” Reliability Engineering & System Safety 271: 112215. https://doi.org/10.1016/j.ress.2026.112215
Yi, Fei, and Yang Wang. 2025. “ModelMap: Kernel-Level Zero-Copy on-Demand Model Loading for Edge AI.” In 2025 lEEE International Conference on Cloud Computing Technology and Science (CloudCom). IEEE. https://doi.org/10.1109/cloudcom67567.2025.11331339
Yi-Chang Chen, Jeu-Yih Jeng, Teh-Sheng Huang, and Phone Lin. 2012. “Design and Implementation of Database Schema Evolution for Service Continuity of Web-Based Internet Applications.” In 2012 14th Asia-Pacific Network Operations and Management Symposium (APNOMS). IEEE. https://doi.org/10.1109/apnoms.2012.6356090
Yilmaz, Buse, Ilyas Turimbetov, and Didem Unat. 2019. “Program Analysis for Process Migration.” In Proceedings of the 8th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis. ACM. https://doi.org/10.1145/3315568.3329969
Yin, Zixiang, Xiaolu Zeng, Xiaopeng Yang, Jiancheng Liao, and Junbo Gong. 2024. “Structure-Coupled Variational Bayesian Method for Building Layout Reconstruction.” In 2024 Photonics & Electromagnetics Research Symposium (PIERS). IEEE. https://doi.org/10.1109/piers62282.2024.10618659
Yin Liu and Ana Milanova. 2009. “Practical Static Analysis for Inference of Security-Related Program Properties.” In 2009 IEEE 17th International Conference on Program Comprehension. IEEE. https://doi.org/10.1109/icpc.2009.5090027
Yokoi, Shinji. 1987. “A Prolog Based Object Oriented Language SPOOL and Its Compiler.” In Logic Programming ‘86. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-18024-9_27
Yonghong Song, S. Kalogeropulos, and P. Tirumalai. 2005. “Design and Implementation of a Compiler Framework for Helper Threading on Multi-Core Processors.” In 14th International Conference on Parallel Architectures and Compilation Techniques (PACT’05). IEEE. https://doi.org/10.1109/pact.2005.17
Yoshimura, Takeshi, Tatsuhiro Chiba, and Hiroshi Horii. 2018. “Column Cache: Buffer Cache for Columnar Storage on HDFS.” In 2018 IEEE International Conference on Big Data (Big Data). IEEE. https://doi.org/10.1109/bigdata.2018.8622527
You, Yi-Ping, and Jian-Ru Chen. 2015a. “A Static Region-Based Compiler for the Dalvik Virtual Machine: STATIC REGION-BASED COMPILER FOR DVM.” Software: Practice and Experience 46 (8): 1109–30. https://doi.org/10.1002/spe.2344
You, Yi-Ping, and Szu-Chieh Chen. 2015b. “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
You, Yucong, and Luxia Yi. 2021. “A Corpus-Based Empirical Study on Energy Enterprises Digital Transformation.” Energy Reports 7: 198–209. https://doi.org/10.1016/j.egyr.2021.10.038
Youn, Dongjun, Sungho Lee, and Sukyoung Ryu. 2023. “Declarative Static Analysis for Multilingual Programs Using CodeQL.” Software: Practice and Experience 53 (7): 1472–95. https://doi.org/10.1002/spe.3199
Young-Min Lee, Byung-Chul Tak, Hye-Seon Maeng, and Shin-Dug Kim. 2000. “Real-Time Java Virtual Machine for Information Appliances.” IEEE Transactions on Consumer Electronics 46 (4): 949–57. https://doi.org/10.1109/30.920445
Yousaf, Mehran, Muddassar Azam Sindhu, Muhammad Hassan Arif, and Shafiq Ur Rehman. 2021. “Efficient Identification of Race Condition Vulnerability in C Code by Abstract Interpretation and Value Analysis.” In 2021 International Conference on Cyber Warfare and Security (ICCWS). IEEE. https://doi.org/10.1109/iccws53234.2021.9702954
Yu, Licheng, Tianzhou Chen, Minghui Wu, and Xueqing Lou. 2018. “Last Level Cache Layout Remapping for Heterogeneous Systems.” Journal of Systems Architecture 87: 49–63. https://doi.org/10.1016/j.sysarc.2018.05.002
Yu, Zhongrui, Martina Megaro-Boldini, Robert W. Sumner, and Abdelaziz Djelouah. 2025b. “Unboxed: Geometrically and Temporally Consistent Video Outpainting.” In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE. https://doi.org/10.1109/cvpr52734.2025.00685
Yu, Zehong, Zhuo Su, Yixiao Yang, et al. 2022b. “Mercury: Instruction Pipeline Aware Code Generation for Simulink Models.” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 41 (11): 4504–15. https://doi.org/10.1109/tcad.2022.3199967
Yu, Weikuan, Yuan Tian, and Jeffrey S. Vetter. 2010. “Efficient Zero-Copy Noncontiguous I/O for Globus on InfiniBand.” In 2010 39th International Conference on Parallel Processing Workshops. IEEE. https://doi.org/10.1109/icppw.2010.56
Yu, Dongjin, Jie Wang, Qing Wu, et al. 2017. “Detecting Java Code Clones with Multi-Granularities Based on Bytecode.” In 2017 IEEE 41st Annual Computer Software and Applications Conference (COMPSAC). IEEE. https://doi.org/10.1109/compsac.2017.104
Yu, Ping, Yijian Wu, Jiahan Peng, Jian Zhang, and Peicheng Xie. 2023. “Towards Understanding Fixes of SonarQube Static Analysis Violations: A Large-Scale Empirical Study.” In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE. https://doi.org/10.1109/saner56733.2023.00059
Yu, Dongjin, Jiazha Yang, Xin Chen, and Jie Chen. 2019. “Detecting Java Code Clones Based on Bytecode Sequence Alignment.” IEEE Access 7: 22421–33. https://doi.org/10.1109/access.2019.2898411
Yu, Qifan, Pengcheng Zhang, Hai Dong, Yan Xiao, and Shunhui Ji. 2022a. “Bytecode Obfuscation for Smart Contracts.” In 2022 29th Asia-Pacific Software Engineering Conference (APSEC). IEEE. https://doi.org/10.1109/apsec57359.2022.00083
Yu, Lian, Jun Zhou, Yue Yi, Ping Li, and Qianxiang Wang. 2008. “Ontology Model-Based Static Analysis on Java Programs.” In 2008 32nd Annual IEEE International Computer Software and Applications Conference. IEEE. https://doi.org/10.1109/compsac.2008.73
Yuan, Jun, and Rob Johnson. 2012. “CAWDOR: Compiler Assisted Worm Defense.” In 2012 IEEE 12th International Working Conference on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2012.30
Yuan, Bo, Sheng Liu, Zekun Jiang, Jianfeng Cui, and Yang Guo. 2025. “AICAWS: Arithmetic Intensity Based Cache-Conscious Adaptive Warp Scheduler.” In 2025 IEEE 43rd International Conference on Computer Design (ICCD). IEEE. https://doi.org/10.1109/iccd65941.2025.00061
Yue, Xin. 2022. “Research on the Semantic Analysis Method of Translation Corpus Based on Natural Language Processing.” Scientific Programming 2022: 1–7. https://doi.org/10.1155/2022/3764230
Yunchao He, Kai Chen, Jinghui Gu, Haipeng Deng, Alei Liang, and Haibing Guan. 2010. “A New Approach to Reorganize Code Layout of Software Cache in Dynamic Binary Translator.” In 2010 3rd International Symposium on Parallel Architectures, Algorithms and Programming. IEEE. https://doi.org/10.1109/paap.2010.60
Yung, Chung, Jheng-Jyun Syu, and Shiang-Yu Yang. 2010. “A Graph-Based Algorithm of Mostly Incremental Garbage Collection for Active Object Systems.” In 2010 International Computer Symposium (ICS2010). IEEE. https://doi.org/10.1109/compsym.2010.5685367
Yurdakurban, Vehbi, and Nadia ErdoĞan. 2018. “Comparison of Machine Learning Methods for Software Project Effort Estimation.” In 2018 26th Signal Processing and Communications Applications Conference (SIU). IEEE. https://doi.org/10.1109/siu.2018.8404495
Yürüm, Ozan Raşit, Hüseyin Ünlü, and Onur Demirörs. 2026. “An Alternative Software Benchmarking Dataset: Effort Estimation with Machine Learning.” Journal of Systems and Software 231: 112591. https://doi.org/10.1016/j.jss.2025.112591
Yutaka, Oiwa, Kenjiro Taura, and Akinori Yonezawa. 2000. “Extending Java Virtual Machine with Integer-Reference Conversion.” Concurrency: Practice and Experience 12 (6): 407–22. https://doi.org/10.1002/1096-9128(200005)12:6<407::aid-cpe482>3.3.co;2-5
Zaballos, Agustín, Adrià Mallorquí, and Joan Navarro. 2023. “Unboxing Trustworthiness through Quantum Internet.” Computer Networks 237: 110094. https://doi.org/10.1016/j.comnet.2023.110094
Zaeske, Wanja, A. Cem Önem, Florian Hartung, and Umut Durak. 2025. “On the Design of a WebAssembly Interpreter for Safety Critical Avionics Applications.” In 2025 AIAA DATC/IEEE 44th Digital Avionics Systems Conference (DASC). IEEE. https://doi.org/10.1109/dasc66011.2025.11257180
Zakowski, Yannick, Calvin Beck, Irene Yoon, Ilia Zaichuk, Vadim Zaliva, and Steve Zdancewic. 2021. “Modular, Compositional, and Executable Formal Semantics for LLVM IR.” Proceedings of the ACM on Programming Languages 5 (ICFP): 1–30. https://doi.org/10.1145/3473572
Zakraoui, Jezia, Moutaz Saleh, Somaya Al-Maadeed, and Jihad Mohammed Jaam. 2021. “Improving Text-to-Image Generation with Object Layout Guidance.” Multimedia Tools and Applications 80 (18): 27423–43. https://doi.org/10.1007/s11042-021-11038-0
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
Zambon, Andrea. 2012. “Aucsmith-Like Obfuscation of Java Bytecode.” In 2012 IEEE 12th International Working Conference on Source Code Analysis and Manipulation. IEEE. https://doi.org/10.1109/scam.2012.14
Zanettin, Federico. 2009. “Corpus-Based Translation Activities for Language Learners.” Interpreter and Translator Trainer 3 (2): 209–24. https://doi.org/10.1080/1750399x.2009.10798789
Zanotti, Mirko. 2002. “Security Typings by Abstract Interpretation.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-45789-5_26
Zare, Fatemeh, Hasan Khademi Zare, and Mohammad Saber Fallahnezhad. 2016. “Software Effort Estimation Based on the Optimal Bayesian Belief Network.” Applied Soft Computing 49: 968–80. https://doi.org/10.1016/j.asoc.2016.08.004
Zartmann, Frank. 1997. “Denotational Abstract Interpretation of Functional Logic Programs.” In Static Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/bfb0032739
Zäschke, Tilmann, Stefania Leone, and Moira C. Norrie. 2012. “Optimising Schema Evolution Operation Sequences in Object Databases for Data Evolution.” In Conceptual Modeling. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-34002-4_29
Zelal, Bircan, Bowling Alison, and Grant Leigh. 2016. “How to Make Better Gambling Decisions: Avoid Heuristics and Biases!” Frontiers in Public Health 4. https://doi.org/10.3389/conf.fpubh.2016.02.00001
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
Zendra, Olivier, Dominique Colnet, and Suzanne Collin. 1997. “Efficient Dynamic Dispatch without Virtual Function Tables: The SmallEiffel Compiler.” ACM SIGPLAN Notices 32 (10): 125–41. https://doi.org/10.1145/263700.263728
Zeng, Jia, and Stephen A. Edwards. 2005. “Separate Compilation for Synchronous Modules.” In Embedded Software and Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/11599555_15
Zeng, Wei-Cheng, and Kuan-Ting Lai. 2026. “DTCore: A Compiler-Directed Control-Minimal FPGA Compute Engine.” In 2026 IEEE 34th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). IEEE. https://doi.org/10.1109/fccm68464.2026.00053
Zetsche, Ulrike, Winfried Rief, and Cornelia Exner. 2015. “Individuals with OCD Lack Unrealistic Optimism Bias in Threat Estimation.” Behavior Therapy 46 (4): 510–20. https://doi.org/10.1016/j.beth.2015.04.002
Zhang, WenHui. 2003. “Combining Static Analysis and Case-Based Search Space Partitioning for Reducing Peak Memory in Model Checking.” Journal of Computer Science and Technology 18 (6): 762–70. https://doi.org/10.1007/bf02945465
Zhang, Jun-Guang. 2008b. “Method Study of Software Project Effort Estimation.” In 2008 4th International Conference on Wireless Communications, Networking and Mobile Computing. IEEE. https://doi.org/10.1109/wicom.2008.1786
Zhang, Guoqing, and Tapani Ahonen. 2013. “A LLVM Based Compiler for COFFEE.” In 16th IEEE International Symposium on Object/component/service-oriented Real-time distributed Computing (ISORC 2013). IEEE. https://doi.org/10.1109/isorc.2013.6913221
Zhang, Rui, Michael D. Bond, and Yinqian Zhang. 2022a. “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, Chaolin, Jiqiu Deng, Hui Zhang, Longbo Li, Liji Sun, and Xiao Ma. 2026b. “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, Yiqin, Sanhong Deng, Qi Zhang, Dongbo Wang, and Hongcun Gong. 2023b. “Comparative Analysis of Language Models for Linguistic Examination of Ancient Chinese Classics: A Case Study of Zuozhuan Corpus.” In 2023 International Conference on Asian Language Processing (IALP). IEEE. https://doi.org/10.1109/ialp61005.2023.10337146
Zhang, Xiao, Yaoyao Ding, Bolin Sun, Yang Hu, Tatiana Shpeisman, and Gennady Pekhimenko. 2026c. “Hexcute: A Compiler Framework for Automating Layout Synthesis in GPU Programs.” In 2026 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). IEEE. https://doi.org/10.1109/cgo68049.2026.11395194
Zhang, Weizhe, Meng Hao, and Marc Snir. 2016b. “Predicting HPC Parallel Program Performance Based on LLVM Compiler.” Cluster Computing 20 (2): 1179–92. https://doi.org/10.1007/s10586-016-0707-1
Zhang, W., J. S. Hu, V. Degalahal, M. Kandemir, N. Vijaykrishnan, and M. J. Irwin. 2002. “Compiler-Directed Instruction Cache Leakage Optimization.” In 35th Annual IEEE/ACM International Symposium on Microarchitecture, 2002. (MICRO-35). Proceedings.. IEEE. https://doi.org/10.1109/micro.2002.1176251
Zhang, W., J. S. Hu, V. Degalahal, M. Kandemir, N. Vijaykrishnan, and M. J. Irwin. 2004. “Reducing Instruction Cache Energy Consumption Using a Compiler-Based Strategy.” ACM Transactions on Architecture and Code Optimization 1 (1): 3–33. https://doi.org/10.1145/980152.980154
Zhang, Zhou, Pei-Quan Jin, Xiao-Liang Wang, Yan-Qi Lv, Shou-Hong Wan, and Xi-Ke Xie. 2021b. “COLIN: A Cache-Conscious Dynamic Learned Index with High Read/Write Performance.” Journal of Computer Science and Technology 36 (4): 721–40. https://doi.org/10.1007/s11390-021-1348-2
Zhang, Wei, Mahmut Kandemir, Mustafa Karakoy, and Guangyu Chen. 2005. “Reducing Data Cache Leakage Energy Using a Compiler-Based Approach.” ACM Transactions on Embedded Computing Systems 4 (3): 652–78. https://doi.org/10.1145/1086519.1086529
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, Lingli, Chandra Krintz, and Priya Nagpurkar. 2007. “Language and Virtual Machine Support for Efficient Fine-Grained Futures in Java.” In 16th International Conference on Parallel Architecture and Compilation Techniques (PACT 2007). IEEE. https://doi.org/10.1109/pact.2007.4336206
Zhang, Dunbo, Qingjie Lang, Ruoxi Wang, and Li Shen. 2024a. “Extension VM: Interleaved Data Layout in Vector Memory.” ACM Transactions on Architecture and Code Optimization 21 (1): 1–23. https://doi.org/10.1145/3631528
Zhang, Sujuan, Wei Li, Yanli Zhang, and Tao Wu. 2012. “Flow Control System Performance Optimization Base-On Zero-Copy.” In Information Computing and Applications. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-34041-3_115
Zhang, Yiqun, Yang Liu, and Pei Cai. 2018. “Research on Masonry Structure Layout Design Based on BIM Technology.” In 2018 International Conference on Advanced Mechatronic Systems (ICAMechS). IEEE. https://doi.org/10.1109/icamechs.2018.8507116
Zhang, Peng, Yueming Liu, and Meikang Qiu. 2019b. “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, Wenhui, Nurbol Luktarhan, Chao Ding, and Bei Lu. 2021a. “Android Malware Detection Using TCN with Bytecode Image.” Symmetry 13 (7): 1107. https://doi.org/10.3390/sym13071107
Zhang, Yu-an, Qinglian Ma, and Hiroshi Furutani. 2014. “Markov Chain Model of Schema Evolution and Its Application to Stationary Distribution.” In 2014 10th International Conference on Natural Computation (ICNC). IEEE. https://doi.org/10.1109/icnc.2014.6975839
Zhang, Yue, Justin Murphy, and Akond Rahman. 2025b. “Come for Syntax, Stay for Speed, Write Secure Code: An Empirical Study of Security Weaknesses in Julia Programs.” Empirical Software Engineering 30 (2): 58. https://doi.org/10.1007/s10664-024-10606-w
Zhang, Yiqun, Carlos Ordonez, and Wellington Cabrera. 2016a. “Big Data Analytics Integrating a Parallel Columnar DBMS and the R Language.” In 2016 16th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing (CCGrid). IEEE. https://doi.org/10.1109/ccgrid.2016.94
Zhang, Weiwei, and Marc Orlando. 2026. “Interpreters’ Note Layout and Coherence Building in Consecutive Interpreting: A Rhetorical Structure Theory Approach.” Acta Psychologica 262: 106192. https://doi.org/10.1016/j.actpsy.2025.106192
Zhang, Yang, Shuai Shao, Huan Liu, Jing Qiu, Dongwen Zhang, and Guanghua Zhang. 2019a. “Refactoring Java Programs for Customizable Locks Based on Bytecode Transformation.” IEEE Access 7: 66292–66303. https://doi.org/10.1109/access.2019.2919203
Zhang, Y., and D. Sheth. 2006. “Mining Software Repositories for Model-Driven Development.” IEEE Software 23 (1): 82–90. https://doi.org/10.1109/ms.2006.23
Zhang, Qirun, Chengnian Sun, and Zhendong Su. 2017. “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, Ling, Yuting Wang, Yalun Liang, and Zhong Shao. 2025c. “CompCertOC: Verified Compositional Compilation of Multi-Threaded Programs with Shared Stacks.” Proceedings of the ACM on Programming Languages 9 (PLDI): 651–74. https://doi.org/10.1145/3729276
Zhang, Ling, Yuting Wang, Jinhua Wu, Jérémie Koenig, and Zhong Shao. 2024c. “Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules.” Proceedings of the ACM on Programming Languages 8 (POPL): 2160–90. https://doi.org/10.1145/3632914
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, Pingjian, and Jianqing Xi. 2008. “Attribute-Driven Design of MDX Compiler.” In 2008 International Conference on Computer Science and Software Engineering. IEEE. https://doi.org/10.1109/csse.2008.685
Zhang, Yuyan, and Ping Xie. 2025. “A Fine-Grained Garbage Collection Scheme for ZNS-SSD Storage Architecture.” In 2025 5th International Conference on Electronic Information Engineering and Computer Science (EIECS). IEEE. https://doi.org/10.1109/eiecs67708.2025.11283562
Zhang, Yu, Lina Yuan, Tingpeng Wu, Wen Peng, and Quanlong Li. 2010a. “Just-in-Time Compiler Assisted Object Reclamation and Space Reuse.” In Network and Parallel Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-15672-4_4
Zhang, Yunhao, Bo Zhang, and Zhenhui Zhou. 2020c. “Zero-Copy Data Transfer for an OpenCL API Remoting System.” In 2020 IEEE 5th International Conference on Cloud Computing and Big Data Analytics (ICCCBDA). IEEE. https://doi.org/10.1109/icccbda49378.2020.9095593
Zhang, Tingxu, Wenguang Zheng, Yingyuan Xiao, and Guangping Xu. 2020a. “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
Zhang, Tianfan, Huaping Zhou, Chengyuan Huang, et al. 2023a. “Achieving Zero-Copy Serialization for Datacenter RPC.” In 2023 IEEE International Performance, Computing, and Communications Conference (IPCCC). IEEE. https://doi.org/10.1109/ipccc59175.2023.10253859
Zhao, Tianqi, Qinxiang Cao, Shenghua Feng, et al. 2026b. “Formal Verification of Functional Correctness for the OpenHarmony LiteOS-M Kernel.” In Formal Methods. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-26220-2_32
Zhao, Gang, Hua Chen, and Dongxia Wang. 2008. “Data-Flow Based Analysis of Java Bytecode Vulnerability.” In 2008 The Ninth International Conference on Web-Age Information Management. IEEE. https://doi.org/10.1109/waim.2008.99
Zhao, Ruizhe, Jianyi Cheng, Wayne Luk, and George A. Constantinides. 2022. “POLSCA: Polyhedral High-Level Synthesis with Compiler Transformations.” In 2022 32nd International Conference on Field-Programmable Logic and Applications (FPL). IEEE. https://doi.org/10.1109/fpl57034.2022.00044
Zhao, Xiangjun, and Zhenlong Du. 2023. “Video Colorization with Semantic Preservation and Consistency.” Computers and Electrical Engineering 108: 108697. https://doi.org/10.1016/j.compeleceng.2023.108697
Zhao, Yuan, Yunlong He, Jianhao Xiao, Zhongbo He, Zuochang Ye, and Yan Wang. 2024. “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, Zhenjie, Yanan Li, and Yanan Zhang. 2026a. “Code Representation for AI-Driven Vulnerability Detection Oriented to Semantic Preservation and Model Adaptation.” In 2026 6th International Conference on Artificial Intelligence, Big Data and Algorithms (CAIBDA). IEEE. https://doi.org/10.1109/caibda70336.2026.11621522
Zhao, Xiaohui, and Chengfei Liu. 2013. “Version Management for Business Process Schema Evolution.” Information Systems 38 (8): 1046–69. https://doi.org/10.1016/j.is.2013.03.006
Zhao, Hongzhi, Xun Liu, Ruiyang Chen, et al. 2025a. “Batched Data Layout Optimization for Im2col-Based Convolutions on CPUs.” Journal of Supercomputing 81 (12): 1219. https://doi.org/10.1007/s11227-025-07706-9
Zhao, Jianzhou, Santosh Nagarakatte, Milo M. K. Martin, and Steve Zdancewic. 2012. “Formalizing the LLVM Intermediate Representation for Verified Program Transformations.” ACM SIGPLAN Notices 47 (1): 427–40. https://doi.org/10.1145/2103621.2103709
Zhao, Jianzhou, Santosh Nagarakatte, Milo M. K. Martin, and Steve Zdancewic. 2013. “Formal Verification of SSA-Based Optimizations for LLVM.” ACM SIGPLAN Notices 48 (6): 175–86. https://doi.org/10.1145/2499370.2462164
Zhao, Beibei, Zhanyong Tang, Zhen Li, et al. 2017. “DexPro: A Bytecode Level Code Protection System for Android Applications.” In Cyberspace Safety and Security. Springer International Publishing. https://doi.org/10.1007/978-3-319-69471-9_27
Zhao, Shuai, Jie Tian, Jie Fu, Jie Chen, and Jinming Wen. 2025c. “FeaMix: Feature Mix with Memory Batch Based on Self-Consistency Learning for Code Generation and Code Translation.” IEEE Transactions on Emerging Topics in Computational Intelligence 9 (1): 192–201. https://doi.org/10.1109/tetci.2024.3395531
Zhao, Pengzhan, Xiongfei Wu, Zhuo Li, and Jianjun Zhao. 2023b. “QChecker: Detecting Bugs in Quantum Programs via Static Analysis.” In 2023 IEEE/ACM 4th International Workshop on Quantum Software Engineering (Q-SE). IEEE. https://doi.org/10.1109/q-se59154.2023.00014
Zhao, Shiwu, Ningjun Zheng, Haoyu Li, et al. 2025b. “DEPHP: A Source Code Recovery Method for PHP Bytecode with Improved Structural Analysis.” In 2025 28th International Symposium on Research in Attacks, Intrusions and Defenses (RAID). IEEE. https://doi.org/10.1109/raid67961.2025.00032
Zhen-Dong, Li, Guo Chang-guo, Ding Bo, Shi Dian-Xi, and Liu Dong-Bo. 2012. “Bytecode-Based Software Monitoring and Trusted Evolution Programming Framework.” In 2012 IEEE Symposium on Robotics and Applications (ISRA). IEEE. https://doi.org/10.1109/isra.2012.6219232
Zheng, Yaowen, Zhanwei Song, Yuyan Sun, Kai Cheng, Hongsong Zhu, and Limin Sun. 2019. “An Efficient Greybox Fuzzing Scheme for Linux-Based IoT Programs through Binary Static Analysis.” In 2019 IEEE 38th International Performance Computing and Communications Conference (IPCCC). IEEE. https://doi.org/10.1109/ipccc47392.2019.8958740
Zheng, Jijie, and Xianjie Wu. 2010. “The Compiler-Based Heterogeneous Multi-Core Structure.” In 2010 International Conference on Multimedia Communications. IEEE. https://doi.org/10.1109/mediacom.2010.38
Zhilei Chai, Xindong Ye, Guang Hu, and Shiliang Tu. 2010. “Predictable Bytecode Cache with Prefetch Mechanism for a Java Processor.” In 2010 3rd International Conference on Computer Science and Information Technology. IEEE. https://doi.org/10.1109/iccsit.2010.5564739
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
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, Xiao, Zekang Dou, Jialin Sun, et al. 2026a. “Heliostat Field Layout Optimization Considering Power Generation and Layout Parameters.” Energies 19 (8): 1984. https://doi.org/10.3390/en19081984
Zhou, Zhide, He Jiang, Zhilei Ren, Yuting Chen, and Lei Qiao. 2022. “LocSeq: Automated Localization for Compiler Optimization Sequence Bugs of LLVM.” IEEE Transactions on Reliability 71 (2): 896–910. https://doi.org/10.1109/tr.2022.3165378
Zhou, Jialu, Jiong Lin, Jiahua Li, et al. 2026b. “NFStitch: Near-Ground Field Image Stitching of Crops Using Gantry Frames Based on Spatial Layout Priors and Object Protection.” Smart Agricultural Technology 14: 102368. https://doi.org/10.1016/j.atech.2026.102368
Zhou, Zhide, Zhilei Ren, Guojun Gao, and He Jiang. 2021. “An Empirical Study of Optimization Bugs in GCC and LLVM.” Journal of Systems and Software 174: 110884. https://doi.org/10.1016/j.jss.2020.110884
Zhou, Qinan, and Paul Tarau. 2002. “Garbage Collection Algorithms for Java-Based Prolog Engines.” In Practical Aspects of Declarative Languages. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-36388-2_21
Zhu, Ying, and Eric Friginal. 2015. “Interactive Visual Text Analysis for Corpus-Based Language Learning.” In 2015 IEEE First International Conference on Big Data Computing Service and Applications. IEEE. https://doi.org/10.1109/bigdataservice.2015.55
Zhu, Guangyu, Jaehyun Han, and Yongseok Son. 2020. “A Preliminary Study: Towards Parallel Garbage Collection for NAND Flash-Based SSDs.” IEEE Access 8: 223574–87. https://doi.org/10.1109/access.2020.3043123
Zhu, Hongfeng, Tianhua Liu, Chuansheng Zhou, and Guiran Chang. 2006. “Research and Implementation of Zero-Copy Technology Based on Device Driver in Linux.” In First International Multi-Symposiums on Computer and Computational Sciences (IMSCCS’06). IEEE. https://doi.org/10.1109/imsccs.2006.256
Zhu, Qian, Yuxuan Liu, Ziyuan Zhu, Shangqing Liu, and Lei Bu. 2025b. “EPSO: A Caching-Based Efficient Superoptimizer for BPF Bytecode.” In 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE. https://doi.org/10.1109/ase63991.2025.00242
Zhu, Di, Jianmin Pang, Xin Zhou, and Wenjie Han. 2021. “Similarity Measure for Smart Contract Bytecode Based on CFG Feature Extraction.” In 2021 International Conference on Computer Information Science and Artificial Intelligence (CISAI). IEEE. https://doi.org/10.1109/cisai54367.2021.00113
Zhu, XiaoAo, Jie Ren, Zhi Qiang Li, Feng Tian, Jie Zheng, and Ling Gao. 2025c. “LLVMTuner: Predictive Compiler Optimization for LLVM IR across Heterogeneous Platforms.” In 2025 28th International Conference on Computer Supported Cooperative Work in Design (CSCWD). IEEE. https://doi.org/10.1109/cscwd64889.2025.11033398
Zhu, Qian, and Cui Tao. 2014. “Pharmacological Class Data Representation in the Web Ontology Language (OWL).” In 2014 IEEE International Conference on Big Data (Big Data). IEEE. https://doi.org/10.1109/bigdata.2014.7004397
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
Zhuang, Yungyu, and Ming-Yang Lu. 2022. “Enabling Type Checking on Columns in Data Frame Libraries by Abstract Interpretation.” IEEE Access 10: 14418–28. https://doi.org/10.1109/access.2022.3146287
Zhuang, Xiaotong, and Santosh Pande. 2005. “Differential Register Allocation.” ACM SIGPLAN Notices 40 (6): 168–79. https://doi.org/10.1145/1064978.1065031
Zhuang, Xiaotong, and Santosh Pande. 2006. “Effective Thread Management on Network Processors with Compiler Analysis.” ACM SIGPLAN Notices 41 (7): 72–82. https://doi.org/10.1145/1159974.1134662
Ziadi, Tewfik, and Lom Messan Hillah. 2018. “Software Product Line Extraction from Bytecode Based Applications.” In 2018 23rd International Conference on Engineering of Complex Computer Systems (ICECCS). IEEE. https://doi.org/10.1109/iceccs2018.2018.00037
Zibin, Yoav, and Joseph Gil. 2003. “Two-Dimensional Bi-Directional Object Layout.” In ECOOP 2003 – Object-Oriented Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-45070-2_15
Zilli, Massimiliano, Wolfgang Raschke, Reinhold Weiss, Johannes Loinig, and Christian Steger. 2014. “A High Performance Java Card Virtual Machine Interpreter Based on an Application Specific Instruction-Set Processor.” In 2014 17th Euromicro Conference on Digital System Design. IEEE. https://doi.org/10.1109/dsd.2014.47
Zimmermann, Wolf. 2006. “On the Correctness of Transformations in Compiler Back-Ends.” In Leveraging Applications of Formal Methods. Springer Berlin Heidelberg. https://doi.org/10.1007/11925040_6
Zitkus, Voldemaras, and Rita Butkiene. 2018. “Coreference Annotation Scheme and Corpus for Lithuanian Language.” In 2018 Fifth International Conference on Social Networks Analysis, Management and Security (SNAMS). IEEE. https://doi.org/10.1109/snams.2018.8554892
Živkovič, Aleš, Cigdem Gencel, and Alain Abran. 2011. “Guest Editorial: Advances in Functional Size Measurement and Effort Estimation – Extended Best Papers.” Information and Software Technology 53 (8): 873. https://doi.org/10.1016/j.infsof.2011.02.003
Zorn, Benjamin. 1993. “The Measured Cost of Conservative Garbage Collection.” Software: Practice and Experience 23 (7): 733–56. https://doi.org/10.1002/spe.4380230704
Zou, Xukai, and Byrav Ramamurthy. 2004. “A Simple Group Diffie-Hellman Key Agreement Protocol without Member Serialization.” In Computational and Information Science. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-30497-5_113
Zou, Ruishi, Siyi Wu, Racquel Fygenson, Bingsheng Yao, Dakuo Wang, and Lace Padilla. 2026. “Striking a Balance: Evaluating How Aggregations of Multiple Forecasts Impact Judgment under Uncertainty.” In 2026 IEEE 19th Pacific Visualization Conference (PacificVis). IEEE. https://doi.org/10.1109/pacificvis68791.2026.00025
Zou, Yanghe, Yiran Zhou, and Qingcheng Xu. 2024. “Heliostat Field Layout via Niching and Elite Competition Swarm Optimization.” IEEE Access 12: 31589–31604. https://doi.org/10.1109/access.2024.3368865
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
Zuo, Tianwei, Yiping Duan, Qiyuan Du, and Xiaoming Tao. 2024. “Semantic Security: A Digital Watermark Method for Image Semantic Preservation.” In ICASSP 2024 - 2024 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE. https://doi.org/10.1109/icassp48485.2024.10446626
Zuo, Hui, Yadong Shi, Zhongyuan Qin, and Xuxian Jiang. 2023. “Smart Contract Bytecode Similarity Detection Based on Self-Supervised Learning.” In 2023 8th International Conference on Signal and Image Processing (ICSIP). IEEE. https://doi.org/10.1109/icsip57908.2023.10271080
Zurstraβen, Niko, Nils Bosbach, Lennart M. Reimann, and Rainer Leupers. 2025. “Static Global Register Allocation for Dynamic Binary Translators.” In 2025 Design, Automation & Test in Europe Conference (DATE). IEEE. https://doi.org/10.23919/date64628.2025.10993060
Đurđanović, Igor. 1991. “A Fast Garbage Collection Algorithm for WAM — Based PROLOG.” In Computer Science Logic. Springer Berlin Heidelberg. https://doi.org/10.1007/3-540-54487-9_55

Primary Sources, Non-Peer-Reviewed

“The 1:100,000 Topographic Map: Layout, Structure, Sources.” 2005. In The Survey of Palestine Under the British Mandate, 1920-1948. Routledge. https://doi.org/10.4324/9780203339558-21
“2360 Garbage Collection Charges [Npl] [US].” 2010. In Encyclopedic Dictionary of Landscape and Urban Planning. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-76435-9_5268
“3. 20The Planning Fallacy.” 2026. In Relentless. De Gruyter. https://doi.org/10.1515/9783112226315-007
“4 Compiler and Runtime Interaction.” 2021. In High Performance Parallel Runtimes. De Gruyter. https://doi.org/10.1515/9783110632729-004
“4. Ein Beispiel-Compiler.” 1975. In Compiler. De Gruyter. https://doi.org/10.1515/9783110826012-006
“6. Speicherplatzfragen — Garbage Collection, Externe Dateien.” 1978. In LISP – Programmierhandbuch. De Gruyter. https://doi.org/10.1515/9783112563748-007
“8 Compiling a Corpus.” 2020. In Idioms and Ambiguity in Context. De Gruyter. https://doi.org/10.1515/9783110685459-012
Abboud, Sahar A., Fatma S. Al-Widyan, and Shahab A. Nadir. 2025. “Industrial Software Effort Estimation Development and Correction Effort.” Journal of Software Engineering and Applications 18 (08): 303–16. https://doi.org/10.4236/jsea.2025.188018
Abdelali, Zakrani, Moutachaouik Hicham, and Namir Abdelwahed. 2019. “An Ensemble of Optimal Trees for Software Development Effort Estimation.” In Lecture Notes in Networks and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-11914-0_6
Abdulfattah Khattab, Shahad Wissam, and Jamal Salahaldeen Alneamy. 2025. “Software Effort Estimation in the Context of Methodology Agile and Software Development.” International Research Journal of Innovations in Engineering and Technology 09 (05): 394–99. https://doi.org/10.47001/irjiet/2025.905044
Abe, Seika, Masami Hagiya, and Ikuo Nakata. 2005. “A Retargetable Code Generator for the Generic Intermediate Language in COINS.” IPSJ Digital Courier 1: 478–95. https://doi.org/10.2197/ipsjdc.1.478
Abnane, Ibtissam, and Ali Idri. 2018. “Improved Analogy-Based Effort Estimation with Incomplete Mixed Data.” In Annals of Computer Science and Information Systems, vol. 15. IEEE. https://doi.org/10.15439/2018f95
Abnane, Ibtissam, Ali Idri, and Alain Abran. 2017. “Empirical Evaluation of Fuzzy Analogy for Software Development Effort Estimation.” In Proceedings of the Symposium on Applied Computing. ACM. https://doi.org/10.1145/3019612.3019905
Abnane, Ibtissam, Ali Idri, Mohamed Hosni, and Alain Abran. 2021. “Heterogeneous Ensemble Imputation for Software Development Effort Estimation.” In Proceedings of the 17th International Conference on Predictive Models and Data Analytics in Software Engineering. ACM. https://doi.org/10.1145/3475960.3475984
Abounegm, Abdelrahman, and Nikolai Kudasov. 2023. “Implementing a Language Server for the Rzk Proof Assistant.” System Informatics, no. 22: 45–50. https://doi.org/10.31144/si.2307-6410.2023.n22.p45-50
Achour, Safaa. 2018. “A Model Based Testing Approach for Java Bytecode Programs.” Journal of Computers: 1098–1114. https://doi.org/10.17706/jcp.13.9.1098-1114
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
Achouri, Amine, Yousra Bendaly Hlaoui, and Leila Jemni Ben Ayed. 2019. “Institution-Based UML Activity Diagram Transformation with Semantic Preservation.” International Journal of Computational Science and Engineering 18 (3): 240. https://doi.org/10.1504/ijcse.2019.098534
Aciu, Razvan-Mihai, and Horia Ciocarlie. 2016. “Runtime Translation of the Java Bytecode to OpenCL and GPU Execution of the Resulted Code.” Acta Polytechnica Hungarica 13 (3): 25–44. https://doi.org/10.12700/aph.13.3.2016.3.2
Acosta, Ramon D. 1994. Proto Code Generation Techniques. Defense Technical Information Center. https://doi.org/10.21236/ada280275
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. Defense Technical Information Center. https://doi.org/10.21236/ada205958
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. 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. 1989c. 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
Adhitama, Rifki. 2018. “Effort Estimation Menggunakan Metode Use Case Point Untuk Pengembangan Perangkat Lunak.” Journal of Informatics, Information System, Software Engineering and Applications (INISTA) 1 (1). https://doi.org/10.20895/inista.v1i1.14
Adibfar, Alireza, and Aaron M. Costin. 2022. “Review of Data Serialization Challenges and Validation Methods for Improving Interoperability.” In Computing in Civil Engineering 2021. American Society of Civil Engineers. https://doi.org/10.1061/9780784483893.065
Adl-Tabatabai, Ali-Reza. 1992. Nonresident and Endangered Variables: The Effects of Code Generation Optimizations on Symbolic Debugging. Defense Technical Information Center. https://doi.org/10.21236/ada263149
Adl-Tabatabai, Ali-Reza, and Thomas Gross. 1992. Evicted Variables and the Interaction of Global Register Allocation and Symbolic Debugging. Defense Technical Information Center. https://doi.org/10.21236/ada260928
Adve, Vikram S., and Chris Lattner. 2026. “The LLVM Compiler Infrastructure.” Communications of the ACM 69 (8): 70–79. https://doi.org/10.1145/3764111
Adwin H. Timmer. 1995. “Conflict Modelling and Instruction Scheduling in Code Generation for in-House DSP Cores.” In 32nd Design Automation Conference. ACM. https://doi.org/10.1109/dac.1995.250016
Affeldt, Reynald, Hidehiko Masuhara, Eijiro Sumii, and Akinori Yonezawa. 2002. “Supporting Objects in Run-Time Bytecode Specialization.” In Proceedings of the ASIAN symposium on Partial evaluation and semantics-based program manipulation. ACM. https://doi.org/10.1145/568173.568179
Agosta, Giovanni, Alessandro Barenghi, Massimo Maggi, and Gerardo Pelosi. 2013. “Compiler-Based Side Channel Vulnerability Analysis and Optimized Countermeasures Application.” In Proceedings of the 50th Annual Design Automation Conference. ACM. https://doi.org/10.1145/2463209.2488833
Agosta, G., S. Crespi Reghizzi, P. Palumbo, and M. Sykora. 2006. “Selective Compilation via Fast Code Analysis and Bytecode Tracing.” In Proceedings of the 2006 ACM symposium on Applied computing. ACM. https://doi.org/10.1145/1141277.1141488
Agrawal, Shyam Sundar, Mandal Abhimanue, Shweta Bansal, and Minakshi Mahajan. 2014b. “Statistical Analysis of Multilingual Text Corpus and Development of Language Models.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/4wq5xoov5pog
Agrawal, Kunal, Jeremy T. Fineman, Jordan Krage, Charles E. Leiserson, and Sivan Toledo. 2012. “Cache-Conscious Scheduling of Streaming Applications.” In Proceedings of the twenty-fourth annual ACM symposium on Parallelism in algorithms and architectures. ACM. https://doi.org/10.1145/2312005.2312049
Agrawal, Anushree, and R. K. Singh. 2020. “Mining Software Repositories for Revision Age-Based Co-Change Probability Prediction.” International Journal of Open Source Software and Processes 11 (2): 16–32. https://doi.org/10.4018/ijossp.2020040102
Ahmed, M., G. Rahman, Noraini B. Ibrahim, W. Nisar, and A. Ahmad. 2025. “Validation of Global Software Development Based Cost Estimation Models and Cost Driver: An Empirical Study.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-96-5214-3_20
Ahmed, Shaikh, Muhammad Usman, Clemens Heitzinger, Rajib Rahman, Andrei Schliwa, and Gerhard Klimeck. 2007. “Symmetry Breaking and Fine Structure Splitting in Zincblende Quantum Dots: Atomistic Simulations of Long-Range Strain and Piezoelectric Field.” In AIP Conference Proceedings, vol. 893. AIP. https://doi.org/10.1063/1.2730157
Ahmed, Waqas, Esteban Zimányi, Alejandro A. Vaisman, and Robert Wrembel. 2021. “Schema Evolution in Multiversion Data Warehouses.” International Journal of Data Warehousing and Mining 17 (4): 1–28. https://doi.org/10.4018/ijdwm.2021100101
Ahmetoglu, Yoana, Duncan Brumby, and Anna Cox. 2024. “Bridging the Gap between Time Management Research and Task Management App Design: A Study on the Integration of Planning Fallacy Mitigation Strategies.” In Proceedings of the 3rd Annual Meeting of the Symposium on Human-Computer Interaction for Work. ACM. https://doi.org/10.1145/3663384.3663404
Aiken, Alexander, and Edward L. Wimmers. 1993. “Type Inclusion Constraints and Type Inference.” In Proceedings of the conference on Functional programming languages and computer architecture. ACM. https://doi.org/10.1145/165180.165188
Air Force Systems Command. 1990. “Ada Compiler Evaluation Capability (ACEC) Data Analysis: An Overview.” ACM SIGAda Ada Letters X (3): 111–25. https://doi.org/10.1145/322837.322850
Ajay Chandna. 1995. “The Aurora RAM Compiler.” In 32nd Design Automation Conference. ACM. https://doi.org/10.1109/dac.1995.250101
AL Hasani, Mundhir. 2019. “What Causes Optimism Bias in Transportation Projects?” European Journal of Economics, Law and Politics 06 (01). https://doi.org/10.19044/elp.v6no1a6
Al Rababeh, Ne’meh, and Ahmed BaniMustafa. 2023. “Random Forests for Predicting Software Effort Estimation Based on Use-Case Points Analysis.” In AIP Conference Proceedings, vol. 3306. AIP Publishing. https://doi.org/10.1063/5.0174699
Al-Naimy, Israa Akram, and Marwa Adeeb Al-Jawaherry. 2025. “Software Effort Estimation Using Ensemble Learning Methods.” In AIP Conference Proceedings, vol. 3264. AIP Publishing. https://doi.org/10.1063/5.0259225
Alabduljalil, Maha, Xun Tang, and Tao Yang. 2013. “Cache-Conscious Performance Optimization for Similarity Search.” In Proceedings of the 36th international ACM SIGIR conference on Research and development in information retrieval. ACM. https://doi.org/10.1145/2484028.2484077
Alansary, Sameh, and Magdy Nagi. 2014. “The International Corpus of Arabic: Compilation, Analysis and Evaluation.” In Proceedings of the EMNLP 2014 Workshop on Arabic Natural Language Processing (ANLP). Association for Computational Linguistics. https://doi.org/10.3115/v1/w14-3602
Albert, Elvira, Samir Genaim, and Miguel Gomez-Zamalloa. 2007. “Heap Space Analysis for Java Bytecode.” In Proceedings of the 6th international symposium on Memory management. ACM. https://doi.org/10.1145/1296907.1296922
Alharbi, Nouf, and Yoshihiko Gotoh. 2016. “Natural Language Descriptions of Human Activities Scenes: Corpus Generation and Analysis.” In Proceedings of the 5th Workshop on Vision and Language. Association for Computational Linguistics. https://doi.org/10.18653/v1/w16-3205
Ali Babar, Muhammad. 2022. “Mining Software Repositories for Security: Data Quality Issues Lessons from Trenches (Keynote).” In Proceedings of the 1st International Workshop on Mining Software Repositories Applications for Privacy and Security. ACM. https://doi.org/10.1145/3549035.3570192
Alley, Sam, and Judith Blanton. 1978. “Successful Projects in New Careers Programs: An Empirical Study.” Human Relations 31 (5): 439–57. https://doi.org/10.1177/001872677803100504
Alliet, Brian, and Adam Megacz. 2004. “Complete Translation of Unsafe Native Code to Safe Bytecode.” In Proceedings of the 2004 workshop on Interpreters, virtual machines and emulators. ACM. https://doi.org/10.1145/1059579.1059589
Ally, Said. 2023. “Critical Factors for the Adoption of Virtualization Software: An Empirical Study.” FUOYE Journal of Engineering and Technology 8 (3). https://doi.org/10.46792/fuoyejet.v8i3.1002
AlMutlaq, Ayman Jalal. 2026. “AI-Based Imputation for Missing Data in Software Effort Estimation: A Systematic Literature Review.” In Lecture Notes on Data Engineering and Communications Technologies. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-23035-5_1
Almutlaq, Ayman Jalal Hassan, and Dayang N. A. Jawawi. 2019. “Missing Data Imputation Techniques for Software Effort Estimation: A Study of Recent Issues and Challenges.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-33582-3_107
AlMutlaq, Ayman Jalal, Dayang N. A. Jawawi, and Adila Firdaus Binti Arbain. 2021. “Fuzzy C-Mean Missing Data Imputation for Analogy-Based Effort Estimation.” International Journal of Advanced Computer Science and Applications 12 (8). https://doi.org/10.14569/ijacsa.2021.0120874
AlMutlaq, Ayman Jalal, Dayang N. A. Jawawi, and Adila Firdaus Binti Arbain. 2023. “Weight Optimization Based on Firefly Algorithm for Analogy-Based Effort Estimation.” International Journal of Advanced Computer Science and Applications 14 (6). https://doi.org/10.14569/ijacsa.2023.0140666
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
Alqadi, Basma S., and Jonathan I. Maletic. 2017. “An Empirical Study of Debugging Patterns among Novices Programmers.” In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education. ACM. https://doi.org/10.1145/3017680.3017761
Alsubhi, Khalid A. 2019. “Effort Estimation in Agile Software Development Using Deep Learning Model.” International Journal of Advances in Computer Science and Technology 8 (12): 41–49. https://doi.org/10.30534/ijacst/2019/018122019
Amaral, Weldson, Luis Rivero, Geraldo Braz Junior, and Davi Viana. 2019. “Using Machine Learning Technique for Effort Estimation in Software Development.” In Proceedings of the XVIII Brazilian Symposium on Software Quality. ACM. https://doi.org/10.1145/3364641.3364670
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
Amarasinghe, Saman. 2023. “Compiler Support for Structured Data.” In Proceedings of the 2023 ACM/SIGDA International Symposium on Field Programmable Gate Arrays. ACM. https://doi.org/10.1145/3543622.3578887
Amasaki, S. 2010. “Performance Comparison for Effort Estimation Models with Log-Normal and Gamma Distributions.” In Software Engineering. ACTAPRESS. https://doi.org/10.2316/p.2010.677-031
Amasaki, Sousuke, and Chris Lokan. 2016b. “A Replication Study on the Effects of Weighted Moving Windows for Software Effort Estimation.” In Proceedings of the 20th International Conference on Evaluation and Assessment in Software Engineering. ACM. https://doi.org/10.1145/2915970.2915983
Amazal, Fatima Azzahra, and Ali Idri. 2019. “Handling of Categorical Data in Software Development Effort Estimation: A Systematic Mapping Study.” In Annals of Computer Science and Information Systems, vol. 18. IEEE. https://doi.org/10.15439/2019f222
Amazal, Fatima Azzahra, Ali Idri, and Alain Abran. 2014b. “Software Development Effort Estimation Using Classical and Fuzzy Analogy: A Cross-Validation Comparative Study.” International Journal of Computational Intelligence and Applications 13 (03): 1450013. https://doi.org/10.1142/s1469026814500138
Amey, P. N., and B. J. Dobbing. 2003. “Static Analysis of Ravenscar Programs.” ACM SIGAda Ada Letters XXIII (4): 58–64. https://doi.org/10.1145/959221.959234
Amin, Gauri, Gouravi Dorkhande, Mukta Ogale, Ankita Mane, and Chhaya Gosavi. 2023. “A Comparative Study of Register Allocation Algorithms.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-99-6568-7_3
Ammachathram, V. M. 2009. “Irrational Fracturing — How Heuristics and Biases Affect Judgments in Fracpacking.” In SPE Hydraulic Fracturing Technology Conference. SPE. https://doi.org/10.2118/118922-ms
“Analysis of the ROMizer of simpleRTJ Embedded Java Virtual Machine.” 2003. KIPS Transactions:PartA 10A (4): 397–404. https://doi.org/10.3745/kipsta.2003.10a.4.397
Anand, Kapil, Matthew Smithson, Khaled Elwazeer, et al. 2013. “A Compiler-Level Intermediate Representation Based Binary Analysis and Rewriting System.” In Proceedings of the 8th ACM European Conference on Computer Systems. ACM. https://doi.org/10.1145/2465351.2465380
Ancona, Davide. 2011. “Coinductive Big-Step Operational Semantics for Type Soundness of Java-like Languages.” In Proceedings of the 13th Workshop on Formal Techniques for Java-Like Programs. ACM. https://doi.org/10.1145/2076674.2076679
Anderson, Ross J. 1999. “The Formal Verification of a Payment System.” In Industrial-Strength Formal Methods in Practice. Springer London. https://doi.org/10.1007/978-1-4471-0523-7_3
Anderson, Todd, Marsha Eng, Neal Glew, Brian Lewis, Vijay Menon, and James Stichnoth. 2004. “Experience Integrating a New Compiler and a New Garbage Collector into Rotor.” Journal of Object Technology 3 (9): 53. https://doi.org/10.5381/jot.2004.3.9.a3
Andrews, Peter B. 1971. “Resolution in Type Theory.” Journal of Symbolic Logic 36 (3): 414–32. https://doi.org/10.2307/2269949
Anemaat, William, Kurt Schueler, William Anemaat, and Kurt Schueler. 1997. “Airplane Configuration Layout Design Using Object-Oriented Methods.” In 1997 World Aviation Congress. AIAA 1997-5510. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.1997-5510
“Annotated Corpus for Sentiment Analysis in the Uzbek Language.” 2025. In филиал федерального государственного автономного образовательного учреждения высшего образования «казанский (приволжский) федеральный университет» В городе джизаке республики узбекистан. ФИЛИАЛ ФЕДЕРАЛЬНОГО ГОСУДАРСТВЕННОГО АВТОНОМНОГО ОБРАЗОВАТЕЛЬНОГО УЧРЕЖДЕНИЯ ВЫСШЕГО ОБРАЗОВАНИЯ «КАЗАНСКИЙ (ПРИВОЛЖСКИЙ) ФЕДЕРАЛЬНЫЙ УНИВЕРСИТЕТ» В ГОРОДЕ ДЖИЗАКЕ РЕСПУБЛИКИ УЗБЕКИСТАН. https://doi.org/10.57033/kfu.jru-2025-0079
Anooja, A. 2017. “Comparative Analysis of Software Cost- Effort Estimation and Agile in Perspective of Software Development.” International Journal of Advanced Research in Computer Science 8 (8): 121–25. https://doi.org/10.26483/ijarcs.v8i8.4666
Ansaloni, Danilo, Walter Binder, Alex Villazón, and Philippe Moret. 2010. “Rapid Development of Extensible Profilers for the Java Virtual Machine with Aspect-Oriented Programming.” In Proceedings of the first joint WOSP/SIPEW international conference on Performance engineering. ACM. https://doi.org/10.1145/1712605.1712616
Ansolabehere, Stephen, and Shanto Iyengar. 2020. “11. Information and Electoral Attitudes: A Case of Judgment under Uncertainty.” In Explorations in Political Psychology. Duke University Press. https://doi.org/10.1515/9780822396697-013
Anuradha, T., R. Pradeep Kashyap, Vinay V. Vasista, and Prashantha Naduthota. 2013. “Experience with Partial Simdization in LLVM-3.1 Compiler Using Dynamic Programming.” In Proceedings of the Student Research Symposium (SRS’13). Research Publishing Services. https://doi.org/10.3850/978-981-07-7393-9_080
Aponte, Jairo, Diana Gomez, Juan Cubillos, and Edwar Rojas. 2022. “Effort Estimation in Agile Software Development: The State of the Practice in Colombia.” Preprint, . https://doi.org/10.2139/ssrn.4149549
Appicharla, Ramakrishna, Kamal Kumar Gupta, Asif Ekbal, and Pushpak Bhattacharyya. 2021. “IITP-MT at CALCS2021: English to Hinglish Neural Machine Translation Using Unsupervised Synthetic Code-Mixed Parallel Corpus.” In Proceedings of the Fifth Workshop on Computational Approaches to Linguistic Code-Switching. Association for Computational Linguistics. https://doi.org/10.18653/v1/2021.calcs-1.5
“Application of High-Rise Building BIM Model and Three-Dimensional Field Layout in Engineering.” 2021. Foreign Language Science and Technology Journal Database Engineering Technology. https://doi.org/10.47939/et.v2i9.163
Aranda, Jorge, and Steve Easterbrook. 2005. “Anchoring and Adjustment in Software Estimation.” ACM SIGSOFT Software Engineering Notes 30 (5): 346–55. https://doi.org/10.1145/1095430.1081761
Araujo, Guido, Srinivas Devadas, Kurt Keutzer, et al. 2002. “Challenges in Code Generation for Embedded Processors.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_3
Arbaugh, William. 2016. Automated Program Analysis for Cybersecurity (APAC). Defense Technical Information Center. https://doi.org/10.21236/ad1011873
Ardiansyah, Ardiansyah, Murein Miksa Mardhia, and Sri Handayaningsih. 2018. “Analogy-Based Model for Software Project Effort Estimation.” International Journal of Advances in Intelligent Informatics 4 (3): 251. https://doi.org/10.26555/ijain.v4i3.266
Arditi, David. 2023. “Unboxed: Content Creators and Influencers.” In Digital Feudalism: Creators, Credit, Consumption, and Capitalism. Emerald Publishing Limited. https://doi.org/10.1108/978-1-80455-766-220231006
Arenaz, Manuel, Juan Touriño, and Ramón Doallo. 2003. “A GSA-Based Compiler Infrastructure to Extract Parallelism from Complex Loops.” In Proceedings of the 17th annual international conference on Supercomputing. ACM. https://doi.org/10.1145/782814.782842
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
Arm. n.d. “Application Binary Interface for the Arm® Architecture.” GitHub. Accessed October 24, 2026. https://github.com/ARM-software/abi-aa
Arnuphaptrairong, Tharwon. 2021. “Enhancing Delphi Method with Algorithmic Estimates for Software Effort Estimation: An Experimental Study.” International Journal of Software Engineering & Applications 12 (04): 01–18. https://doi.org/10.5121/ijsea.2021.12401
Arora, Meenakshi, and Anjana Gosain. 2011. “Schema Evolution for Data Warehouse: A Survey.” International Journal of Computer Applications 22 (6): 6–14. https://doi.org/10.5120/2590-3588
“Arrow Columnar Format.” n.d. Apache Arrow documentation. Accessed October 24, 2026. https://arrow.apache.org/docs/format/Columnar.html
“The Art of Compiler Design: Theory and Practice.” 1992. Choice Reviews Online 30 (03): 30-1559-30-1559. https://doi.org/10.5860/choice.30-1559
Arunagiri, Aravindhan, and Parthasarathy Ramachandran. 2015. “Data Perspectives of Workflow Schema Evolution.” Business Process Management Journal 21 (1): 172–89. https://doi.org/10.1108/bpmj-07-2013-0097
Ashcraft, Ken, and Dawson Engler. 2001. Using Programmer-Written Compiler Extensions to Catch Security Holes. Defense Technical Information Center. https://doi.org/10.21236/ada419600
Ashwini Dogga. 2025. “A Synergistic Approach to Software Effort Estimation Using Fuzzy Logic and Machine Learning.” Journal of Information Systems Engineering and Management 10 (19s): 1–9. https://doi.org/10.52783/jisem.v10i19s.2968
Asundi, Jai. 2005. “The Need for Effort Estimation Models for Open Source Software Projects.” ACM SIGSOFT Software Engineering Notes 30 (4): 1–3. https://doi.org/10.1145/1082983.1083260
Atkinson, Robert G. 1986. “Hurricane: An Optimizing Compiler for Smalltalk.” In Conference proceedings on Object-oriented programming systems, languages and applications - OOPLSA ‘86. ACM Press. https://doi.org/10.1145/28697.28712
Attarzadeh, Iman, and Siew Hock Ow. 2009. “Software Development Effort Estimation Based on a New Fuzzy Logic Model.” International Journal of Computer Theory and Engineering: 473–76. https://doi.org/10.7763/ijcte.2009.v1.77
Attri, Yash, Kashish Joshi, Saksham Makhija, and Mekhala Gupta. 2026. “Leveraging AI for Precise Cost Estimation for Software Projects.” In Sustainable Developments in Computer Engineering, Green Technology and Smart Systems. CRC Press. https://doi.org/10.1201/9781003743774-22
Aurigemma, Salvatore, and Ray Panko. 2014. “Evaluating the Effectiveness of Static Analysis Programs Versus Manual Inspection in the Detection of Natural Spreadsheet Errors.” Journal of Organizational and End User Computing 26 (1): 47–65. https://doi.org/10.4018/joeuc.2014010103
“Automated Code Generation for Tabular Question Answering in Zero-Shot Settings.” 2026. In Proceedings XoveTIC 2025. Servizo de Publicacións. Universidade da Coruña. https://doi.org/10.17979/spu.23.c60
Avalle, Matteo, Alfredo Pironti, and Riccardo Sisto. 2014. “Formal Verification of Security Protocol Implementations: A Survey.” Formal Aspects of Computing 26 (1): 99–123. https://doi.org/10.1007/s00165-012-0269-9
Awasthi, Arpit. 2023. “Deployment of Formal Verification Methodology for AXI Based Protocol for a Memory Model Verification.” SKIT Research Journal 13 (3): 12–16. https://doi.org/10.47904/ijskit.13.3.2023.12-16
Ayers, Everett. 1992. “The Software Development Effort Estimation Exponent: An Effort Estimation Model Accounting for Learning and Integration.” In Cost Estimating and Analysis. Springer New York. https://doi.org/10.1007/978-1-4612-2936-0_4
Ayyıldız, Tülin Erçelebi, and Altan Koçyiğit. 2014. “An Early Software Effort Estimation Method Based on Use Cases and Conceptual Classes.” Journal of Software 9 (8). https://doi.org/10.4304/jsw.9.8.2169-2173
Ayyıldız, Tülin Erçelebi, and Hasan Can Terzi. 2017. “Case Study on Software Effort Estimation.” International Journal of Information and Electronics Engineering 7 (3): 103–7. https://doi.org/10.18178/ijiee.2017.7.3.670
Azeez, Iyaan, and Ibrahim Thorig. 2026. “The Impact of Binary Serialization on Lottie Files: A Comparative Study.” Maldives Journal of Engineering and Technology 3 (1): 22–34. https://doi.org/10.70592/mjet.2026.3.01.003
Aziz, Benjamin. 2021. “Formal Analysis by Abstract Interpretation.” In SpringerBriefs in Applied Sciences and Technology. Springer International Publishing. https://doi.org/10.1007/978-3-030-91153-9_3
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
Azzeh, Mohammad. 2011d. “Software Effort Estimation Based on Optimized Model Tree.” In Proceedings of the 7th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2020390.2020396
Azzeh, Mohammad. 2013. “Dataset Quality Assessment: An Extension for Analogy Based Effort Estimation.” International Journal of Computer Science & Engineering Survey 4 (1): 1–21. https://doi.org/10.5121/ijcses.2013.4101
Azzeh, Mohammad, Yousef Elsheikh, and Marwan Alseid. 2014. “An Optimized Analogy-Based Project Effort Estimation.” International Journal of Advanced Computer Science and Applications 5 (4). https://doi.org/10.14569/ijacsa.2014.050402
Azzeh, Mohammad, and Ali Bou Nassif. 2015. “Analogy-Based Effort Estimation: A New Method to Discover Set of Analogies from Dataset Characteristics.” IET Software 9 (2): 39–50. https://doi.org/10.1049/iet-sen.2013.0165
Azzeh, Mohammad, Daniel Neagu, and Peter Cowling. 2008. “Improving Analogy Software Effort Estimation Using Fuzzy Feature Subset Selection Algorithm.” In Proceedings of the 4th international workshop on Predictor models in software engineering. ACM. https://doi.org/10.1145/1370788.1370805
Azzeh, Mohammad, Daniel Neagu, and Peter Cowling. 2009b. “Software Effort Estimation Based on Weighted Fuzzy Grey Relational Analysis.” In Proceedings of the 5th International Conference on Predictor Models in Software Engineering. ACM. https://doi.org/10.1145/1540438.1540450
Backes, Michael, Robert Künnemann, and Esfandiar Mohammadi. 2016. “Computational Soundness for Dalvik Bytecode.” In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security. ACM. https://doi.org/10.1145/2976749.2978418
“Background on Just-in-Time Compilation.” 2025. In Formal Verification of Just-in-Time Compilation. ACM. https://doi.org/10.1145/3705593.3705596
“Background on the CompCert Compiler.” 2025. In Formal Verification of Just-in-Time Compilation. ACM. https://doi.org/10.1145/3705593.3705597
Backhaus, Nils, and Stefan Brandenburg. 2018. “Unboxing Trust in Cloud Computing. a Survey Study.” In AHFE International. AHFE International. https://doi.org/10.54941/ahfe100129
Bacon, David F., Perry Cheng, and David Grove. 2004. “Garbage Collection for Embedded Systems.” In Proceedings of the 4th ACM international conference on Embedded software. ACM. https://doi.org/10.1145/1017753.1017776
Bacon, David F., Jyh-Herng Chow, Dz-ching R. Ju, Kalyan Muthukumar, and Vivek Sarkar. 2010. “A Compiler Framework for Restructuring Data Declarations to Enhance Cache and TLB Effectiveness.” In CASCON First Decade High Impact Papers on - CASCON ‘10. ACM Press. https://doi.org/10.1145/1925805.1925813
Badea, Carmen, Alexandru Nicolau, and Alexander V. Veidenbaum. 2007. “A Simplified Java Bytecode Compilation System for Resource-Constrained Embedded Processors.” In Proceedings of the 2007 international conference on Compilers, architecture, and synthesis for embedded systems. ACM. https://doi.org/10.1145/1289881.1289920
Baek, Soyeon, and Sungho Lee. 2024b. “Extracting Invariants from Conditional Branches for Abstract Value Refinement in Static Analysis Targeting LLVM IR.” KIISE Transactions on Computing Practices 30 (10): 519–24. https://doi.org/10.5626/ktcp.2024.30.10.519
Bahi, Mouad, and Christine Eisenbeis. 2011. “Rematerialization-Based Register Allocation through Reverse Computing.” In Proceedings of the 8th ACM International Conference on Computing Frontiers. ACM. https://doi.org/10.1145/2016604.2016632
Baird, George, and Arnold Johnson. 1977. COBOL Compiler Validation System, 1974. Version 3.0. Defense Technical Information Center. https://doi.org/10.21236/ada046600
Bajusova, Darina, Radek Silhavy, and Petr Silhavy. 2025. “A Comparative Evaluation of Validation Techniques in Software Effort Estimation Using eSOMCOCOMO.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-00239-6_23
Baker, Henry C., and Carl Hewitt. 1977. “The Incremental Garbage Collection of Processes.” ACM SIGART Bulletin, no. 64: 55–59. https://doi.org/10.1145/872736.806932
Balasa, Florin. 2013. “Compiler-Directed Design of Memory Hierarchy for Embedded Systems.” In Qatar Foundation Annual Research Forum Volume 2013 Issue 1. Hamad bin Khalifa University Press (HBKU Press). https://doi.org/10.5339/qfarf.2013.ictp-055
Balčiūnienė, Ingrida, and Eglė Krivickaitė. 2017. “Early Language Acquisition in Twins: Development and Analysis of the Lithuanian Corpus.” Taikomoji kalbotyra, no. 9: 31–45. https://doi.org/10.15388/tk.2017.17446
Balda, D., and D. A. Gustafson. 1990. “Cost Estimation Models for Reuse and Prototype SW Development Life-Cycles.” ACM SIGSOFT Software Engineering Notes 15 (3): 42–50. https://doi.org/10.1145/101114.101118
Baldwin, Timothy, and Su’ad Awab. 2006. “Open Source Corpus Analysis Tools for Malay.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/2wrhtstg7hyt
Ballard, Grey, James Demmel, Benjamin Lipshitz, Oded Schwartz, and Sivan Toledo. 2013. Communication Efficient Gaussian Elimination with Partial Pivoting Using a Shape Morphing Data Layout. Defense Technical Information Center. https://doi.org/10.21236/ada580196
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
Bandagale, Priyanka, and Vinayak Ashok Bharadi. 2020. “Data Analytics on Columnar Databases in Big Data Environment.” In Lecture Notes in Networks and Systems. Springer Singapore. https://doi.org/10.1007/978-981-15-7421-4_11
Banerjee, Abhijeet. 2014. “Static Analysis Driven Performance and Energy Testing.” In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. ACM. https://doi.org/10.1145/2635868.2666602
Banerjee, Jay, Won Kim, Hyoung-Joo Kim, and Henry F. Korth. 1987. “Semantics and Implementation of Schema Evolution in Object-Oriented Databases.” In Proceedings of the 1987 ACM SIGMOD international conference on Management of data - SIGMOD ‘87. ACM Press. https://doi.org/10.1145/38713.38748
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
Barbuti, Roberto, Cinzia Bernardeschi, and Nicoletta De Francesco. 2002a. “Checking Security of Java Bytecode by Abstract Interpretation.” In Proceedings of the 2002 ACM symposium on Applied computing - SAC ‘02. ACM Press. https://doi.org/10.1145/508832.508839
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. 2002b. “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
Bardsiri, Vahid Khatibi, Dayang Norhayati Abang Jawawi, and Elham Khatibi. 2014. “Towards Improvement of Analogy-Based Software Development Effort Estimation: A Review.” International Journal of Software Engineering and Knowledge Engineering 24 (07): 1065–89. https://doi.org/10.1142/s0218194014500351
Bareikis, Nerijus. 2024. “Rational steel mesh layout influence on plate utilization of large span corrugated steel structure.” Archives of Civil Engineering: 561–78. https://doi.org/10.24425/ace.2024.151002
Baresi, L., M. M. Bersani, F. Marconi, G. Quattrocchi, and M. Rossi. 2020. “Using Formal Verification to Evaluate Theexecution Time of Spark Applications.” Formal Aspects of Computing 32 (1): 33–70. https://doi.org/10.1007/s00165-020-00505-4
Barik, Titus. 2016. “How Should Static Analysis Tools Explain Anomalies to Developers?” In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. ACM. https://doi.org/10.1145/2950290.2983968
Barik, Rajkishore, Jisheng Zhao, and Vivek Sarkar. 2010. “Automatic Vector Instruction Selection for Dynamic Compilation.” In Proceedings of the 19th international conference on Parallel architectures and compilation techniques. ACM. https://doi.org/10.1145/1854273.1854358
Barisone, Andrea, Francesco Bellotti, Riccardo Berta, and Alessandro Gloria. 2000. “Ultrasparc Instruction Level Characterization of Java Virtual Machine Workload.” In Workload Characterization for Computer System Design. Springer US. https://doi.org/10.1007/978-1-4615-4387-9_1
Barker, Martha, Stephen A. Edwards, and Martha A. Kim. 2022. “Synthesized Garbage Collection for FPGA Accelerators.” In Proceedings of the 2022 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays. ACM. https://doi.org/10.1145/3490422.3502341
Barnett, Jeffrey A. 1979. “Garbage Collection versus Swapping.” ACM SIGOPS Operating Systems Review 13 (3): 12–17. https://doi.org/10.1145/850662.850665
Barr, P., and R. Brentrup. 1979. “Influence of PASCAL Compiler Construction on Hardware Design.” In 2nd Computers in Aerospace Conference. AIAA 1979-1967. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.1979-1967
Barros, P., T. Porto, and C. I. Valer. 2023. “Design of Subsea Jumpers with Preliminary Field Layout.” In Offshore Technology Conference Brasil. OTC. https://doi.org/10.4043/32789-ms
Barry, Matthew, Eric Bush, Doug Smith, et al. 2016. Static Analysis Numerical Algorithms. Defense Technical Information Center. https://doi.org/10.21236/ad1008340
Bashir, Ali, Maryam Zakir, and Yusra Bajwa. 2025. “Enhancing Software Effort Estimation in Agile Projects through Expert-Guided Feature Selection and Machine Learning.” International Journal of Scientific Research and Modern Technology: 28–35. https://doi.org/10.38124/ijsrmt.v4i11.949
Baskauf, Steven J. 2021. “Having Your Cake and Eating It Too: JSON-LD as an RDF Serialization Format.” Biodiversity Information Science and Standards 5: e74266. https://doi.org/10.3897/biss.5.74266
Başöz, Tutku. 2026. “L2 Grit Unboxed: A Meta-Analytic Journey into L2 Grit and Its Correlates.” Applied Linguistics: amag027. https://doi.org/10.1093/applin/amag027
Basri, Sufyan, Nazri Kama, Saiful Adli, and Faizura Haneem. 2016b. “Using Static and Dynamic Impact Analysis for Effort Estimation.” IET Software 10 (4): 89–95. https://doi.org/10.1049/iet-sen.2015.0043
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
Basten, Dirk, and Ali Sunyaev. 2014. “A Systematic Mapping of Factors Affecting Accuracy of Software Development Effort Estimation.” Communications of the Association for Information Systems 34. https://doi.org/10.17705/1cais.03404
Bataev, Alexey. 2025a. “LLVM Loop Vectorizer.” In Maker Innovations Series. Apress. https://doi.org/10.1007/979-8-8688-2169-1_5
Bataev, Alexey. 2025b. “LLVM SLP Vectorizer.” In Maker Innovations Series. Apress. https://doi.org/10.1007/979-8-8688-2169-1_6
Bataev, Alexey. 2025c. “RISC-V RVV Specific LLVM-Based Optimizations.” In Maker Innovations Series. Apress. https://doi.org/10.1007/979-8-8688-2169-1_4
Bataev, Alexey. 2025d. “RISC-V RVV Support in Clang-Based Compiler.” In Maker Innovations Series. Apress. https://doi.org/10.1007/979-8-8688-2169-1_2
Bataev, Alexey. 2025e. “Vector Extensions in Clang-Based Compilers.” In Maker Innovations Series. Apress. https://doi.org/10.1007/979-8-8688-2169-1_3
Batra, Geetika, and Mahima Trivedi. 2013. “A Fuzzy Approach for Software Effort Estimation.” International Journal on Cybernetics & Informatics 2 (1): 9–15. https://doi.org/10.5121/ijci.2013.2102
Baum, David, Christina Sixtus, Lisa Vogelsberg, and Ulrich Eisenecker. 2019. “Understanding Conditional Compilation through Integrated Representation of Variability and Source Code.” In Proceedings of the 23rd International Systems and Software Product Line Conference - Volume B. ACM. https://doi.org/10.1145/3307630.3342387
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
Bavishi, Rohan, Hiroaki Yoshida, and Mukul R. Prasad. 2019. “Phoenix: Automated Data-Driven Synthesis of Repairs for Static Analysis Violations.” In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3338906.3338952
Baxter, James, Ana Cavalcanti, Andy Wellings, and Leo Freitas. 2015. “Safety-Critical Java Virtual Machine Services.” In Proceedings of the 13th International Workshop on Java Technologies for Real-time and Embedded Systems. ACM. https://doi.org/10.1145/2822304.2822307
Beaumont, J. G. 1987. “Review: The Brain Code: Mechanisms of Information Transfer and the Role of the Corpus Callosum.” Perception 16 (6): 820–22. https://doi.org/10.1068/p160820
Beckschulze, Eva, Sebastian Biallas, and Stefan Kowalewski. 2012. “Static Analysis of Lockless Microcontroller C Programs.” Electronic Proceedings in Theoretical Computer Science 102: 103–14. https://doi.org/10.4204/eptcs.102.10
Beecher, Karl. 2018. “Layout and Structure.” In Bad Programming Practices 101. Apress. https://doi.org/10.1007/978-1-4842-3411-2_2
Beecher, Karl. 2021. “Abuse of the Type System.” In Bad Programming 101 - Part 1. Apress. https://doi.org/10.1007/978-1-4842-7152-0_6
Beecher, Karl. 2026. “Layout and Structure.” In Bad Programming Practices 101. Apress. https://doi.org/10.1007/979-8-8688-2506-4_2
Beemaraj, Soban Babu, Bilal Muhammed, and Amol Joshi. 2025. “Early-Stage Field Layout Design of Subsea Production System Considering the Reservoir and Geological Uncertainties.” In OTC Brasil. OTC. https://doi.org/10.4043/36022-ms
Beemaraj, Soban Babu, Bilal Muhammed, Amol Joshi, Edmond Coche, and Alain Chanet. 2024. “Quantification of Uncertainty in Field Layout Design of Subsea Production System.” In Offshore Technology Conference. OTC. https://doi.org/10.4043/35121-ms
Beidas, Rami, and Jianwen Zhu. 2005. “Scalable Interprocedural Register Allocation for High Level Synthesis.” In Proceedings of the 2005 conference on Asia South Pacific design automation - ASP-DAC ‘05. ACM Press. https://doi.org/10.1145/1120725.1120951
Bekelman, Justin E., Yan Li, and Cary P. Gross. 2003. “Scope and Impact of Financial Conflicts of Interest in Biomedical Research: A Systematic Review.” JAMA 289 (4): 454. https://doi.org/10.1001/jama.289.4.454
Beliveau, Yvan J., Jerry King, Carl Magnell, Glen Weathers, and J. M. Williams. 1995. Crucial Links for Construction Site Productivity: Real-Time Construction Layout and as-Built Plans. Defense Technical Information Center. https://doi.org/10.21236/ada295233
Belyaev, M., and V. Tsesko. 2012. “LLVM-Based Static Analysis Tool Using Type and Effect Systems.” Automatic Control and Computer Sciences 46 (7): 324–30. https://doi.org/10.3103/s0146411612070073
Ben Asher, Yosi, and Nadav Rotem. 2009. “The Effect of Unrolling and Inlining for Python Bytecode Optimizations.” In Proceedings of SYSTOR 2009: The Israeli Experimental Systems Conference. ACM. https://doi.org/10.1145/1534530.1534550
Benala, Tirimula Rao. 2022. “Value of Random Vector Functional Link Neural Networks in Software Development Effort Estimation.” In Intelligent Systems Reference Library. Springer Nature Singapore. https://doi.org/10.1007/978-981-16-8930-7_7
Benediktsson, O., and D. Dalcher. 2003. “Effort Estimation in Incremental Software Development.” IEE Proceedings - Software 150 (6): 351. https://doi.org/10.1049/ip-sen:20031056
Benediktsson, Oddur, and Darren Dalcher. 2004a. “New Insights into Effort Estimation for Incremental Software Development Projects.” Project Management Journal 35 (2): 5–12. https://doi.org/10.1177/875697280403500202
Bennett, Gareth, Tracy Hall, Steve Counsell, Emily Winter, and Thomas Shippey. 2024. “Do Developers Use Static Application Security Testing (SAST) Tools Straight out of the Box? A Large-Scale Empirical Study.” In Proceedings of the 18th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. ACM. https://doi.org/10.1145/3674805.3690750
Benton, Nick. 2018. “Semantic Equivalence Checking for HHVM Bytecode.” In Proceedings of the 20th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/3236950.3236975
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
Berg, Steven A., and Justin H. Moss. 2021. “Anchoring and Judgment Bias: Disregarding under Uncertainty.” Psychological Reports 125 (5): 2688–2708. https://doi.org/10.1177/00332941211016750
Bernardeschi, Cinzia, Alessandro Fantechi, and Stefania Gnesi. 1997. “Formal Verification of Safety Requirements on Complex Systems.” In Safe Comp 96. Springer London. https://doi.org/10.1007/978-1-4471-0937-2_2
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
Berning, Paul t., Eric R. Anderson, and Frank C. Belz. 1978. Automated Compiler Test Case Generation. Defense Technical Information Center. https://doi.org/10.21236/ada052726
Bertino, Elisa, and Barbara Catania. 1996. “Static Analysis of Intensional Databases in U-Datalog (Extended Abstract).” In Proceedings of the fifteenth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems. ACM. https://doi.org/10.1145/237661.237711
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
Besnard, Jean-Baptiste, Allen Malony, Sameer Shende, Marc Pérache, Patrick Carribault, and Julien Jaeger. 2015. “An MPI Halo-Cell Implementation for Zero-Copy Abstraction.” In Proceedings of the 22nd European MPI Users’ Group Meeting. ACM. https://doi.org/10.1145/2802658.2802669
Bessonov, Vyacheslav, and Lyudmila Lyadova. 2014. “One Approach to Automated Compiler Verification.” In Proceedings of the Spring/Summer Young Researchers’ Colloquium on Software Engineering. Institute for System Programming of the Russian Academy of Sciences. https://doi.org/10.15514/syrcose-2014-8-20
“Beyond Autocomplete: Investigating the Impact of AI Code Generation on Code Quality and Technical Debt.” 2025. In International Conference on Recent Trends in Computer Science and Information Technology. ScienceTech Xplore. https://doi.org/10.63282/3050-9246/icrtcsit-115
Bezan, Sarah, and Peter Sands. 2026. “The Art and Science of Species Revival: De-Extinction, Unboxed.” Configurations 34 (1): 1–21. https://doi.org/10.1353/con.2026.a981314
Bezza, Asma, Rohallah Benaboud, Toufik-Messaoud Maarouk, and Rabea Ameur-Boulifa. 2025. “Formal Verification of the Correctness and Soundness of a Pomset-to-LTS Transformation Algorithm.” Journal of Communications Software and Systems 21 (4): 404–13. https://doi.org/10.24138/jcomss-2025-0028
Bhatt, Pina, Swapnil Vegad, Keval Bhavsar, and Umang Parmar. 2026. “A State-of-the-Art Review on Garbage Collection and Segregation Robot.” In Assistive Robotics. CRC Press. https://doi.org/10.1201/9781003434436-8
Bhattacherjee, Souvik, Gang Liao, Michael Hicks, and Daniel J. Abadi. 2021. “BullFrog: Online Schema Evolution via Lazy Evaluation.” In Proceedings of the 2021 International Conference on Management of Data. ACM. https://doi.org/10.1145/3448016.3452842
Bian, Gaowei, Ken Nakayama, Yoshitake Kobayashi, and Mamoru Maekawa. 1970. “Java Mobile Code Security by Bytecode Analysis.” ECTI Transactions on Computer and Information Technology (ECTI-CIT) 1 (1): 30–39. https://doi.org/10.37936/ecti-cit.200511.51830
Biber, Douglas. 2012. “Corpus-Based and Corpus-Driven Analyses of Language Variation and Use.” In The Oxford Handbook of Linguistic Analysis. Oxford University Press. https://doi.org/10.1093/oxfordhb/9780199544004.013.0008
Bieker, Ulrich. 2002. “Retargetable Compilation of Self-Test Programs Using Constraint Logic Programming.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_13
Biggar, Paul, and David Gregg. 2021. “Building SSA in a Compiler for PHP.” In SSA-based Compiler Design. Springer International Publishing. https://doi.org/10.1007/978-3-030-80515-9_24
Bilgaiyan, Saurabh, Prabin Kumar Panigrahi, and Samaresh Mishra. 2020. “Chaos-Based Modified Morphological Genetic Algorithm for Effort Estimation in Agile Software Development.” In Intelligent Systems Reference Library. Springer International Publishing. https://doi.org/10.1007/978-3-030-40928-9_6
Biliak, Y. 2020. “Modern Concepts of Conflict of Interest Research.” Ekonomika ta derzhava, no. 9: 80. https://doi.org/10.32702/2306-6806.2020.9.80
Binder, Walter, and Jarle Hulaas. 2006. “Flexible and Efficient Measurement of Dynamic Bytecode Metrics.” In Proceedings of the 5th international conference on Generative programming and component engineering. ACM. https://doi.org/10.1145/1173706.1173733
Binder, Walter, Jarle Hulaas, and Philippe Moret. 2007a. “Advanced Java Bytecode Instrumentation.” In Proceedings of the 5th international symposium on Principles and practice of programming in Java - PPPJ ‘07. ACM Press. https://doi.org/10.1145/1294325.1294344
Bingham, Harvey W., David A. Fisher, and Warren L. Semon. 1967. Detection of Essential Ordering Implicit in Compiler Language Programs. Defense Technical Information Center. https://doi.org/10.21236/ad0650845
Bitat, Abir, and Salah Merniz. 2021. “Formal Verification of Pipelined Cryptographic Circuits: A Functional Approach.” Informatica 45 (4). https://doi.org/10.31449/inf.v45i4.3176
Bivens, Mary P. 1986. “An Approach to Incremental Register Allocation (Abstract).” In Proceedings of the 1986 ACM fourteenth annual conference on Computer science - CSC ‘86. ACM Press. https://doi.org/10.1145/324634.325341
Bjesse, Per. 2005. “What Is Formal Verification?” ACM SIGDA Newsletter 35 (24): 1. https://doi.org/10.1145/1113792.1113794
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
Blackburn, Stephen M. 2020. “Garbage Collection: Implementation, Innovation, Performance, and Security (Keynote).” In Proceedings of the 17th International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3426182.3431579
Blacklock, Belinda, and Anna Lord. 2009. “Audi ‘Unboxed’.” In ACM SIGGRAPH 2009 Computer Animation Festival. ACM. https://doi.org/10.1145/1596685.1596698
Blad, A., and O. Gustafsson. 2006. “Energy-Efficient Data Representation in LDPC Decoders.” Electronics Letters 42 (18): 1051–52. https://doi.org/10.1049/el:20061544
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. 2015. “Formal Verification of Compilers and Static Analyzers.” In Proceedings of the Programming Languages Mentoring Workshop. ACM. https://doi.org/10.1145/2792434.2792443
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
Bloom, Howard M., Arthur Hausner, and Robert J. Kushlis. 1976. FORTRAN IV Compiler-Loader for the Wang 520/600 Calculator. Defense Technical Information Center. https://doi.org/10.21236/ada026130
Blott, Stephen. 1990. “Type Inference and Type Classes.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3166-3_17
Bock, Jason. 2016a. “The Future of the Compiler API.” In .NET Development Using the Compiler API. Apress. https://doi.org/10.1007/978-1-4842-2111-2_5
Bock, Jason. 2016b. “An Overview of the Compiler API.” In .NET Development Using the Compiler API. Apress. https://doi.org/10.1007/978-1-4842-2111-2_1
Böck, Markus, Michael Schröder, and Jürgen Cito. 2024. “Language-Agnostic Static Analysis of Probabilistic Programs.” In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. ACM. https://doi.org/10.1145/3691620.3695031
Bockisch, Christoph, Andreas Sewe, and Martin Zandberg. 2011. “ALIA4J’s [(Just-in-Time) Compile-Time] MOP for Advanced Dispatching.” In Proceedings of the compilation of the co-located workshops on DSM’11, TMC’11, AGERE! 2011, AOOPES’11, NEAT’11, & VMIL’11. ACM. https://doi.org/10.1145/2095050.2095101
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
Boehm, Hans-J., and Paul F. Dubois. 1995. “Dynamic Memory Allocation and Garbage Collection.” Computers in Physics 9 (3): 297–303. https://doi.org/10.1063/1.4823407
Boehm, Hans-J., and Mike Spertus. 2009. “Garbage Collection in the Next C++ Standard.” In Proceedings of the 2009 international symposium on Memory management. ACM. https://doi.org/10.1145/1542431.1542437
Bokil, Prasad. 2015. “Application of Function-Behaviour-Structure Variables for Layout Design.” In Design Computing and Cognition ‘14. Springer International Publishing. https://doi.org/10.1007/978-3-319-14956-1_30
Bolas, Bruce J. 1970. “Optimization Problems in Extensible Compilers.” In Proceedings of a symposium on Compiler optimization -. ACM Press. https://doi.org/10.1145/800028.808488
Bolignano, Dominique, and Mourad Debabi. 1994. “A Coherent Type System for a Concurrent, Functional and Imperative Programming Language.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3227-1_14
Bolotnikov, I. V., and A. E. Borodin. 2021. “Interprocedural Static Analysis for Finding Bugs in Go Programs.” Programming and Computer Software 47 (5): 344–52. https://doi.org/10.1134/s0361768821050030
Bommas, Martin. 2024. “Unboxing in Memphis.” In Tutankhamun. Routledge. https://doi.org/10.4324/9781003496472-10
Bond, Michael D., Milind Kulkarni, Man Cao, Meisam Fathi Salmi, and Jipeng Huang. 2015. “Efficient Deterministic Replay of Multithreaded Executions in a Managed Language Virtual Machine.” In Proceedings of the Principles and Practices of Programming on The Java Platform. ACM. https://doi.org/10.1145/2807426.2807434
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. 1963a. JOVIAL-X.2, the Language of the One Pass Jovial Compiler. Defense Technical Information Center. https://doi.org/10.21236/ad0296833
Book, E., H. Bratman, and J. Schwartz. 1963b. A One Pass Jovial Compiler. Defense Technical Information Center. https://doi.org/10.21236/ad0296834
Boquist, Urban. 1995. “Interprocedural Register Allocation for Lazy Functional Languages.” In Proceedings of the seventh international conference on Functional programming languages and computer architecture - FPCA ‘95. ACM Press. https://doi.org/10.1145/224164.224215
Borälv, Arne. 1998. “Case Study: Formal Verification of a Computerized Railway Interlocking.” Formal Aspects of Computing 10 (4): 338–60. https://doi.org/10.1007/s001650050021
Borälv, Arne, and Gunnar Stålmarck. 1999. “Formal Verification in Railways.” In Industrial-Strength Formal Methods in Practice. Springer London. https://doi.org/10.1007/978-1-4471-0523-7_15
Borcherding, Thomas E., and Darren Filson. 2001. “Conflict of Interest in the Hollywood Film Industry: Coming to America-Tales from the Casting Couch, Gross and Net, in a Risky Business.” In Conflict of Interest in the Professions. Oxford University PressNew York, NY. https://doi.org/10.1093/oso/9780195128635.003.0014
Börger, Egon, and Wolfram Schulte. 2000. “Modular Design for the Java Virtual Machine Architecture.” In Architecture Design and Validation Methods. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-57199-2_7
Borhalenko, V. A. 2015. “The Automata Intruder Model for Data Exchange Cryptographic Protocols Formal Verification.” Vestnik komp’iuternykh i informatsionnykh tekhnologii: 23–28. https://doi.org/10.14489/vkit.2015.07.pp.023-028
Bottom, William P., Thomas Gilovich, Dale Griffin, and Daniel Kahneman. 2004. “Heuristics and Biases: The Psychology of Intuitive Judgment.” Academy of Management Review 29 (4): 695. https://doi.org/10.2307/20159081
Boudi, Zakaryae, Abderrahim Ait Wakrime, Mohamed Toub, and Mohamed Haloua. 2023. “A Deep Reinforcement Learning Framework with Formal Verification.” Formal Aspects of Computing 35 (1): 1–17. https://doi.org/10.1145/3577204
Boumaza, Kamal, Cherif Tolba, and Iulian Ober. 2021. “Formal Verification of Emergent Properties.” Informatica 45 (3). https://doi.org/10.31449/inf.v45i3.3160
Boundas, Constantin V. 2017. “Deleuze: Serialization and Subject-Formation.” In Gilles Deleuze and the Theater of Philosophy. Routledge. https://doi.org/10.4324/9781315112503-6
Bounif, Hassina. 2007. “Predicitive Approach for Database Schema Evolution.” In Intelligent Databases. IGI Global. https://doi.org/10.4018/978-1-59904-120-9.ch011
Bounov, Dimitar, Rami Gökhan Kıcı, and Sorin Lerner. 2016. “Protecting C++ Dynamic Dispatch through VTable Interleaving.” In Proceedings 2016 Network and Distributed System Security Symposium. Internet Society. https://doi.org/10.14722/ndss.2016.23421
“Boxing and the Law: A Current Analysis.” 2007. In The Legality of Boxing. Birkbeck Law Press. https://doi.org/10.4324/9780203945063-10
Boyapati, Chandrasekhar, and Karem Sakallah. 2011. Program Analysis Techniques for Efficient Software Model Checking. Defense Technical Information Center. https://doi.org/10.21236/ada567483
Boyer, Robert S., and J. Strother Moore. 1979. “The Correctness of a Simple Optimizing Expression Compiler.” In A Computational Logic. Elsevier. https://doi.org/10.1016/b978-0-12-122950-4.50021-8
Boyland, John, Charles Farnum, and Susan L. Graham. 1992. “Attributed Transformational Code Generation for Dynamic Compilers.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3501-2_13
Brackin, Stephen H., and Ian Sutherland. 1990. Formal Verification of Mathematical Software. Volume 2. Defense Technical Information Center. https://doi.org/10.21236/ada223633
Bradford, Jeffrey P., and Russell Quong. 1999. “An Empirical Study on How Program Layout Affects Cache Miss Rates.” ACM SIGMETRICS Performance Evaluation Review 27 (3): 28–42. https://doi.org/10.1145/340242.340326
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
Brahmia, Zouhaier, Fabio Grandi, and Barbara Oliboni. 2024. “A Literature Review on Schema Evolution in Databases.” Computing Open 02: 2430001. https://doi.org/10.1142/s2972370124300012
Brahmia, Zouhaier, Fabio Grandi, Barbara Oliboni, and Rafik Bouaziz. 2018. “Schema Evolution in Conventional and Emerging Databases.” In Encyclopedia of Information Science and Technology, Fourth Edition. IGI Global. https://doi.org/10.4018/978-1-5225-2255-3.ch177
Brandt, Jens, and Klaus Schneider. 2009. “Separate Compilation for Synchronous Programs.” In Proceedings of th 12th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/1543820.1543822
Brauckmann, Alexander, Andrés Goens, Sebastian Ertel, and Jeronimo Castrillon. 2020. “Compiler-Based Graph Representations for Deep Learning Models of Code.” In Proceedings of the 29th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3377555.3377894
Brauer, Jörg, Thomas Noll, and Bastian Schlich. 2010. “Interval Analysis of Microcontroller Code Using Abstract Interpretation of Hardware and Software.” In Proceedings of the 13th International Workshop on Software & Compilers for Embedded Systems - SCOPES ‘10. ACM Press. https://doi.org/10.1145/1811212.1811216
Bredlau, Carl, and Dorothy Deremer. 2001. “Assembly Language through the Java Virtual Machine.” ACM SIGCSE Bulletin 33 (1): 194–98. https://doi.org/10.1145/366413.364583
Breese, Samuel, Ana Milanova, and Barbara Cutler. 2017. “Using Static Analysis for Automated Assignment Grading in Introductory Programming Classes (Abstract Only).” In Proceedings of the 2017 ACM SIGCSE Technical Symposium on Computer Science Education. ACM. https://doi.org/10.1145/3017680.3022440
Breg, Fabian, and Constantine D. Polychronopoulos. 2001. “Java Virtual Machine Support for Object Serialization.” In Proceedings of the 2001 joint ACM-ISCOPE conference on Java Grande. ACM. https://doi.org/10.1145/376656.376846
Brenneis, Andreas. 2018. “Unboxing.” In Arbeit und Spiel. Nomos Verlagsgesellschaft mbH & Co. KG. https://doi.org/10.5771/9783845285429-357
“Bridging the Semantic Gap for Software Effort Estimation by Hierarchical Feature Selection Techniques.” 2016. Journal of Artificial Intelligence and Data Mining 4 (2). https://doi.org/10.5829/idosi.jaidm.2016.04.02.04
Brinkmann, Raik, and Dave Kelf. 2017. “Formal Verification—the Industrial Perspective.” In Formal System Verification. Springer International Publishing. https://doi.org/10.1007/978-3-319-57685-5_5
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
Brogioli, Michael C. 2019. “Software and Compiler Optimization for Microcontrollers, Embedded Processors, and DSPs.” In Software Engineering for Embedded Systems. Elsevier. https://doi.org/10.1016/b978-0-12-809448-8.00008-4
Bronshteyn, I. E. 2013. “Type Inference for Python Programming Language.” Proceedings of the Institute for System Programming of RAS 24: 161–90. https://doi.org/10.15514/ispras-2013-24-9
Brouwers, Niels, Peter Corke, and Koen Langendoen. 2008a. “Darjeeling, a Java Compatible Virtual Machine for Microcontrollers.” In Proceedings of the ACM/IFIP/USENIX Middleware ‘08 Conference Companion. ACM. https://doi.org/10.1145/1462735.1462740
Brouwers, Niels, Peter Corke, and Koen Langendoen. 2008b. “A Java Compatible Virtual Machine for Wireless Sensor Nodes.” In Proceedings of the 6th ACM conference on Embedded network sensor systems. ACM. https://doi.org/10.1145/1460412.1460456
Brown, Clare. 2018. “Unboxing History Exhibitions.” In The Future of Museum and Gallery Design. Routledge. https://doi.org/10.4324/9781315149486-19
Brown, Nathanael, Jared Gearhart, Amanda Wilson, and Meghan Sahakian. 2026. “Optimal Device-Type Inference in Cyber-Physical Systems Using Packet Data and Expert Rules.” In Proceedings of the Annual Hawaii International Conference on System Sciences. Hawaii International Conference on System Sciences. https://doi.org/10.24251/hicss.2026.154
Brown, Geoffrey, Wayne Luk, and John O’Leary. 1996. “Retargeting a Hardware Compiler Using Protocol Converters.” Formal Aspects of Computing 8 (2): 209–37. https://doi.org/10.1007/bf01214557
Brown, A. D., and P. R. Thomas. 1990. “Implementation of a Mask Verification Language and Its Compiler.” IEE Proceedings E Computers and Digital Techniques 137 (3): 207. https://doi.org/10.1049/ip-e.1990.0026
Brucker, Achim D., and Michael Herzberg. 2018. “A Formal Semantics of the Core DOM in Isabelle/HOL.” In Companion of the The Web Conference 2018 on The Web Conference 2018 - WWW ‘18. ACM Press. https://doi.org/10.1145/3184558.3185980
Brunner, Uwe, Christoph Hechtl, and Vitaliy Mezhuyev. 2020. “Development of a Parameterizable Process-Oriented Model for Freight Cost Estimation.” In Proceedings of the 2020 9th International Conference on Software and Computer Applications. ACM. https://doi.org/10.1145/3384544.3384612
Brunt, Mike. 2010. “Tuning Your Java Virtual Machine: Finding Your Ideal JVM Settings through Metrics Log Analysis.” In Adobe ColdFusion Anthology. Apress. https://doi.org/10.1007/978-1-4302-7214-4_8
Brunthaler, Stefan. 2010a. “Efficient Inline Caching without Dynamic Translation.” In Proceedings of the 2010 ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/1774088.1774542
Bryant, Jay. 2012. “Garbage Collection.” In Java 7 for Absolute Beginners. Apress. https://doi.org/10.1007/978-1-4302-3687-0_13
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
Bsaïes, Khaled. 1993. “Static Analysis for the Synthesis of Eureka Properties for Transforming Logic Programs.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3421-3_3
Bu, Julia, Dawn M. Meyer, Ben Shifflett, and Brett C. Meyer. 2022. “Abstract TP125: Interpreter Requirements Needed for Tpa Evaluations and Resulting Performance (INTERP).” Stroke 53 (Suppl_1). https://doi.org/10.1161/str.53.suppl_1.tp125
Buchwald, Sebastian, Andreas Fried, and Sebastian Hack. 2018. “Synthesizing an Instruction Selection Rule Library from Semantic Specifications.” In Proceedings of the 2018 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3168821
Buck, Reiner. 2013. “Heliostat Field Layout Improvement by Nonrestricted Refinement.” Journal of Solar Energy Engineering 136 (2): 021014. https://doi.org/10.1115/1.4025293
Budd, Arthur E. 1967. A Method for the Evaluation of Software. Volume II. Procedural Language Compilers – Particularly Cobol and Fortran. Defense Technical Information Center. https://doi.org/10.21236/ad0651142
Budd, Timothy. 1988a. “Code Generation Overview.” In An APL Compiler. Springer New York. https://doi.org/10.1007/978-1-4612-3806-5_3
Budd, Timothy. 1988b. “Why a Compiler ?” In An APL Compiler. Springer New York. https://doi.org/10.1007/978-1-4612-3806-5_1
Budd, Timothy A. 1991. “A Parallel Intermediate Representation Based on Lambda Expressions.” In Arrays, Functional Languages, and Parallel Systems. Springer US. https://doi.org/10.1007/978-1-4615-4002-1_9
Buehler, Roger, Dale Griffin, and Johanna Peetz. 2010. “The Planning Fallacy.” In Advances in Experimental Social Psychology. Elsevier. https://doi.org/10.1016/s0065-2601(10)43001-4
Buehler, Roger, Dale Griffin, and Michael Ross. 1994. “Exploring the ‘Planning Fallacy’: Why People Underestimate Their Task Completion Times.” Journal of Personality and Social Psychology 67 (3): 366–81. https://doi.org/10.1037/0022-3514.67.3.366
Buehler, Roger, Dale Griffin, and Michael Ross. 2002. “Inside the Planning Fallacy: The Causes and Consequences of Optimistic Time Predictions.” In Heuristics and Biases. Cambridge University Press. https://doi.org/10.1017/cbo9780511808098.016
“Bug Found in Java Virtual Machine.” 1997. Network Security 1997 (3): 2. https://doi.org/10.1016/s1353-4858(97)83033-4
Bühler, David, André Maroneze, and Valentin Perrelle. 2024. “Abstract Interpretation with the Eva Plug-in.” In Computer Science Foundations and Applied Logic. Springer International Publishing. https://doi.org/10.1007/978-3-031-55608-1_3
Bukszar, Ed. 2003. “Does Overconfidence Lead to Poor Decisions a Comparison of Decision Making and Judgment under Uncertainty.” J. of Business and Management 9 (1): 33–43. https://doi.org/10.1504/jbm.2003.141099
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
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
Burke, Timothy, and Jason Pinney. 2016. “FINRA Publishes Guidance on Research Conflict of Interest Rules.” Journal of Investment Compliance 17 (1): 45–50. https://doi.org/10.1108/joic-08-2015-0057
Burn, Geoffrey, and Daniel Le Métayer. 1996. “Proving the Correctness of Compiler Optimisations Based on a Global Analysis: A Study of Strictness Analysis.” Journal of Functional Programming 6 (1): 75–109. https://doi.org/10.1017/s0956796800001581
Burski, Lavinia. 2025. “Transforming Formal Verification: Insights from MALPAS.” In AI and Safety Critical Systems. Safety-Critical Systems Club C.I.C. https://doi.org/10.65391/r3338
Busch, Bradley, and Edward Watson. 2019. “The One about the Planning Fallacy.” In The Science of Learning. Routledge. https://doi.org/10.4324/9780429461545-4
Büscher, Niklas, and Stefan Katzenbeisser. 2017. “Towards Scalable and Optimizing Compilation for MPC.” In SpringerBriefs in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-67522-0_7
Bush, William R., Gino Cheng, Patrick C. McGeer, and Alvin M. Despain. 1987. An Advanced Silicon Compiler in Prolog. Defense Technical Information Center. https://doi.org/10.21236/ada196284
Bush, William R., Gino Cheng, Patrick C. McGeer, and Alvin M. Despain. 1988. A Prototype Silicon Compiler in Prolog. Defense Technical Information Center. https://doi.org/10.21236/ada210669
Bushell, S. J., A. Dearle, A. L. Brown, and F. A. Vaughan. 1995. “Using C as a Compiler Target Language for Native Code Generation in Persistent Systems.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-2122-0_15
Busse, Susanne, and Claudia Pons. 2001. “Schema Evolution in Federated Information Systems.” In Informatik aktuell. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-56687-5_4
Buszewicz, Katarzyna. 2020. “Performance Analysis of Languages Working on Java Virtual Machine Based on Java, Scala and Kotlin.” Journal of Computer Sciences Institute 15: 189–95. https://doi.org/10.35784/jcsi.1609
Buth, Bettina, and Karl-Heinz Buth. 1992. “An Approach to Automatic Proof Support for Code Generator Verification.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3501-2_11
Butkevich, Sergey, Marco Renedo, Gerald Baumgartner, and Michal Young. 2000. “Compiler and Tool Support for Debugging Object Protocols.” ACM SIGSOFT Software Engineering Notes 25 (6): 50–59. https://doi.org/10.1145/357474.355052
Byun, Sugwoo. 2014. “Implementation of Nondeterministic Compiler Using Monad.” Journal of the Korea Society of Computer and Information 19 (2): 151–59. https://doi.org/10.9708/jksci.2014.19.2.151
“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
Cabri, Giacomo, Letizia Leonardi, and Raffaele Quitadamo. 2006. “Enabling Java Mobile Computing on the IBM Jikes Research Virtual Machine.” In Proceedings of the 4th international symposium on Principles and practice of programming in Java - PPPJ ‘06. ACM Press. https://doi.org/10.1145/1168054.1168064
Cai, Kui, Lei Lu, Shuai-qiang Wang, and Jian-cheng Wan. 2009a. “Complicated Behaviors Modeling and Code Generation Based on Web UI Design Pattern.” Journal of Computer Applications 29 (4): 1139–42. https://doi.org/10.3724/sp.j.1087.2009.01139
Calahan, D. A. 1982. Randomly Sparse Equation Solution by Loopless Code Generation on the CRAY-1. Defense Technical Information Center. https://doi.org/10.21236/ada125738
Callaú, Oscar, Romain Robbes, Éric Tanter, and David Röthlisberger. 2011. “How Developers Use the Dynamic Features of Programming Languages: The Case of Smalltalk.” In Proceedings of the 8th Working Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/1985441.1985448
Campanoni, Simone. 2011a. “Generating, Compiling and Executing Bytecode Programs.” In SpringerBriefs in Computer Science. Springer London. https://doi.org/10.1007/978-1-4471-2194-7_2
Campanoni, Simone. 2011b. “Intermediate Representation (IR).” In SpringerBriefs in Computer Science. Springer London. https://doi.org/10.1007/978-1-4471-2194-7_5
Campbell, Bruce M. S. 2023. “The Extent and Layout of Commonfields in Eastern Norfolk.” In Field Systems and Farming Systems in Late Medieval England. Routledge. https://doi.org/10.4324/9781003417538-2
Campos, Alvaro E., and David R. Hanson. 1994. “Garbage Collection in Distributed EZ.” In Computer Science 2. Springer US. https://doi.org/10.1007/978-1-4757-9805-0_21
Canales, Felipe, Geoffrey Hecht, and Alexandre Bergel. 2021. “Optimization of Java Virtual Machine Flags Using Feature Model and Genetic Algorithm.” In Companion of the ACM/SPEC International Conference on Performance Engineering. ACM. https://doi.org/10.1145/3447545.3451177
Cao, Xiaochun, Xingxing Wei, Xiaojie Guo, Yahong Han, and Jinhui Tang. 2014. “Augmented Image Retrieval Using Multi-Order Object Layout with Attributes.” In Proceedings of the 22nd ACM international conference on Multimedia. ACM. https://doi.org/10.1145/2647868.2654972
“Cap’n Proto: Introduction.” n.d. Cap’n Proto. Accessed October 24, 2026. https://capnproto.org/
Capon, P. C., and P. J. Jinks. 1988a. “Compiler Organisation.” In Compiler Engineering Using Pascal. Macmillan Education UK. https://doi.org/10.1007/978-1-349-10401-7_3
Capon, P. C., and P. J. Jinks. 1988b. “Introduction — What Is a Compiler?” In Compiler Engineering Using Pascal. Macmillan Education UK. https://doi.org/10.1007/978-1-349-10401-7_1
Capon, P. C., and P. J. Jinks. 1988c. “The P Compiler.” In Compiler Engineering Using Pascal. Macmillan Education UK. https://doi.org/10.1007/978-1-349-10401-7_4
Capotondi, Alessandro, and Andrea Marongiu. 2017. “Enabling Zero-Copy OpenMP Offloading on the PULP Many-Core Accelerator.” In Proceedings of the 20th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/3078659.3079071
Capretz, Luiz Fernando, and Venus Marza. 2009. “Improving Effort Estimation by Voting Software Estimation Models.” Advances in Software Engineering 2009: 1–8. https://doi.org/10.1155/2009/829725
Cardinale, Yudith C., Eduardo A. Blanco, and Jesus Oliveira. 2006. “JADIMA: Virtual Machine Architecture for Building JAVA Applications on Grid Platforms.” CLEI Electronic Journal 9 (2). https://doi.org/10.19153/cleiej.9.2.3
Cardone-Noott, Louie, Blanca Rodriguez, and Alfonso Bueno-Orovio. 2018. “Strategies of Data Layout and Cache Writing for Input-Output Optimization in High Performance Scientific Computing: Applications to the Forward Electrocardiographic Problem.” PLOS ONE 13 (8): e0202410. https://doi.org/10.1371/journal.pone.0202410
Carette, Jacques, Oleg Kiselyov, and Chung-Chieh Shan. 2009. “Finally Tagless, Partially Evaluated: Tagless Staged Interpreters for Simpler Typed Languages.” Journal of Functional Programming 19 (5): 509–43. https://doi.org/10.1017/s0956796809007205
Carlson, Travis, and Eric Van Wyk. 2019. “Building Parallel Programming Language Constructs in the AbleC Extensible C Compiler Framework: A PPoPP Tutorial.” In Proceedings of the 24th Symposium on Principles and Practice of Parallel Programming. ACM. https://doi.org/10.1145/3293883.3302574
Carlström, Jesper. 2005. “Interpreting Descriptions in Intensional Type Theory.” Journal of Symbolic Logic 70 (2): 488–514. https://doi.org/10.2178/jsl/1120224725
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
Carp, Sari, and Zur Shapira. 2016. “Heuristics and Biases and Strategic Decision-Making.” In The Palgrave Encyclopedia of Strategic Management. Palgrave Macmillan UK. https://doi.org/10.1057/978-1-349-94848-2_538-1
Carp, Sari, and Zur Shapira. 2018. “Heuristics and Biases and Strategic Decision-Making.” In The Palgrave Encyclopedia of Strategic Management. Palgrave Macmillan UK. https://doi.org/10.1057/978-1-137-00772-8_538
Carpenter, Chris. 2021. “Completion Design Evaluated by Use of Field Offset Well-Pressure Measurements.” Journal of Petroleum Technology 73 (04): 46–47. https://doi.org/10.2118/0421-0046-jpt
Carrera, David, Jonathan Rosales, and A. Gustavo. 2018. “Optimizing Binary Serialization with an Independent Data Definition Format.” International Journal of Computer Applications 180 (28): 15–18. https://doi.org/10.5120/ijca2018916670
Carrick-Hagenbarth, Jessica. 2017. “Conflict of Interest in Research.” In Encyclopedia of Business and Professional Ethics. Springer International Publishing. https://doi.org/10.1007/978-3-319-23514-1_45-1
Carrick-Hagenbarth, Jessica. 2023. “Conflict of Interest in Research.” In Encyclopedia of Business and Professional Ethics. Springer International Publishing. https://doi.org/10.1007/978-3-030-22767-8_45
Carrillo, Snaider, Jakob Siegel, and Xiaoming Li. 2009. “A Control-Structure Splitting Optimization for GPGPU.” In Proceedings of the 6th ACM conference on Computing frontiers. ACM. https://doi.org/10.1145/1531743.1531766
Carse, James P. 1967. “Mr. Locke’s Magic Onions and an Unboxed Beetle for Young Jonathan.” Journal of Religion 47 (4): 331–39. https://doi.org/10.1086/486074
Carvalho, João F. N., Bruno L. Sousa, Marcus R. Araújo, and Mariza A. S. Bigonha. 2017. “The Register Allocation and Instruction Scheduling Challenge.” In Proceedings of the 21st Brazilian Symposium on Programming Languages. ACM. https://doi.org/10.1145/3125374.3125380
Caserta, Pierre, and Olivier Zendra. 2011. “A Tracing Technique Using Dynamic Bytecode Instrumentation of Java Applications and Libraries at Basic Block Level.” In Proceedings of the 6th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems. ACM. https://doi.org/10.1145/2069172.2069178
Cassé, H., L. Féraud, C. Rochange, and P. Sainrat. 1999. “Using the Abstract Interpretation Technique for Static Pointer Analysis.” ACM SIGARCH Computer Architecture News 27 (1): 47–50. https://doi.org/10.1145/309758.309780
Cassiday, Laura. 2008. “Protein-Complex Characterization Goes Tagless.” Journal of Proteome Research 7 (5): 1805–1805. https://doi.org/10.1021/pr083700s
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
Cattell, R. G. 1977. A Survey and Critique of Some Models of Code Generation. Defense Technical Information Center. https://doi.org/10.21236/ada056027
Ceccato, Mariano, and Riccardo Scandariato. 2016. “Static Analysis and Penetration Testing from the Perspective of Maintenance Teams.” In Proceedings of the 10th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. ACM. https://doi.org/10.1145/2961111.2962611
Chabner, Bruce A., and Susan E. Bates. 2018. “Conflict of Interest: An Ethical Firestorm with Consequences for Cancer Research.” Oncologist 23 (12): 1391–93. https://doi.org/10.1634/theoncologist.2018-0662
Chadee, Aaron, Salisha R. Hernandez, and Hector Martin. 2021. “The Influence of Optimism Bias on Time and Cost on Construction Projects.” Emerging Science Journal 5 (4): 429–42. https://doi.org/10.28991/esj-2021-01287
Chahar, Vikas, and Pradeep Kumar Bhatia. 2024. “Selection of Effective Parameters for Optimizing Software Testing Effort Estimation.” In Applied Data Science and Smart Systems. CRC Press. https://doi.org/10.1201/9781003471059-12
Chai, Yunda, Mengyao Chen, Jianan Li, and Lin Han. 2021a. “Implementation and Optimization of Data Prefetching Algorithm Based on LLVM Compilation System.” Journal of Physics: Conference Series 1827 (1): 012136. https://doi.org/10.1088/1742-6596/1827/1/012136
Chaitanya More. 2016. “Efficient Garbage Collection Using WSN.” International Journal of Research in Engineering and Technology 05 (01): 150–51. https://doi.org/10.15623/ijret.2016.0501029
Chakravarty, Manuel M. T. 1995. “Integrating Multithreading into the Spineless Tagless G-Machine.” In Electronic Workshops in Computing. BCS Learning & Development. https://doi.org/10.14236/ewic/fp1995.3
Chalin, Patrice. 2007. “Are the Logical Foundations of Verifying Compiler Prototypes Matching User Expectations?” Formal Aspects of Computing 19 (2): 139–58. https://doi.org/10.1007/s00165-006-0016-1
Chamberlain, Peter. 2014. “Unboxing 2.0 (UBII): A Tool for Package Experience Analysis.” International Journal of Designed Objects 7 (3): 1–9. https://doi.org/10.18848/2325-1379/cgp/v07i03/38681
Chan, Joyce Y. C., P. C. Ching, and Tan Lee. 2005. “Development of a Cantonese-English Code-Mixing Speech Corpus.” In Interspeech 2005. ISCA. https://doi.org/10.21437/interspeech.2005-450
Chandra, Vishal. 2014. “Software Effort Estimation: A Fuzzy Logic Approach.” International Journal of Computer Applications 103 (9): 39–43. https://doi.org/10.5120/18106-9210
Chang, Jin Hee. 2023. “A Study on the Policy Process of the Conflict of Interest Prevention Act.” Korea Association for Corruption Studies 28 (1): 123–44. https://doi.org/10.52663/kcsr.2023.28.1.123
Chapa, Silvia. 2018. “Code Obfuscation Study Using Obfuscator-LLVM.” McNair Scholars Research Journal 22 (1). https://doi.org/10.32855/2642-2492.1106
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
“Chapter 3 Ready to Profit: Inadequate Garbage Collection by Corrupt Regimes.” 2023. In The Politics of Trash. Cornell University Press. https://doi.org/10.1515/9781501766992-005
“Chapter 4 Picking up Trash: Adequate Garbage Collection by Corrupt Regimes.” 2023. In The Politics of Trash. Cornell University Press. https://doi.org/10.1515/9781501766992-006
“Chapter 7 the Politics of Garbage Collection: Lessons Learned.” 2023. In The Politics of Trash. Cornell University Press. https://doi.org/10.1515/9781501766992-009
Charmanas, Konstantinos, Nikolaos Mittas, and Lefteris Angelis. 2020. “Ensemble Software Development Effort Estimation Using Data Envelopment Analysis.” In 24th Pan-Hellenic Conference on Informatics. ACM. https://doi.org/10.1145/3437120.3437307
Charoenwet, Wachiraphan, Patanamon Thongtanunam, Van-Thuan Pham, and Christoph Treude. 2024. “An Empirical Study of Static Analysis Tools for Secure Code Review.” In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3650212.3680313
Chatzikyriakidis, Stergios, and Zhaohui Luo. 2014. “Natural Language Reasoning Using Proof-Assistant Technology: Rich Typing and Beyond.” In Proceedings of the EACL 2014 Workshop on Type Theory and Natural Language Semantics (TTNLS). Association for Computational Linguistics. https://doi.org/10.3115/v1/w14-1405
Chavan, Anand, Byoung Woo Min, and Shiu-Kai Chin. 2001. HOL2GDT a Formal Verification-Based Design Methodology. Defense Technical Information Center. https://doi.org/10.21236/ada387742
Chavoya, Arturo, Cuauhtemoc Lopez-Martin, and M. E. Meda-Campaña. 2013. “Software Development Effort Estimation by Means of Genetic Programming.” International Journal of Advanced Computer Science and Applications 4 (11). https://doi.org/10.14569/ijacsa.2013.041115
Chawla, Harleen, Tejas Sharma, Prarthna Agrawal, and Naman Lakhotia. 2025. “Luxury Unboxed: How Gender, Identity & Screens Shape What We Flaunt.” International Journal For Multidisciplinary Research 7 (3): 47433. https://doi.org/10.36948/ijfmr.2025.v07i03.47433
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
Chemuturi, Murali. 2012. “Effort Estimation for Software Projects.” In The IFPUG Guide to IT and Software Measurement. Auerbach Publications. https://doi.org/10.1201/b11884-10
Chen, Hui. 2005. “A Tag Type for Certifying Compilation of Java Program.” Journal of Software 16 (3): 346. https://doi.org/10.1360/jos160346
Chen, Hui. 2006. “A Typed Low-Level Language Used in Java Virtual Machine.” Journal of Computer Research and Development 43 (1): 15. https://doi.org/10.1360/crad20060103
Chen, Juan. 2009b. “A Typed Intermediate Language for Supporting Interfaces.” In Proceedings of the 11th International Workshop on Formal Techniques for Java-like Programs. ACM. https://doi.org/10.1145/1557898.1557899
Chen, Yu-Li. 2014. “Virtual Reality Software Usage in an EFL Scenario: An Empirical Study.” Journal of Software 9 (2). https://doi.org/10.4304/jsw.9.2.374-381
Chen, Xi. 2018. “Formal Verification of Helicopter Automatic Landing Control Algorithm in Theorem Prover Coq.” International Journal of Performability Engineering. https://doi.org/10.23940/ijpe.18.09.p2.19471957
Chen, Xinghan. 2025a. “Agentic AI Serverless Code Generation: Towards Autonomous Improvement of Performance, Cost, and Code Quality.” In Proceedings of the 26th International Middleware Conference. ACM. https://doi.org/10.1145/3721464.3777437
Chen, Hengzhen. 2025b. “Semantic Preservation and Stylistic Decoupling in Textual Style Migration.” IET Conference Proceedings 2024 (19): 192–201. https://doi.org/10.1049/icp.2024.3982
Chen, Yizi, Dominic D. Ahiaga-Dagbui, Muhammad Jamaluddin Thaheem, and Asheem Shrestha. 2023b. “Toward a Deeper Understanding of Optimism Bias and Transport Project Cost Overrun.” Project Management Journal 54 (5): 561–78. https://doi.org/10.1177/87569728231180268
Chen, J. S. J., and D. Y. Chen. 1987. “A Design Rule Independent Cell Compiler.” In 24th ACM/IEEE conference proceedings on Design automation conference - DAC ‘87. ACM Press. https://doi.org/10.1145/37888.37957
Chen, Kung, and Ju-Bing Chen. 2006. “On Instrumenting Obfuscated Java Bytecode with Aspects.” In Proceedings of the 2006 international workshop on Software engineering for secure systems. ACM. https://doi.org/10.1145/1137627.1137632
Chen, Junjie, Xingyu Fan, Chen Yang, Shuang Liu, and Jun Sun. 2025b. “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, Shyh-Kwei, W. K. Fuchs, and Wen-Mei W. Hwu. 1993. The Application of Compiler-Assisted Multiple Instruction Retry to VLIW Architectures. Defense Technical Information Center. https://doi.org/10.21236/ada266930
Chen, Shyh-Kwei, W. K. Fuchs, and Wen-Mei W. Hwu. 1994. The Application of Compiler-Assisted Multiple Instruction Retry to VLIW Architectures. Defense Technical Information Center. https://doi.org/10.21236/ada281648
Chen, Tianyi, Kihong Heo, and Mukund Raghothaman. 2021a. “Boosting Static Analysis Accuracy with Instrumented Test Executions.” In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3468264.3468626
Chen, Shiyan, and Dagang Li. 2018. “Efficient Zero-Copy Mechanism for Intelligent Video Surveillance Networks.” MATEC Web of Conferences 189: 03021. https://doi.org/10.1051/matecconf/201818903021
Chen, Liqian, Renjian Li, Xueguang Wu, and Ji Wang. 2013a. “Static Analysis of List-Manipulating Programs via Bit-Vectors and Numerical Abstractions.” In Proceedings of the 28th Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/2480362.2480589
Chen, Wei-Yu, Guei-Yuan Lueh, Pratik Ashar, Kaiyu Chen, and Buqi Cheng. 2018b. “Register Allocation for Intel Processor Graphics.” In Proceedings of the 2018 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3168806
Chen, Gang, and Michael D. Smith. 1999. “Reorganizing Global Schedules for Register Allocation.” In Proceedings of the 13th international conference on Supercomputing. ACM. https://doi.org/10.1145/305138.305224
Chen, Kai, Purui Su, Yingjun Zhang, and Dengguo Feng. 2007. “SEPCOM: Customizable Zero Copy Model.” In Proceedings of the 2nd International ICST Conference on Performance Evaluation Methodologies and Tools. ICST. https://doi.org/10.4108/valuetools.2007.1927
Chen, Jolly, Ana Lucia Varbanescu, and Axel Naumann. 2025e. “Optimizing Memory Access Patterns through Automatic Data Layout Transformation (Work in Progress Paper).” In Companion of the 16th ACM/SPEC International Conference on Performance Engineering. ACM. https://doi.org/10.1145/3680256.3722203
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
Chen, Mengyao, Pengyan Yan, Lin Han, Haoran Li, and Cuixia Wang. 2025g. “Research on Optimization Techniques for Thread-Level Parallelism Implementation Targeting the GCC Compiler.” In Fifth International Conference on Signal Processing and Computer Science (SPCS 2024), edited by Haiquan Zhao, Lei Chen. SPIE. https://doi.org/10.1117/12.3054338
Chen, Fang Yuan, Dong Song Zhang, and Zhi Ying Wang. 2012. “Static Analysis of Run-Time Inter-Core Interferences for Concurrent Programs in Shared Cache Multicore Architectures.” Applied Mechanics and Materials 198-199: 523–27. https://doi.org/10.4028/www.scientific.net/amm.198-199.523
Chen, Zhe, and Yuelong Zhao. 2020. “DA-GC: A Dynamic Adjustment Garbage Collection Method Considering Wear-Leveling for SSD.” In Proceedings of the 2020 on Great Lakes Symposium on VLSI. ACM. https://doi.org/10.1145/3386263.3406943
Chen, Yanhua, and Xinghua Zheng. 2022. “Research and Practice of JAVA Virtual Machine Exception Handling Mechanism Testing Technology.” In International Conference on Cloud Computing, Internet of Things, and Computer Applications (CICA 2022), edited by Warwick Powell, Amr Tolba. SPIE. https://doi.org/10.1117/12.2642661
Chen, Sihao, Wanqing Zhu, Xianyi Yang, Menghan Li, and Heng Wang. 2022b. “Urban Domestic Garbage Collection and Transportation Scheduling under the Background of Garbage Classification.” In International Conference on Smart Transportation and City Engineering (STCE 2022), edited by Miroslava Mikusova. SPIE. https://doi.org/10.1117/12.2657922
Cheong, Hoichi. 1992. “Life Span Strategy—a Compiler-Based Approach to Cache Coherence.” In Proceedings of the 6th international conference on Supercomputing - ICS ‘92. ACM Press. https://doi.org/10.1145/143369.143402
Chien, Ting-Hsuan, Chia-Jung Chen, and Rong-Guey Chang. 2014. “An Adaptive Zero-Copy Strategy for Ubiquitous High Performance Computing.” In Proceedings of the 21st European MPI Users’ Group Meeting. ACM. https://doi.org/10.1145/2642769.2642796
Chien, Andrew, Vijay Karamcheti, John Plevyak, and Deepak Sahrawat. 1993. “The Concert System: Compiler and Runtime Technology for Efficient Concurrent Object-Oriented Programming.” In 9th Computing in Aerospace Conference. AIAA 1993-4505. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.1993-4505
Chilimbi, Trishul, Richard Jones, and Benjamin Zorn. 2000. “Designing a Trace Format for Heap Allocation Events.” In Proceedings of the 2nd international symposium on Memory management. ACM. https://doi.org/10.1145/362422.362435
Chin, Wen-Long. 2022. “Logic Synthesis with Design Compiler.” In Principles of Verilog Digital Design. CRC Press. https://doi.org/10.1201/9781003187196-10
Ching, Wai-Mee. 1986. “An APL/370 Compiler and Some Performance Comparisons with APL Interpreter and FORTRAN.” ACM SIGAPL APL Quote Quad 16 (4): 143–47. https://doi.org/10.1145/22008.22029
Chinthanet, Bodin, Passakorn Phannachitta, Yasutaka Kamei, et al. 2016. “A Review and Comparison of Methods for Determining the Best Analogies in Analogy-Based Software Effort Estimation.” In Proceedings of the 31st Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/2851613.2851974
Chishaki, Takeshi, Hao-Hsi Tseng, Hiroshi Tatsumi, and Wen-Chin Huang. 1995. “Approximately Optimal Schedule Procedure of Project under Fuzzy Activities Duration and Fuzzy Cost Estimation.” Journal of Construction Management, JSCE 3: 151–62. https://doi.org/10.2208/procm.3.151
Choi, Kiho, Seongseop Kim, Moon Gi Seok, Jeonghun Cho, and Daejin Park. 2017. “Maximum Stack Memory Monitoring Method Assisted by Static Analysis of the Stack Usage Profile.” In Lecture Notes in Electrical Engineering. Springer Singapore. https://doi.org/10.1007/978-981-10-7605-3_121
Choi, Yoon-Ho, and Jaechang Nam. 2022. “On the Naturalness of Bytecode Instructions.” In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering. ACM. https://doi.org/10.1145/3551349.3559559
Choi, Jin Won, and Jae Wan Park. 2003. “Developing a Building Design Compiler That Frequently Evaluates Building Design Performance within the Design Process.” In CAADRIA proceedings. CAADRIA. https://doi.org/10.52842/conf.caadria.2003.553
Choi, Lynn, and Pen Chung Yew. 1994. “A Compiler-Directed Cache Coherence Scheme with Improved Intertask Locality.” In Proceedings of the 1994 ACM/IEEE conference on Supercomputing - Supercomputing ‘94. ACM Press. https://doi.org/10.1145/602892.602895
Choi, Lynn, and Pen-Chung Yew. 1996. “Compiler and Hardware Support for Cache Coherence in Large-Scale Multiprocessors: Design Considerations and Performance Study.” ACM SIGARCH Computer Architecture News 24 (2): 283–94. https://doi.org/10.1145/232974.233002
Chorafas, Dimitris N. 2009. “The G-20 Conference, Central Banks, and Garbage Collection.” In Capitalism Without Capital. Palgrave Macmillan UK. https://doi.org/10.1057/9780230251021_9
Choudhari, Jitender, and Ugrasen Suman. 2012a. “Phase Wise Effort Estimation for Software Maintenance: An Extended SMEEM Model.” In Proceedings of the CUBE International Information Technology Conference. ACM. https://doi.org/10.1145/2381716.2381790
Chow, Fred. 2013. “Intermediate Representation: The Increasing Significance of Intermediate Representations in Compilers.” Queue 11 (10): 30–37. https://doi.org/10.1145/2542661.2544374
Christodorescu, Mihai, and Somesh Jha. 2006. Static Analysis of Executables to Detect Malicious Patterns. Defense Technical Information Center. https://doi.org/10.21236/ada449067
Chu, Geoffrey, Aaron Harwood, and Peter J. Stuckey. 2009. “Cache Conscious Data Structures for Boolean Satisfiability Solvers.” Journal on Satisfiability, Boolean Modeling and Computation 6 (1–3): 99–120. https://doi.org/10.3233/sat190064
Ciaschini, Vincenzo, and Roberto Gorrieri. 2004. “Contrasting Malicious Applets by Modifying the Java Virtual Machine.” In Security and Protection in Information Processing Systems. Springer US. https://doi.org/10.1007/1-4020-8143-x_4
Cieliebak, Mark, Jan Milan Deriu, Dominic Egger, and Fatih Uzdilli. 2017. “A Twitter Corpus and Benchmark Resources for German Sentiment Analysis.” In Proceedings of the Fifth International Workshop on Natural Language Processing for Social Media. Association for Computational Linguistics. https://doi.org/10.18653/v1/w17-1106
Cieslewicz, John, William Mee, and Kenneth A. Ross. 2009. “Cache-Conscious Buffering for Database Operators with State.” In Proceedings of the Fifth International Workshop on Data Management on New Hardware. ACM. https://doi.org/10.1145/1565694.1565704
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
Ciprich Nikola. 2012. “Using LLVM for a Functional Programming Language Implementation.” In Frontiers in Artificial Intelligence and Applications. IOS Press. https://doi.org/10.3233/978-1-60750-992-9-362
Ciraci, Selim, and Oreste Villa. 2013. “Exploiting Points-to Maps for De-/Serialization Code Generation.” In Proceedings of the 28th Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/2480362.2480686
Clare, M., S. Thomas, M. Cartigny, and M. Mansour. 2015. “Turbidity Current Hazard Assessment for Field Layout Planning.” In Frontiers in Offshore Geotechnics III. CRC Press. https://doi.org/10.1201/b18442-137
Clauss, Philippe, and Benoît Meister. 2000. “Automatic Memory Layout Transformations to Optimize Spatial Locality in Parameterized Loop Nests.” ACM SIGARCH Computer Architecture News 28 (1): 11–19. https://doi.org/10.1145/346023.346031
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
Cnockaert-Guillou, Nina. 2025. “Textual Structure, Dialogue and the Layout of the Manuscripts of Acallam Na Senórach.” Studia Celtica Fennica 20: 125–46. https://doi.org/10.33353/scf.147011
Coblenz, Michael, Michelle L. Mazurek, and Michael Hicks. 2022. “Garbage Collection Makes Rust Easier to Use: A Randomized Controlled Trial of the Bronze Garbage Collector.” In Proceedings of the 44th International Conference on Software Engineering. ACM. https://doi.org/10.1145/3510003.3510107
Cockx, Jesper, and Dominique Devriese. 2018. “Proof-Relevant Unification: Dependent Pattern Matching with Only the Axioms of Your Type Theory.” Journal of Functional Programming 28: e12. https://doi.org/10.1017/s095679681800014x
“Code Generation.” 1987. In Program Construction. Cambridge University Press. https://doi.org/10.1017/cbo9781139171847.007
“Code Generation.” 1992. In Two-Level Functional Languages. Cambridge University Press. https://doi.org/10.1017/cbo9780511526572.007
“Code Generation for Mercury.” 1995. In Logic Programming. The MIT Press. https://doi.org/10.7551/mitpress/4301.003.0029
Coelho, Evita, and Anirban Basu. 2012. “Effort Estimation in Agile Software Development Using Story Points.” International Journal of Applied Information Systems 3 (7): 7–10. https://doi.org/10.5120/ijais12-450574
Coglio, Alessandro. 2005. “Checking Access to Protected Members in the Java Virtual Machine.” Journal of Object Technology 4 (8): 55. https://doi.org/10.5381/jot.2005.4.8.a3
Cohen, Albert. 2013. “Parallelizing and Optimizing Compilation for Synchronous Languages: New Directions for High-Performance Embedded Systems.” In Proceedings of the 10th Workshop on Optimizations for DSP and Embedded Systems. ACM. https://doi.org/10.1145/2443608.2443609
Collins, Kathleen M. 2024. “Research and Policy: Unboxing Difference: Cultivating Inclusive Literacy Classrooms Informed by Disability Studies.” Language Arts 101 (3): 205–13. https://doi.org/10.58680/la202432768
Collis, I. P. 1952. “The Ideal Layout of a Local Record Repository.” Archives: The Journal of the British Records Association 1 (7): 52–60. https://doi.org/10.3828/archives.1952.13
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
Colonna, Pasquale, Nicola Berloco, Paolo Intini, Antonio Perruccio, and Vittorio Ranieri. 2016. “Evaluating Skidding Risk of a Road Layout for All Types of Vehicles.” Transportation Research Record: Journal of the Transportation Research Board 2591 (1): 94–102. https://doi.org/10.3141/2591-11
Comar, Cyrille, Gary Dismukes, and Franco Gasperoni. 1997. “Targeting GNAT to the Java Virtual Machine.” In Proceedings of the conference on TRI-Ada ‘97 - TRI-Ada ‘97. ACM Press. https://doi.org/10.1145/269629.269646
“Comparative Analysis of Software Cost Estimation Methods.” 2020. Journal of Xidian University 14 (4). https://doi.org/10.37896/jxu14.4/155
“Comparing Garbage Collectors.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-7
“Compilatio, Physical Layout, and Decoration: Touchstones.” 1995. In Rereading Middle English Romance. McGill-Queen’s University Press. https://doi.org/10.1515/9780773565067-005
“The Compiler Backend: Bytecode and Native Code.” 2022. In Real World OCaml: Functional Programming for the Masses. Cambridge University Press. https://doi.org/10.1017/9781009129220.031
“Compiler Design in C.” 1990. Choice Reviews Online 28 (02): 28-0998-28-0998. https://doi.org/10.5860/choice.28-0998
“Compiler Design: Analysis and Transformation.” 2013. Choice Reviews Online 50 (10): 50-5637-50-5637. https://doi.org/10.5860/choice.50-5637
“Compiler Design: Virtual Machines.” 2011. Choice Reviews Online 48 (11): 48-6333-48-6333. https://doi.org/10.5860/choice.48-6333
“Concurrent Garbage Collection.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-16
Connor, R. C. H., Q. I. Cutts, G. N. C. Kirby, and R. Morrison. 1994. “Using Persistence Technology to Control Schema Evolution.” In Proceedings of the 1994 ACM symposium on Applied computing - SAC ‘94. ACM Press. https://doi.org/10.1145/326619.326805
Connor, Richard, Quintin Cutts, Graham Kirby, and Ron Morrison. 2000. “Using Persistence Technology to Control Schema Evolution.” In Fully Integrated Data Environments. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-59623-0_43
Constable, Robert L. 2002. “Naïve Computational Type Theory.” In Proof and System-Reliability. Springer Netherlands. https://doi.org/10.1007/978-94-010-0413-8_7
“A Constraint-Based Object Layout System.” 1989. In Visualizing Abstract Objects and Relations. WORLD SCIENTIFIC. https://doi.org/10.1142/9789814434478_0004
Conte, S. D., H. E. Dunsmore, and V. Y. Shen. 1984. Programming Effort Estimation. Defense Technical Information Center. https://doi.org/10.21236/ada145839
Conte, S. D., H. E. Dunsmore, and V. Y. Shen. 1985. “Software Effort Estimation and Productivity.” In Advances in Computers. Elsevier. https://doi.org/10.1016/s0065-2458(08)60364-2
Cook, J. V. 1990. The Language for DENOTE (Denotational Semantics Translation Environment). Defense Technical Information Center. https://doi.org/10.21236/ada237144
Cook, Laetitia, and Chris Cloete. 2023. “Heuristics and Biases Uncovered during the Digitalisation Decision-Making Process in the Property Sector.” In AHFE International. AHFE International. https://doi.org/10.54941/ahfe1003886
Cook, W., and J. Palsberg. 1989. “A Denotational Semantics of Inheritance and Its Correctness.” In Conference proceedings on Object-oriented programming systems, languages and applications. ACM. https://doi.org/10.1145/74877.74922
Cooper, D. C. 1976. “The Design of an Optimizing Compiler.” Computer Journal 19 (2): 150–150. https://doi.org/10.1093/comjnl/19.2.150-a
Cooper, Keith D., and Linda Torczon. 2012. “Instruction Selection.” In Engineering a Compiler. Elsevier. https://doi.org/10.1016/b978-0-12-088478-0.00011-6
Cooper, Keith D., and Linda Torczon. 2023a. “Instruction Selection.” In Engineering a Compiler. Elsevier. https://doi.org/10.1016/b978-0-12-815412-0.00017-6
Cooper, Keith D., and Linda Torczon. 2023b. “Register Allocation.” In Engineering a Compiler. Elsevier. https://doi.org/10.1016/b978-0-12-815412-0.00019-x
Cooper, Keith D., and Li Xu. 2002. “An Efficient Static Analysis Algorithm to Detect Redundant Memory Operations.” In Proceedings of the 2002 workshop on Memory system performance. ACM. https://doi.org/10.1145/773146.773049
“Copying Garbage Collection.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-5
Corporaal, Henk, and Jan Hoogerbrugge. 2002. “Code Generation for Transport Triggered Architectures.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_14
Correia, Luis Cláudio, and João de Deus Barreto Segundo. 2019. “On Presenting Evidence and Unboxing Science.” Journal of Evidence-Based Healthcare 1 (1): 5–7. https://doi.org/10.17267/2675-021xevidence.v1i1.2362
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
Cosmina, Iuliana. 2021. “Garbage Collection.” In Java 17 for Absolute Beginners. Apress. https://doi.org/10.1007/978-1-4842-7080-6_13
Cosmina, Iuliana. 2024. “Garbage Collection.” In Java 23 for Absolute Beginners. Apress. https://doi.org/10.1007/979-8-8688-1041-1_13
“Cost Estimation in Product Development.” 2008. In Series on Manufacturing Systems and Technology. WORLD SCIENTIFIC. https://doi.org/10.1142/9789812832634_0006
Courts, Robert. 1988. “Improving Locality of Reference in a Garbage-Collecting Memory Management System.” Communications of the ACM 31 (9): 1128–38. https://doi.org/10.1145/48529.48536
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
Cox, Anthony D., and John O. Summers. 1987. “Heuristics and Biases in the Intuitive Projection of Retail Sales.” Journal of Marketing Research 24 (3): 290. https://doi.org/10.2307/3151639
Craig, Iain. 1989. “Cost Estimation for Software Development by Bernard Londeix, Addison-Wesley, Wokingham, UK, 1987, 214pages (Incl. Index) (£16.95).” Robotica 7 (1): 85–85. https://doi.org/10.1017/s0263574700005221
Crary, K. 1998. “Programming Language Semantics in Foundational Type Theory.” In Programming Concepts and Methods PROCOMET ’98. Springer US. https://doi.org/10.1007/978-0-387-35358-6_11
“Create a Codasyl Data Definition Language Compiler.” 1986. In An Introduction to Data Base Design. Elsevier. https://doi.org/10.1016/b978-0-12-616870-9.50015-0
Crespo, Luis, Alberto Ramos, Francisco Ramos, and Diego Crespo. 2018. “Revisiting Field Layout Designs for Large STE Tower Plants.” In AIP Conference Proceedings, vol. 2033. Author(s). https://doi.org/10.1063/1.5067047
Cristia, Maximiliano, and Claudia Frydman. 2015. “Formal and Semi-Formal Verification of a Web Voting System.” International Journal of Web Information Systems 11 (2): 183–204. https://doi.org/10.1108/ijwis-11-2014-0042
Crosthwaite, Peter. 2026. “CorpusMate 2.0: Integrating AI-Powered Language Analysis into a Data-Driven Learning Corpus Tool.” Artificial Intelligence in Language Education 2: 104826. https://doi.org/10.29140/aile.2026.104826
Crowcroft, J., and T. Deegan. 2005. “Optimising Data Layout for Delay-Line Memory.” Electronics Letters 41 (6): 358–59. https://doi.org/10.1049/el:20057462
Cuelenaere, A. M. E., M. J. I. M. van Genuchten, and Fj Heemstra. 1991. “Calibrating a Software Cost-Estimation Model: Why and How.” In The Economics of Information Systems and Software. Elsevier. https://doi.org/10.1016/b978-0-7506-1122-0.50015-4
Cui, Tianming, Pen-Chung Yew, Stephen McCamant, and Antonia Zhai. 2025a. “DeCOS: Data-Efficient Reinforcement Learning for Compiler Optimization Selection Ignited by LLM.” In Proceedings of the 39th ACM International Conference on Supercomputing. ACM. https://doi.org/10.1145/3721145.3725765
Cui, Baojiang, Qi Zhao, and Tianyu Liu. 2017. “Study on Android Native Layer Code Protection Based on Improved O-LLVM.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-319-61542-4_26
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
Curino, Carlo A., Hyun J. Moon, and Carlo Zaniolo. 2008. “Graceful Database Schema Evolution: The PRISM Workbench.” Proceedings of the VLDB Endowment 1 (1): 761–72. https://doi.org/10.14778/1453856.1453939
Curino, Carlo, Hyun J. Moon, and Carlo Zaniolo. 2009a. “Automating Database Schema Evolution in Information System Upgrades.” In Proceedings of the 2nd International Workshop on Hot Topics in Software Upgrades. ACM. https://doi.org/10.1145/1656437.1656444
Curtotti, Michael, and Eric C. McCreath. 2011b. “A Corpus of Australian Contract Language: Description, Profiling and Analysis.” In Proceedings of the 13th International Conference on Artificial Intelligence and Law. ACM. https://doi.org/10.1145/2018358.2018387
Curzon, Paul. 1993. “Compiler Correctness and Input/Output.” In Dependable Computing and Fault-Tolerant Systems. Springer Vienna. https://doi.org/10.1007/978-3-7091-4009-3_8
Cuzzocrea, Alfredo. 2025. “Combining Columnar-OLAP and Apache Hive for Speeding-Up Multidimensional Big Data Analytics Tools.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-96-3352-4_15
Czarnacka-Chrobot, Beata. 2012. “Rational Cost Estimation of Dedicated Software Systems.” Journal of Software Engineering and Applications 05 (04): 262–69. https://doi.org/10.4236/jsea.2012.54031
D’Avenia, Samuele, Eliana Di Palma, Marta Marchiori Manerba, and Valerio Basile. 2026. “HurtLens: A Perspectivist Corpus Analysis of Hurtful Language.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/483mhsjprvmo
D’Elia, Daniele Cono, and Camil Demetrescu. 2016. “Flexible on-Stack Replacement in LLVM.” In Proceedings of the 2016 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/2854038.2854061
D’Ursi, Antonio Castaldo, Luca Cavallaro, and Mattia Monga. 2007. “On Bytecode Slicing and aspectJ Interferences.” In Proceedings of the 6th workshop on Foundations of aspect-oriented languages. ACM. https://doi.org/10.1145/1233833.1233839
Dahdouh, Marwa, Mouhamad Ayman, Souheil Khawatmi, and Amer Bouchi. 2019. “Design an Optimized Compiler to Enhance Performance of Android Applications.” International Journal of Computer Applications 177 (24): 42–50. https://doi.org/10.5120/ijca2019919709
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
Dalieva, Madina. 2024. “Methods, Challenges, and Ethical Considerations in Data Collection of Corpus Compilation.” Innovative Technologica: Methodical Research Journal 3 (3). https://doi.org/10.47134/innovative.v3i3.122
Daly, Charles, Jane Horgan, James Power, and John Waldron. 2001. “Platform Independent Dynamic Java Virtual Machine Analysis: The Java Grande Forum Benchmark Suite.” In Proceedings of the 2001 joint ACM-ISCOPE conference on Java Grande. ACM. https://doi.org/10.1145/376656.376826
Dantas, Emanuel, Alexandre Costa, Marcus Vinicius, Mirko Perkusich, Hyggo Almeida, and Angelo Perkusich. 2019. “An Effort Estimation Support Tool for Agile Software Development: An Empirical Evaluation.” In International Conferences on Software Engineering and Knowledge Engineering, vol. 2019. KSI Research Inc. and Knowledge Systems Institute Graduate School. https://doi.org/10.18293/seke2019-141
Dantas, Emanuel, Mirko Perkusich, Ednaldo Dilorenzo, Danilo F. S. Santos, Hyggo Almeida, and Angelo Perkusich. 2018a. “Effort Estimation in Agile Software Development: An Updated Review.” International Journal of Software Engineering and Knowledge Engineering 28 (11n12): 1811–31. https://doi.org/10.1142/s0218194018400302
Darquier, Tomás, and Pablo Alejandro Virgolini. 2024. “Prototyping and Validation of a Low-Code Platform for Dynamic Code Generation in Microservices.” EthAIca 3: 132. https://doi.org/10.56294/ai2024132
Dasare, Ashwini, Pradyoth Hegde, Supritha Shetty, and K. T. Deepak. 2023. “The Role of Formant and Excitation Source Features in Perceived Naturalness of Low Resource Tribal Language TTS: An Empirical Study.” In Interspeech 2023. ISCA. https://doi.org/10.21437/interspeech.2023-1644
Dasgupta, Pallab. 2015. “A Logical Perspective of Formal Verification: A Narrative on the Genesis and Evolution of the Formal Verification Group at IIT Kharagpur.” In The Mind of an Engineer. Springer Singapore. https://doi.org/10.1007/978-981-10-0119-2_49
Dash, Sanket Sunand, Rama Shankar Yadav, Monika Gupta, and Poonam Rathi. 2019. “Kooda Collection Ltd: Systematic Garbage Collection in India.” Emerging Economies Cases Journal 1 (1–2): 27–32. https://doi.org/10.1177/2516604219892080
Dashti, Maedeh, and Taghi Javdani Gandomani. 2022. “A Taxonomy of Approaches and Methods for Software Effort Estimation.” In Lecture Notes in Networks and Systems. Springer Singapore. https://doi.org/10.1007/978-981-16-8987-1_11
“Data Compiler.” 2024. In Encyclopedia of Computer Graphics and Games. Springer International Publishing. https://doi.org/10.1007/978-3-031-23161-2_300302
“Data Serialization with S-Expressions.” 2022. In Real World OCaml: Functional Programming for the Masses. Cambridge University Press. https://doi.org/10.1017/9781009129220.024
“Dataflow Analysis.” 1997. In Modern Compiler Implementation in ML. Cambridge University Press. https://doi.org/10.1017/cbo9780511811449.018
“Dataflow Analysis.” 2002. In Modern Compiler Implementation in Java. Cambridge University Press. https://doi.org/10.1017/cbo9780511811432.018
Date, Toshihiko. 1995. “Sound Field Offset Device.” Journal of the Acoustical Society of America 97 (5): 3219–3219. https://doi.org/10.1121/1.411797
Daum, Berthold. 2003. “Schema Evolution.” In Modeling Business Objects with XML Schema. Elsevier. https://doi.org/10.1016/b978-155860816-0/50014-8
Dausmann, Manfred, Guido Persch, and Georg Winterstein. 1980. “LIS as Object Code for an ADA-O-Compiler.” In Informatik-Fachberichte. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-67600-0_8
Dave, Maulik A. 2003. “Compiler Verification: A Bibliography.” ACM SIGSOFT Software Engineering Notes 28 (6): 2–2. https://doi.org/10.1145/966221.966235
Dave, Avani. 2021. “FVCARE: Formal Verification of Security Primitives in Resilient Embedded SoCs.” International Journal of Science and Research (IJSR) 10 (12): 1503–12. https://doi.org/10.21275/sr24628131028
Dave, Vachik S., and Kamlesh Dutta. 2011a. “Comparison of Regression Model, Feed-Forward Neural Network and Radial Basis Neural Network for Software Development Effort Estimation.” ACM SIGSOFT Software Engineering Notes 36 (5): 1–5. https://doi.org/10.1145/2020976.2020982
Davidson, Steven A. 1992a. Detailed Example of Using ACEC Release 3.0 with the DEC VAX Ada Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada267880
Davidson, Stephen A. 1992b. A Step-by-Step Guide for Producing ACEC Reports Using the DEC VAX ADA Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada251915
Davies, D. Julia. M. 1984. “Memory Occupancy Patterns in Garbage Collection Systems.” Communications of the ACM 27 (8): 819–25. https://doi.org/10.1145/358198.358226
Davis, Michael. 2012. “Empirical Research on Conflict of Interest: A Critical Look.” In Conflict of Interest in Global, Public and Corporate Governance. Cambridge University Press. https://doi.org/10.1017/cbo9781139248945.005
De Andrés Suárez, Javier, Daniel Fernández-Lanvin, and Pedro Lorca. 2015. “Cost Estimation in Software Engineering Projects with Web Components Development.” DYNA 82 (192): 266–75. https://doi.org/10.15446/dyna.v82n192.43366
de Groot, W. Herman. 1991. “Plant Location, Layout, Building Structure, Plant Documentation.” In Sulphonation Technology in the Detergent Industry. Springer Netherlands. https://doi.org/10.1007/978-94-015-7918-6_10
de la Torre, Juan Carlos, Javier Jareño, José Miguel Aragón-Jurado, Sébastien Varrette, and Bernabé Dorronsoro. 2024. “Source Code Obfuscation with Genetic Algorithms Using LLVM Code Optimizations.” Logic Journal of the IGPL 33 (5): jzae069. https://doi.org/10.1093/jigpal/jzae069
De Lucia, Andrea, Eugenio Pompella, and Silvio Stefanucci. 2002. “Effort Estimation for Corrective Software Maintenance.” In Proceedings of the 14th international conference on Software engineering and knowledge engineering. ACM. https://doi.org/10.1145/568760.568831
De Paula, Everton G., and Michael L. Nelson. 1991. Clustering, Concurrency Control, Crash Recovery, Garbage Collection, and Security in Object-Oriented Database Management Systems. Defense Technical Information Center. https://doi.org/10.21236/ada235448
de Putter, Sander, and Anton Wijs. 2018. “A Formal Verification Technique for Behavioural Model-to-Model Transformations.” Formal Aspects of Computing 30 (1): 3–43. https://doi.org/10.1007/s00165-017-0437-z
Debbabi, Mourad, Abdelouahed Gherbi, Lamia Ketari, et al. 2005. “E-Bunny: A Dynamic Compiler for Embedded Java Virtual Machines.” Journal of Object Technology 4 (1): 83. https://doi.org/10.5381/jot.2005.4.1.a2
Debray, Saumya. 2002. “Making Compiler Design Relevant for Students Who Will (Most Likely) Never Design a Compiler.” ACM SIGCSE Bulletin 34 (1): 341–45. https://doi.org/10.1145/563517.563473
“Decisions, Heuristics and Biases.” 2015. In Attitudes and Decisions. Psychology Press. https://doi.org/10.4324/9781315668222-11
Degenbaev, Ulan, Michael Lippautz, and Hannes Payer. 2019. “Garbage Collection as a Joint Venture.” Communications of the ACM 62 (6): 36–41. https://doi.org/10.1145/3316772
Dehghan, Ali, Kelly Blincoe, and Daniela Damian. 2016. “A Hybrid Model for Task Completion Effort Estimation.” In Proceedings of the 2nd International Workshop on Software Analytics. ACM. https://doi.org/10.1145/2989238.2989242
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
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
Denehy, Timothy E., and Chang-Hyun Jo. 2000. “Parallel-C++ for the Java Virtual Machine.” In Proceedings of the 2000 ACM symposium on Applied computing - Volume 2. ACM. https://doi.org/10.1145/338407.338576
Deng, LiangJun, Hang Lei, Zheng Yang, et al. 2023. “Formal Verification Platform as a Service: WebAssembly Vulnerability Detection Application.” Computer Systems Science and Engineering 45 (2): 2155–70. https://doi.org/10.32604/csse.2023.027680
Deng, Ping, Xiaolong Zhu, Haiyan Sun, and Yi Ren. 2021. “Back-End Porting of FT_MX Based on LLVM Compilation Architecture.” MATEC Web of Conferences 336: 04018. https://doi.org/10.1051/matecconf/202133604018
“The Denotational Semantics of IMP.” 1993. In The Formal Semantics of Programming Languages. The MIT Press. https://doi.org/10.7551/mitpress/3054.003.0007
Derezińska, Anna. 2008. “Experiences from an Empirical Study of Programs Code Coverage.” In Advances in Computer and Information Sciences and Engineering. Springer Netherlands. https://doi.org/10.1007/978-1-4020-8741-7_11
“The Design and Analysis of the Fast Sliding Compaction Garbage Collection.” 2002. In Advanced LISP Technology. CRC Press. https://doi.org/10.1201/b12542-20
“Design of a Multicomputer Dataparallel C Compiler.” 1991. In Data-Parallel Programming on MIMD Computers. The MIT Press. https://doi.org/10.7551/mitpress/2278.003.0005
“Design of a Multiprocessor Dataparallel C Compiler.” 1991. In Data-Parallel Programming on MIMD Computers. The MIT Press. https://doi.org/10.7551/mitpress/2278.003.0006
“Design of Garbage Collection.” 2016. In Advanced Design and Implementation of Virtual Machines. CRC Press. https://doi.org/10.1201/9781315386706-8
“Detecting Security Vulnerabilities with Static Analysis – a Case Study.” 2021. Pollack Periodica. https://doi.org/10.1556/606.2021.00454
Detlefs, David, Christine Flood, Steve Heller, and Tony Printezis. 2004. “Garbage-First Garbage Collection.” In Proceedings of the 4th international symposium on Memory management. ACM. https://doi.org/10.1145/1029873.1029879
Detmer, D. E., D. G. Fryback, and K. Gassner. 1978. “Heuristics and Biases in Medical Decision-Making.” Academic Medicine 53 (8): 682–3. https://doi.org/10.1097/00001888-197808000-00012
Devadithya, Tharaka, and Kenneth Chiu. 2006. “Poster Reception—Fast Binary Serialization for Grid Systems with XBS.” In Proceedings of the 2006 ACM/IEEE conference on Supercomputing - SC ‘06. ACM Press. https://doi.org/10.1145/1188455.1188608
Devriese, Dominique, and Frank Piessens. 2012. “Finally Tagless Observable Recursion for an Abstract Grammar Model.” Journal of Functional Programming 22 (6): 757–96. https://doi.org/10.1017/s0956796812000226
Dewar, Robert B. K. 2007. “The Compiler as a Static Analysis Tool.” ACM SIGAda Ada Letters XXVII (3): 83–88. https://doi.org/10.1145/1315607.1315601
Dey, Anik, and Pascale Fung. 2014. “A Hindi-English Code-Switching Corpus.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/5ob9ksw5t5um
Dhavachelvan, P. 2010. “Requirement Phase Effort Estimation Using Software Metrics.” In Proceedings of the International Conference and Workshop on Emerging Trends in Technology. ACM. https://doi.org/10.1145/1741906.1742244
Di Carlo, Miriam. 2021. “Unboxing.” Italiano digitale, no. 19. https://doi.org/10.35948/2532-9006/2021.11642
di Martino, Sergio. 2007. “Effort Estimation for the Development of Web Portals.” In Encyclopedia of Portal Technologies and Applications. IGI Global. https://doi.org/10.4018/978-1-59140-989-2.ch051
Diaconescu, Roxana E., Lei Wang, Zachary Mouri, and Matt Chu. 2005. A Compiler and Runtime Infrastructure for Automatic Program Distribution. Defense Technical Information Center. https://doi.org/10.21236/ada437431
Dickenson, Chris, Lana Radloff, and H. Reinder Reinders. 2014. “Layout and Structure of the Southeast Gate.” In The City of New Halos and its Southeast Gate. Barkhuis. https://doi.org/10.2307/j.ctt2250ths.9
Dijkstra, Edsger W., Leslie Lamport, A. J. Martin, C. S. Scholten, and E. F. M. Steffens. 2022. “On-the-Fly Garbage Collection: An Exercise in Cooperation.” In Edsger Wybe Dijkstra. ACM. https://doi.org/10.1145/3544585.3544607
Dimovski, Aleksandar S. 2025b. “While-Guard Synthesis by Abstract Static Analysis and CHC Solving.” In Annals of Computer Science and Information Systems, vol. 43. Polish Information Processing Society. https://doi.org/10.15439/2025f8874
Ding, Yonghua, and Zhiyuan Li. 2003. “A Compiler Analysis of Interprocedural Data Communication.” In Proceedings of the 2003 ACM/IEEE conference on Supercomputing. ACM. https://doi.org/10.1145/1048935.1050162
Ding, Xiao Hong, and Guo Jie Li. 2010. “Topology Design Optimization of Rib Layout in Box Structure.” Advanced Materials Research 97-101: 3531–35. https://doi.org/10.4028/www.scientific.net/amr.97-101.3531
Ding, Chen, and Yutao Zhong. 2002. “Compiler-Directed Run-Time Monitoring of Program Data Access.” In Proceedings of the 2002 workshop on Memory system performance. ACM. https://doi.org/10.1145/773146.773040
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
Dişli, Semra Özlem. 2026. “Interspecies Labor and Shared Precarity: Donkeys and Humans in Garbage Collection in Mardin, Türkiye.” Society & Animals: 1–19. https://doi.org/10.1163/15685306-bja10312
Divakaran, Adarsh. 2025. “Data Serialization and Persistence.” In Deep Dive Python. Apress. https://doi.org/10.1007/979-8-8688-1261-3_17
Diwan, Amer, David Tarditi, and Eliot Moss. 1993a. Memory Subsystem Performance of Programs Using Copying Garbage Collection. Defense Technical Information Center. https://doi.org/10.21236/ada274258
Diwan, Amer, David Tarditi, and Eliot Moss. 1993b. Memory Subsystem Performance of Programs with Intensive Heap Allocation. Defense Technical Information Center. https://doi.org/10.21236/ada274122
Djukic, M., M. Popovic, N. Cetic, and I. Povazan. 2014. “Embedded Processor Oriented Compiler Infrastructure.” Advances in Electrical and Computer Engineering 14 (3): 123–30. https://doi.org/10.4316/aece.2014.03016
Dmitry S., Victorov, Zhidkov Evgeny N., and Zhidkov Roman E. 2018. “Static Analysis Technique for Searching Natural Semantic Defects of Program Objects and Software Implementation of This Approach Based on the LLVM Compiler Infrastructure and the Clang Frontend.” Journal of Siberian Federal University. Engineering & Technologies 11 (7): 801–10. https://doi.org/10.17516/1999-494x-0095
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
Dobravec, Tomaž. 2020. “Selected Tools for Java Class and Bytecode Inspection in the Educational Environment.” Open Computer Science 11 (1): 43–50. https://doi.org/10.1515/comp-2020-0170
Dolgorukova, Ksenia. 2015. “Implementation of Memory Scalability Approach for Llvm-Based Link-Time Optimization and Static Analyzing Systems.” Proceedings of the Institute for System Programming of the RAS 27 (6): 97–110. https://doi.org/10.15514/ispras-2015-27(6)-7
Dollard, Kathleen. 2004. “Introducing Code Generation.” In Code Generation in Microsoft .NET. Apress. https://doi.org/10.1007/978-1-4302-0705-4_1
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
Dombrowski, Marcel, Kenneth B. Kent, Michael Dawson, Charlie Gracie, and Rainer Herpers. 2013. “Dynamic Monitor Allocation in the Java Virtual Machine.” In Proceedings of the 11th International Workshop on Java Technologies for Real-time and Embedded Systems. ACM. https://doi.org/10.1145/2512989.2512996
Dominik, Caroline. 2026. “Polynomial Formal Verification.” In BestMasters. Springer Fachmedien Wiesbaden. https://doi.org/10.1007/978-3-658-50155-6_2
Donegan, Michael K. 1978. “The Design of a Space Efficient Compiler.” ACM SIGMINI Newsletter 4 (2): 6–6. https://doi.org/10.1145/1041259.1041267
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.10012850
Dong, Yuan, Kai Ren, Sheng-Yuan Wang, and Su-Qin Zhang. 2010. “Construction and Certification of a Bytecode Virtual Machine.” Journal of Software 21 (2): 305–17. https://doi.org/10.3724/sp.j.1001.2010-.03794
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
Dong, Shijia, Haoruo Zhao, and Paul Harvey. 2026. “Code vs Serialized AST Inputs for LLM-Based Code Summarization: An Empirical Study.” In Proceedings of the 3rd International Workshop on Large Language Models For Code. ACM. https://doi.org/10.1145/3786181.3788712
Doshi, Vishwaraj, Jie Hu, and Do Young Eun. 2024. “Self-Repellent Random Walks on General Graphs: Achieving Minimal Sampling Variance via Nonlinear Markov Chains (Extended Abstract).” In Proceedings of the Thirty-ThirdInternational Joint Conference on Artificial Intelligence. International Joint Conferences on Artificial Intelligence Organization. https://doi.org/10.24963/ijcai.2024/929
Dossary, Mubarak. 2016. “Automatic Calibration of Uncertainty Estimates Using Anchoring Heuristics.” In SPE Kingdom of Saudi Arabia Annual Technical Symposium and Exhibition. SPE. https://doi.org/10.2118/182797-ms
Dou, Xintan, Wendi Feng, and Jun Liu. 2024. “GRAPE: GPU-Accelerated Zero-Copy IoT Measurement Data Compression Transmission.” In Proceedings of the 8th Asia-Pacific Workshop on Networking. ACM. https://doi.org/10.1145/3663408.3665814
Doyon, Stéphane, and Mourad Debbabi. 2000b. “Verifying Object Initialization in the Java Bytecode Language.” In Proceedings of the 2000 ACM symposium on Applied computing - Volume 2. ACM. https://doi.org/10.1145/338407.338573
“DRAW: A New Data-gRouping-AWare Data Placement Scheme for Data Intensive Applications with Interest Locality.” 2018. International Journal of Recent Trends in Engineering and Research 4 (6): 172–81. https://doi.org/10.23883/ijrter.2018.4333.w8uli
Drechsler, Rolf, and Alireza Mahzoon. 2022. “Polynomial Formal Verification: Ensuring Correctness under Resource Constraints.” In Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design. ACM. https://doi.org/10.1145/3508352.3561104
Dresvina, Juliana. 2016. “East Anglian Margarets: Lydgate, Bokenham, and the Harley 4012 Compiler.” In A Maid with a Dragon. British Academy. https://doi.org/10.5871/bacad/9780197265963.003.0006
Drozdov, A. Yu., S. V. Novikov, V. E. Vladislavlev, E. L. Kochetkov, and P. V. Il’in. 2014. “Program Auto Parallelizer and Vectorizer Implemented on the Basis of the Universal Translation Library and LLVM Technology.” Programming and Computer Software 40 (3): 128–38. https://doi.org/10.1134/s0361768814030037
Duboscq, Gilles, Thomas Würthinger, Lukas Stadler, Christian Wimmer, Doug Simon, and Hanspeter Mössenböck. 2013. “An Intermediate Representation for Speculative Optimizations in a Dynamic Compiler.” In Proceedings of the 7th ACM workshop on Virtual machines and intermediate languages. ACM. https://doi.org/10.1145/2542142.2542143
Duong, Nguyen An Thuyen, Radek Silhavy, and Petr Silhavy. 2025. “Machine Learning for Effort Estimation in Agile: A Systematic Literature Review.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-04725-0_31
Dupont de Dinechin, Benoît. 2021. “SSA Form and Code Generation.” In SSA-based Compiler Design. Springer International Publishing. https://doi.org/10.1007/978-3-030-80515-9_18
Dutt, Nikil, Rajesh Gupta, Alex Nicolau, and Alex Veidenbaum. 2003. COPPER: Compiler-Controlled on-Demand Approach to Power-Efficient Computing. Defense Technical Information Center. https://doi.org/10.21236/ada418787
Dutta, Kamlesh, Varun Gupta, and Vachik S. Dave. 2019. “Analysis and Comparison of Neural Network Models for Software Development Effort Estimation.” Journal of Cases on Information Technology 21 (2): 88–112. https://doi.org/10.4018/jcit.2019040106
Dutta, Kamlesh, Varun Gupta, and Vachik S. Dave. 2022. “Analysis and Comparison of Neural Network Models for Software Development Effort Estimation.” In Research Anthology on Agile Software, Software Development, and Testing. IGI Global. https://doi.org/10.4018/978-1-6684-3702-5.ch009
Dyer, Robert, Hoan Nguyen, Hridesh Rajan, and Tien Nguyen. 2012. “Analyzing Ultra-Large-Scale Code Corpus with Boa.” In Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity. ACM. https://doi.org/10.1145/2384716.2384729
Dyer, Robert, Hridesh Rajan, Hoan Anh Nguyen, and Tien N. Nguyen. 2014. “Mining Billions of AST Nodes to Study Actual and Potential Usage of Java Language Features.” In Proceedings of the 36th International Conference on Software Engineering. ACM. https://doi.org/10.1145/2568225.2568295
“Dynamic Dispatch.” 2012. In Practical Foundations for Programming Languages. Cambridge University Press. https://doi.org/10.1017/cbo9781139342131.026
Dzafic, Izudin, Priyanka Mohapatra, and Nenad Lecek. 2011. “Model Driven Real-Time Power System Application Development Using Just-In-Time Compilation.” In Lecture Notes in Electrical Engineering. Springer Netherlands. https://doi.org/10.1007/978-94-007-2792-2_7
Dzurinadib, Muhammad Ilham, Muhamat Maariful Huda, and Tito Prabowo. 2026. “Comparison of JSON and MessagePack Serialization Performance on End-to-End Latency over HTTP Protocol.” G-Tech: Jurnal Teknologi Terapan 10 (3): 1117–30. https://doi.org/10.70609/g-tech.v10i3.10072
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
Ecker, Wolfgang, and Johannes Schreiner. 2016. “Metamodeling and Code Generation in the Springer Science+Business Media Dordrecht.” In Handbook of Hardware/Software Codesign. Springer Netherlands. https://doi.org/10.1007/978-94-017-7358-4_32-1
Ecker, Wolfgang, and Johannes Schreiner. 2017. “Metamodeling and Code Generation in the Hardware/Software Interface Domain.” In Handbook of Hardware/Software Codesign. Springer Netherlands. https://doi.org/10.1007/978-94-017-7267-9_32
Ecma International. 2012. Common Language Infrastructure (CLI). ECMA-335, 6th edition. Ecma International. https://www.ecma-international.org/publications-and-standards/standards/ecma-335/
Editor, Special Issues. 2016. “A Formal Verification Method for Hybrid Systems.” International Journal of Simulation: Systems, Science & Technology. https://doi.org/10.5013/ijssst.a.17.16.01
Edler von Koch, Tobias J. K., Igor Böhm, and Björn Franke. 2010. “Integrated Instruction Selection and Register Allocation for Compact Code Generation Exploiting Freeform Mixing of 16- and 32-Bit Instructions.” In Proceedings of the 8th annual IEEE/ACM international symposium on Code generation and optimization. ACM. https://doi.org/10.1145/1772954.1772980
Eduardo Carbonera, Carlos, Kleinner Farias, and Vinicius Bischoff. 2020. “Software Development Effort Estimation: A Systematic Mapping Study.” IET Software 14 (4): 328–44. https://doi.org/10.1049/iet-sen.2018.5334
Edwards, Stephen H., Nischel Kandru, and Mukund B. M. Rajagopal. 2017. “Investigating Static Analysis Errors in Student Java Programs.” In Proceedings of the 2017 ACM Conference on International Computing Education Research. ACM. https://doi.org/10.1145/3105726.3106182
Edwards, Jonathan, Tomas Petricek, Tijs van der Storm, and Geoffrey Litt. 2024. “Schema Evolution in Interactive Programming Systems.” Art, Science, and Engineering of Programming 9 (1): 2. https://doi.org/10.22152/programming-journal.org/2025/9/2
“Effort Estimation of Use Cases for Incremental Large-Scale Software Development.” 2006. In Software Process Improvement. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-32179-8_17
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
Ehrenfried, Daniel H. 1994. “Static Analysis of Ada Programs.” ACM SIGAda Ada Letters XIV (4): 28–35. https://doi.org/10.1145/181476.181479
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
Eisl, Josef, Stefan Marr, Thomas Würthinger, and Hanspeter Mössenböck. 2017. “Trace Register Allocation Policies: Compile-Time vs. Performance Trade-Offs.” In Proceedings of the 14th International Conference on Managed Languages and Runtimes. ACM. https://doi.org/10.1145/3132190.3132209
Ekembe Ngondi, Gerard. 2021. “Denotational Semantics of Channel Mobility in UTP-CSP.” Formal Aspects of Computing 33 (4–5): 803–26. https://doi.org/10.1007/s00165-021-00546-3
El farissi, Ilhame, Mostafa Azizi, Jean-Louis Lanet, and Mimoun Moussaoui. 2013. “Evaluation of Detection System of Fault Attacks Based on Neural Network into a Java Virtual Machine.” International Journal of Computers & Technology 10 (3): 1482–88. https://doi.org/10.24297/ijct.v10i3.3278
El-Kharashi, M. Watheq, Fayez Elguibaly, and Kin F. Li. 2001. “Adapting Tomasulo’s Algorithm for Bytecode Folding Based Java Processors.” ACM SIGARCH Computer Architecture News 29 (5): 1–8. https://doi.org/10.1145/563647.563649
Elder, Henry, Jennifer Foster, James Barry, and Alexander O’Connor. 2019. “Designing a Symbolic Intermediate Representation for Neural Surface Realization.” In Proceedings of the Workshop on Methods for Optimizing and Evaluating Neural Language Generation. Association for Computational Linguistics. https://doi.org/10.18653/v1/w19-2308
Electronic Systems Div Hanscom Afb Ma. 1970. User’s Manual Jovial Compiler Validation System. Defense Technical Information Center. https://doi.org/10.21236/ad0711370
Elof Frank. 1995. “Constrained Register Allocation in Bus Architectures.” In 32nd Design Automation Conference. ACM. https://doi.org/10.1109/dac.1995.250085
Elsman, Martin, and Niels Hallenberg. 2021. “Integrating Region Memory Management and Tag-Free Generational Garbage Collection.” Journal of Functional Programming 31: e4. https://doi.org/10.1017/s0956796821000010
“An Empirical Study of Measuring Relative Gender Bias in the Rural Development Programs in Bangladesh.” 2020. Journal of Primeasia 1 (1): 1–8. https://doi.org/10.25163/primeasia.560017
“An Empirical Study on the Effect of Corpus-Driven Instruction on Academic English Writing Production.” 2026. Frontiers in Educational Research 9 (4). https://doi.org/10.25236/fer.2026.090418
Energy Management Consultants INC Denver CO. 1981. Energy Engineering Analysis (EEA) Program for Corpus Christi Army Depot, Texas; Executive Summary. Defense Technical Information Center. https://doi.org/10.21236/ada330582
Engebreth, Gunnard. 2021. “JIT Compiler.” In PHP 8 Revealed. Apress. https://doi.org/10.1007/978-1-4842-6818-6_1
Engel, Michael, and Peter Marwedel. 2020. “Soft Error Handling for Embedded Systems Using Compiler-OS Interaction.” In Embedded Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-52017-5_2
Engler, Dawson, Benjamin Chelf, Andy Chou, and Seth Hallem. 2000. Checking System Rules Using System-Specific, Programmer-Written Compiler Extensions. Defense Technical Information Center. https://doi.org/10.21236/ada419626
“Ensuring Safety and Reliability: Formal Verification of Communication-Based Train Control Systems.” 2024. In Conference Proceeding. ICCDETS. https://doi.org/10.62919/hejk9341
Epley, Nicholas, and Thomas Gilovich. 2002. “Putting Adjustment Back in the Anchoring and Adjustment Heuristic.” In Heuristics and Biases. Cambridge University Press. https://doi.org/10.1017/cbo9780511808098.009
Eremondi, Joey. 2013. “The Poor Man’s Proof Assistant: Using Prolog to Develop Formal Language Theoretic Proofs.” In Proceedings of the 2013 companion publication for conference on Systems, programming, & applications: software for humanity. ACM. https://doi.org/10.1145/2508075.2527300
Ergene, Boğaç, and Atabey Kaygun. 2020. “Semantic Mapping of an Ottoman Fetva Compilation: EBUSSUUD Efendi’s Jurisprudence through a Computational Lens.” Journal of Islamic Studies 32 (1): 62–115. https://doi.org/10.1093/jis/etaa032
Erickson, Britt E. 2004. “Research Profiles: Imaging Tagless DNA.” Analytical Chemistry 76 (15): 259 A-259 A. https://doi.org/10.1021/ac041613n
Erkkinen, Tom. 2003. “High-Integrity Production Code Generation.” In AIAA Guidance, Navigation, and Control Conference and Exhibit. AIAA 2003-5488. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.2003-5488
Erkkinen, Tom. 2007. “Multiple Purpose Automatic Code Generation.” In AIAA Modeling and Simulation Technologies Conference and Exhibit. AIAA 2007-6883. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.2007-6883
Erkkinen, Tom, and Chris Hote. 2006. “Automatic Flight Code Generation with Integrated Static Run-Time Error Checking and Code Analysis.” In AIAA Modeling and Simulation Technologies Conference and Exhibit. AIAA 2006-6257. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.2006-6257
Ermakov, M., and S. Vartanov. 2015. “Dynamic Java Program Analysis Using Virtual Machine Modification.” Proceedings of the Institute for System Programming of the RAS 27 (2): 23–38. https://doi.org/10.15514/ispras-2015-27(2)-2
Ernst, Michael. 2016. Verification Games: Crowd-Sourced Formal Verification. Defense Technical Information Center. https://doi.org/10.21236/ad1006471
Esplanada, Paula, and Eliezer Albacea. 2012. “Assessing Applicability, Validity and Calibration of Software Development Effort Estimation Model.” In Conference proceedings on 3rd Annual International Software Engineering & Applications. Global Science Technology Forum. https://doi.org/10.5176/2251-2217_sea12.09
Essadki, Mohamed, Bertrand Michel, Bruno Maugars, Oleksandr Zinenko, Nicolas Vasilache, and Albert Cohen. 2023. “Code Generation for in-Place Stencils.” In Proceedings of the 21st ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3579990.3580006
“The Essence of ML Type Inference.” 2004. In Advanced Topics in Types and Programming Languages. The MIT Press. https://doi.org/10.7551/mitpress/1104.003.0016
Eulenstein, Michael. 1988a. “Compiler-Generierende Systeme.” In Informatik-Fachberichte. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-73431-1_1
Eulenstein, Michael. 1988b. “Das Compiler-Generierende System POCO: Die Konzeption.” In Informatik-Fachberichte. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-73431-1_3
Evers, Leon, Maria Eva Lijding, and Jan Kuper. 2008. “Generic Multi–Packet Communication through Object Serialization.” In Proceedings of the 3rd international workshop on Middleware for sensor networks. ACM. https://doi.org/10.1145/1462698.1462703
“Extending Gödel’s Modal Interpretation to Type Theory and Set Theory.” 1985. In Studies in Logic and the Foundations of Mathematics. Elsevier. https://doi.org/10.1016/s0049-237x(08)70141-1
Ezick, James. 2004. “An Optimizing Compiler for Batches of Temporal Logic Formulas.” In Proceedings of the 2004 ACM SIGSOFT international symposium on Software testing and analysis. ACM. https://doi.org/10.1145/1007512.1007537
Fahmid, Ahmad, Fahim Foysal, Wasif Haider, Shafin Rahman, and Md Adnan Arefeen. 2025. “NSU_PiedPiper at BLP-2025 Task 2: A Chain-of-Thought with Iterative Debugging Approach for Code Generation with Bangla Instruction.” In Proceedings of the Second Workshop on Bangla Language Processing (BLP-2025). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.banglalp-1.60
Fähndrich, Manuel, Diego Garbervetsky, and Wolfram Schulte. 2008. “A Static Analysis to Detect Re-Entrancy in Object Oriented Programs.” Journal of Object Technology 7 (5): 5. https://doi.org/10.5381/jot.2008.7.5.a1
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
Farah basil alhamdany and Laheeb Mohammad Ibrahim. 2022. “Software Development Effort Estimation Techniques: A Survey.” Journal of Education and Science 31 (1): 80–92. https://doi.org/10.33899/edusj.2022.132274.1201
Farih, Nour elhouda, Khalid Nafil, and Rochdi El Messousi. 2021. “Effort Estimation in Agile Software Development: A Systematic Mapping Study.” In Frontiers in Artificial Intelligence and Applications. IOS Press. https://doi.org/10.3233/faia210022
Farionova, Тetyana A., and Oleksandr S. Oriekhov. 2024. “A Review of Software Development Effort Estimation Methods.” Collection of Scientific Publications NUS, no. 1 (494): 102–11. https://doi.org/10.15589/znp2024.1(494).15
Farka, FRANTIŠEK, Ekaterina Komendantskya, and Kevin Hammond. 2018. “Proof-Relevant Horn Clauses for Dependent Type Inference and Term Synthesis.” Theory and Practice of Logic Programming 18 (3–4): 484–501. https://doi.org/10.1017/s1471068418000212
Farkas, Keith I., Jason Flinn, Godmar Back, Dirk Grunwald, and Jennifer M. Anderson. 2000. “Quantifying the Energy Consumption of a Pocket Computer and a Java Virtual Machine.” ACM SIGMETRICS Performance Evaluation Review 28 (1): 252–63. https://doi.org/10.1145/345063.339421
Farvardin, Kavon, and John Reppy. 2018. “Compiling with Continuations and LLVM.” Electronic Proceedings in Theoretical Computer Science 285: 131–42. https://doi.org/10.4204/eptcs.285.5
Fattah, Hossam. 2021. “Data Serialization and Deserialization.” In LTE™ Cellular Narrowband Internet of Things (NB-IoT). CRC Press. https://doi.org/10.1201/9781003120018-6
“FED C Compiler Library Functions.” 2002. In Microcontroller Based Temperature Monitoring and Control. Elsevier. https://doi.org/10.1016/b978-075065556-9/50012-8
Fei, Yuan, Huibiao Zhu, and Jiaqi Yin. 2023. “FVF-AKA: A Formal Verification Framework of AKA Protocols for Multi-Server IoT.” Formal Aspects of Computing 35 (4): 1–36. https://doi.org/10.1145/3599731
Felder, Ludwig, Tobias Eisenreich, Mahsa Fischer, Stefan Wagner, and Chunyang Chen. 2026. “Adoption of Generative Artificial Intelligence in the German Software Engineering Industry: An Empirical Study.” In Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3803437.3805207
Fellir, Fadoua, Khalid Nafil, and Rochdi Messoussi. 2015b. “Integrating Non-Functional Requirements into a Case Based Reasoning Model for Software Effort Estimation.” International Review on Computers and Software (IRECOS) 10 (12): 1225. https://doi.org/10.15866/irecos.v10i12.8042
Fellir, Fadoua, Khalid Nafil, Rajaa Touahni, and Lawrence Chung. 2018b. “Improving Case Based Software Effort Estimation Using a Multi-Criteria Decision Technique.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-319-91186-1_46
Fellir Fadoua, Nafil Khalid, Idri Ali, and Chung Lawrence. 2018. “A Web Tool for Improving Case-Based Reasoning Model for Software Effort Estimation.” In Frontiers in Artificial Intelligence and Applications. IOS Press. https://doi.org/10.3233/978-1-61499-900-3-688
Fellows, L. K., and M. J. Farah. 2007. “The Role of Ventromedial Prefrontal Cortex in Decision Making: Judgment under Uncertainty or Judgment per Se?” Cerebral Cortex 17 (11): 2669–74. https://doi.org/10.1093/cercor/bhl176
Felten, Sebastian, and Rebecca Kahn. 2021. “Unboxed: Transgender in a Gay Museum?” TSQ: Transgender Studies Quarterly 8 (2): 257–64. https://doi.org/10.1215/23289252-8890621
Feng, Haonan. 2018. “Formal Verification of Double Two out of Two Computer Systems.” International Journal of Performability Engineering. https://doi.org/10.23940/ijpe.18.11.p22.27602768
Feret, Jé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
Ferrandina, Fabrizio, and Sven-Eric Lautemann. 1997. “An Integrated Approach to Schema Evolution for Object Databases.” In OOIS’96. Springer London. https://doi.org/10.1007/978-1-4471-0973-0_20
Ferrara, Pietro, Agostino Cortesi, and Fausto Spoto. 2018. “CIL to Java-Bytecode Translation for Static Analysis Leveraging.” In Proceedings of the 6th Conference on Formal Methods in Software Engineering. ACM. https://doi.org/10.1145/3193992.3193994
Ferreira, Paulo, and Marc Shapiro. 1995. “Garbage Collection of Persistent Objects in Distributed Shared Memory.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-2122-0_16
Ferries, Jonathan. 2022. “A Corpus Analysis of Loanword Effects on Second Language Production.” Englishes in Practice 5 (1): 107–32. https://doi.org/10.2478/eip-2022-0005
“File I/O and Object Serialization.” 2010. In Pro VB 2010 and the .NET 4 Platform. Apress. https://doi.org/10.1007/978-1-4302-2986-5_20
Firouzi, Ehsan, Mohammad Ghafari, and Mike Ebrahimi. 2024. “ChatGPT’s Potential in Cryptography Misuse Detection: A Comparative Analysis with Static Analysis Tools.” In Proceedings of the 18th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. ACM. https://doi.org/10.1145/3674805.3695408
Fischer, Robert. 2015. “Lambdas in Java Bytecode.” In Java Closures and Lambda. Apress. https://doi.org/10.1007/978-1-4302-5999-2_8
Fischhoff, Baruch. 1975. Attribution Theory and Judgment under Uncertainty. Defense Technical Information Center. https://doi.org/10.21236/ada014128
Fischhoff, B. 2003. “Hindsight != Foresight: The Effect of Outcome Knowledge on Judgment under Uncertainty.” Quality and Safety in Health Care 12 (4): 304–11. https://doi.org/10.1136/qhc.12.4.304
Fitch, J. P. 1978. “A Note on Compacting Garbage Collection.” Computer Journal 21 (1): 31–34. https://doi.org/10.1093/comjnl/21.1.31
Fitzhenry, P. 1995. “Enhanced Software Project Management by Application of Metrics and Cost Estimation Techniques.” In IEE Colloquium on Project Management for Software Engineers, vol. 1995. IEE. https://doi.org/10.1049/ic:19951542
“FlatBuffers Docs.” n.d. FlatBuffers. Accessed October 24, 2026. https://flatbuffers.dev/
Forbes, Shanna-Shaye. 2009. Real-Time C Code Generation in Ptolemy II for the Giotto Model of Computation. Defense Technical Information Center. https://doi.org/10.21236/ada538394
“Formal Verification of a JIT Backend Compiler.” 2025. In Formal Verification of Just-in-Time Compilation. ACM. https://doi.org/10.1145/3705593.3705601
“Formal Verification of Autonomous System Software.” 2022. International Journal of Emerging Research in Engineering and Technology 3. https://doi.org/10.63282/3050-922x.ijeret-v3i1p110
“Formal Verification of Impure Coq JITs.” 2025. In Formal Verification of Just-in-Time Compilation. ACM. https://doi.org/10.1145/3705593.3705600
“Formal Verification Tools: Understanding Their Strengths and Limitations.” 2004. In Professional Verification. Springer US. https://doi.org/10.1007/1-4020-7876-5_13
“Formalizing Operational Semantics.” 2025. In Proof Theory and Logic Programming. Cambridge University Press. https://doi.org/10.1017/9781009561280.014
Fornari, Miguel R., Lia G. Golendziner, and Flávio R. Wagner. 1995. “Schema Evolution in the STAR Framework.” In Electronic Design Automation Frameworks. Springer US. https://doi.org/10.1007/978-0-387-34880-3_5
Fox, Craig R., and Yuval Rottenstreich. 2003. “Partition Priming in Judgment under Uncertainty.” Psychological Science 14 (3): 195–200. https://doi.org/10.1111/1467-9280.02431
Fraser, Joy. 2018. “Conflict of Interest: A Major Problem in Medical Research.” In Excessive Medical Spending. CRC Press. https://doi.org/10.1201/9781315378763-3
Freeman, Adam. 2010. “Garbage Collection.” In Introducing Visual C# 2010. Apress. https://doi.org/10.1007/978-1-4302-3172-1_18
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
Freudenberger, Stefan M., and John C. Ruttenberg. 1992. “Phase Ordering of Register Allocation and Instruction Scheduling.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3501-2_9
Frisch, Deborah. 1992. “Toward an Integrated Theory of Judgment under Uncertainty.” Contemporary Psychology: A Journal of Reviews 37 (7): 670–71. https://doi.org/10.1037/032342
Frost, Christian, Casper Svenning Jensen, Kasper Søe Luckow, and Bent Thomsen. 2011. “WCET Analysis of Java Bytecode Featuring Common Execution Environments.” In Proceedings of the 9th International Workshop on Java Technologies for Real-Time and Embedded Systems. ACM. https://doi.org/10.1145/2043910.2043916
Fu, Peng, and Ekaterina Komendantskaya. 2017. “Operational Semantics of Resolution and Productivity in Horn Clause Logic.” Formal Aspects of Computing 29 (3): 453–74. https://doi.org/10.1007/s00165-016-0403-1
Fuchs, W. K., and Wen-Mei Hwu. 1992. Compiler Assisted Recovery for Fault-Tolerant Highly Parallel Multiprocessor Architectures. Defense Technical Information Center. https://doi.org/10.21236/ada256942
Fuhrmann, Kay, and Jan Hiemer. 1999. “Formal Verification of Statemate-Statecharts.” In Tool Support for System Specification, Development and Verification. Springer Vienna. https://doi.org/10.1007/978-3-7091-6355-9_7
Fujita, Masahiro, Indradeep Ghosh, and Mukul Prasad. 2008. “Basic Technology for Formal Verification.” In Verification Techniques for System-Level Design. Elsevier. https://doi.org/10.1016/b978-012370616-4.50004-5
Fung, R. Y. K., and K. Popplewell. 1994. “A Neural Network Model for Cost Estimation and Evaluation in Manufacturing.” In Advancement of Intelligent Production. Elsevier. https://doi.org/10.1016/b978-0-444-81901-7.50026-8
Gaissaryan, Sergey, Shamil Kurmangaleev, Kseniya Dolgorukova, Valery Savchenko, and Sevak Sargsyan. 2014. “Applying Two-Stage LLVM-Based Compilation Approach to Application Deployment via Cloud Storage.” Proceedings of the Institute for System Programming of RAS 26 (1): 315–26. https://doi.org/10.15514/ispras-2014-26(1)-11
Gallagher, Kevin. 2022. “Writing Essentials: Preparation, Layout, and Structure.” In Essential Study and Employment Skills for Business and Management Students. Oxford University Press. https://doi.org/10.1093/hebz/9780198809883.003.0008
Gan, Maohua, Zeynep YÜCel, Akito Monden, and Kentaro Sasaki. 2020. “Empirical Evaluation of Mimic Software Project Data Sets for Software Effort Estimation.” IEICE Transactions on Information and Systems E103.D (10): 2094–2103. https://doi.org/10.1587/transinf.2019edp7150
Ganachari, Girish. 2019. “Schema Evolution and Interoperability: Contrasting Apache Avro with Thrift and Protocol Buffers.” International Journal of Science and Research (IJSR) 8 (10): 1888–92. https://doi.org/10.21275/sr24827142344
Ganesan, Karthik, Yao-Min Chen, and Xiaochen Pan. 2017. “Scaling the Java Virtual Machine on a Many-Core System.” In Emerging Technology and Architecture for Big-data Analytics. Springer International Publishing. https://doi.org/10.1007/978-3-319-54840-1_1
Gannon, C., and R. Meeson. 1979. “An Empirical Evaluation of Static Analysis and Path Testingof Software.” In 2nd Computers in Aerospace Conference. AIAA 1979-1980. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.1979-1980
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
“Garbage Collection.” 1997. In Modern Compiler Implementation in ML. Cambridge University Press. https://doi.org/10.1017/cbo9780511811449.014
“Garbage Collection.” 2002a. In Modern Compiler Implementation in Java. Cambridge University Press. https://doi.org/10.1017/cbo9780511811432.014
“Garbage Collection.” 2009. In Learn Objective-C for Java Developers. Apress. https://doi.org/10.1007/978-1-4302-2370-2_9
“Garbage Collection and Segregation in Rural Setting.” 2024. International Research Journal of Economics and Management Studies 3 (2). https://doi.org/10.56472/25835238/irjems-v3i2p135
“Garbage Collection of an Extended Common Lisp System for SIMD Architectures.” 2002b. In Advanced LISP Technology. CRC Press. https://doi.org/10.1201/b12542-19
“Garbage Collection on the Fly.” 2026. In Formal Methods, Informally. Cambridge University Press. https://doi.org/10.1017/9781009421003.021
“Garbage Collection Support.” 2016. In Advanced Design and Implementation of Virtual Machines. CRC Press. https://doi.org/10.1201/9781315386706-13
Garbervetsky, Diego, Zvonimir Pavlinovic, Michael Barnett, Madanlal Musuvathi, Todd Mytkowicz, and Edgardo Zoppi. 2017a. “Static Analysis for Optimizing Big Data Queries.” In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering. ACM. https://doi.org/10.1145/3106237.3117774
Garbervetsky, Diego, Edgardo Zoppi, and Benjamin Livshits. 2017b. “Toward Full Elasticity in Distributed Static Analysis: The Case of Callgraph Analysis.” In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering. ACM. https://doi.org/10.1145/3106237.3106261
Garner, Robin, Stephen M. Blackburn, and Daniel Frampton. 2007. “Effective Prefetch for Mark-Sweep Garbage Collection.” In Proceedings of the 6th international symposium on Memory management. ACM. https://doi.org/10.1145/1296907.1296915
Garoche, Pierre-Loïc, Marc Pantel, and Xavier Thirioux. 2007. “Abstract Interpretation-Based Static Safety for Actors.” Journal of Software 2 (3). https://doi.org/10.4304/jsw.2.3.87-98
Gautam, Abhilekh, Bishal Lamichhane, Ankit Lamichhane, Aashan Bhattarai, and Amit Shrivastava. 2024. “Design and Implementation of a Minimalist Programming Language Stab Using Flex, Bison and LLVM.” Journal of Science and Technology 4 (2): 65–70. https://doi.org/10.3126/jost.v4i2.78954
Gebotys, Catherine H. 1997. “Low Energy Memory and Register Allocation Using Network Flow.” In Proceedings of the 34th annual conference on Design automation conference - DAC ‘97. ACM Press. https://doi.org/10.1145/266021.266192
“Gender Representation in Hong Kong Primary English-Language Textbooks: A Corpus Study.” 2015. In Gender Representation in Learning Materials. Routledge. https://doi.org/10.4324/9781315764092-9
“Generational Garbage Collection.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-10
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
Ghag, Rutik. 2025. “Fabrication of Manual Plastic Boat for Garbage Collection from Water Surface.” International Journal of Scientific Research in Engineering and Management 09 (04): 1–9. https://doi.org/10.55041/ijsrem46375
Ghali, Mohsen, Yuzo Ohno, and Hideo Ohno. 2015. “Vertical Electric Field Induced Suppression of Fine Structure Splitting of Excited State Excitons in a Single GaAs/AlGaAs Island Quantum Dots.” Applied Physics Letters 107 (12): 123102. https://doi.org/10.1063/1.4931360
Ghanbari, Ali, Samuel Benton, and Lingming Zhang. 2019. “Practical Program Repair via Bytecode Mutation.” In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3293882.3330559
Gharehchopogh, Farhad Soleimanian, Isa Maleki, and Seyyed Reza Khaze. 2014. “A Novel Particle Swarm Optimization Approach for Software Effort Estimation.” International Journal of Academic Research 6 (2): 69–76. https://doi.org/10.7813/2075-4124.2014/6-2/a.12
Ghelli, Giorgio. 1991. “A Static Type System for Message Passing.” In Conference proceedings on Object-oriented programming systems, languages, and applications. ACM. https://doi.org/10.1145/117954.117964
Ghiglio, Pietro, Uwe Dolinsky, Mehdi Goli, and Kumudha Narasimhan. 2022. “Improving Performance of SYCL Applications on CPU Architectures Using LLVM-Directed Compilation Flow.” In Proceedings of the Thirteenth International Workshop on Programming Models and Applications for Multicores and Manycores. ACM. https://doi.org/10.1145/3528425.3529099
Ghoshal, Devarshi, Arun Chauhan, and Beth Plale. 2013. “Static Compiler Analysis for Workflow Provenance.” In Proceedings of the 8th Workshop on Workflows in Support of Large-Scale Science. ACM. https://doi.org/10.1145/2534248.2534250
Gibbons, William, Jon Jonsson, Steve Abelman, and Randall Bass. 2014. “Observed Heuristics and Biases in Air Traffic Management Decision Making Using Convective Weather Uncertainty.” In 6th AIAA Atmospheric and Space Environments Conference. AIAA 2014-2901. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.2014-2901
Giegerich, Robert, and Susan L. Graham. 1992. “Discussion: Code Generator Specification Techniques.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3501-2_4
Giegerich, Robert, and Georg Sauthoff. 2011. “Yield Grammar Analysis in the Bellman’s GAP Compiler.” In Proceedings of the Eleventh Workshop on Language Descriptions, Tools and Applications. ACM. https://doi.org/10.1145/1988783.1988790
Gill, Swati, Anupama Kaushik, and Yudhvir Singh. 2025. “Hybrid Models for Agile Software Effort Estimation: Integrating LSTM, Ensemble Learning, and Genetic Algorithms.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-96-7131-1_40
Gilmore, Paul C. 2001. “An Intensional Type Theory: Motivation and Cut-Elimination.” Journal of Symbolic Logic 66 (1): 383–400. https://doi.org/10.2307/2694928
Gilson, Nikhil K., and Alester Joseph Vanreyk. 2016. “Review of Cost Estimation Models.” International Journal of Scientific Engineering and Research 4 (3): 42–44. https://doi.org/10.70729/ijser15714
Ginika Mahajan and Raja. 2016. “Metamorphic Malware Detection Using LLVM IR and Hidden Markov Model.” In Advances in Intelligent Systems and Computing. Springer Singapore. https://doi.org/10.1007/978-981-10-0767-5_44
Ginossar, Zvi, and Yaacov Trope. 1987. “Problem Solving in Judgment under Uncertainty.” Journal of Personality and Social Psychology 52 (3): 464–74. https://doi.org/10.1037//0022-3514.52.3.464
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
Gitelman, J. J., and C. W. Garrett. 1967. Nuclear Reactor Pulse Analysis, an Application of a Real-Time Compiler. Defense Technical Information Center. https://doi.org/10.21236/ad0685626
Glandorf, Frank. 1985. Integrated Information Support System (IISS). Volume 8. User Interface Subsystem. Part 16. Forms Language Compiler Unit Test Plan. Defense Technical Information Center. https://doi.org/10.21236/ada182584
Glasco, Sharon Bailey. 2010. “Restoring Order out of Chaos: Garbage Collection in Theory and Practice.” In Constructing Mexico City. Palgrave Macmillan US. https://doi.org/10.1057/9780230109612_5
Glass, Kathleen Cranley, and Trudo Lemmens. 1999. “Conflict of Interest and Commercialization of Biomedical Research: What Is the Role of Research Ethics Review?” In The Commercialization of Genetic Research. Springer US. https://doi.org/10.1007/978-1-4615-4713-6_6
Gledhill, Tom. 2020. “Woodland, Industry and Common Rights — A Conflict of Interest.” In The Archaeology of Industrialization. Routledge. https://doi.org/10.4324/9781003077169-8
Glennie, A. E. 1960. On the Syntax Machine and the Construction of a Universal Compiler. Defense Technical Information Center. https://doi.org/10.21236/ad0240512
Glicksman, Caroline. 2021. “Conflict of Interest in Research and Publication: Has the Pendulum Swung Too Far?” Aesthetic Surgery Journal 42 (4): 431–34. https://doi.org/10.1093/asj/sjab305
Glindtvad, Karin, and Hanne Riis Nielson. 1991. “Correctness Preserving Transformations on a Multipass Occam Compiler.” DAIMI Report Series 20 (368). https://doi.org/10.7146/dpb.v20i368.6600
Godefroid, Patrice, and Johannes Kinder. 2010. “Proving Memory Safety of Floating-Point Computations by Combining Static and Dynamic Program Analysis.” In Proceedings of the 19th international symposium on Software testing and analysis. ACM. https://doi.org/10.1145/1831708.1831710
Goerigk, Wolfgang. 2000. “Compiler Verification Revisited.” In Advances in Formal Methods. Springer US. https://doi.org/10.1007/978-1-4757-3188-0_15
Goka-Dubose, Emiko, and Cass Dykeman. 2024. “Code-Switching in Native Authored Children’s Books: A Corpus-Based Study.” Preprint, . https://doi.org/10.2139/ssrn.4694696
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
Goldberg, Benjamin, and Michael Gloger. 1992. “Polymorphic Type Reconstruction for Garbage Collection without Tags.” In Proceedings of the 1992 ACM conference on LISP and functional programming. ACM. https://doi.org/10.1145/141471.141504
Goldberg, Benjamin, Krishna V. Palem, and Michael O. Rabin. 2003. ASC3: Algorithmic Strategies for Compiler Controlled Caches. Defense Technical Information Center. https://doi.org/10.21236/ada418767
Golling, André. 2019. “Unboxing YouTube.” merz | medien + erziehung 63 (3): 3–5. https://doi.org/10.21240/merz/2019.3.4
Goltiano, Henry. 2023. “Participatory Extension for Empowerment: Paradoxes Unboxed in the Fishery Sector.” Annals of Tropical Research: 36–60. https://doi.org/10.32945/atr4513.2023
Gomez, Diana, Juan Cubillos, Jairo Aponte, and Edwar Rojas. 2023. “Effort Estimation in Agile Software Development: The State of the Practice in Colombia.” In Anais do XXVI Congresso Ibero-Americano em Engenharia de Software (CIbSE 2023). Sociedade Brasileira de Computação. https://doi.org/10.5753/cibse.2023.24689
Gonçalves, João Carlos, and Marcelo de Almeida Maia. 2025. “An Empirical Study on the Effectiveness of Iterative LLM-Based Improvements for Static Analysis Issues.” In Anais do XXXIX Simpósio Brasileiro de Engenharia de Software (SBES 2025). Sociedade Brasileira de Computação. https://doi.org/10.5753/sbes.2025.9964
Goncharova, Oxana V. 2026. “Artificial Intelligence in Contemporary Language Education Research: A Corpus and Network Analysis.” Russian Language Studies 24 (1): 7–24. https://doi.org/10.22363/2618-8163-2026-24-1-7-24
Gong, Ke, and Jian Zhang. 2026. “Experience Report: Insights from Deploying Educational Static Analysis in Introductory Programming Courses.” In Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3803437.3805779
González-Ladrón-de-Guevara, Fernando, and Marta Fernández-Diego. 2014. “ISBSG Variables Most Frequently Used for Software Effort Estimation: A Mapping Review.” In Proceedings of the 8th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. ACM. https://doi.org/10.1145/2652524.2652550
Goodman, J. R., and W.-C. Hsu. 1988. “Code Scheduling and Register Allocation in Large Basic Blocks.” In Proceedings of the 2nd international conference on Supercomputing - ICS ‘88. ACM Press. https://doi.org/10.1145/55364.55407
Goodman, James R., and Wei Chung Hsu. 2014a. “Author Retrospective for Code Scheduling and Register Allocation in Large Basic Blocks.” In 25th Anniversary International Conference on Supercomputing Anniversary Volume -. ACM Press. https://doi.org/10.1145/2591635.2591640
Goodman, J. R., and W.-C. Hsu. 2014b. “Code Scheduling and Register Allocation in Large Basic Blocks.” In 25th Anniversary International Conference on Supercomputing Anniversary Volume -. ACM Press. https://doi.org/10.1145/2591635.2667158
Gopinath, K. 2002. “Register Allocation.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579.ch13
Gopinath, K., and John L. Hennessy. 1987. Copy Elimination with Abstract Interpretation. Defense Technical Information Center. https://doi.org/10.21236/ada179451
Gora, Rajani Kumari, and Ripu Ranjan Sinha. 2023. “Ensemble Machine Learning and Software Development Effort Estimation.” Journal of Analysis and Computations 17 (1): 41–46. https://doi.org/10.30696/jac.xvii.1.2023.41-46
Gorrara, Claire. 2024. “Memory Unboxed: Reckoning with German Memories of the Second World War in Nora Krug’s Heimat: A German Family Album (2018).” In Mediating Historical Responsibility. De Gruyter. https://doi.org/10.1515/9783111013299-012
Gosipathala, Sarath Babu. 2025. “Semantic Data Lake Architecture with Automated Schema Evolution for Intelligent Transportation Data Management.” World Journal of Advanced Research and Reviews 27 (1): 2772–82. https://doi.org/10.30574/wjarr.2025.27.1.2686
Goswami, Viplove. 2026. “Managing Schema Evolution and Backward Compatibility in Kafka-Driven Enterprise Integrations.” International Journal of Computer Science and Mobile Computing 15 (3): 212–21. https://doi.org/10.47760/ijcsmc.2026.v15i03.023
Goswami, Dhiraj Kumar, Soham Chakrabarti, and Saurabh Bilgaiyan. 2020. “Effort Estimation of Web Based Applications Using ERD, Use Case Point Method and Machine Learning.” In Learning and Analytics in Intelligent Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-38006-9_2
Gothard, A. 2005. “Back to the Source [Automatic Code Generation].” Information Professional 2 (4): 38–42. https://doi.org/10.1049/inp:20050407
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
Goyal, Somya. 2022a. “Comparative Analysis of Machine Learning Techniques for Software Effort Estimation.” In Lecture Notes in Electrical Engineering. Springer Nature Singapore. https://doi.org/10.1007/978-981-19-0252-9_7
Goyal, Somya, and Pradeep K. Bhatia. 2019. “Feature Selection Technique for Effective Software Effort Estimation Using Multi-Layer Perceptrons.” In Lecture Notes in Electrical Engineering. Springer International Publishing. https://doi.org/10.1007/978-3-030-30577-2_15
Graafland, Johan, and Hugo Smid. 2016. “Decoupling among CSR Policies, Programs, and Impacts: An Empirical Study.” Business & Society 58 (2): 231–67. https://doi.org/10.1177/0007650316647951
Graham, Susan L., Robert R. Henry, and Robert A. Schulman. 1982. An Experiment in Table Driven Code Generation. Defense Technical Information Center. https://doi.org/10.21236/ada120610
Graham, S. L., and Benjamin G. Zorn. 1984. Experiences with Ada (Trademark) Code Generation. Defense Technical Information Center. https://doi.org/10.21236/ada167568
“Graph Theory and Environmental Algorithmic Solutions to Assign Vehicles: Application to Garbage Collection in Vietnam.” 2019. Advances in Decision Sciences 23 (3): 1–35. https://doi.org/10.47654/v23y2019i3p1-35
Gray, Robert W., Steven P. Levi, Vincent P. Heuring, Anthony M. Sloane, and William M. Waite. 1992. “Eli: A Complete, Flexible Compiler Construction System.” Communications of the ACM 35 (2): 121–30. https://doi.org/10.1145/129630.129637
Grech, Neville, Kyriakos Georgiou, James Pallister, Steve Kerrison, Jeremy Morse, and Kerstin Eder. 2015. “Static Analysis of Energy Consumption for LLVM IR Programs.” In Proceedings of the 18th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/2764967.2764974
Green, Nathan, and Septina Dian Larasati. 2014. “Votter Corpus: A Corpus of Social Polling Language.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/3ankmkxr6t46
Grether, David M. 1982. “Inference in Practice: Judgment under Uncertainty . Heuristics and Biases. Daniel Kahneman, Paul Slovic, and Amos Tversky, Eds. Cambridge University Press, New York, 1982. Xiv, 556 Pp., Illus. Cloth, $44.50; Paper, $14.95.” Science 218 (4579): 1300–1301. https://doi.org/10.1126/science.218.4579.1300
Grimstad, Stein, and Magne Jørgensen. 2008. “A Preliminary Study of Sequence Effects in Judgment-Based Software Development Work-Effort Estimation.” In Electronic Workshops in Computing. BCS Learning & Development. https://doi.org/10.14236/ewic/ease2008.14
Grimstad, S., and M. Jørgensen. 2009. “Preliminary Study of Sequence Effects in Judgment-Based Software Development Work-Effort Estimation.” IET Software 3 (5): 435–41. https://doi.org/10.1049/iet-sen.2008.0110
Grochowski, Konrad, Michał Breiter, and Robert Nowak. 2020. “Serialization in Object-Oriented Programming Languages.” In Introduction to Data Science and Machine Learning. IntechOpen. https://doi.org/10.5772/intechopen.86917
Große, Daniel, and Rolf Drechsler. 2003. “Ein Ansatz Zur Formalen Verifikation Von Schaltungsbeschreibungen in SystemC (an Approach for Formal Verification of Circuits in SystemC).” it - Information Technology 45 (4): 219–26. https://doi.org/10.1524/itit.45.4.219.22731
Grover, Monika, and Pradeep Kumar Bhatia. 2016. “Analytical Review of Software Testing Effort Estimation Using Case Point Method.” In Proceedings of the 2016 Sixth International Conference on Advanced Computing & Communication Technologies. Research Publishing Services. https://doi.org/10.3850/978-981-11-0783-2_451
Gruian, Flavius, and Mehmet Ali Arslan. 2012. “Java Bytecode to Hardware Made Easy with Bluespec System Verilog.” In Proceedings of the 10th International Workshop on Java Technologies for Real-time and Embedded Systems. ACM. https://doi.org/10.1145/2388936.2388951
Gruian, Radu, and Tim Teitelbaum. 2005. Static Analysis for Detecting Vulnerabilities in COTS. Defense Technical Information Center. https://doi.org/10.21236/ada431817
Guerrini, Giovanna, Marco Mesiti, and Daniele Rossi. 2005. “Impact of XML Schema Evolution on Valid Documents.” In Proceedings of the 7th annual ACM international workshop on Web information and data management. ACM. https://doi.org/10.1145/1097047.1097056
Guha, Dipnarayan, and Thambipillai Srikanthan. 2008. “Compiler Back End Design for Translating Multi-Radio Descriptions to Operating System-Less Asynchronous Processor Datapaths.” Journal of Computers 3 (1). https://doi.org/10.4304/jcp.3.1.7-14
“Guidelines for Dealing with Faculty Conflicts of Commitment and Conflicts of Interest in Research. July 1990. Association of American Medical Colleges Ad Hoc Committee on Misconduct and Conflict of Interest in Research.” 1990. Academic Medicine 65 (7): 487–96. https://doi.org/10.1097/00001888-199007000-00025
“Guidelines for Faculty Involvement in Commercially Supported Continuing Medical Education. AAMC Ad Hoc Committee on Misconduct and Conflict of Interest in Research. AAMC Subcommittee on Conflict of Interest in Continuing Medical Education.” 1992. Academic Medicine 67 (9): 615–21. https://doi.org/10.1097/00001888-199209000-00021
Gulden, Samuel L. 1988. The Development of a Compiler Design Course with Ada as the Implementation Language. Defense Technical Information Center. https://doi.org/10.21236/ada265126
Gulezian, R. C. 1988. Application of Statistical Methods to the Development of Naval Software Maintenance and Related Cost Estimation Models. Defense Technical Information Center. https://doi.org/10.21236/ada201840
Gunnerson, Eric. 2001. “Execution-Time Code Generation.” In A Programmer’s Introduction to C#. Apress. https://doi.org/10.1007/978-1-4302-0909-6_30
Gunter, Carl A., Peter D. Mosses, and Dana S. Scott. 1989. Semantic Domains and Denotational Semantics. Defense Technical Information Center. https://doi.org/10.21236/ada220285
Guo, Zhanjie. 2018. “A New Compiler Framework Based on Superword Level Parallel.” International Journal of Performability Engineering. https://doi.org/10.23940/ijpe.18.10.p27.25112521
Guo, Katherine, Mark Hayden, Robbert Van Renesse, Werner Vogels, and Kenneth P. Birman. 1997. GSGC: An Efficient Gossip-Style Garbage Collection Scheme for Scalable Reliable Multicast. Defense Technical Information Center. https://doi.org/10.21236/ada542422
Guo, Pengshuai, Kai Nie, and Qinglei Zhou. 2024b. “Structure Layout Optimization Based on GCC.” In Third International Conference on Electronic Information Engineering, Big Data, and Computer Technology (EIBDCT 2024), edited by Jie Zhang, Ning Sun. SPIE. https://doi.org/10.1117/12.3031287
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, Harish. 2024. “Conflict of Interest in Research.” Journal of Medical Evidence 5 (4): 360–360. https://doi.org/10.4103/jme.jme_56_24
Gupta, Sumit, Nargish Gupta, and Rishabh Gupta. 2014a. “Objects and Method Calling in Java Virtual Machine.” International Journal of Computer Applications 86 (11): 34–36. https://doi.org/10.5120/15032-3353
Gupta, Deepti, and Sushma Malik. 2020. “Implementation of Data Mining Techniques for Software Development Effort Estimation.” In Computational Intelligence Techniques and Their Applications to Software Engineering Problems. CRC Press. https://doi.org/10.1201/9781003079996-3
Gupta, Rajiv, Eduard Mehofer, and Youtao Zhang. 2002. “Profile-Guided Compiler Optimizations.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579.ch4
Gupta, Rajiv, Santosh Pande, and Soner Onder. 2003. Power-Adaptive Microarchitecture and Compiler Design for Mobile Computing. Defense Technical Information Center. https://doi.org/10.21236/ada416016
Gupta, Manish, and Edith Schonberg. 1997. “Static Analysis to Reduce Synchronization Costs Data-Parallel Programs with Remote Memory Copy.” Parallel Processing Letters 07 (02): 145–56. https://doi.org/10.1142/s0129626497000164
Gupta, Syona, Geeta Sikka, and Harsh Verma. 2011. “Recent Methods for Software Effort Estimation by Analogy.” ACM SIGSOFT Software Engineering Notes 36 (4): 1–5. https://doi.org/10.1145/1988997.1989016
Gupta, Avinash, Aprna Tripathi, and Dharmendra Singh Kuswaha. 2014b. “Use Case Based Approach to Analyze Software Change Impact and Its Regression Test Effort Estimation.” In Lecture Notes in Electrical Engineering. Springer International Publishing. https://doi.org/10.1007/978-3-319-07674-4_98
Ha, Thi-Minh-Phuong, and Ngoc-Tho Huynh. 2026. “A Comprehensive Survey on Software Effort Estimation Using Machine Learning and Optimization Algorithms.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-00972-2_22
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
Häfner, Dion, and Filippo Vicentini. 2021. “mpi4jax: Zero-Copy MPI Communication of JAX Arrays.” Journal of Open Source Software 6 (65): 3419. https://doi.org/10.21105/joss.03419
Hagedorn, Bastian, Larisa Stoltzfus, Michel Steuwer, Sergei Gorlatch, and Christophe Dubach. 2018. “High Performance Stencil Code Generation with Lift.” In Proceedings of the 2018 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3168824
Hai, Vo Van, Ho Le Thi Kim Nhung, and Huynh Thai Hoc. 2020. “A Productivity Optimising Model for Improving Software Effort Estimation.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-63322-6_62
Hai, Vo Van, Ho Le Le Le Nhung, and Roman Jasek. 2022. “Toward Applying Agglomerative Hierarchical Clustering in Improving the Software Development Effort Estimation.” In Lecture Notes in Networks and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-031-09070-7_30
Haidl Michael, Hagedorn Bastian, and Gorlatch Sergei. 2016. “Programming GPUs with C++14 and Just-In-Time Compilation.” In Advances in Parallel Computing. IOS Press. https://doi.org/10.3233/978-1-61499-621-7-247
Hajrić, Zlata, Amela Pašić, and Razija Spahić. 2017. “Outcome of Multivisceral Echinococcosis: A Case Report Conflict of Interest.” Sanamed 12 (2): 109–14. https://doi.org/10.24125/sanamed.v12i2.188
Halbwachs, Nicolas. 1993a. “Distributed Code Generation.” In Synchronous Programming of Reactive Systems. Springer US. https://doi.org/10.1007/978-1-4757-2231-4_7
Halbwachs, Nicolas. 1993b. “Sequential Code Generation.” In Synchronous Programming of Reactive Systems. Springer US. https://doi.org/10.1007/978-1-4757-2231-4_6
Hamed, Injy, Mohamed Elmahdy, and Slim Abdennadher. 2018. “Collection and Analysis of Code-Switch Egyptian Arabic-English Speech Corpus.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/2fi2pfcqkpmk
Hamid, Nadeem A., and Zhong Shao. 2005. Interfacing Hoare Logic and Type Systems for Foundational Proof-Carrying Code. Defense Technical Information Center. https://doi.org/10.21236/ada436479
Hamilton, J. 1953. “Convergence in the Intermediate Representation.” Mathematical Proceedings of the Cambridge Philosophical Society 49 (4): 642–49. https://doi.org/10.1017/s030500410002884x
Hamilton, G. W., and S. B. Jones. 1991. “Compile-Time Garbage Collection by Necessity Analysis.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3810-5_6
Hamza, Hamza, Alan Hughes, and Raimund Kirner. 2015. “On the Design of a Java Virtual Machine for Mixed-Criticality Systems.” In Proceedings of the 13th International Workshop on Java Technologies for Real-time and Embedded Systems. ACM. https://doi.org/10.1145/2822304.2822315
Hankins, Richard A., and Jignesh M. Patel. 2003. “Effect of Node Size on the Performance of Cache-Conscious B + -Trees.” ACM SIGMETRICS Performance Evaluation Review 31 (1): 283–94. https://doi.org/10.1145/885651.781063
Hanono, Silvina, and Srinivas Devadas. 1998. “Instruction Selection, Resource Allocation, and Scheduling in the AVIV Retargetable Code Generator.” In Proceedings of the 35th annual conference on Design automation conference - DAC ‘98. ACM Press. https://doi.org/10.1145/277044.277184
Hansen, Niels Damgaard, and Kim Halskov Madsen. 1982. “Formal Semantics by a Combination of Denotational Semantics and High-Level Petri Nets.” DAIMI Report Series 11 (152). https://doi.org/10.7146/dpb.v11i152.7426
Hansson Erik and Kessler Christoph. 2016. “Optimized Variant-Selection Code Generation for Loops on Heterogeneous Multicore Systems.” In Advances in Parallel Computing. IOS Press. https://doi.org/10.3233/978-1-61499-621-7-103
Hao, Hao, Vicky Singh, and Wenliang Du. 2013. “On the Effectiveness of API-Level Access Control Using Bytecode Rewriting in Android.” In Proceedings of the 8th ACM SIGSAC symposium on Information, computer and communications security. ACM. https://doi.org/10.1145/2484313.2484317
Hardin, David S. 2015. “Reasoning about LLVM Code Using Codewalker.” Electronic Proceedings in Theoretical Computer Science 192: 79–92. https://doi.org/10.4204/eptcs.192.7
Hardin, David S., Jennifer A. Davis, David A. Greve, and Jedidiah R. McClurg. 2014. “Development of a Translator from LLVM to ACL2.” Electronic Proceedings in Theoretical Computer Science 152: 163–77. https://doi.org/10.4204/eptcs.152.13
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
Harel, Assaf, Dwight J. Kravitz, and Chris I. Baker. 2012. “Deconstructing Visual Scenes in Cortex: Gradients of Object and Spatial Layout Information.” Cerebral Cortex 23 (4): 947–57. https://doi.org/10.1093/cercor/bhs091
Hariati, Mehdi. 2020. “Formal Verification Issues for Component-Based Development.” Informatica 44 (4). https://doi.org/10.31449/inf.v44i4.3152
Hariri, Farah, and August Shi. 2018. “SRCIROR: A Toolset for Mutation Testing of C Source Code and LLVM Intermediate Representation.” In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering. ACM. https://doi.org/10.1145/3238147.3240482
Harish Kumar, K., and K. Srinivas. 2022. “Efficient Analogy-Based Software Effort Estimation Using ANOVA Convolutional Neural Network in Software Project Management.” In Smart Innovation, Systems and Technologies. Springer Nature Singapore. https://doi.org/10.1007/978-981-16-9669-5_35
Harper, Robert, and Christopher Stone. 2000. “A Type-Theoretic Interpretation of Standard ML.” In Proof, Language, and Interaction. The MIT Press. https://doi.org/10.7551/mitpress/5641.003.0019
Harrison, Warren. 1987. “An Extensible Static Analysis Tool for COBOL Programs.” In Proceedings of the 15th annual conference on Computer Science - CSC ‘87. ACM Press. https://doi.org/10.1145/322917.322962
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
Harrison John. 2011. “Formal Verification.” In NATO Science for Peace and Security Series - D: Information and Communication Security. IOS Press. https://doi.org/10.3233/978-1-60750-711-6-103
Hart, Ruth M., and Marilyn S. McClanahan. 1981. JOVIAL (J73) Compiler Validator. Defense Technical Information Center. https://doi.org/10.21236/ada102386
Hasan, Mujtaba. 2026. “StructHallu-Drift: Benchmarking Structured Hallucinations under Schema Evolution in LLMs.” In Proceedings of the First Workshop on Structured Understanding, Retrieval, and Generation in the LLM Era (SURGeLLM 2026). Association for Computational Linguistics. https://doi.org/10.18653/v1/2026.surgellm-1.22
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
Hatledal, Lars Ivar, Houxiang Zhang, Arne Styve, and Geir Hovland. 2018. “FMI4j: A Software Package for Working with Functional Mock-up Units on the Java Virtual Machine.” In Linköping Electronic Conference Proceedings, vol. 153. Linköping University Electronic Press. https://doi.org/10.3384/ecp1815337
Häubl, Christian, and Hanspeter Mössenböck. 2011. “Trace-Based Compilation for the Java HotSpot Virtual Machine.” In Proceedings of the 9th International Conference on Principles and Practice of Programming in Java. ACM. https://doi.org/10.1145/2093157.2093176
Häubl, Christian, Christian Wimmer, and Hanspeter Mössenböck. 2008. “Optimized Strings for the Java HotSpot™ Virtual Machine.” In Proceedings of the 6th international symposium on Principles and practice of programming in Java. ACM. https://doi.org/10.1145/1411732.1411747
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
Hausler, Dominique. 2024. “Estimation, Impact and Visualization of Schema Evolution in Graph Databases.” In Proceedings of the ACM/IEEE 27th International Conference on Model Driven Engineering Languages and Systems. ACM. https://doi.org/10.1145/3652620.3688196
Hayashi, Akihiro, Jisheng Zhao, Michael Ferguson, and Vivek Sarkar. 2015. “LLVM-Based Communication Optimizations for PGAS Programs.” In Proceedings of the Second Workshop on the LLVM Compiler Infrastructure in HPC. ACM. https://doi.org/10.1145/2833157.2833164
Hayes, Will, and James W. Over. 1997. The Personal Software Process (PSPSM): An Empirical Study of the Impact of PSP on Individual Engineers. Defense Technical Information Center. https://doi.org/10.21236/ada335543
Hazaea, Abduljalil Nasr, and Mutahar Qassem. 2024. “Translation Competence in Translator Training Programs at Saudi Universities: Empirical Study.” Open Education Studies 6 (1): 20240029. https://doi.org/10.1515/edu-2024-0029
He, Gao Ming. 2013. “Research on Protection Methods of Embedded Operating System Software Based on Hardware Compiler.” Applied Mechanics and Materials 443: 556–60. https://doi.org/10.4028/www.scientific.net/amm.443.556
He, Linwei, Matthew Gilbert, Thomas Johnson, and Chris Smith. 2017. “Human-in-the-Loop Layout and Geometry Optimization of Structures and Components.” In Advances in Structural and Multidisciplinary Optimization. Springer International Publishing. https://doi.org/10.1007/978-3-319-67988-4_102
Heckman, Sarah, and Laurie Williams. 2008. “On Establishing a Benchmark for Evaluating Static Analysis Alert Prioritization and Classification Techniques.” In Proceedings of the Second ACM-IEEE international symposium on Empirical software engineering and measurement. ACM. https://doi.org/10.1145/1414004.1414013
Heil, Timothy H., and James E. Smith. 2000. “Concurrent Garbage Collection Using Hardware-Assisted Profiling.” In Proceedings of the 2nd international symposium on Memory management. ACM. https://doi.org/10.1145/362422.362466
Heil, Timothy, and James E. Smith. 2002. “Concurrent Garbage Collection Using Hardware-Assisted Profiling.” In Java Microarchitectures. Springer US. https://doi.org/10.1007/978-1-4615-0993-6_8
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
Heine, Bernd, Heiko Narrog, and Douglas Biber. 2015. “Corpus-Based and Corpus-Driven Analyses of Language Variation and Use.” In The Oxford Handbook of Linguistic Analysis. Oxford University Press. https://doi.org/10.1093/oxfordhb/9780199677078.013.0008
Heintze, Nevin. 1994. Control-Flow Analysis and Type Systems. Defense Technical Information Center. https://doi.org/10.21236/ada289338
Hema, N., K. G. Srinivasa, Saravanan Chidambaram, et al. 2016. “Performance Analysis of Java Virtual Machine for Machine Learning Workloads Using Apache Spark.” In Proceedings of the International Conference on Informatics and Analytics. ACM. https://doi.org/10.1145/2980258.2982117
Hemmert, Scott, Brad Hutchings, and Anshul Malvi. 2006. An Application-Specific Compiler for High-Speed Binary Image Morphology. Defense Technical Information Center. https://doi.org/10.21236/ada443748
Henglein, Fritz, and Jakob Rehof. 1995. “Safe Polymorphic Type Inference for a Dynamically Typed Language: Translating Scheme to ML.” In Proceedings of the seventh international conference on Functional programming languages and computer architecture - FPCA ‘95. ACM Press. https://doi.org/10.1145/224164.224203
Hennell, M. A., W. M. McNicol, and J. Hawkins. 1980. “The Static Analysis of Cobol Programs.” ACM SIGSOFT Software Engineering Notes 5 (4): 17–25. https://doi.org/10.1145/1010884.1010889
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
Hepburn, Sharon A. Roger, and Jeffrey Ruggles. 2004. “The Unboxing of Henry Brown.” Journal of Southern History 70 (4): 917. https://doi.org/10.2307/27648588
Herczeg, Zoltán. 2014. “Extending the PCRE Library with Static Backtracking Based Just-in-Time Compilation Support.” In Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/2581122.2544146
Heredia, Maite, Jeremy Barnes, and Aitor Soroa. 2025. “EuskañolDS: A Naturally Sourced Corpus for Basque-Spanish Code-Switching.” In Proceedings of the 7th Workshop on Computational Approaches to Linguistic Code-Switching. Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.calcs-1.1
Hertz, Matthew, Neil Immerman, and J. Eliot B. Moss. 2002. “Framework for Analyzing Garbage Collection.” In Foundations of Information Technology in the Era of Network and Mobile Computing. Springer US. https://doi.org/10.1007/978-0-387-35608-2_20
Heuring, Vincent P., William M. Waite, and Gerhard Fischer. 1990. Automatic Compiler Construction. Defense Technical Information Center. https://doi.org/10.21236/ada218777
“Heuristics and Biases in Audience Decision Making.” 2016a. In Persuasive Communication. Routledge. https://doi.org/10.4324/9781315687117-13
“Heuristics and Biases in Decision Making about Risk.” 2016b. In Routledge Handbook of Risk Studies. Routledge. https://doi.org/10.4324/9781315776835-22
Heyliger, George E., Lyle L. McElhaney, Timothy H. Dwyer, and Patrick J. Keziah. 1980. Recommendations for a Retargetable Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada084195
Hibino, Yasushi. 1980. “A Practical Parallel Garbage Collection Algorithm and Its Implementation.” In Proceedings of the 7th annual symposium on Computer Architecture - ISCA ‘80. ACM Press. https://doi.org/10.1145/800053.801916
Hickey, Jason, Aleksey Nogin, Adam Granicz, and Brian Aydemir. 2003b. Formal Compiler Implementation in a Logical Framework. Defense Technical Information Center. https://doi.org/10.21236/ada437424
Hidalgo-Suarez, Carlos Giovanny, Victor Andres Bucheli-Guerrero, and Hugo Armando Ordoñez-Eraso. 2022. “VIGHUB: A Technology Forecasting Tool Based on Mining Software Repositories.” Inge CuC 18 (1): 83–94. https://doi.org/10.17981/ingecuc.18.1.2022.07
Hilbig, Aaron, Daniel Lehmann, and Michael Pradel. 2021. “An Empirical Study of Real-World WebAssembly Binaries: Security, Languages, Use Cases.” In Proceedings of the Web Conference 2021. ACM. https://doi.org/10.1145/3442381.3450138
Hillah, Nico, and Thibault Estier. 2018. “The Application of Change Indicators in Mining Software Repositories.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-319-77712-2_40
Hills, Mark, Paul Klint, and Jurgen Vinju. 2013. “An Empirical Study of PHP Feature Usage: A Static Analysis Perspective.” In Proceedings of the 2013 International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/2483760.2483786
Himschoot, Peter. 2020a. “Conclusion: Debugging Blazor WebAssembly.” In Practical Blazor Debugging. Apress. https://doi.org/10.1007/978-1-4842-6592-5_8
Himschoot, Peter. 2020b. “Debugging Blazor WebAssembly.” In Practical Blazor Debugging. Apress. https://doi.org/10.1007/978-1-4842-6592-5_2
Himschoot, Peter. 2020c. “Targeting Both Blazor Server and Blazor WebAssembly.” In Practical Blazor Debugging. Apress. https://doi.org/10.1007/978-1-4842-6592-5_3
Hindle, Abram, Alex Wilson, Kent Rasmussen, E. Jed Barlow, Joshua Charles Campbell, and Stephen Romansky. 2014. “GreenMiner: A Hardware Based Mining Software Repositories Software Energy Consumption Framework.” In Proceedings of the 11th Working Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/2597073.2597097
“Hindsight ≠ Foresight: The Effect of Outcome Knowledge on Judgment under Uncertainty.” 2013. In Judgment and Decision Making. Routledge. https://doi.org/10.4324/9780203141939-14
Hira, Anandi, Barry Boehm, Robert Stoddard, and Michael Konrad. 2018. “Preliminary Causal Discovery Results with Software Effort Estimation Data.” In Proceedings of the 11th Innovations in Software Engineering Conference. ACM. https://doi.org/10.1145/3172871.3172876
Hiraoka, Tatsuya. 2026. “Corpus-Dependent Subcharacter Encoding via HMM-Guided Code Assignment.” In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics. https://doi.org/10.18653/v1/2026.acl-long.1596
Hirschman, Elizabeth C. 1983. “Book Review: Judgement under Uncertainty: Heuristics and Biases.” Journal of Marketing Research 20 (2): 217–217. https://doi.org/10.1177/002224378302000213
Hirschman, Elizabeth C., Daniel Kahneman, Paul Slovic, and Amos Tversky. 1983. “Judgement under Uncertainty: Heuristics and Biases.” Journal of Marketing Research 20 (2): 217. https://doi.org/10.2307/3151689
Hlavac, Jim. 2016. “Code-Switching, Lexico-Grammatical Features and Loan Translation: Data from a Large Macedonian-English Corpus.” Philologia Estonica Tallinnensis 1 (1): 38–60. https://doi.org/10.22601/pet.2016.01.04
Hobbs, Chris. 2025a. “Formal Verification.” In Embedded Software Development for Safety-Critical Systems. CRC Press. https://doi.org/10.1201/9781003598145-18
Hobbs, Chris. 2025b. “Semi-Formal Verification.” In Embedded Software Development for Safety-Critical Systems. CRC Press. https://doi.org/10.1201/9781003598145-17
Hoc, Huynh Thai, Vo Van Hai, and Ho Le Thi Kim Nhung. 2019. “A Review of the Regression Models Applicable to Software Project Effort Estimation.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-31362-3_39
Hoebel, Lou, and Chris Welty. 1999. “Backtracking: Garbage Collection.” intelligence 10 (2): 48. https://doi.org/10.1145/309697.309710
Hofer, Peter, David Gnedt, Andreas Schörgenhumer, and Hanspeter Mössenböck. 2016. “Efficient Tracing and Versatile Analysis of Lock Contention in Java Applications on the Virtual Machine Level.” In Proceedings of the 7th ACM/SPEC on International Conference on Performance Engineering. ACM. https://doi.org/10.1145/2851553.2851559
Hofer, Peter, and Hanspeter Mössenböck. 2014. “Efficient and Accurate Stack Trace Sampling in the Java Hotspot Virtual Machine.” In Proceedings of the 5th ACM/SPEC international conference on Performance engineering. ACM. https://doi.org/10.1145/2568088.2576759
Hohenauer, Manuel, and Rainer Leupers. 2009. “Results for Semantics Based Compiler Generation.” In C Compilers for ASIPs. Springer New York. https://doi.org/10.1007/978-1-4419-1176-6_7
Holtmann, Ulrich, and Peter Blinzer. 1998. “Design of a SPDIF Receiver Using Protocol Compiler.” In Proceedings of the 35th annual conference on Design automation conference - DAC ‘98. ACM Press. https://doi.org/10.1145/277044.277243
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
Horváth, Gábor, and Norbert Pataki. 2016. “Source Language Representation of Function Summaries in Static Analysis.” In Proceedings of the 11th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems. ACM. https://doi.org/10.1145/3012408.3012414
Horwat, Waldemar. 1988. A Concurrent Smalltalk Compiler for the Message-Driven Processor. Defense Technical Information Center. https://doi.org/10.21236/ada202182
Hoshieah, Noura, Samer Zein, Norsaremah Salleh, and John Grundy. 2019. “A Static Analysis of Android Source Code for Lifecycle Development Usage Patterns.” Journal of Computer Science 15 (1): 92–107. https://doi.org/10.3844/jcssp.2019.92.107
Hoshino, Tetsuya, Toyohiko Yatagai, and Masahide Itoh. 2012. “A Columnar Model Explaining Long-Term Memory.” Optical Memory and Neural Networks 21 (4): 209–18. https://doi.org/10.3103/s1060992x12040042
Hosking, Antony L. 2006. “Portable, Mostly-Concurrent, Mostly-Copying Garbage Collection for Multi-Processors.” In Proceedings of the 5th international symposium on Memory management. ACM. https://doi.org/10.1145/1133956.1133963
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
Hosni, Mohamed, and Ali Idri. 2017. “Software Effort Estimation Using Classical Analogy Ensembles Based on Random Subspace.” In Proceedings of the Symposium on Applied Computing. ACM. https://doi.org/10.1145/3019612.3019784
Hosni, Mohamed, Ali Idri, and Alain Abran. 2017. “Investigating Heterogeneous Ensembles with Filter Feature Selection for Software Effort Estimation.” In Proceedings of the 27th International Workshop on Software Measurement and 12th International Conference on Software Process and Product Measurement. ACM. https://doi.org/10.1145/3143434.3143456
Hosni Mohamed and Idri Ali. 2018. “Software Development Effort Estimation Using Feature Selection Techniques.” In Frontiers in Artificial Intelligence and Applications. IOS Press. https://doi.org/10.3233/978-1-61499-900-3-439
Hou, Hsiao-I. 2014. “‘A Knockout on the Palates!’ a Corpus-Based Analysis of Language Use in the Wine Community.” Journal of Language and Literature 5 (1): 78–88. https://doi.org/10.7813/jll.2014/5-1/12
Houghton, H. A. G. 2020. “Chapter 5. the Layout and Structure of the Catena.” In Codex Zacynthius: Catena, Palimpsest, Lectionary. Gorgias Press. https://doi.org/10.31826/9781463241087-009
Hsiao, Chun-Hung, Michael Cafarella, and Satish Narayanasamy. 2014. “Using Web Corpus Statistics for Program Analysis.” In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications. ACM. https://doi.org/10.1145/2660193.2660226
Hu, Xian Chuan. 2013. “Zero-Copy Implementation in the Linux Operating System.” Advanced Materials Research 765-767: 968–71. https://doi.org/10.4028/www.scientific.net/amr.765-767.968
Hu, Chunling, John McCabe, Daniel A. Jiménez, and Ulrich Kremer. 2005. “The Camino Compiler Infrastructure.” ACM SIGARCH Computer Architecture News 33 (5): 3–8. https://doi.org/10.1145/1127577.1127580
Hu, Huimin, Yingying Wang, Julia Rubin, and Michael Pradel. 2025. “An Empirical Study of Suppressed Static Analysis Warnings.” Proceedings of the ACM on Software Engineering 2 (FSE): 290–311. https://doi.org/10.1145/3715729
Hu, Tianxun, Tianzheng Wang, and Qingqing Zhou. 2022a. “Online Schema Evolution Is (Almost) Free for Snapshot Databases.” Proceedings of the VLDB Endowment 16 (2): 140–53. https://doi.org/10.14778/3565816.3565818
Huang, Martin. 2021. “Unpacking Planning Fallacy.” International Journal of Psychological Studies 13 (2): 84. https://doi.org/10.5539/ijps.v13n2p84
Huang, Mu-Eng, Chung-Yi Chen, Yi-Ping You, and Wuu Yang. 2025b. “CompressRA+: Enhanced Register Allocation for Compressed ISAs.” In Workshop Proceedings of the 54th International Conference on Parallel Processing. ACM. https://doi.org/10.1145/3750720.3757286
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
Huang, Changyun, Yasutaka Kamei, Kazuhiro Yamashita, and Naoyasu Ubayashi. 2013b. “Using Alloy to Support Feature-Based DSL Construction for Mining Software Repositories.” In Proceedings of the 17th International Software Product Line Conference co-located workshops. ACM. https://doi.org/10.1145/2499777.2500714
Huang Bo, Fang Zhijun, Wu Guoqing, Sun Xiankun, and Gao Yongbin. 2017. “A New Code Generation Method for Software Engineering: From Requirements Model to Source Code.” In Frontiers in Artificial Intelligence and Applications. IOS Press. https://doi.org/10.3233/978-1-61499-800-6-747
Huelsbergen, Lorenz, and Phil Winterbottom. 1998. “Very Concurrent Mark-&-Sweep Garbage Collection without Fine-Grain Synchronization.” In Proceedings of the 1st international symposium on Memory management. ACM. https://doi.org/10.1145/286860.286878
Hughes, Jacob. 2024. “Retro-Fitting Garbage Collection into Rust (Invited Talk).” In Companion Proceedings of the 8th International Conference on the Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3660829.3661030
“Human-in-the-Loop Secure Code Synthesis: Integrating Security Heuristics in AI Code Generation.” 2025. International Journal of Emerging Research in Engineering and Technology 6 (4). https://doi.org/10.63282/3050-922x.ijeret-v6i4p101
Humberstone, I. L. 1987. “Operational Semantics for Positive Rm R.” Notre Dame Journal of Formal Logic 29 (1): 61–80. https://doi.org/10.1305/ndjfl/1093637771
Humphrey, Laura, Ryan Baity, and Kenneth Hopkinson. 2021. “Formal Verification of Safety-Critical Software Using SPARK.” In Aviation Cybersecurity: Foundations, principles, and applications. IET / SciTech. https://doi.org/10.1049/sbra545e_ch2
Hunt, John. 1997. “Memory Management and Garbage Collection.” In Smalltalk and Object Orientation. Springer London. https://doi.org/10.1007/978-1-4471-0961-7_30
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
Huo, Junzhou. 2014. “Coupling Layout Design of Disc Cutters Group and Cutterhead Supporting Structure.” Journal of Mechanical Engineering 50 (21): 23. https://doi.org/10.3901/jme.2014.21.023
Husbands, Parry, Costin Iancu, and Katherine Yelick. 2003. “A Performance Analysis of the Berkeley UPC Compiler.” In Proceedings of the 17th annual international conference on Supercomputing - ICS ‘03. ACM Press. https://doi.org/10.1145/782821.782825
Hussain, Azath, Maheswari Raja, Pandimurugan Vellaisamy, Sangeetha Krishnan, and Lakshminarayanan Rajendran. 2021. “Enhanced Framework for Ensemble Effort Estimation by Using Recursive-Based Classification.” IET Software 15 (3): 230–38. https://doi.org/10.1049/sfw2.12020
Hwu, W. W., and P. P. Chang. 1989. “Achieving High Instruction Cache Performance with an Optimizing Compiler.” ACM SIGARCH Computer Architecture News 17 (3): 242–51. https://doi.org/10.1145/74926.74953
“The IBM J9 Java Virtual Machine for Java 6.” 2009. In Pro IBM® WebSphere® Application Server 7 Internals. Apress. https://doi.org/10.1007/978-1-4302-1959-0_2
Ibrahim, Hamdy, and Behrouz Far. 2016. “Clustering and Artificial Neural Network Ensembles Based Effort Estimation.” 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-250
Ibrahim, Mohamed Assem, Onur Kayiran, and Shaizeen Aga. 2021. “Efficient Cache Utilization via Model-Aware Data Placement for Recommendation Models.” In The International Symposium on Memory Systems. ACM. https://doi.org/10.1145/3488423.3519317
Ichisugi, Yuuji, and Akinori Yonezawa. 1991. “Distributed Garbage Collection Using Group Reference Counting.” In Software Science and Engineering. WORLD SCIENTIFIC. https://doi.org/10.1142/9789814360128_0011
Ide, Masahiro, and Kimio Kuramitsu. 2013. “Just-in-Time Compiler for KonohaScript Using LLVM.” IPSJ Online Transactions 6 (0): 9–16. https://doi.org/10.2197/ipsjtrans.6.9
“The Ideal Layout of a Local Record Repository.” 1951. Archives: The Journal of the British Records Association 1 (6): 31–35. https://doi.org/10.3828/archives.1951.21
Idri, Ali, Wafa El Boukili, and Abdelali Zakrani. 2014. “Comparing the Performance of Rbfn Networks Based Software Effort Estimation Models.” In Decision Making and Soft Computing. WORLD SCIENTIFIC. https://doi.org/10.1142/9789814619998_0106
Idrissi, Hind, El Mamoun Souidi, and Arnaud Revel. 2015. “Mobile Agent Security Using ID-Based Agreement Protocol and Binary Serialization.” International Journal of Security and Its Applications 9 (5): 19–30. https://doi.org/10.14257/ijsia.2015.9.5.02
Ika, Lavagnon A. 2025. “The Rise and Fall of the Planning Fallacy: From the Impulsion to the Compulsion to Theorize.” In Cambridge Handbook of Project Behavior. Cambridge University Press. https://doi.org/10.1017/9781009322737.003
Ilesanmi, Solanke, Alomaja Victor Ojumu, Ajayi Abiodun Folurera, and Ajao Aisha Omorinbola. 2021. “Empirical Investigation of Cloud, Grid and Virtualization Using Compiler Optimization Level for Threads Processes.” International Journal of Innovative Research in Computer Science & Technology 9 (5). https://doi.org/10.21276/ijircst.2021.9.5.5
“Implementation of Cloud Integrated IoT as Garbage Collection System.” 2017. International Journal of Recent Trends in Engineering and Research 3 (4): 374–78. https://doi.org/10.23883/ijrter.2017.3160.0or9m
“Implementing Prolog with Chronological Garbage Collection.” 1999. In Logic Programming. The MIT Press. https://doi.org/10.7551/mitpress/4304.003.0057
“Implications of Compiler and Systems Issues for Software.” 2006. In A Programmer’s Companion to Algorithm Analysis. Chapman and Hall/CRC. https://doi.org/10.1201/9781420011708.ch6
“Improvement of Algebraic Models of Abstract Pipelines for Formal Verification.” 2018. Academic Journal of Computing & Information Science 1 (1). https://doi.org/10.25236/ajcis.010006
“An Improving Long Short Term Memory-Grid Search Based Deep Learning Neural Network for Software Effort Estimation.” 2023. International Journal of Intelligent Engineering and Systems 16 (4): 164–80. https://doi.org/10.22266/ijies2023.0831.14
“In Praise of Engineering a Compiler Second Edition.” 2012. In Engineering a Compiler. Elsevier. https://doi.org/10.1016/b978-0-12-088478-0.00021-9
Inafune, Tetsuya, Shinichi Miura, Toshihiro Taketa, and Yukio Hiranaka. 2018. “Symbolic Backward Simulation of Java Bytecode Program.” In Proceedings of the 10th International Conference on Computer Modeling and Simulation. ACM. https://doi.org/10.1145/3177457.3177480
Independent Researcher, Usa, and Jyoti Kunal Shah. 2023. “Ethical Considerations of LLM-Driven Quantum Code Generation for Optimization Tasks.” American Journal of Engineering and Technology 05 (12): 52–59. https://doi.org/10.37547/tajet/volume05issue12-13
Indra Kurniawan, Dwi Retna Sulistyowati, and Yasa Maulana. 2022. “Penerapan Seleksi Fitur Median Weighted Information Gain Dengan K-NN Pada Dataset Label Hours Software Effort Estimation.” Jurnal CoSciTech (Computer Science and Information Technology) 3 (2): 52–57. https://doi.org/10.37859/coscitech.v3i2.3876
Information Management INC San Francisco CA. 1970. User’s Manual Cobol Compiler Validation System. Defense Technical Information Center. https://doi.org/10.21236/ad0711369
Inoue, Hiroshi. 2012. “A Trace-Based Java JIT Compiler for Large-Scale Applications.” In Proceedings of the sixth ACM workshop on Virtual machines and intermediate languages. ACM. https://doi.org/10.1145/2414740.2414742
Inoue, Hiroshi, Hiroshige Hayashizaki, Peng Wu, and Toshio Nakatani. 2012. “Adaptive Multi-Level Compilation in a Trace-Based Java JIT Compiler.” In Proceedings of the ACM international conference on Object oriented programming systems languages and applications. ACM. https://doi.org/10.1145/2384616.2384630
“Instruction Selection.” 1997. In Modern Compiler Implementation in ML. Cambridge University Press. https://doi.org/10.1017/cbo9780511811449.010
“Instruction Selection.” 2002. In Modern Compiler Implementation in Java. Cambridge University Press. https://doi.org/10.1017/cbo9780511811432.010
“Instruction Selection Using Tree Parsing Priti Shankar.” 2002. In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579-19
“An Intensional Type Theory.” 2005. In Logicism Renewed. A K Peters/CRC Press. https://doi.org/10.1201/9781439864364-8
“An Intensional Type Theory.” 2017. In Logicism Renewed. Cambridge University Press. https://doi.org/10.1017/9781316755808.004
“Introduction to Compiler Design.” 2012. Choice Reviews Online 49 (07): 49-3909-49-3909. https://doi.org/10.5860/choice.49-3909
“Introduction to Operational Semantics.” 1993. In The Formal Semantics of Programming Languages. The MIT Press. https://doi.org/10.7551/mitpress/3054.003.0004
“Introduction to Operational Semantics Sanjiva Prasad and S. Arun-Kumar.” 2002. In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579-26
“Intuitionistic Type Theory.” 2015. In Computation, Proof, Machine. Cambridge University Press. https://doi.org/10.1017/cbo9781139026581.010
Ioannidis, John P. A., and John F. Trepanowski. 2018. “Conflict of Interest in Nutrition Research—Reply.” JAMA 320 (1): 94. https://doi.org/10.1001/jama.2018.5678
Iok Kuan, Simon Wu. 2017. “Factors on Software Effort Estimation.” International Journal of Software Engineering & Applications 8 (1): 23–32. https://doi.org/10.5121/ijsea.2017.8103
Iqbal, Danish, Sher Badshah, and Irfan Kazim. 2022. “The Influence of Cost Drivers on Effort Estimation in Distributed Software Development.” In The International Conference on Evaluation and Assessment in Software Engineering 2022. ACM. https://doi.org/10.1145/3530019.3531331
Iqbal, Adeel, and Minhaj Ahmad Khan. 2025a. “Efficient Java Bytecode Analysis and Sequence Identification for Embedded Systems.” VAWKUM Transactions on Computer Sciences 13 (2): 276–96. https://doi.org/10.21015/vtcs.v13i2.2227
Iqbal, Adeel, and Minhaj Ahmad Khan. 2025b. “Optimising Java Bytecode Execution Performance on Embedded Systems Using Instruction Set Enhancement.” International Journal of Embedded Systems 1 (1): 10075611. https://doi.org/10.1504/ijes.2025.10075611
Ismail, Kareem, Roberto Perrelli, and Jessie Yang. 2020. “Optimism Bias in Growth Forecasts—the Role of Planned Policy Adjustments.” IMF Working Papers 2020 (229): 1. https://doi.org/10.5089/9781513560373.001
“Itanium C++ ABI.” n.d. itanium-cxx-abi.github.io. Accessed October 24, 2026. https://itanium-cxx-abi.github.io/cxx-abi/abi.html
Iturriaga, Renato, Thomas A. Standish, Rudolph A. Krutar, and Jackson C. Earley. 1966. “Techniques and Advantages of Using the Formal Compiler Writing System FSL to Implement a Formula Algol Compiler.” In Proceedings of the April 26-28, 1966, Spring joint computer conference on XX - AFIPS ‘66 (Spring). ACM Press. https://doi.org/10.1145/1464182.1464212
Ivannikov, Victor, Shamil Kurmangaleev, Andrey Belevantsev, et al. 2014. “Implementing Obfuscating Transformations in the LLVM Compiler Infrastructure.” Proceedings of the Institute for System Programming of RAS 26 (1): 327–42. https://doi.org/10.15514/ispras-2014-26(1)-12
Ivanov, Lubomir. 2001. “Formal Verification of Microinstruction Sequencing.” In Computing and Information Technologies. WORLD SCIENTIFIC. https://doi.org/10.1142/9789812810885_0022
Iwai, Teruo, and Masakazu Nakanishi. 1999. “Restraint of Garbage Collection in a Parallel Lisp System Equipped with Parallel Garbage Collection.” IEEJ Transactions on Electronics, Information and Systems 119 (10): 1194–1200. https://doi.org/10.1541/ieejeiss1987.119.10_1194
Iwata, Kazunori, Toyoshiro Nakashima, Yoshiyuki Anan, and Naohiro Ishii. 2017. “Machine Learning Classification to Effort Estimation for Embedded Software Development Projects.” International Journal of Software Innovation 5 (4): 19–32. https://doi.org/10.4018/ijsi.2017100102
Iwata, Kazunori, Toyoshiro Nakashima, Yoshiyuki Anan, and Naohiro Ishii. 2022. “Machine Learning Classification to Effort Estimation for Embedded Software Development Projects.” In Research Anthology on Agile Software, Software Development, and Testing. IGI Global. https://doi.org/10.4018/978-1-6684-3702-5.ch078
Izam, Zakwan, Marlyna Maros, Azhar Jaludin, and Imran Ho Abdullah. 2023. “Penukaran Kod Dalam Korpus Hansard Malaysia: Analisis Berpandukan Korpus (Code-Switching in the Malaysian Hansard Corpus: A Corpus-Based Approach).” GEMA Online® Journal of Language Studies 23 (2). https://doi.org/10.17576/gema-2023-2302-12
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
Jablotschkin, Sarah, Elke Teich, and Heike Zinsmeister. 2024. “DE-Lite: A New Corpus of Easy German: Compilation, Exploration, Analysis.” In Proceedings of the Fourth Workshop on Language Technology for Equality, Diversity, Inclusion. Association for Computational Linguistics. https://doi.org/10.18653/v1/2024.ltedi-1.9
Jackson, Wallace. 2016. “JSON Arrays: Serialized Data Store Structures.” In JSON Quick Syntax Reference. Apress. https://doi.org/10.1007/978-1-4842-1863-1_5
Jackson, Daniel, and Allison Waingold. 1999. “Lightweight Extraction of Object Models from Bytecode.” In Proceedings of the 21st international conference on Software engineering. ACM. https://doi.org/10.1145/302405.302465
Jacob, Dejice, and Jeremy Singer. 2022. “Boehm-Demers-Weiser Garbage Collection on Morello.” In Proceedings of the 19th International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3546918.3560808
Jahagirdar, Ashok. 2026. “Type Systems in Programming Languages: A Performance, Safety, and Development Efficiency-Analysis of Static (Java/C++) vs. Dynamic (Python) Typing Paradigms.” International Journal of Science and Research (IJSR): 941–43. https://doi.org/10.21275/sr26113212016
Jain, Shashank Mohan. 2021a. “Extending Istio with WebAssembly.” In WebAssembly for Cloud. Apress. https://doi.org/10.1007/978-1-4842-7496-5_8
Jain, Shashank Mohan. 2021b. “WebAssembly Introduction.” In WebAssembly for Cloud. Apress. https://doi.org/10.1007/978-1-4842-7496-5_1
Jain, Shashank Mohan. 2021c. “WebAssembly Module Internals: Sections and Memory Model.” In WebAssembly for Cloud. Apress. https://doi.org/10.1007/978-1-4842-7496-5_2
Jain, Shashank Mohan. 2021d. “WebAssembly Text Toolkit and Other Utilities.” In WebAssembly for Cloud. Apress. https://doi.org/10.1007/978-1-4842-7496-5_3
Jain, Shashank Mohan. 2021e. “WebAssembly with Rust and JavaScript: An Introduction to Wasm-Bindgen.” In WebAssembly for Cloud. Apress. https://doi.org/10.1007/978-1-4842-7496-5_4
Jakimi, Abdeslam, and Mohammed Elkoutbi. 2009. “Automatic Code Generation from UML State Chart.” International Journal of Engineering and Technology 1 (2): 165–68. https://doi.org/10.7763/ijet.2009.v1.30
James, Sara I. 2022. “Structure and Layout.” In Radical Reporting. CRC Press. https://doi.org/10.1201/9781003216162-8
James, Sara I. 2024. “Structure and Layout.” In Radical Reporting. CRC Press. https://doi.org/10.1201/9781003422365-8
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
Jangra, Anubhav, Preksha Nema, and Aravindan Raghuveer. 2022. “T-STAR: Truthful Style Transfer Using AMR Graph as Intermediate Representation.” In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics. https://doi.org/10.18653/v1/2022.emnlp-main.602
Janik, Arkadiusz, and Jakub Krawczyk. 2016. “AJVM – JAVA Virtual Machine Implemented in Actionscript 3.0.” Journal of Automation, Mobile Robotics & Intelligent Systems 10 (1): 58–68. https://doi.org/10.14313/jamris_1-2016/8
Jansen van Vüren, Joshua Miles, Febe de Wet, and Thomas Niesler. 2024. “Automatic Partitioning of a Code-Switched Speech Corpus Using Mixed-Integer Programming.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA) and ICCL. https://doi.org/10.63317/4e4uf4ciujnr
Jaoua, Imen. 2026. “Integrating Static Analysis with Learning-Based Systems for Automated Code Review.” In Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3803437.3804441
“The Java Virtual Machine.” 2006. In Virtual Machines. Springer London. https://doi.org/10.1007/978-1-84628-246-1_3
“A Java Virtual Machine for Sensor Networks.” 2008. Journal of Institute of Control, Robotics and Systems 14 (1): 13–20. https://doi.org/10.5302/j.icros.2008.14.1.013
Jawa, Misha, and Shweta Meena. 2022a. “Comparative Analysis of Ensemble Models for Software Effort Estimation.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-19-5292-0_5
Jemli, Mamdouh, and Jean-Pierre Rosen. 2010. “A Methodology for Avoiding Known Compiler Problems Using Static Analysis.” In Proceedings of the ACM SIGAda annual international conference on SIGAda. ACM. https://doi.org/10.1145/1879063.1879073
Jendrosch, Manfred, Gerhard W. Dueck, Charlie Gracie, and André Hinkenjann. 2014. “PC Based Escape Analysis in the Java Virtual Machine.” Lecture Notes on Software Engineering: 16–20. https://doi.org/10.7763/lnse.2014.v2.87
Jensen, Simon Holm, Magnus Madsen, and Anders Møller. 2011. “Modeling the HTML DOM and Browser API in Static Analysis of JavaScript Web Applications.” In Proceedings of the 19th ACM SIGSOFT symposium and the 13th European conference on Foundations of software engineering. ACM. https://doi.org/10.1145/2025113.2025125
Jervis, E. W. 1963. Mobile. a Mobidic Cobol Compiler. Defense Technical Information Center. https://doi.org/10.21236/ad0411444
Jetley, Raoul Praful, Paul L. Jones, and Paul Anderson. 2008. “Static Analysis of Medical Device Software Using CodeSonar.” In Proceedings of the 2008 workshop on Static analysis. ACM. https://doi.org/10.1145/1394504.1394507
Jeusfeld, Manfred A., and Matthias Jarke. 1996. “Enterprise Integration by Market-Driven Schema Evolution.” Concurrent Engineering 4 (3): 207–18. https://doi.org/10.1177/1063293x9600400302
Ji, Jaewon, and Joonho Bae. 2025. “Resource-Efficient Quantum Data Representation Based on Grover’s Algorithm.” International Journal of Quantum Information 23 (06): 2550018. https://doi.org/10.1142/s0219749925500182
Jia, Nan, Anita Raja, and Raffi Khatchadourian. 2026. “An Empirical Framework for Evaluating Semantic Preservation Using Hugging Face.” In Proceedings of the Annual Hawaii International Conference on System Sciences. Hawaii International Conference on System Sciences. https://doi.org/10.24251/hicss.2026.886
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
Jiao, Yushu, Xiaoman Dong, Peilong Tian, Xiaoyang Zhang, and Sunwei Li. 2025. “A Declarative Conversion Framework for Legacy CAE Input Systems: Pattern-Based Parsing and Unified Intermediate Representation.” In Proceedings of the 2025 2nd International Conference on Cloud Computing and Big Data. ACM. https://doi.org/10.1145/3779475.3779498
Jiefang Jin. 2026. “Research on Virtual Reality Scene Construction and Space Layout Optimization in Interior Design Based on Collaborative Optimization Algorithm.” International Journal of Computer Information Systems and Industrial Management Applications 18: 22. https://doi.org/10.70917/ijcisim-2026-0366
Jifeng, He, and Jonathan Bowen. 1994. “Specification, Verification and Prototyping of an Optimized Compiler.” Formal Aspects of Computing 6 (6): 643–58. https://doi.org/10.1007/bf03259390
Jin, Lesheng, Zhenyuan Ruan, Haohui Mai, and Jingbo Shang. 2025. “VeriLocc: End-to-End Cross-Architecture Register Allocation via LLM.” In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.emnlp-main.1538
Jing, Xiao-Yuan, Fumin Qi, Fei Wu, and Baowen Xu. 2016. “Missing Data Imputation Based on Low-Rank Recovery and Semi-Supervised Regression for Software Effort Estimation.” In Proceedings of the 38th International Conference on Software Engineering. ACM. https://doi.org/10.1145/2884781.2884827
Jing-Schmidt, Zhuo. 2019. “Corpus and Computational Methods for Usage-Based Chinese Language Learning: Toward a Professional Multilingualism.” In Chinese Language Learning Sciences. Springer Nature Singapore. https://doi.org/10.1007/978-981-13-3570-9_2
Johannsen, D. 1988. “Bristle Blocks: A Silicon Compiler.” In Papers on Twenty-five years of electronic design automation. ACM. https://doi.org/10.1145/62882.62903
Johannsen, D. L., S. K. Tsubota, and K. McElvain. 1987. “An Intelligent Compiler Subsystem for a Silicon Compiler.” In 24th ACM/IEEE conference proceedings on Design automation conference - DAC ‘87. ACM Press. https://doi.org/10.1145/37888.37954
Johnson, Frank R., Fletcher Jr., and Paul E. 1989. S7001 User’s Guide. Version 1.0. Static Analysis of Framed Structures. Defense Technical Information Center. https://doi.org/10.21236/ada236733
Johnson, Ralph E., Justin O. Graver, and Laurance W. Zurawski. 1988. “TS: An Optimizing Compiler for Smalltalk.” In Conference proceedings on Object-oriented programming systems, languages and applications. ACM. https://doi.org/10.1145/62083.62086
Johnsson, Richard K. 1975. An Approach to Global Register Allocation. Defense Technical Information Center. https://doi.org/10.21236/ada024966
Joisha, Pramod G. 2006. “Compiler Optimizations for Nondeferred Reference: Counting Garbage Collection.” In Proceedings of the 5th international symposium on Memory management. ACM. https://doi.org/10.1145/1133956.1133976
Jolley, Rachael. 2014. “Brain Unboxed: Interview with Scientist Jim Al-Khalili.” Index on Censorship 43 (2): 127–30. https://doi.org/10.1177/0306422014537184
Jones, Simon L. Peyton. 1992. “Implementing Lazy Functional Languages on Stock Hardware: The Spineless Tagless G-Machine.” Journal of Functional Programming 2 (2): 127–202. https://doi.org/10.1017/s0956796800000319
Jones, Richard, Antony Hosking, and Eliot Moss. 2023a. “Comparing Garbage Collectors.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-6
Jones, Richard, Antony Hosking, and Eliot Moss. 2023b. “Concurrent Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-15
Jones, Richard, Antony Hosking, and Eliot Moss. 2023c. “Copying Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-4
Jones, Richard, Antony Hosking, and Eliot Moss. 2023d. “Energy-Aware Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-20
Jones, Richard, Antony Hosking, and Eliot Moss. 2023e. “Generational Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-9
Jones, Richard, Antony Hosking, and Eliot Moss. 2023f. “Mark-Compact Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-3
Jones, Richard, Antony Hosking, and Eliot Moss. 2023g. “Mark-Sweep Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-2
Jones, Richard, Antony Hosking, and Eliot Moss. 2023h. “Parallel Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-14
Jones, Richard, Antony Hosking, and Eliot Moss. 2023i. “Persistence and Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-21
Jones, Richard, Antony Hosking, and Eliot Moss. 2023j. “Real-Time Garbage Collection.” In The Garbage Collection Handbook. Chapman and Hall/CRC. https://doi.org/10.1201/9781003276142-19
Jones, Robert B., Jens U. Skakkebaek, and David L. Dill. 2002b. Reducing Manual Abstraction in Formal Verification of out-of-Order Execution. Defense Technical Information Center. https://doi.org/10.21236/ada400402
Jones, Karen, Kevin Walker, Christopher Caruso, and Stephanie Strassel. 2024. “MAGLIC: The Maghrebi Language Identification Corpus.” In The Speaker and Language Recognition Workshop (Odyssey 2024). ISCA. https://doi.org/10.21437/odyssey.2024-13
Jones, Simon B., and Michael White. 1991. “Is Compile Time Garbage Collection Worth the Effort?” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3810-5_14
Jordan, Alexander, Florian Brandner, and Martin Schoeberl. 2013b. “Static Analysis of Worst-Case Stack Cache Behavior.” In Proceedings of the 21st International conference on Real-Time Networks and Systems. ACM. https://doi.org/10.1145/2516821.2516828
Joseph, P., Y. Srikant, Kapil Vaswani, and Matthew Jacob. 2007. “Statistical and Machine Learning Techniques in Compiler Design.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420043839.ch8
Joyce Onyowoicho Odeh et al. 2024. “IoT-Based Garbage Collection Robot Using Wireless Communication (EcoPicker-M).” Multimedia Research 7 (4): 39–50. https://doi.org/10.46253/j.mr.v7i4.a4
Juboraj, Md. Fahmid-Ul-Alam, Soumik Deb Niloy, Mahbub E. Sobhani, and Farig Sadeque. 2025. “BRACU_CL at BLP-2025 Task 2: CodeMist: A Transformer-Based Framework for Bangla Instruction-to-Code Generation.” In Proceedings of the Second Workshop on Bangla Language Processing (BLP-2025). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.banglalp-1.67
“Judgment under Uncertainty.” 2002. In Foundations of Cognitive Psychology. The MIT Press. https://doi.org/10.7551/mitpress/3080.003.0038
“Judgment, Heuristics and Biases.” 2017. In Critical Thinking. Cambridge University Press. https://doi.org/10.1017/9781316537411.012
“Judgmental Heuristics and Biases.” 2015. In Straight Choices. Psychology Press. https://doi.org/10.4324/9781315727080-12
Juega, J. C., J. I. Gomez, C. Tenllado, and F. Catthoor. 2014. “Adaptive Mapping and Parameter Selection Scheme to Improve Automatic Code Generation for GPUs.” In Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/2544137.2544145
Juhász, Dávid, and Tamás Kozsik. 2012. “Superoptimization in LLVM.” Annales Universitatis Scientiarum Budapestinensis de Rolando Eötvös Nominatae. Sectio computatorica, no. 36: 179–99. https://doi.org/10.71352/ac.36.179
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
Julien Bertrane, Julien, Patrick Cousot, Radhia Cousot, et al. 2011. “Static Analysis by Abstract Interpretation of Embedded Critical Software.” ACM SIGSOFT Software Engineering Notes 36 (1): 1–8. https://doi.org/10.1145/1921532.1921553
Jung, Dong-Heon, Sung-Hwan Bae, Jaemok Lee, Soo-Mook Moon, and JongKuk Park. 2006b. “Supporting Precise Garbage Collection in Java Bytecode-to-C Ahead-of-Time Compiler for Embedded Systems.” In Proceedings of the 2006 international conference on Compilers, architecture and synthesis for embedded systems. ACM. https://doi.org/10.1145/1176760.1176767
Jung, Woosung, Eunjoo Lee, and Chisu Wu. 2012. “A Survey on Mining Software Repositories.” IEICE Transactions on Information and Systems E95.D (5): 1384–1406. https://doi.org/10.1587/transinf.e95.d.1384
Jung, D.-H., S.-M. Moon, and S.-H. Bae. 2011. “Evaluation of a Java Ahead-of-Time Compiler for Embedded Systems.” Computer Journal 55 (2): 232–52. https://doi.org/10.1093/comjnl/bxr100
Jung, Chang-Duk, and You-Keun Park. 2010. “A Study on Garbage Collection Algorithm for Ubiquitous Real-Time System.” In Multimedia. InTech. https://doi.org/10.5772/7627
Jung, Dong-Heon, Jong Kuk Park, Sung-Hwan Bae, Jaemok Lee, and Soo-Mook Moon. 2006a. “Efficient Exception Handling in Java Bytecode-to-c Ahead-of-Time Compiler for Smbedded Systems.” In Proceedings of the 6th ACM & IEEE International conference on Embedded software - EMSOFT ‘06. ACM Press. https://doi.org/10.1145/1176887.1176915
“JVM Code Generation.” 2012. In Introduction to Compiler Construction in a Java World. Chapman and Hall/CRC. https://doi.org/10.1201/9781482215076-11
Jyothish Sreedharan. 2026. “Event-Driven Document Processing: MongoDB, Flink, and AI Schema Evolution.” Journal of Information Systems Engineering and Management 11 (2s): 808–31. https://doi.org/10.52783/jisem.v11i2s.14497
Jørgensen, Magne. 2022. “Measurement of Software Development Effort Estimation Bias: Avoiding Biased Measures of Estimation Bias.” In Embedded Systems and Applications. Academy and Industry Research Collaboration Center (AIRCC). https://doi.org/10.5121/csit.2022.120607
Jørgensen, Magne, and Stein Grimstad. 2009. “Software Development Effort Estimation — Demystifying and Improving Expert Estimation.” In Simula Research Laboratory. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-01156-6_26
Jørgensen, M., and E. Løhre. 2012. “First Impressions in Software Development Effort Estimation: Easy to Create and Difficult to Neutralize.” In 16th International Conference on Evaluation & Assessment in Software Engineering (EASE 2012). IET. https://doi.org/10.1049/ic.2012.0028
Kad, Sandeep, and Vinay Chopra. 2011. “Software Development Effort Estimation Using Soft Computing.” International Journal of Machine Learning and Computing: 548–51. https://doi.org/10.7763/ijmlc.2012.v2.186
Kaewkasi, Chanwit. 2010. “Towards Performance Measurements for the Java Virtual Machine’s Invokedynamic.” In Virtual Machines and Intermediate Languages. ACM. https://doi.org/10.1145/1941054.1941057
Kafura, Dennis, Doug Washabaugh, and Jeff Nelson. 1991. “Progress in the Garbage Collection of Active Objects.” In Proceedings of the workshop on Object-based concurrent programming. ACM. https://doi.org/10.1145/127056.127081
Kahndelwal, Mukesh Kumar, and Neetu Sharma. 2023. “A Survey on Applications of Particle Swarm Optimization Algorithms for Software Effort Estimation.” In Algorithms for Intelligent Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-99-4577-1_32
“KAHNEMAN, D., SLOVIC, P. & TVERSKY, a. (Eds.) 1982. Judgment under Uncertainty: Heuristics and Biases. Cambridge, MA: Cambridge University Press.” 1988. In 1988. De Gruyter. https://doi.org/10.1515/9783112469187-009
Kakimoto, Takeshi, Masateru Tsunoda, and Akito Monden. 2017. “Should Duration and Team Size Be Used for Effort Estimation?” In Studies in Computational Intelligence. Springer International Publishing. https://doi.org/10.1007/978-3-319-62048-0_7
Kama Nazri, Basri Sufyan, Asl Mehran Halimi, and Ibrahim Roslina. 2014. “COCHCOMO: A Change Effort Estimation Tool for Software Development Phase.” In Frontiers in Artificial Intelligence and Applications. IOS Press. https://doi.org/10.3233/978-1-61499-434-3-1029
Kamei, Yasutaka, Jacky Keung, Akito Monden, and Ken-ichi Matsumoto. 2008. “An over-Sampling Method for Analogy-Based Software Effort Estimation.” In Proceedings of the Second ACM-IEEE international symposium on Empirical software engineering and measurement. ACM. https://doi.org/10.1145/1414004.1414064
Kamianetska, Oksana. 2025. “The Governance Imperative: Combating Optimism Bias and Systemic Misrepresentation in Megaproject Procurement through Data-Driven Forecasting and Digital Mandates.” In Proceedings of the International Scientific Conference “Science, Research, and Innovation in a Changing World”. PE Lesiuk T.P. https://doi.org/10.64076/iedc251230.01
Kanagasabapathi, Somasundaram, and Mg Thushara. 2020. “Forward and Backward Static Analysis for Critical Numerical Accuracy in Floating Point Programs.” Computer Science 21 (2). https://doi.org/10.7494/csci.2020.21.2.3421
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
Kandemir, M., J. Ramanujam, and A. Choudhary. 1997. “A Compiler Algorithm for Optimizing Locality in Loop Nests.” In Proceedings of the 11th international conference on Supercomputing - ICS ‘97. ACM Press. https://doi.org/10.1145/263580.263650
Kandemir, Mahmut, Xulong Tang, Jagadish Kotra, and Mustafa Karakoy. 2022. “Fine-Granular Computation and Data Layout Reorganization for Improving Locality.” In Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design. ACM. https://doi.org/10.1145/3508352.3549386
Kanellou, Maria. 2025. “Unboxing Sea and Nautical Metaphors.” In Greek Erotic Epigram. Oxford University PressOxford. https://doi.org/10.1093/oso/9780198816140.003.0003
Kangwantrakool, Tachanun, Kobkrit Viriyayudhakorn, and Thanaruk Theeramunkong. 2020. “Software Development Effort Estimation from Unstructured Software Project Description by Sequence Models.” IEICE Transactions on Information and Systems E103.D (4): 739–47. https://doi.org/10.1587/transinf.2019iip0014
Kansomkeat, Supaporn, Jeff Offutt, and Wanchai Rivepiboon. 1970. “Bytecode-Based Analysis for Increasing Class-Component Testability.” ECTI Transactions on Computer and Information Technology (ECTI-CIT) 2 (1): 33–44. https://doi.org/10.37936/ecti-cit.200621.53268
Kant, Tanya. 2019. “Algorithmic Women’s Work: The Labour of Negotiating Black-Boxed Representation.” AoIR Selected Papers of Internet Research 2019. https://doi.org/10.5210/spir.v2019i0.10994
Kao, Chien-Lung. 2025. “From Source to Bytecode: How.py Becomes.pyc.” In CPython. Apress. https://doi.org/10.1007/979-8-8688-1769-4_13
Kapre, Nachiket, and André Dehon. 2011. “An NoC Traffic Compiler for Efficient FPGA Implementation of Sparse Graph-Oriented Workloads.” International Journal of Reconfigurable Computing 2011: 1–14. https://doi.org/10.1155/2011/745147
Kapustin, D. A., V. V. Shvyrov, and T. I. Shulika. 2023. “Static Analysis of Corpus of Source Codes of Python Applications.” Programming and Computer Software 49 (4): 302–9. https://doi.org/10.1134/s0361768823040072
Karabal, Cem. 2018. “Resistance to Change and Conflict of Interest: A Case Study.” In Organizational Conflict. InTech. https://doi.org/10.5772/intechopen.71578
Kartiko, Condro, Novanda Alim Setya Nugraha, and Dery Sudrajat. 2019. “Effort Estimation for Software Development on Mobile Application of ‘Tangkap Reptil’.” Jurnal Infotel 11 (4). https://doi.org/10.20895/infotel.v11i4.459
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
Kashyap, Divya. 2012. “Software Development Effort and Cost Estimation: Neuro-Fuzzy Model.” IOSR Journal of Computer Engineering 2 (4): 12–14. https://doi.org/10.9790/0661-0241214
Kashyap, Vineeth, Kyle Dewey, Ethan A. Kuefner, et al. 2014. “JSAI: A Static Analysis Platform for JavaScript.” In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. ACM. https://doi.org/10.1145/2635868.2635904
Kashyap, Divya, and A. K. Misra. 2013. “An Approach for Software Effort Estimation Using Fuzzy Numbers and Genetic Algorithm to Deal with Uncertainity.” In Computer Science & Information Technology ( CS & IT ). Academy & Industry Research Collaboration Center (AIRCC). https://doi.org/10.5121/csit.2013.3407
Katagiri, Yukinori, Takuya Yoshida, and Tatsurou Yashiki. 2009. “E208 AUTOMATIC CODE GENERATION SYSTEM FOR POWER PLANT DYNAMIC SIMULATORS(Power System-2).” Proceedings of the International Conference on Power Engineering (ICOPE) 2009.2 (0): _2-401_-_2-406_. https://doi.org/10.1299/jsmeicope.2009.2._2-401_
Kato, Shinpei, Jason Aumiller, and Scott Brandt. 2013. “Zero-Copy I/O Processing for Low-Latency GPU Computing.” In Proceedings of the ACM/IEEE 4th International Conference on Cyber-Physical Systems. ACM. https://doi.org/10.1145/2502524.2502548
Kaufmann, Daniela. 2022. “Formal Verification of Multiplier Circuits Using Computer Algebra.” it - Information Technology 64 (6): 285–91. https://doi.org/10.1515/itit-2022-0039
Kaufmann, Marco, Matthias Häsing, Thomas Preußer, and Rainer Spallek. 2011. “The Java Virtual Machine in Retargetable, High-Performance Instruction Set Simulation.” In Proceedings of the 9th International Conference on Principles and Practice of Programming in Java. ACM. https://doi.org/10.1145/2093157.2093161
Kaur, Mandeep. 2018. “Comprehensive Analysis of Effort Estimation in Software Development.” International Journal for Research in Applied Science and Engineering Technology 6 (5): 1066–72. https://doi.org/10.22214/ijraset.2018.5171
Kaur, Pawandeep, and Rupinder Singh. 2015. “A Proposed Framework for Software Effort Estimation Using the Combinational Approach of Fuzzy Logic and Neural Networks.” International Journal of Hybrid Information Technology 8 (10): 73–80. https://doi.org/10.14257/ijhit.2015.8.10.07
Kaur, Arvinder, and Vidhi Vig. 2016. “Mining Software Repositories for Empirical Validation of Laws of Software Evolution for Java Projects.” International Journal of Computational Systems Engineering 2 (3): 155. https://doi.org/10.1504/ijcsyse.2016.079003
KaurSehra, Sumeet, Jasneet Kaur, and Sukhjit Singh Sehra. 2013. “Effect of Data Preprocessing on Software Effort Estimation.” International Journal of Computer Applications 69 (25): 29–32. https://doi.org/10.5120/12130-8506
Kaushik, Jyoti, and Om Prakash Sangwan. 2025. “Analysis and Design of Software Effort Estimation Model Using Machine Learning Techniques: A Systematic Literature Review.” In Lecture Notes in Electrical Engineering. Springer Nature Singapore. https://doi.org/10.1007/978-981-97-9045-6_27
Kaushik, Anupama, Devendra Kumar Tayal, and Kalpana Yadav. 2022a. “The Role of Neural Networks and Metaheuristics in Agile Software Development Effort Estimation.” In Research Anthology on Agile Software, Software Development, and Testing. IGI Global. https://doi.org/10.4018/978-1-6684-3702-5.ch047
Kawabe, Yoshiko, Shinobu Yoshida, Shozo Saegusa, Itsuro Kajiwara, and Akio Nagamatsu. 1998. “Optimization for Vibration Problems: Junction Layout of a Combined Structure under Oscillation.” In Volume 2: 24th Design Automation Conference. American Society of Mechanical Engineers. https://doi.org/10.1115/detc98/dac-5801
Ke, Gaurav S., Stephen A. Edwards, Gail E. Kaiser, and Angelos Keromytis. 2002. CASPER: Compiler-Assisted Securing of Programs at Runtime. Defense Technical Information Center. https://doi.org/10.21236/ada446095
Ke, Ya Ming, Yong Bin Wang, and Ying Li. 2014. “A High Performance Web Server Based on Asynchronous and Zero-Copy.” Applied Mechanics and Materials 543-547: 3118–21. https://doi.org/10.4028/www.scientific.net/amm.543-547.3118
Keaton, David, and Robert C. Seacord. 2014. Performance of Compiler-Assisted Memory Safety Checking. Defense Technical Information Center. https://doi.org/10.21236/ada610094
Keil, Patrick, Daniel J. Paulish, and Raghvinder S. Sangwan. 2006. “Cost Estimation for Global Software Development.” In Proceedings of the 2006 international workshop on Economics driven software engineering research. ACM. https://doi.org/10.1145/1139113.1139117
Keirsgieter, Wim, and Willem Visser. 2020. “Graft: Static Analysis of Java Bytecode with Graph Databases.” In Conference of the South African Institute of Computer Scientists and Information Technologists 2020. ACM. https://doi.org/10.1145/3410886.3410901
Kemp, B., P. Soper, and A. King. 1995. “Continuation Compilation for Concurrent Logic Programming.” In Artificial Intelligence in Real-Time Control 1994. Elsevier. https://doi.org/10.1016/b978-0-08-042236-7.50051-1
“KERNELGEN — A PROTOTYPE OF LLVM-BASED AUTO-PARALLELIZING C/FORTRAN COMPILER FOR NVIDIA GPUs.” 2013. Bulletin of the South Ural State University. Series “Computational Mathematics and Software Engineering” 2 (4). https://doi.org/10.14529/cmse130403
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
Khan, Sadia, and Ammad Adil. 2022. “A Novel Software Architecture to Calculate Effort Estimation for Industrial Big Data.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-19-1610-6_54
Khan, Nasim Ahmed, Chau L. Nguyen, Talha Khawar, Horace Spencer, and Karina D. Torralba. 2018. “Association of Author’s Financial Conflict of Interest with Characteristics and Outcome of Rheumatoid Arthritis Randomized Controlled Trials.” Rheumatology 58 (5): 776–85. https://doi.org/10.1093/rheumatology/key368
Khatibi, Elham. 2012. “Efficient Indicators to Evaluate the Status of Software Development Effort Estimation inside the Organizations.” International Journal of Managing Information Technology 4 (3): 23–32. https://doi.org/10.5121/ijmit.2012.4303
Khatibi Bardsiri, V., D. N. A. Jawawi, S. Z. M. Hashim, and E. Khatibi. 2012a. “Increasing the Accuracy of Software Development Effort Estimation Using Projects Clustering.” IET Software 6 (6): 461–73. https://doi.org/10.1049/iet-sen.2011.0210
Khatibi. B, Vahid, Dayang N. A. Jawawi, and Elham Khatibi. 2013. “Increasing the Accuracy of Analogy Based Software Development Effort Estimation Using Neural Networks.” International Journal of Computer and Communication Engineering: 78–81. https://doi.org/10.7763/ijcce.2013.v2.142
Khattab, Shahad Wissam Abdulfattah, and Jamal Salahaldeen Alneamy. 2026. “The Model of Software Effort Estimation in the Context of Methodology Agile and Software Development.” Journal of Internet Services and Information Security 16 (1): 49–69. https://doi.org/10.58346/jisis.2026.i1.004
Khedker, Uday, and Amitabha Sanyal. 2007. “Garbage Collection Techniques.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420043839.ch6
Khmyznikov, Gleb. 2026. “Comparative Analysis of MSVC and Clang/LLVM Compilation on Windows on Arm.” American Journal of Engineering and Technology 08 (04): 192–203. https://doi.org/10.37547/tajmei/volume08issue04-16
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, Hyunjun, Sungin Hong, Hyeonsu Lee, Euiseong Seo, and Hwansoo Han. 2019a. “Compiler-Assisted GPU Thread Throttling for Reduced Cache Contention.” In Proceedings of the 48th International Conference on Parallel Processing. ACM. https://doi.org/10.1145/3337821.3337886
Kim, Kwonil, and Sunwoo Kim. 2024. “A Legal Study on Conflict of Interest in Research Commercialization at Government-Funded Science and Technology Research Institutes.” Korea Anti-Corruption Law Association 7 (2): 33–58. https://doi.org/10.36433/kacla.2024.7.2.33
Kim, Gyuyeon, Hyunwoo Kim, and Jun Han. 2024b. “Poster: Towards Acoustic-Based Tagless Object Tracking with Smartwatches.” In Proceedings of the 22nd Annual International Conference on Mobile Systems, Applications and Services. ACM. https://doi.org/10.1145/3643832.3661411
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, JiHun, Kwangman Ko, and Jonghee M. Youn. 2017. “Building the De-Obfuscation Platform Based on LLVM.” In Lecture Notes in Electrical Engineering. Springer Singapore. https://doi.org/10.1007/978-981-10-7605-3_202
Kim, Suhyun, and Soo-Mook Moon. 2008. “Rotating Register Allocation with Multiple Rotating Branches.” In Proceedings of the 22nd annual international conference on Supercomputing. ACM. https://doi.org/10.1145/1375527.1375563
Kim, Donghoon, Emerson Murphy-Hill, Chris Parnin, Christian Bird, and Ronald Garcia. 2013b. “The Reaction of Open-Source Projects to New Language Features: An Empirical Study of C# Generics.” Journal of Object Technology 12 (4): 1:1. https://doi.org/10.5381/jot.2013.12.4.a1
Kim, Sunghun, Thomas Zimmermann, Rahul Premraj, Nicolas Bettenburg, and Shivkumar Shivaji. 2013a. “Predicting Method Crashes with Bytecode Operations.” In Proceedings of the 6th India Software Engineering Conference. ACM. https://doi.org/10.1145/2442754.2442756
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
Kinross, Robin. 1979. “Colin Banks (Compiler), Social Communication: Public Information Graphics in Britain.” Information Design Journal 1 (2): 140–140. https://doi.org/10.1075/idj.1.2.10kin
Kirmani, Mudasir Manzoor, and Abdul Wahid. 2015. “Impact of Modification Made in Re-UCP on Software Effort Estimation.” Journal of Software Engineering and Applications 08 (06): 276–89. https://doi.org/10.4236/jsea.2015.86028
Kirsch, Uri, and Shenghu Liu. 1996. “Structural Reanalysis for General Layout Modifications.” In 6th Symposium on Multidisciplinary Analysis and Optimization. AIAA 1996-4115. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.1996-4115
Kirtchev, Hristian Hristov. 2012. “A New Robust and Efficient Implementation of Controlled Types in the GNAT Compiler.” ACM SIGAda Ada Letters 32 (3): 43–50. https://doi.org/10.1145/2402709.2402693
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
Klein, Bernd. 2013. “Bytecode und Maschinencode.” In Einführung in Python 3. Carl Hanser Verlag GmbH & Co. KG. https://doi.org/10.3139/9783446437173.003
Klein, Bernd. 2014. “Bytecode und Maschinencode.” In Einführung in Python 3. Carl Hanser Verlag GmbH & Co. KG. https://doi.org/10.3139/9783446441514.003
Klein, Bernd. 2017. “Bytecode und Maschinencode.” In Einführung in Python 3. Carl Hanser Verlag GmbH & Co. KG. https://doi.org/10.3139/9783446453876.003
Klein, Bernd. 2021. “Bytecode und Maschinencode.” In Einführung in Python 3. Carl Hanser Verlag GmbH & Co. KG. https://doi.org/10.3139/9783446465565.003
Knese, Karsten, and Michael Pöhnl. 2019. “A True Zero Copy RMW Implementation for ROS2.” In ROSCon Macau 2019. Open Robotics. https://doi.org/10.36288/roscon2019-900893
Knill, Kate M., Diane Nicholls, Mark J. F. Gales, Mengjie Qian, and Pawel Stroinski. 2025. “Introducing the Speak & Improve Corpus 2025: An L2 English Speech Corpus for Language Assessment and Feedback.” In 10th Workshop on Speech and Language Technology in Education (SLaTE). ISCA. https://doi.org/10.21437/slate.2025-34
Knott, Gary D. 2017. “Garbage Collection.” In Interpreting LISP. Apress. https://doi.org/10.1007/978-1-4842-2707-7_28
Ko, Kwang-Man. 2005. “Design and Implementation of the Virtual Machine for the Redesigned Java Class File.” KIPS Transactions:PartA 12A (3): 229–34. https://doi.org/10.3745/kipsta.2005.12a.3.229
Koch, Stefan, and Johann Mitloehner. 2008. “Effort Estimation Using Social Choice.” In Information Systems Development. Springer US. https://doi.org/10.1007/978-0-387-78578-3_24
Koehler, Derek J., Lyle Brenner, and Dale Griffin. 2002. “The Calibration of Expert Judgment: Heuristics and Biases beyond the Laboratory.” In Heuristics and Biases. Cambridge University Press. https://doi.org/10.1017/cbo9780511808098.041
Koes, David Ryan, and Seth Copen Goldstein. 2008. “Near-Optimal Instruction Selection on Dags.” In Proceedings of the 6th annual IEEE/ACM international symposium on Code generation and optimization. ACM. https://doi.org/10.1145/1356058.1356065
Koes, David Ryan, and Seth Copen Goldstein. 2009. “Register Allocation Deconstructed.” In Proceedings of th 12th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/1543820.1543824
Kojima, Hideharu, and Rolf Adams. 2001. “jShio — A Customization Language Compiler—Compiler.” In OOIS 2001. Springer London. https://doi.org/10.1007/978-1-4471-0719-4_36
Kokosa, Konrad. 2018a. “Garbage Collection: Introduction.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/978-1-4842-4027-4_7
Kokosa, Konrad. 2018b. “Garbage Collection: Mark Phase.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/978-1-4842-4027-4_8
Kokosa, Konrad. 2018c. “Garbage Collection: Plan Phase.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/978-1-4842-4027-4_9
Kokosa, Konrad. 2018d. “Garbage Collection: Sweep and Compact.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/978-1-4842-4027-4_10
Kokosa, Konrad, Christophe Nasarre, and Kevin Gosse. 2024a. “Garbage Collection – Introduction.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/979-8-8688-0453-3_7
Kokosa, Konrad, Christophe Nasarre, and Kevin Gosse. 2024b. “Garbage Collection – Mark Phase.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/979-8-8688-0453-3_8
Kokosa, Konrad, Christophe Nasarre, and Kevin Gosse. 2024c. “Garbage Collection – Plan Phase.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/979-8-8688-0453-3_9
Kokosa, Konrad, Christophe Nasarre, and Kevin Gosse. 2024d. “Garbage Collection – Sweep and Compact.” In Pro .NET Memory Management. Apress. https://doi.org/10.1007/979-8-8688-0453-3_10
Kolodner, Elliot, Barbara Liskov, and William Weihl. 1989. “Atomic Garbage Collection: Managing a Stable Heap.” ACM SIGMOD Record 18 (2): 15–25. https://doi.org/10.1145/66926.66928
Komal, Komal, Mohit Saxena, Shashank Chaturvedi, and Neeraj Kr. Shukla. 2015. “A Novel Optimal 2-D Layout for Cache Memory at 45nm CMOS Technology.” International Journal of Advanced Science and Technology 82: 33–44. https://doi.org/10.14257/ijast.2015.82.04
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
Kongari, Sai Shiva Reddy, Saurav Kant Kumar, and Abhishek Kumar. 2026. “Trustworthy and Secure LLM-Assisted Code Generation for Enterprise Software Development.” International journal of data science and machine learning 06 (01): 222–37. https://doi.org/10.55640/ijdsml-06-01-04
Koparkar, Chaitanya. 2022. “Efficient Data Representation Using FlatBuffers.” XRDS: Crossroads, The ACM Magazine for Students 29 (2): 50–51. https://doi.org/10.1145/3571304
Kopeć, Igor, and Jakub Smołka. 2019. “A Performance Comparison of Garbage Collector Algorithms in Java Virtual Machine.” Journal of Computer Sciences Institute 13: 359–65. https://doi.org/10.35784/jcsi.1333
Kopel, Michael, and Vinay Ramani. 2023. “The Bright Side of the Planning Fallacy in Distribution Channels.” Preprint, . https://doi.org/10.2139/ssrn.4572881
Kornerup, Peter, Bent Bruun Kristensen, and Ole Lehrmann Madsen. 1978. “Interpretation and Code Generation Based on Intermediate Languages.” DAIMI Report Series 7 (88). https://doi.org/10.7146/dpb.v7i88.6503
Korobeynikov, Anton. 2007. “Improving Switch Lowering for the LLVM Compiler System.” In Proceedings of the Spring/Summer Young Researchers’ Colloquium on Software Engineering. Institute for System Programming of the Russian Academy of Sciences. https://doi.org/10.15514/syrcose-2007-1-2
Korotkevitch, Dmitri. 2015. “Garbage Collection.” In Expert SQL Server In-Memory OLTP. Apress. https://doi.org/10.1007/978-1-4842-1136-6_9
“Korpustutkimus Kielitypologiassa Sovellettuna Udmurttiin [Computer Corpus Analysis in Language Typology Applied to Udmurt (Votyak)] by Pirkko Suihkonen (Review).” 1991. Language 67 (3): 665–665. https://doi.org/10.1353/lan.1991.0010
Koseki, Akira, Hideaki Komatsu, and Yoshiaki Fukazawa. 1996. “A Register Allocation Technique Using Guarded PDG.” In Proceedings of the 10th international conference on Supercomputing - ICS ‘96. ACM Press. https://doi.org/10.1145/237578.237615
Koshelev, V. K., A. O. Izbyshev, and I. A. Dudina. 2014. “Interprocedural Taint Analysis for LLVM-Bitcode.” Proceedings of the Institute for System Programming of RAS 26 (2): 97–118. https://doi.org/10.15514/ispras-2014-26(2)-4
Koshelev, V. K., A. O. Izbyshev, and I. A. Dudina. 2015. “Interprocedural Taint Analysis for LLVM-Bitcode.” Programming and Computer Software 41 (4): 237–45. https://doi.org/10.1134/s0361768815040027
Kosti, Makrina Viola, Nikolaos Mittas, and Lefteris Angelis. 2012. “Alternative Methods Using Similarities in Software Effort Estimation.” In Proceedings of the 8th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2365324.2365333
Kota, Teja Krishna. 2025. “AI-Based Schema Evolution Detection and Data Consistency Checking in SQL to Cloud Migrations.” In Recent Trends in Data Analytics and Computing. CRC Press. https://doi.org/10.1201/9781003724995-44
Kourai, Kenichi, and Hiroki Ooba. 2015. “Zero-Copy Migration for Lightweight Software Rejuvenation of Virtualized Systems.” In Proceedings of the 6th Asia-Pacific Workshop on Systems. ACM. https://doi.org/10.1145/2797022.2797026
Koutbi, Salma El, and Ali Idri. 2018. “Software Effort Estimation Risk Management over Projects Portfolio.” Computer and Information Science 11 (4): 45. https://doi.org/10.5539/cis.v11n4p45
Koziolek, Heiko, and Anne Koziolek. 2024. “LLM-Based Control Code Generation Using Image Recognition.” In Proceedings of the 1st International Workshop on Large Language Models for Code. ACM. https://doi.org/10.1145/3643795.3648385
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
Kreahling, William C., and Cindy Norris. 2000. “Profile Assisted Register Allocation.” In Proceedings of the 2000 ACM symposium on Applied computing - Volume 2. ACM. https://doi.org/10.1145/338407.338562
Krishna Chaitanya Batchu. 2025. “Metadata-Driven ETL Framework for Automated Schema Evolution and Impact Analysis.” Journal of Computer Science and Technology Studies 7 (7): 846–52. https://doi.org/10.32996/jcsts.2025.7.7.91
Kristanto, Jeremy, and Juneman Abraham. 2016. “‘Decisional Procrastination: The Role of Courage, Media Multitasking and Planning Fallacy ‘.” In European Proceedings of Social & Behavioural Sciences. Cognitive-crcs. https://doi.org/10.15405/epsbs.2016.11.69
Kroetsch, Curtis. 2014. “Multi-Dimensional Data Statistics for Columnar in-Memory Databases.” In Proceedings of the 2014 ACM SIGMOD International Conference on Management of Data. ACM. https://doi.org/10.1145/2588555.2612663
Krude, Johannes, Mirko Stoffers, and Klaus Wehrle. 2018. “Circuit Switched VM Networks for Zero-Copy IO.” In Proceedings of the 2018 Afternoon Workshop on Kernel Bypassing Networks. ACM. https://doi.org/10.1145/3229538.3229539
Krueger, Steven. 1989. “VLSI-Appropriate Garbage Collection Support.” In The Kluwer International Series in Engineering and Computer Science. Springer US. https://doi.org/10.1007/978-1-4613-1619-0_7
Krynski, Tevye R., and Joshua B. Tenenbaum. 2007. “The Role of Causality in Judgment under Uncertainty.” Journal of Experimental Psychology: General 136 (3): 430–50. https://doi.org/10.1037/0096-3445.136.3.430
Krysinski, Mary Jo. 2017. “Layout and Structure.” In The Art of Type and Typography. Routledge. https://doi.org/10.4324/9781315301556-8
Kuan, George, and David MacQueen. 2007. “Efficient Type Inference Using Ranked Type Variables.” In Proceedings of the 2007 workshop on Workshop on ML. ACM. https://doi.org/10.1145/1292535.1292538
Kuhlen, David. 2024. “Contribution of Code Generation in Order to Save Process Costs in Software Development.” International Journal of Research Publication and Reviews 5 (7): 2385–90. https://doi.org/10.55248/gengpi.5.0724.1814
Kulkarni, Sameer, and John Cavazos. 2012. “Mitigating the Compiler Optimization Phase-Ordering Problem Using Machine Learning.” In Proceedings of the ACM international conference on Object oriented programming systems languages and applications. ACM. https://doi.org/10.1145/2384616.2384628
Kumar, Rajan. 2012. Microfluidic Flow Retardation Device for Tagless Cancer Cell Analysis for Metastatic Potential. Defense Technical Information Center. https://doi.org/10.21236/ada566934
Kumar, Pradeep. 2020. “Garbage Collection and Sustainability: Energy Efficiency in Computing.” International Journal of Multidisciplinary Research and Growth Evaluation. 1 (5): 138–47. https://doi.org/10.54660/.ijmrge.2020.1.5.138-147
Kumar, Ritesh. 2026. “text2ql: Multi-Target Natural Language Querying via a Language-Agnostic Intermediate Representation.” International Journal of Computer Applications 187 (114): 54–62. https://doi.org/10.5120/ijcaff3006d1ef8e
Kumar, Atul, and Shyam Agrawal. 2018. “Empirical Study of Speech Synthesis Markup Language and Its Implementation for Punjabi Language.” In 6th Workshop on Spoken Language Technologies for Under-Resourced Languages (SLTU 2018). ISCA. https://doi.org/10.21437/sltu.2018-22
Kumar, Abhishek, and Unmukh Datta. 2015. “An Effort Estimation Model for Software Development Using Ensemble Learning.” International Journal of Computer Applications 115 (21): 37–41. https://doi.org/10.5120/20279-2713
Kumar, Krishan, and Prabhpreet Kaur. 2018. “A Comparative Analysis of Static and Dynamic Java Bytecode Watermarking Algorithms.” In Advances in Intelligent Systems and Computing. Springer Singapore. https://doi.org/10.1007/978-981-10-8848-3_31
Kumar, Surender, and Rajeev Kumar. 2012. “Precise Static Analysis for Generic Programs in Object Oriented Languages.” ACM SIGSOFT Software Engineering Notes 37 (3): 1–6. https://doi.org/10.1145/2180921.2180937
Kumar, Neeraj, Yogesh Kumar, and Rahul Rishi. 2019. “Software Effort Estimation Techniques.” International Journal of Computer Sciences and Engineering 7 (1): 139–42. https://doi.org/10.26438/ijcse/v7i1.139142
Kumar, K. Harish, and K. Srinivas. 2024. “Software Requirements Based Software Effort Estimation Using RSLU-GNL-GRU in Software Project Management.” In Algorithms in Advanced Artificial Intelligence. CRC Press. https://doi.org/10.1201/9781003529231-60
Kumar B, Mari, P. Latha, and E. Praynlin. 2014. “Software Effort Estimation Using Genetic Algorithm.” International Journal on Information Sciences and Computing 8 (1): 9–16. https://doi.org/10.18000/ijisac.50142
Kumaresh, Sakthi, and Ramachandran Baskaran. 2015. “Mining Software Repositories for Defect Categorization.” Journal of Communications Software and Systems 11 (1): 31. https://doi.org/10.24138/jcomss.v11i1.115
KumarSingh, Brajesh, and A. K. Misra. 2012. “Software Effort Estimation by Genetic Algorithm Tuned Parameters of Modified Constructive Cost Model for NASA Software Projects.” International Journal of Computer Applications 59 (9): 22–26. https://doi.org/10.5120/9577-4053
Kummervold, Per, Freddy Wetjen, and Javier de la Rosa. 2022. “The Norwegian Colossal Corpus: A Text Corpus for Training Large Norwegian Language Models.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/32wyuuryhsxc
Kunchukuttan, Anoop, and Pushpak Bhattacharyya. 2015. “Data Representation Methods and Use of Mined Corpora for Indian Language Transliteration.” In Proceedings of the Fifth Named Entity Workshop. Association for Computational Linguistics. https://doi.org/10.18653/v1/w15-3912
Kupietz, Marc, Nils Diewald, Philippe Genêt, and Andreas Witt. 2026. “National Library as Corpus: DeLiKo-2025@DNB – a Very Large Corpus of German-Language Contemporary Literature.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/59wsms6588ys
Kurdahi, F. J., and A. C. Parker. 1987. “REAL: A Program for REgister ALlocation.” In 24th ACM/IEEE conference proceedings on Design automation conference - DAC ‘87. ACM Press. https://doi.org/10.1145/37888.37920
Kurmangaleev, Sh. F. 2013. “Machine-Specific Optimization Methods for C/C++ Applications That Are Distributed in the LLVM Intermediate Representation Format.” Proceedings of the Institute for System Programming of RAS 24: 127–44. https://doi.org/10.15514/ispras-2013-24-7
Kurmangaleev, S. F., V. P. Korchagin, V. V. Savchenko, and S. S. Sargsyan. 2012. “Building Obfuscation Compiler Based on LLVM Infrastructure.” Proceedings of the Institute for System Programming of RAS 23: 77–92. https://doi.org/10.15514/ispras-2012-23-5
Kurniawan, Indra. 2020. “Kombinasi Median Weighted Information Gain Dengan k-Nearest Neighbor Pada Dataset Label Months Software Effort Estimation.” Jurnal Teknoinfo 14 (2): 138. https://doi.org/10.33365/jti.v14i2.647
Kurshan, R. P. 2000. “Formal Verification in a Commercial Settings.” In Verification of Digital and Hybrid Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-59615-5_11
Kusano, Markus, and Chao Wang. 2016. “Flow-Sensitive Composition of Thread-Modular Abstract Interpretation.” In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. ACM. https://doi.org/10.1145/2950290.2950291
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
Kushnir, Ivan, and Valentyna Kyrii. 2026. “Software Development Effort Estimation Model Based on Pre-Trained Zero-Shot Models.” Management Information System and Devises, no. 189: 196–210. https://doi.org/10.30837/0135-1710.2026.189.196
Kushwaha, Dharmender Singh, and A. K. Misra. 2008. “Software Test Effort Estimation.” ACM SIGSOFT Software Engineering Notes 33 (3): 1–5. https://doi.org/10.1145/1360602.1361211
Kusters, R. J., M. J. I. M. van Genuchten, and F. J. Heemstra. 1991. “Are Software Cost-Estimation Models Accurate?” In The Economics of Information Systems and Software. Elsevier. https://doi.org/10.1016/b978-0-7506-1122-0.50017-8
Kuznetsov, S. D. 2024. “Typed Unknown Values: A Step towards Solving the Problem of Missing Data Representation in Relational Databases.” Programming and Computer Software 50 (7): 532–48. https://doi.org/10.1134/s0361768824700257
Kwan, Carmen. 2019. “Fingerprints for Compressed Columnar Data Search.” In Proceedings of the 2019 International Conference on Management of Data. ACM. https://doi.org/10.1145/3299869.3300094
Kyle, Kristopher. 2021. “Natural Language Processing for Learner Corpus Research.” International Journal of Learner Corpus Research 7 (1): 1–16. https://doi.org/10.1075/ijlcr.00019.int
Kyrylkov, Sergiy, and Darko Stefanovic. 2005a. Comparison of Garbage Collectors Operating in a Large Address Space. Defense Technical Information Center. https://doi.org/10.21236/ada498926
Kyrylkov, Sergiy, and Darko Stefanovic. 2005b. A Study of Garbage Collection with a Large Address Space for Server Applications. Defense Technical Information Center. https://doi.org/10.21236/ada500077
Laaksonen, Antti. 2026. “Code Generation.” In Undergraduate Topics in Computer Science. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-07453-9_5
Laboudi, Fatima Zohra, Kamilia Menghour, and Labiba Souici-Meslati. 2025. “Integrating Chicken Swarm Optimization with Deep Learning for Software Effort Estimation.” In Advances in Intelligent Systems Research. Atlantis Press International BV. https://doi.org/10.2991/978-94-6463-805-9_21
Lafrance, Arthur, David Detweiler, Zhaofeng Li, Xiangdong Chen, Vikram Narayanan, and Anton Burtsev. 2023. “Extending Rust with Support for Zero Copy Communication.” In Proceedings of the 12th Workshop on Programming Languages and Operating Systems. ACM. https://doi.org/10.1145/3623759.3624552
Lagorio, Giovanni. 2007. “Modelling a JVM for Polymorphic Bytecode.” Journal of Object Technology 6 (5): 71. https://doi.org/10.5381/jot.2007.6.5.a2
Lajus, Jonathan, and Hannes Mühleisen. 2014. “Efficient Data Management and Statistics with Zero-Copy Integration.” In Proceedings of the 26th International Conference on Scientific and Statistical Database Management. ACM. https://doi.org/10.1145/2618243.2618265
Lakhdar, Riyane Sid, Henri-Pierre Charles, and Maha Kooli. 2020. “Data-Layout Optimization Based on Memory-Access-Pattern Analysis for Source-Code Performance Improvement.” In Proceedings of the 23th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/3378678.3391874
Laktionova, Anastasiia. 2021. “Compiling a Specialised Corpus for Translation Research in the Environmental Domain.” In Proceedings of the Student Research Workshop Associated with RANLP 2021. INCOMA Ltd. Shoumen, BULGARIA. https://doi.org/10.26615/issn.2603-2821.2021_014
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
Lallemand, Eric, and Guy Leduc. 1992. “A LOTOS Data Facility Compiler (DAFY).” In Formal Description Techniques, IV. Elsevier. https://doi.org/10.1016/b978-0-444-89402-1.50031-x
Lam, King Tin, and Cho-Li Wang. 2010. “Web Application Server Clustering with Distributed Java Virtual Machine.” In Handbook of Research on Scalable Computing Technologies. IGI Global. https://doi.org/10.4018/978-1-60566-661-7.ch028
Lance, Don, Roland H. Untch, and Nancy J. Wahl. 1999. “Bytecode-Based Java Program Analysis.” In Proceedings of the 37th annual Southeast regional conference (CD-ROM). ACM. https://doi.org/10.1145/306363.306382
Lanet, Jean-Louis. 2011. “Bytecode Verification.” In Encyclopedia of Cryptography and Security. Springer US. https://doi.org/10.1007/978-1-4419-5906-5_486
Lanet, Jean-Louis. 2025. “Bytecode Verification.” In Encyclopedia of Cryptography, Security and Privacy. Springer Nature Switzerland. https://doi.org/10.1007/978-3-030-71522-9_486
Lang, Michael, Kieran Conboy, and Siobhán Keaveney. 2013. “Cost Estimation in Agile Software Development Projects.” In Information Systems Development. Springer New York. https://doi.org/10.1007/978-1-4614-4951-5_55
Lanneer, Dirk, Johan Praet, Augusli Kifli, et al. 2002. “Chess: Retargetable Code Generation for Embedded DSP Processors.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_5
Lano, Kevin. 1995. “Implementation and Code Generation.” In Formal Object-Oriented Development. Springer London. https://doi.org/10.1007/978-1-4471-3073-4_8
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
Larose, Octave, Michael Vollmer, and Stefan Marr. 2026. “AST, Bytecode, and the Space in Between: An Exploration of Interpreter Design Tradeoffs.” Journal of Object Technology 25 (1): 1:1. https://doi.org/10.5381/jot.2026.25.1.a15
Larson, Eric, and Todd Austin. 2000. “Compiler Controlled Value Prediction Using Branch Predictor Based Confidence.” In Proceedings of the 33rd annual ACM/IEEE international symposium on Microarchitecture. ACM. https://doi.org/10.1145/360128.360164
Lass, Stanley E. 1991. “The Compiler Controlled Pack Cache and Messaging.” ACM SIGARCH Computer Architecture News 19 (4): 80–85. https://doi.org/10.1145/122576.122584
Lateef, Mohammed Abdul, and A. Kavitha. 2024. “Blockchain Smart Contract Fortification Using Bytecode Analysis to Address Vulnerabilities.” In Computing, Communication and Intelligence. CRC Press. https://doi.org/10.1201/9781003581215-18
Latendresse, Mario, and Marc Feeley. 2003. “Generation of Fast Interpreters for Huffman Compressed Bytecode.” In Proceedings of the 2003 workshop on Interpreters, virtual machines and emulators. ACM. https://doi.org/10.1145/858570.858574
Lavazza, L., and S. Morasca. 2012. “Software Effort Estimation with a Generalized Robust Linear Regression Technique.” In 16th International Conference on Evaluation & Assessment in Software Engineering (EASE 2012). IET. https://doi.org/10.1049/ic.2012.0027
Lawrence, Willie, and Eiji Adachi. 2021. “Assessing the Occurrence of Blocking Operations in Database Schema Evolution: A Case Study.” In Anais do IX Workshop de Visualização, Evolução e Manutenção de Software (VEM 2021). Sociedade Brasileira de Computação - SBC. https://doi.org/10.5753/vem.2021.17209
“Layout Data Structures.” 2004. In Handbook of Data Structures and Applications. Chapman and Hall/CRC. https://doi.org/10.1201/9781420035179-66
Le Roux, Julien, and Julien Sade. 2024. “arcMS: Transformation of Multi-Dimensional High-Resolution Mass Spectrometry Data to Columnar Format for Compact Storage and Fast Access.” Bioinformatics Advances 4 (1): vbae160. https://doi.org/10.1093/bioadv/vbae160
Le Thi Kim Nhung, Ho, Vo Van Hai, and Huynh Thai Hoc. 2021. “Analyzing Correlation of the Relationship between Technical Complexity Factors and Environmental Complexity Factors for Software Development Effort Estimation.” In Lecture Notes in Networks and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-90318-3_65
League, Christopher A. 2002. A Type-Preserving Compiler Infrastructure. Defense Technical Information Center. https://doi.org/10.21236/ada436496
League, Christopher, Zhong Shao, and Valery Trifonov. 2005. Precision in Practice: A Type-Preserving Java Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada436468
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
Leavitt, Thomas, and Kermit Terrell. 1991d. Ada Compiler Evaluation Capability: Version Description Document, Release 2.0. Defense Technical Information Center. https://doi.org/10.21236/ada236684
Lebeck, Alvin R. 1999. “Cache Conscious Programming in Undergraduate Computer Science.” ACM SIGCSE Bulletin 31 (1): 247–51. https://doi.org/10.1145/384266.299772
Lee, Graham. 1982. “Code Generation.” In From Hardware to Software. Macmillan Education UK. https://doi.org/10.1007/978-1-349-16786-9_25
Lee, Jooyong. 2007. “A Case for Dynamic Reverse-Code Generation.” BRICS Report Series 14 (15). https://doi.org/10.7146/brics.v14i15.22179
Lee, Yangsun. 2022. “A Study on Intermediate Code Generation for Security Weakness Analysis of Smart Contract Chaincode.” Webology 19 (1): 4745–60. https://doi.org/10.14704/web/v19i1/web19318
Lee, Hyojeong, Qichen Chen, Heon Young Yeom, and Yongseok Son. 2020a. “An Efficient Garbage Collection in Java Virtual Machine via Swap I/O Optimization.” In Proceedings of the 35th Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/3341105.3373982
Lee, Sang-Un, Jeong-Ho Gang, and Jung-Yang Park. 2002. “Software Development Effort Estimation Using Function Point.” KIPS Transactions:PartD 9D (4): 603–12. https://doi.org/10.3745/kipstd.2002.9d.4.603
Lee, Junhee, Seongjoon Hong, and Hakjoo Oh. 2018. “MemFix: Static Analysis-Based Repair of Memory Deallocation Errors for C.” 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.3236079
Lee, Seonghyeon, Suyeon Kim, Joonwon Jang, HeeJae Chon, Dongha Lee, and Hwanjo Yu. 2024. “Eliciting Instruction-Tuned Code Language Models’ Capabilities to Utilize Auxiliary Function for Code Generation.” In Findings of the Association for Computational Linguistics: EMNLP 2024. Association for Computational Linguistics. https://doi.org/10.18653/v1/2024.findings-emnlp.100
Lee, Hayun, Gyungmo Kim, and Dongkun Shin. 2023a. “Code Generation and Data Layout Transformation Techniques for Processing-in-Memory.” Journal of KIISE 50 (8): 639–45. https://doi.org/10.5626/jok.2023.50.8.639
Lee, Hae Young, So Jin Lee, Hyung-Jong Kim, and SeungHyun Byun. 2016. “Regression Analysis-Based Cost Estimation of Simulation Models in Model Cost Database.” In Advanced Science and Technology Letters. Science & Engineering Research Support soCiety. https://doi.org/10.14257/astl.2016.139.49
Lee, Ig-hoon, Jae-won Lee, Junho Shim, and Sang-goo Lee. 2010. “Cache Conscious Trees on Modern Microprocessors.” In Proceedings of the 4th International Conference on Uniquitous Information Management and Communication. ACM. https://doi.org/10.1145/2108616.2108668
Lee, Grandee, and Haizhou Li. 2020. “Modeling Code-Switch Languages Using Bilingual Parallel Corpus.” 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.80
Lee, Seong-Won, and Soo-Mook Moon. 2011. “Selective Just-in-Time Compilation for Client-Side Mobile Javascript Engine.” In Proceedings of the 14th international conference on Compilers, architectures and synthesis for embedded systems. ACM. https://doi.org/10.1145/2038698.2038703
Lee, Dong hee, Chae yun Oh, Kyung Rok Oh, and Ki joo Hur. 2021. “An Effect of Boxing Coach’s Instruction Type on Boxing Player’s Exercise Commitment and Exercise Continuance Intention.” Journal of Sport and Leisure Studies 85: 311–19. https://doi.org/10.51979/kssls.2021.07.85.311
Lee, Juhnyoung, and Sang H. Son. 1993. Using Dynamic Adjustment of Serialization Order for Real-Time Database Systems. Defense Technical Information Center. https://doi.org/10.21236/ada466196
Lee, Sophia, and Zhongqing Wang. 2015. “Emotion in Code-Switching Texts: Corpus Construction and Analysis.” In Proceedings of the Eighth SIGHAN Workshop on Chinese Language Processing. Association for Computational Linguistics. https://doi.org/10.18653/v1/w15-3116
Lee, Dokeun, Youjip Won, Yongjun Park, and Seongjin Lee. 2020b. “Two-Tier Garbage Collection for Persistent Object.” In Proceedings of the 35th Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/3341105.3373986
Lee, Seungll, Byung-Sun Yang, Suhyun Kim, et al. 2000. “Efficient Java Exception Handling in Just-in-Time Compilation.” In Proceedings of the ACM 2000 conference on Java Grande. ACM. https://doi.org/10.1145/337449.337453
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
Leite, Gustavo, Carlos E. C. Barbosa, Hervé Yviquel, and Sandro Rigo. 2025. “Implementing New RISC-V Instructions with the LLVM Compiler Infrastructure.” In Minicursos do SSCAD 2025. SBC. https://doi.org/10.5753/sbc.18460.5.2
Lemmens, Trudo, and Benjamin Freedman. 2017. “Review for Sale? Conflict of Interest and Commercial Research Review Boards.” In Human Experimentation and Research. Routledge. https://doi.org/10.4324/9781315198231-33
Lemmens, Trudo, and Lori Luther. 2008. “Financial Conflict of Interest in Medical Research.” In The Cambridge Textbook of Bioethics. Cambridge University Press. https://doi.org/10.1017/cbo9780511545566.035
Leone, Mark, and Peter Lee. 1993. Deferred Compilation: The Automation of Run-Time Code Generation. Defense Technical Information Center. https://doi.org/10.21236/ada274124
Leroy, Xavier. 2009. “Formal Verification of a Realistic Compiler.” Communications of the ACM 52 (7): 107–15. https://doi.org/10.1145/1538788.1538814
Leroy, Xavier. 2018. “Formal Verification of Code Generators for Modeling Languages: Invited Presentation at the Third Workshop on Models for Formal Analysis of Real Systems and Sixth International Workshop on Verification and Program Transformation.” Electronic Proceedings in Theoretical Computer Science 268. https://doi.org/10.4204/eptcs.268.0.1
Lester, David. 1994. “Distributed Garbage Collection of Cyclic Structures.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3236-3_13
Leupers, Rainer. 1997. “Code Generation.” In Retargetable Code Generation for Digital Signal Processors. Springer US. https://doi.org/10.1007/978-1-4757-2570-4_4
Leupers, Rainer. 2000a. “Register Allocation for Common Subexpressions in DSP Data Paths.” In Proceedings of the 2000 conference on Asia South Pacific design automation - ASP-DAC ‘00. ACM Press. https://doi.org/10.1145/368434.368618
Leupers, Rainer. 2000b. “Register Allocation for DSP Data Paths.” In Code Optimization Techniques for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4757-3169-9_3
Leupers, Rainer, and Peter Marwedel. 2001a. “Compilers in Embedded System Design.” In Retargetable Compiler Technology for Embedded Systems. Springer US. https://doi.org/10.1007/978-1-4757-6420-8_2
Leupers, Rainer, and Peter Marwedel. 2001b. “Retargetable Compiler Case Studies.” In Retargetable Compiler Technology for Embedded Systems. Springer US. https://doi.org/10.1007/978-1-4757-6420-8_5
Leupers, Rainer, and Peter Marwedel. 2001c. “Some Compiler Technology Background.” In Retargetable Compiler Technology for Embedded Systems. Springer US. https://doi.org/10.1007/978-1-4757-6420-8_3
Leverett, Bruce W. 1982. Topics in Code Generation and Register Allocation. Defense Technical Information Center. https://doi.org/10.21236/ada120104
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
Lexchin, Joel. 2026. “Medical Research and Individual Researcher Conflict of Interest: What Is Happening and What Is to Be Done.” In Progress in Research Integrity. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-27479-3_3
Lezos, Christakis, Ioannis Latifis, Grigoris Dimitroulakos, and Konstantinos Masselos. 2016. “Compiler-Directed Data Locality Optimization in MATLAB.” In Proceedings of the 19th International Workshop on Software and Compilers for Embedded Systems. ACM. https://doi.org/10.1145/2906363.2906378
Li, Wei. 1995. “Compiler Cache Optimizations for Banded Matrix Problems.” In Proceedings of the 9th international conference on Supercomputing - ICS ‘95. ACM Press. https://doi.org/10.1145/224538.224541
Li, Liwu. 1998a. “Data Structure Serialization.” In Java: Data Structures and Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-95851-9_12
Li, Liwu. 1998b. “Java Virtual Machine.” In Java: Data Structures and Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-95851-9_5
Li, Liwu. 1998c. “Object Serialization.” In Java: Data Structures and Programming. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-95851-9_11
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, Tingting. 2016. “Test of Exception Handling in Different Java Virtual Machine.” In Proceedings of the 2016 5th International Conference on Measurement, Instrumentation and Automation (ICMIA 2016). Atlantis Press. https://doi.org/10.2991/icmia-16.2016.98
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, Yong, Ahmed Abousamra, Rami Melhem, and Alex K. Jones. 2010. “Compiler-Assisted Data Distribution for Chip Multiprocessors.” In Proceedings of the 19th international conference on Parallel architectures and compilation techniques. ACM. https://doi.org/10.1145/1854273.1854335
Li, Haonan, Yu Hao, Yizhuo Zhai, and Zhiyun Qian. 2023a. “Assisting Static Analysis with Large Language Models: A ChatGPT Experiment.” 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.3613078
Li, Hao, Chengchen Hu, Peng Zhang, and Lei Xie. 2016a. “Modular SDN Compiler Design with Intermediate Representation.” In Proceedings of the 2016 ACM SIGCOMM Conference. ACM. https://doi.org/10.1145/2934872.2959061
Li, Fei, Yonghao Jin, Weisong Liu, Bhanu Pratap Singh Rawat, Pengshan Cai, and Hong Yu. 2019. “Fine-Tuning Bidirectional Encoder Representations from Transformers (BERT)–Based Models on Large-Scale Electronic Health Record Notes: An Empirical Study.” JMIR Medical Informatics 7 (3): e14830. https://doi.org/10.2196/14830
Li, Zhenhao, and Hang Lei. 2024. “Code Clone Detection Based on Bytecode and Twin Neural Networks.” Applied Mathematics and Nonlinear Sciences 9 (1): 20241172. https://doi.org/10.2478/amns-2024-1172
Li, Yan Xin, and Guang Yu Li. 2013. “Design of Mini-Message Bus Control System Compiler.” Applied Mechanics and Materials 416-417: 895–99. https://doi.org/10.4028/www.scientific.net/amm.416-417.895
Li, Qiwei, Zuchao Li, Xiantao Cai, Bo Du, and Hai Zhao. 2023b. “Enhancing Visually-Rich Document Understanding via Layout Structure Modeling.” In ACM Multimedia Asia Workshops. ACM. https://doi.org/10.1145/3611380.3628554
Li, Zongjie, Pingchuan Ma, Huaijin Wang, et al. 2022d. “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, Shuyue Stella, Hannah Peeler, Andrew N. Sloss, Kenneth N. Reid, and Wolfgang Banzhaf. 2022a. “Genetic Improvement in the Shackleton Framework for Optimizing LLVM Pass Sequences.” In Proceedings of the Genetic and Evolutionary Computation Conference Companion. ACM. https://doi.org/10.1145/3520304.3534000
Li, Yue, Zhong Ren, Zhiqi Wang, et al. 2024a. “Fine-SE: Integrating Semantic Features and Expert Features for Software Effort Estimation.” In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. ACM. https://doi.org/10.1145/3597503.3623349
Li, Jingzhou, and Guenther Ruhe. 2006. “A Comparative Study of Attribute Weighting Heuristics for Effort Estimation by Analogy.” In Proceedings of the 2006 ACM/IEEE international symposium on Empirical software engineering. ACM. https://doi.org/10.1145/1159733.1159746
Li, Jingzhou, and Guenther Ruhe. 2008. “Software Effort Estimation by Analogy Using Attribute Selection Based on Rough Set Analysis.” International Journal of Software Engineering and Knowledge Engineering 18 (01): 1–23. https://doi.org/10.1142/s0218194008003532
Li, Chung-Chi J., Elliot M. Stewart, and W. K. Fuchs. 1990. Compiler-Assisted Full Checkpointing. Defense Technical Information Center. https://doi.org/10.21236/ada274291
Li, YuanZhang, Yu-An Tan, WenMing Wang, QiKun Zhang, and Zuo Wang. 2013a. “A Cache-Conscious Structure Definition for List.” Journal of Applied Sciences 13 (8): 1192–98. https://doi.org/10.3923/jas.2013.1192.1198
Li, Qin Shan, and Tie Cheng Wang. 2012. “Based on the Point Cloud Data of Columnar Structures to Tilt Analysis.” Advanced Materials Research 591-593: 1607–11. https://doi.org/10.4028/www.scientific.net/amr.591-593.1607
Li, Zhuohua, Jincheng Wang, Mingshen Sun, and John C. S. Lui. 2021. “MirChecker: Detecting Bugs in Rust Programs via Static Analysis.” In Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security. ACM. https://doi.org/10.1145/3460120.3484541
Li, Haoyu, Mingyu Wu, and Haibo Chen. 2018. “Analysis and Optimizations of Java Full Garbage Collection.” In Proceedings of the 9th Asia-Pacific Workshop on Systems. ACM. https://doi.org/10.1145/3265723.3265735
Li, Yuzhang, Tao Xu, and Chunlu Wang. 2024b. “IRaDT: LLVM IR as Target for Efficient Neural Decompilation.” International Journal of Software Engineering and Knowledge Engineering 34 (12): 1971–92. https://doi.org/10.1142/s0218194024500463
Li, Pengyuan, Rongcai Zhao, Qinghua Zhang, and Lin Han. 2016b. “An SIMD Code Generation Technology for Indirect Array.” International Journal of Computer Theory and Engineering 8 (3): 218–22. https://doi.org/10.7763/ijcte.2016.v8.1047
Li-mei, Sun, Song Bao-yan, Yu Ya-xin, Li Fang-fang, and Yu Ge. 2006. “Cache-Conscious Index Mechanism for Main-Memory Databases.” Wuhan University Journal of Natural Sciences 11 (1): 309–12. https://doi.org/10.1007/bf02831753
Li-Xia, Zhang. 2014. “A Corpus-Based Empirical Study on the Use of Get by English Majors.” In Advances in Intelligent Systems Research. Atlantis Press. https://doi.org/10.2991/emtc-14.2014.21
Liana, Putri, Rahmat Irsyada, and Roihatur Rohmah. 2023. “Development of an Internet of Things-Based Garbage Collection Robot.” Ultima Computing: Jurnal Sistem Komputer: 1–7. https://doi.org/10.31937/sk.v15i1.2863
Liang, Yifan, Hongjun Dai, Bingcai Sui, Zhenyu Zhao, and Tong Ding. 2026. “A Light Application Level Virtualization Framework with Zero-Copy and Migration Agent.” Tsinghua Science and Technology 31 (4): 2005–19. https://doi.org/10.26599/tst.2024.9010238
Liao, Stan, Srinivas Devadas, Kurt Keutzer, and Steve Tjiang. 2002. “Instruction Selection Using Binate Covering for Code Size Optimization.” In Readings in Hardware/Software Co-Design. Elsevier. https://doi.org/10.1016/b978-155860702-6/50044-2
Liaw, Heh-Tyan, Ay-Hwa Andy Liou, and Shang Huang. 2012. “Applying the Framework of Turing Machine Developing System for Implementing Java Virtual Machine.” Journal of Computational Methods in Sciences and Engineering 12 (s1): S161-S168. https://doi.org/10.3233/jcm-2012-0446
Liblit, Ben, and Alexander Aiken. 1999. Type Systems for Distributed Data Structures. Defense Technical Information Center. https://doi.org/10.21236/ada603881
Liegeois, Kim, Brian Kelley, Eric Phipps, and Sivasankaran Rajamanickam. 2024. “Towards Reverse Mode Automatic Differentiation of Kokkos-Based Code Using the LLVM Compiler Infrastructure.” In SIAM PP 2024 - Baltimore, Maryland, United States of America - March - 2024. US DOE. https://doi.org/10.2172/2540384
Liem, Clifford. 1997. “Practical Issues in Compiler Design for Embedded Processors.” In Retargetable Compilers for Embedded Core Processors. Springer US. https://doi.org/10.1007/978-1-4757-6422-2_4
“Life Cycle Cost Models and Cost Estimation Methods.” 2009. In Life Cycle Costing for Engineers. CRC Press. https://doi.org/10.1201/9781439816899-7
Lin, Yu-Cheng, Tao Ban, Shin-Ming Cheng, Takeshi Takahashi, and Wei-Chung Teng. 2025a. “Cross-Architecture IoT Malware Analysis Using P-Code Intermediate Representation.” In Proceedings of the 2025 Workshop on Recent Advances in Resilient and Trustworthy MAchine learning-driveN systems. ACM. https://doi.org/10.1145/3733821.3763028
Lin, Jin Cherng, and Chu Ting Chang. 2011. “Genetic Algorithm and Support Vector Regression for Software Effort Estimation.” Advanced Materials Research 282-283: 748–52. https://doi.org/10.4028/www.scientific.net/amr.282-283.748
Lin, Jun, Hong Ni, Hui Zhang, and Peng Sun. 2013. “Porting Java Virtual Machine in Embedded Systems Based on Qt4.” Advanced Materials Research 756-759: 1459–63. https://doi.org/10.4028/www.scientific.net/amr.756-759.1459
Lin, Jin, and Pen-Chung Yew. 2010. “A Compiler Framework for General Memory Layout Optimizations Targeting Structures.” In Proceedings of the 2010 Workshop on Interaction between Compilers and Computer Architecture. ACM. https://doi.org/10.1145/1739025.1739033
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
Lion, Benjamin, and David Nowak. 2025. “Time Aware Compilation Verified: A Category-Theoretic Approach in Rocq.” In Proceedings of the International Symposium on Formal Methods and Models for System Design. ACM. https://doi.org/10.1145/3742875.3754693
Lipka-Bartosik, Patryk. 2020. “Unboxing Hidden Correlations.” Quantum Views 4: 35. https://doi.org/10.22331/qv-2020-05-07-35
Lipp, Stephan, Sebastian Banescu, and Alexander Pretschner. 2022. “An Empirical Study on the Effectiveness of Static C Code Analyzers for Vulnerability Detection.” In Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3533767.3534380
Liskov, Barbara, and Rivka Ladin. 1986. Highly-Available Distributed Services and Fault-Tolerant Distributed Garbage Collection. Defense Technical Information Center. https://doi.org/10.21236/ada229264
Listkiewicz, Piotr, Krzysztof Stuglik, Mateusz Kulczyk, and Marcin Pietron. 2023. “J-Parallelio: Automatic Parallelization Framework for Java Virtual Machine.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-37963-5_22
Litteken, Andrew, Yung-Ching Fan, Devina Singh, Margaret Martonosi, and Frederic T. Chong. 2020. “An Updated LLVM-Based Quantum Research Compiler with Further OpenQASM Support.” Quantum Science and Technology 5 (3): 034013. https://doi.org/10.1088/2058-9565/ab8c2c
Little, Rachael, and Dongpeng Xu. 2025. “Inspecting Compiler Optimizations on Mixed Boolean Arithmetic Obfuscation.” In Proceedings 2025 Workshop on Binary Analysis Research. Internet Society. https://doi.org/10.14722/bar.2025.23007
Liu, Xuquan. 2024a. “Design and Optimization of CMOS Layout Structure.” Science and Technology of Engineering, Chemistry and Environmental Protection 2 (6): 5142. https://doi.org/10.61173/zeh4p809
Liu, Shaoying. 2024b. “Testing-Based Formal Verification.” In Agile-SOFL. Springer Nature Singapore. https://doi.org/10.1007/978-981-97-2285-3_9
Liu, David, Jonathan Calver, and Michelle Craig. 2024d. “A Static Analysis Tool in CS1: Student Usage and Perceptions of PythonTA.” In Proceedings of the 26th Australasian Computing Education Conference. ACM. https://doi.org/10.1145/3636243.3636262
Liu, Chien-Tsai, Shi-Kuo Chang, and Panos K. Chrysanthis. 1994. “Database Schema Evolution Using EVER Diagrams.” In Proceedings of the workshop on Advanced visual interfaces - AVI ‘94. ACM Press. https://doi.org/10.1145/192309.192338
Liu, C. L., G. D. Chang, and R. E. Marks. 1967. “The Design and Implementation of a Table Driven Compiler System.” In Proceedings of the April 18-20, 1967, spring joint computer conference on - AFIPS ‘67 (Spring). ACM Press. https://doi.org/10.1145/1465482.1465593
Liu, Renping, Junhua Chen, Peng Chen, Linbo Long, Anping Xiong, and Duo Liu. 2024c. “Hi-ZNS: High Space Efficiency and Zero-Copy LSM-Tree Based Stores on ZNS SSDs.” In Proceedings of the 53rd International Conference on Parallel Processing. ACM. https://doi.org/10.1145/3673038.3673096
Liu, Li, You-peng Gu, and De-bo Tang. 2013b. “Just-in-Time Compilation for Improving Response Speed of User Interaction.” Journal of Computer Applications 32 (3): 823–26. https://doi.org/10.3724/sp.j.1087.2012.00823
Liu, Feng, Zhan-rong Li, Yang Gao, and Sheng-si Luo. 2017a. “The Improvement of Network Performance by Using the Technique of PF-RING Zero-Copy to Optimize Spark Streaming.” In Proceedings of the International Conference on Computer Networks and Communication Technology (CNCT 2016). Atlantis Press. https://doi.org/10.2991/cnct-16.2017.9
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, Yu, Sergey Mechtaev, Pavle Subotić, and Abhik Roychoudhury. 2023d. “Program Repair Guided by Datalog-Defined Static Analysis.” 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.3616363
Liu, Side, Jiang Ming, Guodong Zhou, Xinyi Liu, Jianming Fu, and Guojun Peng. 2025a. “Analyzing PDFs like Binaries: Adversarially Robust PDF Malware Analysis via Intermediate Representation and Language Model.” In Proceedings of the 2025 ACM SIGSAC Conference on Computer and Communications Security. ACM. https://doi.org/10.1145/3719027.3744829
Liu, Zhinan, Jianshe Wu, Haoran Gong, and Yuxin Wang. 2023a. “A Complement Graph Based Heuristic Algorithm for Embedded Register Allocation.” In Lecture Notes in Electrical Engineering. Springer Nature Singapore. https://doi.org/10.1007/978-981-19-6613-2_474
Liu, Tianhua, Dawei Zhang, and Yichen Jiang. 2014. “Research and Implementation of Bytecode Instruction Folding on Java Card.” In Proceedings of the 2014 International Conference on Computer, Communications and Information Technology. Atlantis Press. https://doi.org/10.2991/ccit-14.2014.104
Liu, Dingbang, Xiangyu Zou, Tao Lu, et al. 2025c. “Garbage Collection Does Not Only Collect Garbage: Piggybacking-Style Defragmentation for Deduplicated Backup Storage.” In Proceedings of the Twentieth European Conference on Computer Systems. ACM. https://doi.org/10.1145/3689031.3717493
LLVM Project. n.d.-a. “LLVM Language Reference Manual.” LLVM Documentation. Accessed October 24, 2026. https://llvm.org/docs/LangRef.html
LLVM Project. n.d.-b. “The Often Misunderstood GEP Instruction.” LLVM Documentation. Accessed October 24, 2026. https://llvm.org/docs/GetElementPtr.html
LLVM Project. n.d.-c. “Performance Tips for Frontend Authors.” LLVM Documentation. Accessed October 24, 2026. https://llvm.org/docs/Frontend/PerformanceTips.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
Lobbrecht, Pascal, Xavier Blanca, and Luc Sonke. 1992. “Layout and Logical Structure Recognition.” In Integrated Management of Technical Documentation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-84840-7_13
Loh, Woong-Kee, Won-Sik Kim, and Wook-Shin Han. 2007. “CC-GiST: A Generalized Framework for Efficiently Implementing Arbitrary Cache-Conscious Search Trees.” KIPS Transactions:PartD 14D (1): 21–34. https://doi.org/10.3745/kipstd.2007.14-d.1.021
Lokan, C., and E. Mendes. 2009b. “Investigating the Use of Chronological Split for Software Effort Estimation.” IET Software 3 (5): 422–34. https://doi.org/10.1049/iet-sen.2008.0107
Lokhande, Pranjal. 2016. “Garbage Collection Management System.” International Journal Of Engineering And Computer Science. https://doi.org/10.18535/ijecs/v5i11.14
Lokuciejewski, Paul, and Peter Marwedel. 2011a. “Machine Learning Techniques in Compiler Design.” In Embedded Systems. Springer Netherlands. https://doi.org/10.1007/978-90-481-9929-7_6
Lokuciejewski, Paul, and Peter Marwedel. 2011b. “WCC—WCET-Aware C Compiler.” In Embedded Systems. Springer Netherlands. https://doi.org/10.1007/978-90-481-9929-7_3
Lomüller, Victor, and Henri-Pierre Charles. 2014. “A LLVM Extension for the Generation of Low Overhead Runtime Program Specializer.” In Proceedings of International Workshop on Adaptive Self-tuning Computing Systems. ACM. https://doi.org/10.1145/2553062.2553064
London, Ralph L. 1972. “Correctness of a Compiler for a Lisp Subset.” ACM SIGACT News, no. 14: 121–27. https://doi.org/10.1145/942580.807080
Long, Christopher. 2021. “Fred Unboxed, the Fred Rogers Center at Saint Vincent College, Latrobe, Pennsylvania.” Archivaria, no. 91: 218–22. https://doi.org/10.7202/1078473ar
Long, Junsheng, W. K. Fuchs, and Jacob A. Abraham. 1991. Compiler-Assisted Static Checkpoint Insertion. Defense Technical Information Center. https://doi.org/10.21236/ada246496
Long, Junsheng, W. K. Fuchs, and Jacob A. Abraham. 1992. Compiler-Assisted Static Checkpoint Insertion. Defense Technical Information Center. https://doi.org/10.21236/ada256039
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
Lorko, Matej, Maroš Servátka, and Le Zhang. 2018. “Anchoring in Project Duration Estimation.” Preprint, . https://doi.org/10.2139/ssrn.3230550
Lourenço, L. Miguel, João Costa Seco, and Francisco Martins. 2013. “Concurrent Typed Intermediate Language.” In Proceedings of the 28th Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/2480362.2480658
Louri, Ahmed, and Hongki Sung. 1992. “A New Compiler-Directed Cache Coherence Scheme for Shared Memory Multiprocessors with Fast and Parallel Explicit Invalidation (Abstract).” ACM SIGARCH Computer Architecture News 20 (2): 428. https://doi.org/10.1145/146628.140426
Love, Andrew, and Peter Athanas. 2013. “FPGA Meta-Data Management System for Accelerating Implementation Time with Incremental Compilation (Abstract Only).” In Proceedings of the ACM/SIGDA international symposium on Field programmable gate arrays. ACM. https://doi.org/10.1145/2435264.2435323
“Low-Power/Energy Compiler Optimizations.” 2018. In Low-Power Electronics Design. CRC Press. https://doi.org/10.1201/9781420039559-44
Lowe, Gavin. 1998. “Casper: A Compiler for the Analysis of Security Protocols.” Journal of Computer Security 6 (1–2): 53–84. https://doi.org/10.3233/jcs-1998-61-204
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
Lozada-Martinez, Ivan David, David A. Hernandez-Paez, and Fabriccio J. Visconti-Lopez. 2026. “Institutional Use of Meta-Research to Manage Conflict of Interest.” In Progress in Research Integrity. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-27479-3_7
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, Xiao-Nan. 2026. “On Pool Selection Criteria for Generating Quasi-Random Designs with Constant Pool Sizes in Non-Adaptive Group Testing.” IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences E109.A (3): 424–32. https://doi.org/10.1587/transfun.2025tap0019
Luan, Hua, Xiao-Yong Du, and Shan Wang. 2010. “Cache-Conscious Computation of Closed Iceberg Cubes.” Journal of Software 21 (4): 620–31. https://doi.org/10.3724/sp.j.1001.2010.03498
Lucas, Paul J. 2025. “Dynamic Dispatch.” In Why Learn C. Apress. https://doi.org/10.1007/979-8-8688-1597-3_26
Lukács, Dániel, and Melinda Tóth. 2018. “Analysis of Erlang Source Dependencies in BEAM Bytecode.” In Proceedings of the 10th International Conference on Applied Informatics. Eszterházy Károly University. https://doi.org/10.14794/icai.10.2017.191
Lumley, John, Roger Gimson, and Owen Rees. 2005. “A Framework for Structure, Layout & Function in Documents.” In Proceedings of the 2005 ACM symposium on Document engineering. ACM. https://doi.org/10.1145/1096601.1096615
Lumsdaine, Peter LeFanu. 2010. “Weak Omega-Categories from Intensional Type Theory.” Logical Methods in Computer Science Volume 6, Issue 3: 1062. https://doi.org/10.2168/lmcs-6(3:24)2010
Luna Sandoval, Ma. del Refugio Ofelia, and José Ruiz Ascencio. 2016. “MUREM: A Multiplicative Regression Method for Software Development Effort Estimation.” Computación y Sistemas 20 (4). https://doi.org/10.13053/cys-20-4-2378
Lunniss, Will, Sebastian Altmeyer, and Robert I. Davis. 2012. “Optimising Task Layout to Increase Schedulability via Reduced Cache Related Pre-Emption Delays.” In Proceedings of the 20th International Conference on Real-Time and Network Systems. ACM. https://doi.org/10.1145/2392987.2393008
Luo, Ziyang, Kaixin Li, Hongzhan Lin, Yuchen Tian, Mohan Kankanhalli, and Jing Ma. 2025. “Tree-of-Evolution: Tree-Structured Instruction Evolution for Code Generation in Large Language Models.” In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.acl-long.14
Luo, Jun-Wei, Ranber Singh, Alex Zunger, and Gabriel Bester. 2012. “Influence of the Atomic-Scale Structure on the Exciton Fine-Structure Splitting in InGaAs and GaAs Quantum Dots in a Vertical Electric Field.” Physical Review B 86 (16): 161302. https://doi.org/10.1103/physrevb.86.161302
Lv, Jingru, Jianpeng Hu, Jin Zhao, and Yonghao Luo. 2026. “A Chinese Abbreviation Prediction Framework Based on Chain-of-Thought Prompting and Semantic Preservation Dynamic Adjustment.” Computers, Materials & Continua 87 (1): 1–10. https://doi.org/10.32604/cmc.2025.073212
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
Lyddon, Paul A. 2017. “Discovering Language Discovering Language Properties through Corpus-Based Dictionary Data Analysis.” Vocabulary Learning and Instruction 6 (2): 61–70. https://doi.org/10.7820/vli.v06.2.lyddon
Lynn, Donald S. 1978. Interactive Compiler Proving Using Hoare Proof Rules. Defense Technical Information Center. https://doi.org/10.21236/ada052911
Lysecky, Roman, Kris Miller, Frank Vahid, and Kees Vissers. 2005. “Firm-Core Virtual FPGA for Just-in-Time FPGA Compilation (Abstract Only).” In Proceedings of the 2005 ACM/SIGDA 13th international symposium on Field-programmable gate arrays. ACM. https://doi.org/10.1145/1046192.1046247
Lysecky, Roman, Frank Vahid, and Sheldon X.-D. Tan. 2004. “Dynamic FPGA Routing for Just-in-Time FPGA Compilation.” In Proceedings of the 41st annual Design Automation Conference. ACM. https://doi.org/10.1145/996566.996819
Lyu, Jianyang, Ossama Abdelkhalik, and Shangyan Zou. 2020. “Optimization of Both the Layout of an Array and the Buoy Dimension for Two Types of Arrays.” In Volume 9: Ocean Renewable Energy. American Society of Mechanical Engineers. https://doi.org/10.1115/omae2020-19155
Lyu, Dau-Cheng, Tien-Ping Tan, Eng Siong Chng, and Haizhou Li. 2010. “SEAME: A Mandarin-English Code-Switching Speech Corpus in South-East Asia.” In Interspeech 2010. ISCA. https://doi.org/10.21437/interspeech.2010-563
Ma, Weigang, and Xinhong Hei. 2012. “An Research for Formal Verification of Safety-Critical Software.” In Proceedings of the 2nd International Conference on Computer Application and System Modeling. Atlantis Press. https://doi.org/10.2991/iccasm.2012.212
Ma, Y.-S., N. Sajadfar, and L. Campos Triana. 2014. “A Feature-Based Semantic Model for Automatic Product Cost Estimation.” International Journal of Engineering and Technology 6 (2): 109–13. https://doi.org/10.7763/ijet.2014.v6.676
Ma, Xutong, Jiwei Yan, Jun Yan, and Jian Zhang. 2024. “Panda: A Concurrent Scheduler for Compiler-Based Tools.” In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3650212.3685311
MacDonell, Stephen G. 1994. “Comparative Review of Functional Complexity Assessment Methods for Effort Estimation.” Software Engineering Journal 9 (3): 107. https://doi.org/10.1049/sej.1994.0014
“Machine-Code Generation.” 1991. In Compiling with Continuations. Cambridge University Press. https://doi.org/10.1017/cbo9780511609619.014
MacMillan, Jean, Michael J. Paley, Yuri N. Levchuk, and Daniel Serfaty. 1999. Designing the Information Space and Physical Layout for a Command Center Based on an Optimized Organizational Structure. Defense Technical Information Center. https://doi.org/10.21236/ada458636
MacMillen, Don. 2001. Nimble Compiler Environment for Agile Hardware. Volume 1. Defense Technical Information Center. https://doi.org/10.21236/ada405143
Madsen, Magnus, Benjamin Livshits, and Michael Fanning. 2013. “Practical Static Analysis of JavaScript Applications in the Presence of Frameworks and Libraries.” In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering. ACM. https://doi.org/10.1145/2491411.2491417
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
Mahadevan, Sai Veerya, Yuuki Takano, and Atsuko Miyaji. 2024. “PRSafe: A Domain Specific Language Created with LLVM.” Journal of Information Processing 32 (0): 207–22. https://doi.org/10.2197/ipsjjip.32.207
Mahale, Devyani Suresh, and Vidya Kawtikwar. 2026. “SmartVulNet: A Comparative Analysis of Deep Learning Models for Smart Contract Vulnerability Detection Using Visual Bytecode Representation.” Indian Journal Of Science And Technology 19 (14): 931–40. https://doi.org/10.17485/ijst/v19i14.306
Maheshwari, Umesh, and Barbara Liskov. 1997. “Partitioned Garbage Collection of a Large Object Store.” ACM SIGMOD Record 26 (2): 313–23. https://doi.org/10.1145/253262.253338
Mahoney, William, Philip Sigillito, Jeff Smolinski, Todd McDonald, and George Grispos. 2022. “Analyzing the Performance of Block-Splitting in LLVM Fingerprinting.” International Conference on Cyber Warfare and Security 17 (1): 176–84. https://doi.org/10.34190/iccws.17.1.39
Mailund, Thomas. 2021. “Reference Counting Garbage Collection.” In Pointers in C Programming. Apress. https://doi.org/10.1007/978-1-4842-6927-5_15
Majeti, Deepak, Kuldeep S. Meel, Rajkishore Barik, and Vivek Sarkar. 2016. “Automatic Data Layout Generation and Kernel Mapping for CPU+GPU Architectures.” In Proceedings of the 25th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/2892208.2892210
Majo, Zoltan, and Thomas R. Gross. 2012. “Matching Memory Access Patterns and Data Placement for NUMA Systems.” In Proceedings of the Tenth International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/2259016.2259046
Majumder, Abhilash. 2025. “FormalGym: Deep Reinforcement Learning Agent Based Formal Compiler Optimization Framework.” In Proceedings of the International Conference on Research in Adaptive and Convergent Systems. ACM. https://doi.org/10.1145/3769002.3769975
Makowski, Christine, and Lori L. Pollock. 1995. “Achieving Efficient Register Allocation via Parallelism.” In Proceedings of the 1995 ACM symposium on Applied computing - SAC ‘95. ACM Press. https://doi.org/10.1145/315891.315935
Malanowska, Agnieszka, and Ilona Bluemke. 2019. “ISO 25010 Support in Test Point Analysis for Testing Effort Estimation.” In Studies in Computational Intelligence. Springer International Publishing. https://doi.org/10.1007/978-3-030-26574-8_15
Malathi, S., and S. Sridhar. 2012. “Performance Evaluation of Software Effort Estimation Using Fuzzy Analogy Based on Complexity.” International Journal of Computer Applications 40 (3): 32–37. https://doi.org/10.5120/5026-7172
Malik, Avinash. 2025. “Efficient Compilation and Execution of Synchronous Programs via Type-State Programming.” In Proceedings of the International Symposium on Formal Methods and Models for System Design. ACM. https://doi.org/10.1145/3742875.3754680
Mallen, Adam B., and Dennis Brylow. 2010. “Compiler Construction with a Dash of Concurrency and an Embedded Twist.” In Proceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion. ACM. https://doi.org/10.1145/1869542.1869568
Maltsev, Eduard, and Riaz Ul Amin. 2024. “Impact of Serialization Format on Inter-Service Latency.” Advances in Cyber-Physical Systems 9 (2): 89–94. https://doi.org/10.23939/acps2024.02.089
Manchana, RamaKrishna. 2015. “Java Virtual Machine (JVM): Architecture, Goals, and Tuning Options.” International Journal of Scientific Research and Engineering Trends 1 (3): 42–52. https://doi.org/10.61137/ijsret.vol.1.issue3.42
Manchana, RamaKrishna. 2018. “Garbage Collection Tuning in Java: Techniques, Algorithms, and Best Practices.” International Journal of Scientific Research and Engineering Trends 4 (4): 765–73. https://doi.org/10.61137/ijsret.vol.4.issue4.236
Mandell, R., and G. Estrin. 1966. “A Meta-Compiler as a Design Automation Tool.” In Proceedings of the SHARE design automation project on - DAC ‘66. ACM Press. https://doi.org/10.1145/800267.810785
Mandl, Robert. 1985. “Orthogonal Latin Squares: An Application of Experiment Design to Compiler Testing.” Communications of the ACM 28 (10): 1054–58. https://doi.org/10.1145/4372.4375
Maneesh Gupta. 2025. “Implementing Zero-Copy Integration in Hybrid Cloud Environments for Seamless Salesforce Data Exchange.” Journal of Advances in Developmental Research 16 (1): 1435. https://doi.org/10.71097/ijaidr.v16.i1.1435
Manegold, Stefan, Peter Boncz, Niels Nes, and Martin Kersten. 2004. “Cache-Conscious Radix-Decluster Projections.” In Proceedings 2004 VLDB Conference. Elsevier. https://doi.org/10.1016/b978-012088469-8.50061-9
Mangalure, Shubham, Ganesh Misal, Sanket Shelke, and Shrihari Waykule. 2023. “Garbage Collection Android Application.” International Journal for Research in Applied Science and Engineering Technology 11 (10): 1964–68. https://doi.org/10.22214/ijraset.2023.56345
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
Mannarswamy, Sandya S., and R. Govindarajan. 2010. “Analyzing Cache Performance Bottlenecks of STM Applications and Addressing Them with Compiler’s Help.” In Proceedings of the 19th international conference on Parallel architectures and compilation techniques. ACM. https://doi.org/10.1145/1854273.1854345
Manor, Kfir. 2025. “Does Risk Assessment Matter in Corporate Compliance Programs? An Empirical Study Examining the Impact of Risk Assessment on Corporations’ Compliance Programs.” Risk and Decision Analysis 11 (3–4): 120–51. https://doi.org/10.1177/15697371251375287
Manuel, José, Calderón Trilla, Michael Hicks, Stephen Magill, Piotr Mardziel, and Ian Sweet. 2020. “Probabilistic Abstract Interpretation: Sound Inference and Application to Privacy.” In Foundations of Probabilistic Programming. Cambridge University Press. https://doi.org/10.1017/9781108770750.012
ManzoorKirmani, Mudasir, and Abdul Wahid. 2015. “Use Case Point Method of Software Effort Estimation: A Review.” International Journal of Computer Applications 116 (15): 43–47. https://doi.org/10.5120/20415-2835
Marangoni, Matthew, and Thomas Wischgoll. 2016. “Paper: Togpu: Automatic Source Transformation from C++ to CUDA Using Clang/LLVM.” Electronic Imaging 28 (1): 1–9. https://doi.org/10.2352/issn.2470-1173.2016.1.vda-487
Marcet, S., K. Ohtani, and H. Ohno. 2010. “Vertical Electric Field Tuning of the Exciton Fine Structure Splitting and Photon Correlation Measurements of GaAs Quantum Dot.” Applied Physics Letters 96 (10): 101117. https://doi.org/10.1063/1.3360212
Mareschal, Denis, Mark H. Johnson, Sylvain Sirois, Michael W. Spratling, Michael S. C. Thomas, and Gert Westermann. 2007. “Embrainment: The Brain Unboxed.” In Neuroconstructivism - IHow the brain constructs cognition. Oxford University Press. https://doi.org/10.1093/acprof:oso/9780198529910.003.0003
“Mark-Compact Garbage Collection.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-4
“Mark-Sweep Garbage Collection.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-3
Marom, Yuval, and Ingrid Zukerman. 2009. “An Empirical Study of Corpus-Based Response Automation Methods for an E-Mail-Based Help-Desk Domain.” Computational Linguistics 35 (4): 597–635. https://doi.org/10.1162/coli.2009.35.4.35404
Marsan, Charles, and Maude Laliberté. 2015. “Research Conflict of Interest: Flaws in Professional Codes of Ethics.” In Integrity in the Global Research Arena. WORLD SCIENTIFIC. https://doi.org/10.1142/9789814632393_0009
Martin, Daniel. 1977. “An Emulator Used to Teach Compiler Design.” In Proceedings of the 15th annual Southeast regional conference on - ACM-SE 15. ACM Press. https://doi.org/10.1145/1795396.1795398
Martínez Lopez, Pablo E. 2007. “Static Type Systems: From Specification to Implementation.” In Verification, Validation and Testing in Software Engineering. IGI Global. https://doi.org/10.4018/978-1-59140-851-2.ch011
Martinez Vallina, Fernando, and Henry Styles. 2015. “Unlocking FPGAs Using High Level Synthesis Compiler Technologies.” In Proceedings of the 2015 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays. ACM. https://doi.org/10.1145/2684746.2721403
Martinsen, Jan Kasper, Håkan Grahn, and Anders Isberg. 2014. “An Argument for Thread-Level Speculation and Just-in-Time Compilation in the Google’s V8 JavaScript Engine.” In Proceedings of the 11th ACM Conference on Computing Frontiers. ACM. https://doi.org/10.1145/2597917.2597950
Martišius, Vaclovas. 2008. “Anchoring Effect in Estimation of Event Occurrence Time.” Psichologija 37: 20–25. https://doi.org/10.15388/psichol.2008.0.2617
Marwedel, Peter. 2002. “Code Generation for Embedded Processors: An Introduction.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_1
Marx, Stefan, and Sebastian Erdweg. 2024. “Abstract Interpretation of Java Bytecode in Sturdy.” In Proceedings of the 26th ACM International Workshop on Formal Techniques for Java-like Programs. ACM. https://doi.org/10.1145/3678721.3686226
Maryanski, Fred, John Bedell, Sheilah Hoelscher, et al. 1991. “Generating Object-Oriented Database Systems with the Data Model Compiler.” In Topics in Information Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-84374-7_18
Mason, Oliver. 1996. “Review of Stubbs (1996): Text and Corpus Analysis: Computer-Assisted Studies of Language and Culture.” Functions of Language 3 (2): 269–72. https://doi.org/10.1075/fol.3.2.11mas
Masri, Wes, and Andy Podgurski. 2006. “An Empirical Study of the Strength of Information Flows in Programs.” In Proceedings of the 2006 international workshop on Dynamic systems analysis. ACM. https://doi.org/10.1145/1138912.1138927
Mateen, Sana. 2026. “Adaptive LLVM-Based Code Obfuscation Using a Random Forest Selection Framework.” International Journal for Research in Applied Science and Engineering Technology 14 (4): 1394–1400. https://doi.org/10.22214/ijraset.2026.79512
Matsuura, Yusuke, and Chung Jaeah. 2024. “Dyslexia Articles Unboxed: Analyzing Their Readability Level.” Journal of Developmental & Behavioral Pediatrics 45 (3): e211-e216. https://doi.org/10.1097/dbp.0000000000001274
Matthes, Ralph. 2006. “Verification of Programs on Truly Nested Datatypes in Intensional Type Theory.” In Electronic Workshops in Computing. BCS Learning & Development. https://doi.org/10.14236/ewic/msfp2006.10
Matthes, Ralph. 2009. “An Induction Principle for Nested Datatypes in Intensional Type Theory.” Journal of Functional Programming 19 (3–4): 439–68. https://doi.org/10.1017/s095679680900731x
Mavaddat, Farhad. 2002. “On Transforming Code Generation to a Parsing Problem.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_9
Maxwell, Katrina, Luk Van Wassenhove, and Soumitra Dutta. 1999. “Performance Evaluation of General and Company Specific Models in Software Development Effort Estimation.” Management Science 45 (6): 787–803. https://doi.org/10.1287/mnsc.45.6.787
Mayer, Clemens, Stefan Hanenberg, Romain Robbes, Éric Tanter, and Andreas Stefik. 2012. “An Empirical Study of the Influence of Static Type Systems on the Usability of Undocumented Software.” In Proceedings of the ACM international conference on Object oriented programming systems languages and applications. ACM. https://doi.org/10.1145/2384616.2384666
Mayer, Barbara A., and Monica M. Lu. 1989. Guidelines for Formal Verification Systems. Defense Technical Information Center. https://doi.org/10.21236/ada385357
Mayuri Dhaygude. 2016. “Analysis and Reporting of Programming Skills Using Mobile Cloud Based Compiler.” International Journal of Research in Engineering and Technology 05 (01): 266–68. https://doi.org/10.15623/ijret.2016.0501053
Mazibuko, Gugulethu, and Hloniphani Ndebele. 2017. “Corpora and Corpus Tools for Indigenous African Languages: The Case of an IsiZulu-English Spoken Word Code-Switching Corpus.” Mankind Quarterly 58 (2): 268–83. https://doi.org/10.46469/mq.2017.58.2.4
Mbengue, Ramatoulaye. 2015. “Cartographic Approach to Garbage Collection on the Coast of Ngor (Dakar, Senegal).” American Journal of Environmental Protection 4 (4): 174. https://doi.org/10.11648/j.ajep.20150404.11
McCool, Michael, and Stefanus Du Toit. 2009. “Intermediate Representation.” In Metaprogramming GPUs with Sh. A K Peters/CRC Press. https://doi.org/10.1201/9781568816692-14
McCray, Gordon E., Russell L. Purvis, and Coleen G. McCray. 2002. “Project Management under Uncertainty: The Impact of Heuristics and Biases.” Project Management Journal 33 (1): 49–57. https://doi.org/10.1177/875697280203300108
McEnery, Anthony, and Zhonghua Xiao. 2004. “The Lancaster Corpus of Mandarin Chinese: A Corpus for Monolingual and Contrastive Language Study.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/3rj7enx8i87i
McGee, Ethan T., and John D. McGregor. 2017. “A Realization Effort Estimation Model for Dynamic Software Product Lines.” In Proceedings of the 21st International Systems and Software Product Line Conference - Volume B. ACM. https://doi.org/10.1145/3109729.3109740
McGeer, Patrick C., William R. Bush, Jonathan D. Pincus, and Alvin M. Despain. 1986. Design Considerations for a Prolog Silicon Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada173049
McKee, Derrick, Nathan Burow, and Mathias Payer. 2023. “Accurate Compiler and Optimization Independent Function Identification Using Program State Transformations.” In Proceedings 2023 Workshop on Binary Analysis Research. Internet Society. https://doi.org/10.14722/bar.2023.23003
McKenzie, Bruce. 1999. “Modern Compiler Implementation in ML: Basic Techniques by Andrew W. Appel, Cambridge University Press, 1997, ISBN 0521587751.” Journal of Functional Programming 9 (1): 105–11. https://doi.org/10.1017/s0956796899233242
McLellan, William G., and Philip Gilbert. 1967. Compiler Generation Using Formal Specification of Procedure-Oriented and Machine Languages. Defense Technical Information Center. https://doi.org/10.21236/ad0658029
Meadows, Catherine A. 1995. Formal Verification of Cryptographic Protocols: A Survey. Defense Technical Information Center. https://doi.org/10.21236/ada464292
“Measurement of Effectiveness Training & Development Programs in the Case of Research Affairs of Haramaya University, Oromia Region, Ethiopia Country: Empirical Study.” 2021. Journal of Education and Practice. https://doi.org/10.7176/jep/12-07-05
Meenakshi and Meenakshi Pareek. 2024. “Software Effort Estimation Using Deep Learning: A Gentle Review.” In Algorithms for Intelligent Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-97-0327-2_26
Meharunnisa, Muhammad Saqlain, Muhammad Abid, Muhammad Awais, and Željko Stević. 2023. “Analysis of Software Effort Estimation by Machine Learning Techniques.” Ingénierie des systèmes d information 28 (6). https://doi.org/10.18280/isi.280602
Mehdi, Riyadh A. K. 2024. “Predicting and Explaining Variations in Software Effort Estimation Using Adaptive Fuzzy-Neural Networks with Clustering.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-47721-8_51
Mehnert, Hannes. 2010. “Extending Dylan’s Type System for Better Type Inference and Error Detection.” In Proceedings of the 2010 international conference on Lisp. ACM. https://doi.org/10.1145/1869643.1869645
Mehrara, Mojtaba, and Todd Austin. 2006. “Reliability-Aware Data Placement for Partial Memory Protection in Embedded Processors.” In Proceedings of the 2006 workshop on Memory system performance and correctness. ACM. https://doi.org/10.1145/1178597.1178600
Mehravaran, Mahmoud. 2024. “Examination of Compound Verbs in the Persian Language through Corpus Analysis [In Persian].” Journal of Studies in Applied Language 7 (1): 83–105. https://doi.org/10.61186/jsal.7.1.83
Mehta, Ashok B. 2021. “Compiler Directives.” In Introduction to SystemVerilog. Springer International Publishing. https://doi.org/10.1007/978-3-030-71319-5_27
Mei, Song Zhu, Yong Cheng, Jiang Chun Ren, et al. 2014. “TCFI4J: A Trust Enhanced Control Flow Integrity in Java Virtual Machine.” Applied Mechanics and Materials 513-517: 1477–84. https://doi.org/10.4028/www.scientific.net/amm.513-517.1477
Meiohas, Chiara, Stephen M. Blackburn, and Erez Petrank. 2023. “Linear-Mark: Locality vs. Accuracy in Mark-Sweep Garbage Collection.” In Proceedings of the International Symposium on Memory Systems. ACM. https://doi.org/10.1145/3631882.3631893
Meleis, Waleed M., and Edward S. Davidson. 1994. “Optimal Local Register Allocation for a Multiple-Issue Machine.” In Proceedings of the 8th international conference on Supercomputing - ICS ‘94. ACM Press. https://doi.org/10.1145/181181.181318
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
Men, Honghua. 2025. “Constructing China’s New Strategic Layout.” In Understanding China. Springer Nature Singapore. https://doi.org/10.1007/978-981-96-5467-3_13
Mendes, Emilia. 2008a. “How to Improve Your Company’s Effort Estimation Practices.” In Cost Estimation Techniques for Web Projects. IGI Global. https://doi.org/10.4018/978-1-59904-135-3.ch009
Mendes, Emilia. 2008b. “Web Effort Estimation Usiing Regression Analysis.” In Cost Estimation Techniques for Web Projects. IGI Global. https://doi.org/10.4018/978-1-59904-135-3.ch005
Mendes, Emilia. 2008c. “Web Effort Estimation Using Case-Based Reasoning.” In Cost Estimation Techniques for Web Projects. IGI Global. https://doi.org/10.4018/978-1-59904-135-3.ch006
Mendes, Emilia. 2008d. “Web Effort Estimation Using Classification and Regression Trees.” In Cost Estimation Techniques for Web Projects. IGI Global. https://doi.org/10.4018/978-1-59904-135-3.ch007
Mendes, Emilia. 2012b. “Software and Web Effort Estimation via Predictive and Diagnostic Reasoning.” In The IFPUG Guide to IT and Software Measurement. Auerbach Publications. https://doi.org/10.1201/b11884-11
Mendes, Emilia. 2014b. “Introduction to Effort Estimation.” In Practitioner’s Knowledge Representation. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-54157-5_3
Mendes, Emilia, and Silvia Abrahão. 2008. “Web Development Effort Estimation: An Empirical Analysis.” In Handbook of Research on Web Information Systems Quality. IGI Global. https://doi.org/10.4018/978-1-59904-847-5.ch002
Mendes, Emilia, and Simon Baker. 2013. “Using Knowledge Management and Aggregation Techniques to Improve Web Effort Estimation.” In Advances in Systems Analysis, Software Engineering, and High Performance Computing. IGI Global. https://doi.org/10.4018/978-1-4666-4229-4.ch005
Mendes, Emilia, Carmel Pollino, and Nile Mosley. 2009. “Building an Expert-Based Web Effort Estimation Model Using Bayesian Networks.” In Electronic Workshops in Computing. BCS Learning & Development. https://doi.org/10.14236/ewic/ease2009.5
Mendez, Emilia. 2010. “Using Bayesian Networks for Web Effort Estimation.” In Advances in Computational Intelligence and Robotics. IGI Global. https://doi.org/10.4018/978-1-60566-758-4.ch002
Mendez S., Luis Andres, Ho Yin Ng, Zin Yin Lim, Yi-Jie Lu, and Ping-Hsuan Han. 2022. “MovableBag: Substitutional Robot for Enhancing Immersive Boxing Training with Encountered-Type Haptic.” In SIGGRAPH Asia 2022 XR. ACM. https://doi.org/10.1145/3550472.3558406
Menendez, David, and Santosh Nagarakatte. 2016. “Termination-Checking for LLVM Peephole Optimizations.” In Proceedings of the 38th International Conference on Software Engineering. ACM. https://doi.org/10.1145/2884781.2884809
Meng, Xiangwei, Chen Gao, Wei Li, and Fengyuan Ren. 2026. “Low-Compilation-Cost Register Allocation in LLVM-Based Binary Translation.” In Proceedings of the 21st European Conference on Computer Systems. ACM. https://doi.org/10.1145/3767295.3803591
Mengel, Susan A., and Vinay Yerramilli. 1999. “A Case Study of the Static Analysis of the Quality of Novice Student Programs.” ACM SIGCSE Bulletin 31 (1): 78–82. https://doi.org/10.1145/384266.299689
Menon, Jai, and Larry Stockmeyer. 1998. “An Age-Threshold Algorithm for Garbage Collection in Log-Structured Arrays and File Systems.” In High Performance Computing Systems and Applications. Springer US. https://doi.org/10.1007/978-1-4615-5611-4_13
Menzies, Tim, Ekrem Kocagüneli, Leandro Minku, Fayola Peters, and Burak Turhan. 2015. “Effort Estimation.” In Sharing Data and Models in Software Engineering. Elsevier. https://doi.org/10.1016/b978-0-12-417295-1.00009-6
Mesnage, Cédric, Xiaoyang Wang, Hang Dong, and Aishwaryaprajna. 2025. “Evaluating Inductive Reasoning and Programming Capabilities of Large Language Models with the One-Dimensional Abstract Reasoning Corpus.” Intelligenza Artificiale 19 (2): 102–15. https://doi.org/10.1177/17248035251363882
Meth, Kalman, Joel Nider, and Mike Rapoport. 2018. “Zero-Copy Receive for Virtualized Network Devices.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-02683-7_45
Meth, Kalman, Mike Rapoport, Joel Nider, and Razya Ladelsky. 2017. “Zero-Copy Receive Path in Virtio.” In Proceedings of the 10th ACM International Systems and Storage Conference. ACM. https://doi.org/10.1145/3078468.3078488
Metodi, Tzvetan S., and Samuel D. Gasster. 2010. “Design and Implementation of a Quantum Compiler.” In SPIE Proceedings, vol. 7702, edited by Eric J. Donkor, Andrew R. Pirich, Howard E. Brandt. SPIE. https://doi.org/10.1117/12.852548
Meyer, Walter. 1972. “Garbage Collection, Sunday Strolls, and Soldering Problems.” Mathematics Teacher 65 (4): 307–9. https://doi.org/10.5951/mt.65.4.0307
Meyer, Werner G. 2014. “The Effect of Optimism Bias on the Decision to Terminate Failing Projects.” Project Management Journal 45 (4): 7–20. https://doi.org/10.1002/pmj.21435
Mezini, Mira. 1998. “A Denotational Semantics of RONDO.” In Variational Object-Oriented Programming Beyond Classes and Inheritance. Springer US. https://doi.org/10.1007/978-1-4615-5627-5_4
Michell, Kalani. 2026. “Unboxing Magazines.” In Working Title: Media Packaging and the Margins of Art. University of California Press. https://doi.org/10.1525/luminos.270.e
Mikami, Hiro, Seira Iwai, and Masato Edahiro. 2023. “LLVM-IR Instruction Latency Estimation Using Deep Neural Networks for a Software–Hardware Interface for Multi-Many-Cores.” International Journal of Computers & Technology 23: 49–79. https://doi.org/10.24297/ijct.v23i.9472
Mikami, Hiro, Kei Torigoe, Makoto Inokawa, and Masato Edahiro. 2022. “LLVM Instruction Latency Measurement for Software-Hardware Interface for Multi-Many-Core.” International Journal of Computers & Technology 22: 50–63. https://doi.org/10.24297/ijct.v22i.9231
Mikirtumov, Ivan B. 2018. “Type Theoretical Grammar, Intensional Entities and Epistemic Attitudes.” Epistemology & Philosophy of Science 55 (4): 53–57. https://doi.org/10.5840/eps201855466
Milojković, Nevena, and Oscar Nierstrasz. 2016. “Exploring Cheap Type Inference Heuristics in Dynamically Typed Languages.” In Proceedings of the 2016 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. ACM. https://doi.org/10.1145/2986012.2986017
Miloudi, Chaymae, Laila Cheikhi, and Alain Abran. 2022b. “Systematic Review of Machine Learning-Based Open-Source Software Maintenance Effort Estimation.” Recent Advances in Computer Science and Communications 16 (3): e090622205786. https://doi.org/10.2174/2666255816666220609110712
Miloudi, Chaymae, Laila Cheikhi, and Ali Idri. 2020. “A Review of Open Source Software Maintenance Effort Estimation.” In Proceedings of the 13th International Conference on Intelligent Systems: Theories and Applications. ACM. https://doi.org/10.1145/3419604.3419809
Miloudi, Chaymae, Laila Cheikhi, Ali Idri, and Alain Abran. 2022a. “The Impact of Instance Selection Algorithms on Maintenance Effort Estimation for Open-Source Software.” In Lecture Notes in Networks and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-031-04829-6_17
Milyutin, N. A., T. D. Ovasapyan, and D. V. Ivanov. 2026. “Deobfuscation of Malicious Software Using LLVM Intermediate Representation.” Problems of information security. Computer systems, no. 2: 70–81. https://doi.org/10.66424/2071-8217-2026-2-6
Miné, Antoine. 2012. “Static Analysis of Run-Time Errors in Embedded Real-Time Parallel C Programs.” Logical Methods in Computer Science Volume 8, Issue 1: 799. https://doi.org/10.2168/lmcs-8(1:26)2012
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
Minku, Leandro L. 2016. “On the Terms within- and Cross-Company in Software Effort Estimation.” In Proceedings of the The 12th International Conference on Predictive Models and Data Analytics in Software Engineering. ACM. https://doi.org/10.1145/2972958.2972968
Minku, Leandro L. 2021. “Multi-Stream Online Transfer Learning for Software Effort Estimation: Is It Necessary?” In Proceedings of the 17th International Conference on Predictive Models and Data Analytics in Software Engineering. ACM. https://doi.org/10.1145/3475960.3475988
Minku, Leandro L., and Xin Yao. 2011. “A Principled Evaluation of Ensembles of Learning Machines for Software Effort Estimation.” In Proceedings of the 7th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2020390.2020399
Minku, Leandro L., and Xin Yao. 2012. “Can Cross-Company Data Improve Performance in Software Effort Estimation?” In Proceedings of the 8th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2365324.2365334
Minku, Leandro L., and Xin Yao. 2013a. “An Analysis of Multi-Objective Evolutionary Algorithms for Training Ensemble Models Based on Different Performance Measures in Software Effort Estimation.” In Proceedings of the 9th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2499393.2499396
Minku, Leandro L., and Xin Yao. 2014. “How to Make Best Use of Cross-Company Data in Software Effort Estimation?” In Proceedings of the 36th International Conference on Software Engineering. ACM. https://doi.org/10.1145/2568225.2568228
Miranda, M., C. Ghez, C. Kulkarni, F. Catthoor, and D. Verkest. 2001. “Systematic Speed-Power Memory Data-Layout Exploration for Cache Controlled Embedded Multimedia Applications.” In Proceedings of the 14th international symposium on Systems synthesis - ISSS ‘01. ACM Press. https://doi.org/10.1145/500024.500027
Miranda, Javier, Edmond Schonberg, and Hristian Kirtchev. 2005. “The Implementation of Ada 2005 Synchronized Interfaces in the GNAT Compiler.” ACM SIGAda Ada Letters XXV (4): 41–48. https://doi.org/10.1145/1104011.1103853
Misonizhnik, Alexander Vladimirovich, Alexey Alexandrovich Babushkin, Sergey Antonovich Morozov, Yurii Olegovich Kostyukov, Dmitry Alexandrovich Mordvinov, and Dmitry Vladimirovich Koznov. 2022. “Automated Testing of LLVM Programs with Complex Input Data Structures.” Proceedings of the Institute for System Programming of the RAS 34 (4): 49–62. https://doi.org/10.15514/ispras-2022-34(4)-4
Mitchell, John C. 1996. Advances in Type Systems for Computing. Defense Technical Information Center. https://doi.org/10.21236/ada310227
Mitra, Tulika, and Abhik Roychoudhury. 2007. “Worst-Case Execution Time and Energy Analysis.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420043839.ch1
Mitzner, Kraig. 2007. “Project Structures and the Layout Tool Set.” In Complete PCB Design Using OrCad Capture and Layout. Elsevier. https://doi.org/10.1016/b978-075068214-5/50004-4
Miyoshi, T. 2005. “Unified Phase Compiler by Use of 3-D Representation Space.” IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences E88-A (4): 838–45. https://doi.org/10.1093/ietfec/e88-a.4.838
Mockus, Audris. 2014. “Is Mining Software Repositories Data Science? (Keynote).” In Proceedings of the 11th Working Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/2597073.2600728
“Models Used in Static Analysis for Deadlocks of Ada Tasking Programs by M. Tiusanen and T. Murata.” 2018. In Deadlock Resolution in Computer-Integrated Systems. CRC Press. https://doi.org/10.1201/9781315214665-23
“Modern Compiler Design.” 2013. Choice Reviews Online 50 (06): 50-3309-50-3309. https://doi.org/10.5860/choice.50-3309
Mogensen, Torben Ægidius. 2011a. “Intermediate-Code Generation.” In Undergraduate Topics in Computer Science. Springer London. https://doi.org/10.1007/978-0-85729-829-4_6
Mogensen, Torben Ægidius. 2011b. “Register Allocation.” In Undergraduate Topics in Computer Science. Springer London. https://doi.org/10.1007/978-0-85729-829-4_8
Mogensen, Torben Ægidius. 2017a. “Intermediate-Code Generation.” In Undergraduate Topics in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-66966-3_6
Mogensen, Torben Ægidius. 2017b. “Machine-Code Generation.” In Undergraduate Topics in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-66966-3_7
Mogensen, Torben Ægidius. 2017c. “Register Allocation.” In Undergraduate Topics in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-66966-3_8
Mogensen, Torben Ægidius. 2024a. “Intermediate-Code Generation.” In Undergraduate Topics in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-031-46460-7_6
Mogensen, Torben Ægidius. 2024b. “Machine-Code Generation.” In Undergraduate Topics in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-031-46460-7_7
Mogensen, Torben Ægidius. 2024c. “Register Allocation.” In Undergraduate Topics in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-031-46460-7_8
Mohagheghi, Parastoo, Bente Anda, and Reidar Conradi. 2005. “Effort Estimation of Use Cases for Incremental Large-Scale Software Development.” In Proceedings of the 27th international conference on Software engineering - ICSE ‘05. ACM Press. https://doi.org/10.1145/1062455.1062516
Mohamad Rishwan, Raden, E. Haodudin Nurkifli, and Arip Solehudin. 2024. “Analisis Perbandingan Performa Server Websocket Dengan Menggunakan Payload JSON, Binary Serialization, Dan Protobuf Dengan Menggunakan Metode Load Testing.” JATI (Jurnal Mahasiswa Teknik Informatika) 9 (1): 706–12. https://doi.org/10.36040/jati.v9i1.12484
Mohamed Shabeer, K. P., S. I. Unni Krishnan, and G. Deepa. 2021. “Software Effort Estimation Using Genetic Algorithms with the Variance-Accounted-For (VAF) and the Manhattan Distance.” In Smart Innovation, Systems and Technologies. Springer Singapore. https://doi.org/10.1007/978-981-16-3675-2_32
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
Mohebbi, Hamid Reza, Omid Kashefi, and Mohsen Sharifi. 2011. “ZIVM: A Zero-Copy Inter-VM Communication Mechanism for Cloud Computing.” Computer and Information Science 4 (6). https://doi.org/10.5539/cis.v4n6p18
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
Mokhov, Serguei A., Joey Paquet, and Xin Tong. 2009. “A Type System for Hybrid Intensional-Imperative Programming Support in GIPSY.” In Proceedings of the 2nd Canadian Conference on Computer Science and Software Engineering. ACM. https://doi.org/10.1145/1557626.1557642
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
Molnar, Peter, Andreas Krall, and Florian Brandner. 2009. “Stack Allocation of Objects in the CACAO Virtual Machine.” In Proceedings of the 7th International Conference on Principles and Practice of Programming in Java. ACM. https://doi.org/10.1145/1596655.1596680
Mondshein, L. F. 1967. Vital Compiler System: Reference Manual. Defense Technical Information Center. https://doi.org/10.21236/ad0649140
Monk, Simon, and Ian Sommerville. 1993. “Schema Evolution in OODBs Using Class Versioning.” ACM SIGMOD Record 22 (3): 16–22. https://doi.org/10.1145/163090.163094
Monniaux, David. 2023. “Completeness in Static Analysis by Abstract Interpretation: A Personal Point of View.” In Intelligent Systems Reference Library. Springer Nature Singapore. https://doi.org/10.1007/978-981-19-9601-6_6
Moon, David A. 1984. “Garbage Collection in a Large LISP System.” In Proceedings of the 1984 ACM Symposium on LISP and functional programming - LFP ‘84. ACM Press. https://doi.org/10.1145/800055.802040
Mooney, P., and M. Minghini. 2022. “Geospatial Data Exchange Using Binary Data Serialization Approaches.” International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences XLVIII-4/W1-2022: 307–13. https://doi.org/10.5194/isprs-archives-xlviii-4-w1-2022-307-2022
Mooney, Vincent J., III. 2003. Compiler Optimizations for Power-Aware Computing. Volume 1 of 2. Defense Technical Information Center. https://doi.org/10.21236/ada418765
Moreno, Eduardo Sánchez, and Enrique García Riaza. 2024. “Unboxing the Gift: Diplomatic Presents in Their Cultural Contexts.” In The Materiality of Diplomacy in the Hellenistic-Roman Mediterranean. Edinburgh University Press. https://doi.org/10.3366/edinburgh/9781399530385.003.0001
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
Mori, Hitoshi, Takuya Nomoto, Ryotaro Arita, and Elena R. Margine. 2024. “Efficient Anisotropic Migdal-Eliashberg Calculations with an Intermediate Representation Basis and Wannier Interpolation.” Physical Review B 110 (6): 064505. https://doi.org/10.1103/physrevb.110.064505
Moro, Mirella M., Susan Malaika, and Lipyeow Lim. 2007. “Preserving XML Queries during Schema Evolution.” In Proceedings of the 16th international conference on World Wide Web. ACM. https://doi.org/10.1145/1242572.1242841
Moroz, Olha. 2022. “Compilation-Semantic Verification of Time-Parameterized Multi-Parallel Programs for Information Management Systems.” Bulletin of V.N. Karazin Kharkiv National University, series «Mathematical modeling. Information technology. Automated control systems», no. 56: 43–50. https://doi.org/10.26565/2304-6201-2022-56-04
Morozov, A., K. Janschek, and Y. Zhou. 2018. “LLVM-Based Stochastic Error Propagation Analysis of Manually Developed Software Components.” In Safety and Reliability – Safe Societies in a Changing World. CRC Press. https://doi.org/10.1201/9781351174664-319
Morrisett, Greg. 2016. “Challenges in Compiling Coq.” In Proceedings of the 18th International Symposium on Principles and Practice of Declarative Programming. ACM. https://doi.org/10.1145/2967973.2970379
Morschel, Lea, Olufemi Adeyemi, Vincent Garonne, et al. 2020. “dCache – Efficient Message Encoding for Inter-Service Communication in dCache: Evaluation of Existing Serialization Protocols as a Replacement for Java Object Serialization.” EPJ Web of Conferences 245: 05017. https://doi.org/10.1051/epjconf/202024505017
Mosaner, Raphael, David Leopoldseder, Wolfgang Kisling, Lukas Stadler, and Hanspeter Mössenböck. 2022. “Compilation Forking: A Fast and Flexible Way of Generating Data for Compiler-Internal Machine Learning Tasks.” Art, Science, and Engineering of Programming 7 (1): 3. https://doi.org/10.22152/programming-journal.org/2023/7/3
Moss, Eliot. 2013. “The Cleanest Garbage Collection: Technical Perspective.” Communications of the ACM 56 (12): 100–100. https://doi.org/10.1145/2534706.2534725
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
Mössenböck, Hanspeter. 2025a. “Code Generation.” In Compiler Construction. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-84813-1_6
Mössenböck, Hanspeter. 2025b. “The Compiler Generator Coco/R.” In Compiler Construction. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-84813-1_7
Mosses, Peter D. 1980. “A Constructive Approach to Compiler Correctness.” DAIMI Report Series 9 (118). https://doi.org/10.7146/dpb.v9i118.6536
Mosses, Peter D. 1990. “Denotational Semantics.” In Formal Models and Semantics. Elsevier. https://doi.org/10.1016/b978-0-444-88074-1.50016-0
Mounes-Toussi, Farnaz, and David J. Lilja. 1994. “Performance Limits of Compiler-Directed Multiprocessor Cache Coherence Enforcement.” In The Interaction of Compilation Technology and Computer Architecture. Springer US. https://doi.org/10.1007/978-1-4615-2684-1_7
Mowry, Todd C., Angela K. Demke, and Orran Krieger. 1996. “Automatic Compiler-Inserted I/O Prefetching for out-of-Core Applications.” In Proceedings of the second USENIX symposium on Operating systems design and implementation. ACM. https://doi.org/10.1145/238721.238734
Mowry, Todd C., and Chi-Keung Luk. 1998. Compiler and Hardware Support for Automatic Instruction Prefetching: A Cooperative Approach. Defense Technical Information Center. https://doi.org/10.21236/ada352369
Mozaffarian, Dariush. 2017. “Conflict of Interest and the Role of the Food Industry in Nutrition Research.” JAMA 317 (17): 1755. https://doi.org/10.1001/jama.2017.3456
Mueller, Marcus, and Viktor Leis. 2026. “BareHeap: Virtual Memory Assisted Memory Allocation for High Performance Query Processing.” In Proceedings of the 22nd International Workshop on Data Management on New Hardware. ACM. https://doi.org/10.1145/3789237.3809126
Muhammad, Zakiy Qiros, and Renny Sari Dewi. 2026. “Cost Estimation Based on Use Case Points in the Development of AIoT Monitoring Infusion Test Software.” International Journal of Multidisciplinary Research and Analysis 09 (01). https://doi.org/10.47191/ijmra/v9-i1-49
Müller, Stephan, and Hasso Plattner. 2011. “Aggregation Strategies for Columnar in-Memory Databases in a Mixed Workload.” In Proceedings of the 4th workshop on Workshop for Ph.D. students in information & knowledge management. ACM. https://doi.org/10.1145/2065003.2065015
Müller, Stephan, and Hasso Plattner. 2012. “An in-Depth Analysis of Data Aggregation Cost Factors in a Columnar in-Memory Database.” In Proceedings of the fifteenth international workshop on Data warehousing and OLAP. ACM. https://doi.org/10.1145/2390045.2390057
Müller, Heinrich, and Frank Weichert. 2017. “Formale Sprachen und Compiler.” In Vorkurs Informatik. Springer Fachmedien Wiesbaden. https://doi.org/10.1007/978-3-658-16141-5_21
“Multi-Agent Orchestration for Autonomous Data Pipeline Governance: Schema Evolution, Anomaly Detection, and Incident Remediation in Cloud-Native Data Platforms.” 2026. International Journal of Intelligent Systems and Applications in Engineering. https://doi.org/10.17762/ijisae.v14i1.8344
“A Multi-Threaded Implementation of PaiLisp Interpreter and Compiler Using the Steal-Help Evaluation Strategy.” 2002. In Advanced LISP Technology. CRC Press. https://doi.org/10.1201/b12542-8
Muni Prabaharan, M. 2012. “Static Analysis for Container Drop Test with a Case Study.” International Journal of Modeling and Optimization: 50–52. https://doi.org/10.7763/ijmo.2011.v1.84
Munonye, Kindson, and P. Martinek. 2020. “Enhancing Performance of Distributed Transactions in Microservices via Buffered Serialization.” Journal of Web Engineering. https://doi.org/10.13052/jwe1540-9589.19564
Munsil, Wes, and Chia-Jiu Wang. 1998. “Reducing Stack Usage in Java Bytecode Execution.” ACM SIGARCH Computer Architecture News 26 (1): 7–11. https://doi.org/10.1145/1216461.1216464
Murg, Luca, Christopher Lane, and Roxanne M. Tutchton. 2026. “Gaunt and Breit Two-Electron Contributions to Mean-Field Transformations and Fine Structure Splitting.” Physical Chemistry Chemical Physics 28 (24): 14758–63. https://doi.org/10.1039/d6cp01222a
Murray, Jim, Jim Whitehead, and Florent Kirchner. 2016. Crowd-Sourced Help with Emergent Knowledge for Optimized Formal Verification (CHEKOFV). Defense Technical Information Center. https://doi.org/10.21236/ad1005654
Mushiri, Tawanda, and Emmison Gocheki. 2020. “Design of a Garbage Collection Robot.” In Advances in Computational Intelligence and Robotics. IGI Global. https://doi.org/10.4018/978-1-5225-9924-1.ch004
Mustyala, Sarika, Pravali Manchala, and Manjubala Bisi. 2025. “Case Studies: Machine Learning Approaches for Software Development Effort Estimation.” In Artificial Intelligence-Enhanced Software and Systems Engineering. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-88188-6_5
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
“My Tiny Forth Compiler.” 2018. In Build Your Own Robot!. A K Peters/CRC Press. https://doi.org/10.1201/b12888-6
Nadishan, Yuresh. 2020. “An Empirical Study of Students’ Satisfaction with Professional Accounting Education Programs.” Preprint, . https://doi.org/10.2139/ssrn.3658364
Nagpal, Geeta, Moin Uddin, and Arvinder Kaur. 2013. “Analyzing Software Effort Estimation Using k Means Clustered Regression Approach.” ACM SIGSOFT Software Engineering Notes 38 (1): 1–9. https://doi.org/10.1145/2413038.2413045
Nagy, Lajos, and Ryan Stansifer. 2006. “Polymorphic Type Inference for the Relational Algebra in the Functional Database Programming Language Neon.” In Proceedings of the 44th annual Southeast regional conference. ACM. https://doi.org/10.1145/1185448.1185596
Nai, Lifeng, Yinglong Xia, Ching-Yung Lin, Bo Hong, and Hsien-Hsin S. Lee. 2014. “Cache-Conscious Graph Collaborative Filtering on Multi-Socket Multicore Systems.” In Proceedings of the 11th ACM Conference on Computing Frontiers. ACM. https://doi.org/10.1145/2597917.2597935
Nair, Geethu C. 2026. “AI Tools for Code Generation: Transforming Modern Software Development.” International Journal of Science and Research (IJSR): 152–54. https://doi.org/10.21275/sr26501234801
Naish, Lee. 2015. “Sharing Analysis in the Pawns Compiler.” PeerJ Computer Science 1: e22. https://doi.org/10.7717/peerj-cs.22
Najjar, Walid, and Jason Villarreal. 2013. “FPGA Code Accelerators: The Compiler Perspective.” In Proceedings of the 50th Annual Design Automation Conference. ACM. https://doi.org/10.1145/2463209.2488908
Najm, Assia, Abdelali Zakrani, and Abdelaziz Marzak. 2020. “Systematic Review Study of Decision Trees Based Software Development Effort Estimation.” International Journal of Advanced Computer Science and Applications 11 (7). https://doi.org/10.14569/ijacsa.2020.0110767
Najm, Assia, Abdelali Zakrani, and Abdelaziz Marzak. 2023. “Efficient Shapely Explanation of Support Vector Regression for Agile and Non-Agile Software Effort Estimation.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-19-7663-6_67
Nakamura, Hayataka, Atsuya Sonoyama, Takeshi Kamiyama, Masato Oguchi, and Saneyasu Yamaguchi. 2024. “Performance Study of Kotlin and Java Programs with Bytecode Analysis.” Journal of Information Processing 32 (0): 380–95. https://doi.org/10.2197/ipsjjip.32.380
Nakao, Masahiro, and Hitoshi Murai. 2020. “Implementation and Performance Evaluation of Omni Compiler.” In XcalableMP PGAS Programming Language. Springer Singapore. https://doi.org/10.1007/978-981-15-7683-6_2
Nakatani, Toshio, and Kemal Ebcioǧlu. 1991. “Using a Lookahead Window in a Compaction-Based Parallelizing Compiler.” ACM SIGMICRO Newsletter 22 (1): 8–19. https://doi.org/10.1145/1096503.1096504
Nallamalli, Ranjana, and Durg Singh Chauhan. 2019. “Rapid Formal Verification as Requirements Stage Verification and Validation Technique.” International Review on Computers and Software (IRECOS) 14 (1): 27. https://doi.org/10.15866/irecos.v14i1.17684
Nam Kil Im. 2007. “Compilation of Tentatively Named ‘Korean Usage Dictionary’ Using Learner Corpus.” Korean Language Research null (20): 131–54. https://doi.org/10.16876/klrc.2007..20.131
Namboodiri, Anoop M., and Anil K. Jain. 2007. “Document Structure and Layout Analysis.” In Advances in Pattern Recognition. Springer London. https://doi.org/10.1007/978-1-84628-726-8_2
Nan, Shi, and Cao Lei. 2026. “Research on the Construction of a Big Data-Based Cost Estimation Quota Compilation Platform for NPP Construction Projects.” In Proceedings of the 2026 5th International Conference on Big Data, Information and Computer Network. ACM. https://doi.org/10.1145/3801228.3801230
Nanda, Mangala Gowri, and S. Arun-Kumar. 2016. “Decompiling Boolean Expressions from Java™ Bytecode.” In Proceedings of the 9th India Software Engineering Conference. ACM. https://doi.org/10.1145/2856636.2856651
Natarajan, Ramakrishnan, and K. Balachandran. 2022. “Ensemble Model of Machine Learning for Integrating Risk in Software Effort Estimation.” In Lecture Notes on Data Engineering and Communications Technologies. Springer Nature Singapore. https://doi.org/10.1007/978-981-16-9416-5_46
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. 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
Naundorf, Holger. 1997. “Grundlagen der Garbage Collection.” In MAMMUT. Vieweg+Teubner Verlag. https://doi.org/10.1007/978-3-322-93083-5_2
Nayebi, Fatih, Alain Abran, and Jean-Marc Desharnais. 2015. “Automated Selection of a Software Effort Estimation Model Based on Accuracy and Uncertainty.” Artificial Intelligence Research 4 (2). https://doi.org/10.5430/air.v4n2p45
Nedelcu, Nicusor. 2016. “Plug-in-Based Asset Compiler Architecture.” In Encyclopedia of Computer Graphics and Games. Springer International Publishing. https://doi.org/10.1007/978-3-319-08234-9_3-1
Nedelcu, Nicusor. 2024. “Plug-in-Based Asset Compiler Architecture.” In Encyclopedia of Computer Graphics and Games. Springer International Publishing. https://doi.org/10.1007/978-3-031-23161-2_3
Neff, Norman. 2004. “Attribute Based Compiler Implemented Using Visitor Pattern.” ACM SIGCSE Bulletin 36 (1): 130–34. https://doi.org/10.1145/1028174.971347
Negishi, Yasushi, Hiroki Murata, Guojing Cong, Hui-Fang Wen, and I-Hsin Chung. 2012. “A Static Analysis Tool Using a Three-Step Approach for Data Races in HPC Programs.” In Proceedings of the 2012 Workshop on Parallel and Distributed Systems: Testing, Analysis, and Debugging. ACM. https://doi.org/10.1145/2338967.2336809
Newell, Ben R., David A. Lagnado, and David R. Shanks. 2022. “Judgemental Heuristics and Biases.” In Straight Choices. Psychology Press. https://doi.org/10.4324/9781003289890-6
Newman, I. A. 1987. “A Hybrid Multiple Processor Garbage Collection Algorithm.” Computer Journal 30 (2): 119–27. https://doi.org/10.1093/comjnl/30.2.119
Newmarch, Jan. 2017. “Data Serialization.” In Network Programming with Go. Apress. https://doi.org/10.1007/978-1-4842-2692-6_4
Nguyen, Tristan. 2020. “Applying Simplifying Heuristics When Making Judgment under Uncertainty – a Field Study.” Journal of Economics and Business 3 (4). https://doi.org/10.31014/aior.1992.03.04.290
Nguyen, Hoan Anh, Robert Dyer, Tien N. Nguyen, and Hridesh Rajan. 2014. “Mining Preconditions of APIs in Large-Scale Code Corpus.” In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. ACM. https://doi.org/10.1145/2635868.2635924
Nguyen, Tam The, Phong Minh Vu, and Tung Thanh Nguyen. 2019b. “Code Search on Bytecode for Mobile App Development.” In Proceedings of the 2019 ACM Southeast Conference. ACM. https://doi.org/10.1145/3299815.3314471
Nguyen Quang Do, Lisa, and Eric Bodden. 2018. “Gamifying Static Analysis.” 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.3264830
Nhung, Ho Le Thi Kim, Huynh Thai Hoc, and Vo Van Hai. 2019. “A Review of Use Case-Based Development Effort Estimation Methods in the System Development Context.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-30329-7_44
Nhung, Ho Le Thi Kim, Vo Van Hai, and Roman Jašek. 2022. “Towards a Correction Factors-Based Software Productivity Using Ensemble Approach for Early Software Development Effort Estimation.” In Lecture Notes in Networks and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-031-09070-7_35
Nie, Lunyiu, Shulin Cao, Jiaxin Shi, et al. 2022. “GraphQ IR: Unifying the Semantic Parsing of Graph Query Languages with One Intermediate Representation.” In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics. https://doi.org/10.18653/v1/2022.emnlp-main.394
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
Nielsen, Benjamin Barslev, Behnaz Hassanshahi, and François Gauthier. 2019. “Nodest: Feedback-Driven Static Analysis of Node.js Applications.” In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3338906.3338933
Nielson, Flemming, Hanne Riis Nielson, and Chris Hankin. 1999. “Abstract Interpretation.” In Principles of Program Analysis. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-03811-6_4
Nikhil, Rishiyur S., and Umakishore Ramachandran. 2000. “Garbage Collection of Timestamped Data in Stampede.” In Proceedings of the nineteenth annual ACM symposium on Principles of distributed computing. ACM. https://doi.org/10.1145/343477.343539
Nilges, Edward G. 2004a. “A Brief History of Compiler Technology.” In Build Your Own .NET Language and Compiler. Apress. https://doi.org/10.1007/978-1-4302-0698-9_1
Nilges, Edward G. 2004b. “A Compiler Flyover.” In Build Your Own .NET Language and Compiler. Apress. https://doi.org/10.1007/978-1-4302-0698-9_3
Nilges, Edward G. 2004c. “The Lexical Analyzer for the QuickBasic Compiler.” In Build Your Own .NET Language and Compiler. Apress. https://doi.org/10.1007/978-1-4302-0698-9_5
Nilges, Edward G. 2004d. “The Syntax for the QuickBasic Compiler.” In Build Your Own .NET Language and Compiler. Apress. https://doi.org/10.1007/978-1-4302-0698-9_4
Niño, Jaime. 2012. “Type Systems Directed Programming Language Evolution: Overview and Research Trends.” In Proceedings of the 50th Annual Southeast Regional Conference. ACM. https://doi.org/10.1145/2184512.2184560
Nirban, Virendra Singh, and Meenakshi Raman. 2013. “Characterizing Language Usage in Formal and Informal Webpage Text Corpus.” Online Journal of Communication and Media Technologies 3 (4). https://doi.org/10.29333/ojcmt/2444
Niwa, Junpei, Takashi Matsumoto, and Kei Hiraki. 2000. “Comparative Study of Page-Based and Segment-Based Software DSM through Compiler Optimization.” In Proceedings of the 14th international conference on Supercomputing. ACM. https://doi.org/10.1145/335231.335259
Nixon, Brian, Lawrence Chung, John Mylopoulos, David Lauzon, Alex Borgida, and M. Stanley. 1987. “Implementation of a Compiler for a Semantic Data Model: Experiences with Taxis.” ACM SIGMOD Record 16 (3): 118–31. https://doi.org/10.1145/38714.38731
Noce, Pasquale. 2023. “Formal Verification of Cryptographic Protocols with Isabelle/HOL.” In Handbook of Formal Analysis and Verification in Cryptography. CRC Press. https://doi.org/10.1201/9781003090052-4
Nocera, Sabato, Nyyti Saarimäki, Valentina Lenarduzzi, Davide Taibi, and Sira Vegas. 2026. “Stop Comparing Apples and Oranges: Matching for Better Results in Mining Software Repositories Studies.” In Proceedings of the 23rd International Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/3793302.3793378
Nong, Xiao, and Hu Shouren. 1996. “An Object Oriented C++ Parallel Compiler System.” Wuhan University Journal of Natural Sciences 1 (3–4): 437–41. https://doi.org/10.1007/bf02900865
Noor Azmi, Noor Adam, and Haslizatul Fairuz Mohamed Hanum. 2026. “Textual Adversarial Example Generation Using Bigram Unigram-Semantic Preservation Optimization Algorithm.” Malaysian Journal of Computing 11 (1): 2437–46. https://doi.org/10.24191/mjoc.vo11i1.11057
Novack, Steven, Alex Nicolau, and Nikil Dutt. 2002. “A Unified Code Generation Approach Using Mutation Scheduling.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_12
Novitasari, Dinda, Imam Cholissodin, and Wayan Firdaus Mahmudy. 2016. “Optimizing SVR Using Local Best PSO for Software Effort Estimation.” Journal of Information Technology and Computer Science 1 (1): 28. https://doi.org/10.25126/jitecs.2016117
NTP Cryptosoft and S. K. Muravyev. 2025. “The a Vulnerabilities of GCC and LLVM to Optimization Pipeline Attacks.” Voprosy kiberbezopasnosti 4 (68): 9–16. https://doi.org/10.21681/2311-3456-2025-4-9-16
Nugraha, Cisya Dewantara, Ahmad Muam, and Supriyono Supriyono. 2023. “An Analysis of Gender Representation in English Language Advertisements in Indonesia: A Corpus-Based Study.” Interference: Journal of Language, Literature, and Linguistics 4 (2): 235. https://doi.org/10.26858/interference.v4i2.45728
Nwosu, P. C., F. E. Onuodu, and U. A. Okengwu. 2024. “Enhanced Model for Mining Software Repositories.” International Journal of Computer Applications 186 (40): 41–46. https://doi.org/10.5120/ijca2024923997
Nystrom, Nathaniel. 2011. “Harmless Compiler Plugins.” In Proceedings of the 13th Workshop on Formal Techniques for Java-Like Programs. ACM. https://doi.org/10.1145/2076674.2076678
O’Carroll, Francis, Hiroshi Tezuka, Atsushi Hori, and Yutaka Ishikawa. 1998. “The Design and Implementation of Zero Copy MPI Using Commodity Hardware with a High Performance Network.” In Proceedings of the 12th international conference on Supercomputing. ACM. https://doi.org/10.1145/277830.277883
O’Leary, John, Geoffrey Brown, and Wayne Luk. 1997. “Verified Compilation of Communicating Processes into Clocked Circuits.” Formal Aspects of Computing 9 (5–6): 537–59. https://doi.org/10.1007/bf01211459
“Object Persistence: Serialization.” 2004. In Object-Oriented Programming with Visual Basic.NET. Cambridge University Press. https://doi.org/10.1017/cbo9780511734861.012
Octeau, Damien, Somesh Jha, and Patrick McDaniel. 2012. “Retargeting Android Applications to Java Bytecode.” In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/2393596.2393600
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
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
Ofir, Chezy, and John G. Lynch Jr. 1984. “Context Effects on Judgment under Uncertainty.” Journal of Consumer Research 11 (2): 668. https://doi.org/10.1086/209003
Ogata, Kazunori, Hideaki Komatsu, and Toshio Nakatani. 2002. “Bytecode Fetch Optimization for a Java Interpreter.” ACM SIGARCH Computer Architecture News 30 (5): 58–67. https://doi.org/10.1145/635506.605404
Ogunleye, Julius Olufemi. 2020. “Review of Current Data Mining Techniques Used in the Software Effort Estimation.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-63322-6_32
Ogunleye, Julius Olufemi. 2023. “Finding Suitable Data Mining Techniques for Software Development Effort Estimation.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-37963-5_35
Oh, Saenae, and Youngje Lee. 2015. “Aspects of Actual Usage about Names of Korean Language: Analysis of the Twenty-First Century’s Korean Newspaper Corpus.” Korean Semantics 47: 83. https://doi.org/10.19033/sks.2015.03.47.83
Oh, Hyeong-Seok, Soo-Mook Moon, and Dong-Heon Jung. 2012. “Hybrid Java Compilation of Just-in-Time and Ahead-of Time for Embedded Systems.” Journal of Circuits, Systems and Computers 21 (02): 1240001. https://doi.org/10.1142/s0218126612400014
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
Ohori, Atsushi, and Peter Buneman. 1988. “Type Inference in a Database Programming Language.” In Proceedings of the 1988 ACM conference on LISP and functional programming. ACM. https://doi.org/10.1145/62678.62700
Ohori, Atsushi, Peter Buneman, and Val Breazu-Tannen. 1989. “Database Programming in Machiavelli—a Polymorphic Language with Static Type Inference.” ACM SIGMOD Record 18 (2): 46–57. https://doi.org/10.1145/66926.66931
Oi, Hitoshi. 2006. “Instruction Folding in a Hardware-Translation Based Java Virtual Machine.” In Proceedings of the 3rd conference on Computing frontiers. ACM. https://doi.org/10.1145/1128022.1128041
Okike, Kanu, Mininder S. Kocher, Charles T. Mehlman, and Mohit Bhandari. 2007. “Conflict of Interest in Orthopaedic Research: An Association between Findings and Funding in Scientific Presentations.” Journal of Bone & Joint Surgery 89 (3): 608–13. https://doi.org/10.2106/jbjs.f.00994
Oliva, Dino P., John D. Ramsdell, and Mitchell Wand. 1995. “The VLISP Verified PreScheme Compiler.” In VLISP A Verfied Implementation of Scheme. Springer US. https://doi.org/10.1007/978-1-4615-2339-0_3
Oliveira, Fábio A. D., Rafael B. Ávila, Marcos E. Barreto, and Philippe O. A. Navaux. 2001. “Low-Latency and Zero-Copy Message Passing Protocols for SCI-Based Clusters.” In Anais do XIII Symposium on Computer Architecture and High Performance Computing (SBAC-PAD 2001). Sociedade Brasileira de Computação. https://doi.org/10.5753/sbac-pad.2001.22203
Olsson, Mikael. 2013. “Boxing and Unboxing.” In Java Quick Syntax Reference. Apress. https://doi.org/10.1007/978-1-4302-6287-9_21
Olsson, Mikael. 2018. “Boxing and Unboxing.” In Java Quick Syntax Reference. Apress. https://doi.org/10.1007/978-1-4842-3441-9_21
Olsson, Mikael. 2021. “Boxing and Unboxing.” In Java 17 Quick Syntax Reference. Apress. https://doi.org/10.1007/978-1-4842-7371-5_22
Ömüral, Neslihan Küçükateş, and Onur Demirörs. 2017. “Effort Estimation Methods for ERP Projects Based on Function Points: A Case Study.” In Proceedings of the 27th International Workshop on Software Measurement and 12th International Conference on Software Process and Product Measurement. ACM. https://doi.org/10.1145/3143434.3143464
“On the Application of Static Code Analysis Tools in the Serbian It Industry: An Empirical Study.” 2024. In Proceedings of the 17th IADIS International Conference Information Systems 2024,. IADIS Press. https://doi.org/10.33965/is2024_202401l007
Oortwijn, Wytse, Stefan Blom, and Marieke Huisman. 2016. “Future-Based Static Analysis of Message Passing Programs.” Electronic Proceedings in Theoretical Computer Science 211: 65–72. https://doi.org/10.4204/eptcs.211.7
Opdahl, Jacob P. 2016. “Concurrent Compaction in JVM Garbage Collection.” Scholarly Horizons: University of Minnesota, Morris Undergraduate Journal 3 (1). https://doi.org/10.61366/2576-2176.1033
Opdebeeck, Ruben, Mahmoud Alfadel, Akond Rahman, et al. 2026. “An Empirical Study of Policy as Code: Adoption, Purpose, and Maintenance.” In Proceedings of the 23rd International Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/3793302.3793355
“Operational Semantics.” 1992. In Logic Programming. Cambridge University Press. https://doi.org/10.1017/cbo9780511526534.003
Opler, Ascher, and Myra Gray. 1961. “Design of a Multiprogrammed Algebraic Compiler.” In Proceedings of the 1961 16th ACM national meeting on -. ACM Press. https://doi.org/10.1145/800029.808497
“Optimization for Garbage Collection Algorithm Based on Embedded Java Virtual Machine.” 2011. In International Conference on Information Technology and Computer Science, 3rd (ITCS 2011). ASME Press. https://doi.org/10.1115/1.859742.paper62
“Optimizations of Garbage Collection.” 2016. In Advanced Design and Implementation of Virtual Machines. CRC Press. https://doi.org/10.1201/9781315386706-18
“Optimizing Web Application’s Execution Time by Caching PHP ByteCode Using Zend OPCache.” 2015. In International Academy of Engineers (IA-E) April 24-25, 2015 Pattaya (Thailand). International Academy of Engineers. https://doi.org/10.15242/iae.iae0415015
Öqvist, Jesper, and Görel Hedin. 2013. “Extending the JastAdd Extensible Java Compiler to Java 7.” In Proceedings of the 2013 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools. ACM. https://doi.org/10.1145/2500828.2500843
Orgilés-Amorós, Macarena. 2026. “Unboxing Higher Education Institutions’ Marketing: A Bibliometric Analysis of Effective Communication Strategies.” Research in Comparative and International Education 21 (2): 242–68. https://doi.org/10.1177/17454999261418789
Ortin, F. 2011. “Type Inference to Optimize a Hybrid Statically and Dynamically Typed Language.” Computer Journal 54 (11): 1901–24. https://doi.org/10.1093/comjnl/bxr067
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, David. 1993. Analysis of the Program Analysis and Evaluation Directorate Library’s Space Requirements and Technological Modernization Options. Defense Technical Information Center. https://doi.org/10.21236/ada302555
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
Oskooei, Amirkia Rafiei, Kaan Baturalp Cosdan, Husamettin Isiktas, and Mehmet S. Aktas. 2026. “When Many-Shot Prompting Fails: An Empirical Study of LLM Code Translation.” In Proceedings of the 1st Workshop on Code Translation, Transformation, and Modernization. ACM. https://doi.org/10.1145/3786180.3788314
Osmelak, Doreen, and Shuly Wintner. 2023. “The Denglisch Corpus of German-English Code-Switching.” In Proceedings of the 5th Workshop on Research in Computational Linguistic Typology and Multilingual NLP. Association for Computational Linguistics. https://doi.org/10.18653/v1/2023.sigtyp-1.5
Ostberg, Jan-Peter, Stefan Wagner, and Erica Weilemann. 2016. “Does Personality Influence the Usage of Static Analysis Tools?: An Explorative Experiment.” In Proceedings of the 9th International Workshop on Cooperative and Human Aspects of Software Engineering. ACM. https://doi.org/10.1145/2897586.2897599
Österlund, Erik. 2026. “ZGC Memory Layout.” In The Z Garbage Collector. Chapman and Hall/CRC. https://doi.org/10.1201/9781003595366-3
Otani, Thomas W., Doron Drusinsky, James B. Michael, and Man-Tak Shing. 2008. A Comparison of Priority-Based and Incremental Real-Time Garbage Collectors in the Implementation of the Shadow Design Pattern. Defense Technical Information Center. https://doi.org/10.21236/ada484635
Othman, Siti Zubaidah. 2009. “The Planning Fallacy and Utilization of Human Resources Information Systems.” In Encyclopedia of Human Resources Information Systems. IGI Global. https://doi.org/10.4018/978-1-59904-883-3.ch102
Otten, Ralph H. J. M. 1988. “Layout Compiler-Annealing Applied to Floorplan Design.” In Handbook of Advanced Semiconductor Technology and Computer Systems. Springer Netherlands. https://doi.org/10.1007/978-94-011-7056-7_19
Ozkaya, Mert. 2015. “Formal Verification of Contractual Software Architectures Using SPIN.” Malaysian Journal of Computer Science 28 (4): 318–37. https://doi.org/10.22452/mjcs.vol28no4.4
ÖZtÜRk, Şaban. 2021. “Hash Code Generation Using Deep Feature Selection Guided Siamese Network for Content-Based Medical Image Retrieval.” Gazi University Journal of Science 34 (3): 733–46. https://doi.org/10.35378/gujs.710730
P.A. Lokhande. 2016. “A Review: Garbage Collection Management System.” International Journal of Research in Engineering and Technology 05 (06): 79–82. https://doi.org/10.15623/ijret.2016.0506016
Padmaja, M., and D. Haritha. 2018. “Software Effort Estimation Using Grey Relational Analysis with K-Means Clustering.” In Advances in Intelligent Systems and Computing. Springer Singapore. https://doi.org/10.1007/978-981-10-7512-4_92
Pagalla, Bhavani Shankar, and Reddy M. Babu. 2023. “Significant Strategies to Assess Software Effort Estimation: A View of Functional Point.” i-manager’s Journal on Software Engineering 17 (3): 33. https://doi.org/10.26634/jse.17.3.19246
Paganelli, Gabriele. 2016. “Horn Binary Serialization Analysis.” Electronic Proceedings in Theoretical Computer Science 219: 56–68. https://doi.org/10.4204/eptcs.219.6
Pahta, Päivi, and Arja Nurmi. 2011. “Multilingual Discourse in the Domain of Religion in Medieval and Early Modern England: A Corpus Approach to Research on Historical Code-Switching.” In Code-Switching in Early English. DE GRUYTER. https://doi.org/10.1515/9783110253368.219
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
Pakdel, Majid. 2024. “Code Generation Using Simulink, PSIM, and PLECS.” In DSP 320F28335 Programming. River Publishers. https://doi.org/10.1201/9788770042116-6
Pakdel, Majid. 2025. “Discretization and Code Generation of an SVC.” In Arduino Programming using Simulink. River Publishers. https://doi.org/10.1201/9788743800828-3
Paleyes, Andrei, Diana Robinson, Radzim Sendyka, Christian Cabrera, and Neil D. Lawrence. 2026. “Code Roulette: How Prompt Variability Affects LLM Code Generation.” In Proceedings of the 3rd International Workshop on Large Language Models For Code. ACM. https://doi.org/10.1145/3786181.3788724
Palsberg, Jens, and Michael I. Schwartzbach. 1990. “A Unified Type System for Object-Oriented Programming.” DAIMI Report Series 19 (341). https://doi.org/10.7146/dpb.v19i341.6571
Palsberg, Jens, and Michael I. Schwartzbach. 1991. “Object-Oriented Type Inference.” In Conference proceedings on Object-oriented programming systems, languages, and applications. ACM. https://doi.org/10.1145/117954.117965
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
Paltenghi, Matteo, and Michael Pradel. 2024. “Analyzing Quantum Programs with LintQ: A Static Analysis Framework for Qiskit.” Proceedings of the ACM on Software Engineering 1 (FSE): 2144–66. https://doi.org/10.1145/3660802
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
Panda, Aditi, Santanu Kumar, and Shashank Mouli. 2015. “Neural Network Models for Agile Software Effort Estimation Based on Story Points.” In International Conference on Advances in Computing, Control and Networking - ACCN 2015. Institute of Research Engineers and Doctors. https://doi.org/10.15224/978-1-63248-038-5-06
Panda, Preeti Ranjan, Luc Semeria, and Giovanni de Micheli. 2001. “Cache-Efficient Memory Layout of Aggregate Data Structures.” In Proceedings of the 14th international symposium on Systems synthesis - ISSS ‘01. ACM Press. https://doi.org/10.1145/500024.500026
Panda, Biswabandan, and André Seznec. 2018. “Synergistic Cache Layout for Reuse and Compression.” In Proceedings of the 27th International Conference on Parallel Architectures and Compilation Techniques. ACM. https://doi.org/10.1145/3243176.3243178
Pang, Shuo, and Kenith E. Meissner. 2008. “Tagless Remote Refractometric Sensor Based on WGMs in Quantum Dot-Embedded Microspheres.” In SPIE Proceedings, vol. 6863, edited by Gerard L. Coté, Alexander V. Priezzhev. SPIE. https://doi.org/10.1117/12.763730
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
“Parallel Garbage Collection.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-15
Parasnis, D. S. 1991. “4. Large-Layout Harmonic Field Systems.” In Electromagnetic Methods in Applied Geophysics. Society of Exploration Geophysicists. https://doi.org/10.1190/1.9781560802686.ch4
Pareta, Chetana, Rajeev Mathur, and A. K. Sharma. 2024. “Critical Analysis of the Utilization of Machine Learning Techniques in the Context of Software Effort Estimation.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-99-9489-2_18
Park, Chang Mok. 2015. “Formal Verification of PLC Program Safety in Manufacturing Automation System.” Journal of the Korea Safety Management and Science 17 (1): 179–92. https://doi.org/10.12812/ksms.2015.17.1.179
Park, Jihyeok, Seungmin An, and Sukyoung Ryu. 2022a. “Automatically Deriving JavaScript Static Analyzers from Specifications Using Meta-Level Static Analysis.” In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3540250.3549097
Park, Sangcheol, Jin-Ku Kang, and Yongwoo Kim. 2026. “Design and Implementation of an IREE Bytecode Interpreter on RISC-V SoCs for Efficient AI Inference.” Journal of the Institute of Electronics and Information Engineers 63 (4): 3–11. https://doi.org/10.5573/ieie.2026.63.4.3
Park, Joonyoung, Jihyeok Park, Dongjun Youn, and Sukyoung Ryu. 2021. “Accelerating JavaScript Static Analysis via Dynamic Shortcuts.” In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3468264.3468556
Park, Shin, Park, and Kyung. 1998. “Radix-4 Multiplier with Regular Layout Structure.” Electronics Letters 34 (15): 1446–47. https://doi.org/10.1049/el:19981068
Park, David Y., Jens U. Skakkebaek, and David L. Dill. 1997. Static Analysis to Identify Invariants in RSML Specifications. Defense Technical Information Center. https://doi.org/10.21236/ada400398
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
“Parsing as Type Inference.” 1992. In Constraint-Based Grammar Formalisms. The MIT Press. https://doi.org/10.7551/mitpress/2123.003.0006
“Partial Marking GC: Generational Parallel Garbage Collection and Its Performance Analysis.” 2002. In Advanced LISP Technology. CRC Press. https://doi.org/10.1201/b12542-18
Pasuksmit, Jirat. 2021. “Investigating Documented Information for Accurate Effort Estimation in Agile Software Development.” In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3468264.3473106
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
Patil, M. V. 2007. “Software Effort Estimation and Risk Analysis: A Case Study.” In IET-UK International Conference on Information and Communication Technology in Electrical Sciences (ICTES 2007). IEE. https://doi.org/10.1049/ic:20070756
Patra, H. Parthasarathi, and Kumar Rajnish. 2018. “Development of Software Effort Estimation Using a Non-Fuzzy Model.” International Journal of Computational Systems Engineering 4 (1): 17. https://doi.org/10.1504/ijcsyse.2018.090636
Patty, Anthony Rudolf. 2023. “Gender Representation Analysis in Igcse English as a Second Language 5TH Edition Textbook.” English Journal 17 (2): 79–92. https://doi.org/10.32832/english.v17i2.14918
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
PaulevÉ, LOÏC, Morgan Magnin, and Olivier Roux. 2012. “Static Analysis of Biological Regulatory Networks Dynamics Using Abstract Interpretation.” Mathematical Structures in Computer Science 22 (4): 651–85. https://doi.org/10.1017/s0960129511000739
Pavesi, Maria. 2014. “This and That in the Language of Film Dubbing: A Corpus-Based Analysis.” Meta 58 (1): 103–33. https://doi.org/10.7202/1023812ar
Paz, Freddy, Claudia Zapata, and José Antonio Pow-Sang. 2014. “An Approach for Effort Estimation in Incremental Software Development Using Cosmic Function Points.” In Proceedings of the 8th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. ACM. https://doi.org/10.1145/2652524.2652571
Pearl, Raymond. 1918. “Statistics of Garbage Collection and Garbage Grease Recovery in American Cities.” Journal of Industrial & Engineering Chemistry 10 (11): 927–30. https://doi.org/10.1021/ie50107a019
Pearlmutter, B. 1996. “Garbage Collection with Pointers to Individuals Cells.” Communications of the ACM 39 (12es): 202. https://doi.org/10.1145/272682.272712
Peck, Luna, and Susan Brown. 2024. “Tool for Constructing a Large-Scale Corpus of Code Comments and Other Source Code Annotations.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA) and ICCL. https://doi.org/10.63317/4cc6wuzjdth9
Pedersen, Rasmus Ulslev, and Martin Schoeberl. 2018. “Direct Garbage Collection: Two-Fold Speedup for Managed Language Embedded Systems.” International Journal of Embedded Systems 10 (5): 394. https://doi.org/10.1504/ijes.2018.095138
Peeler, Hannah, Shuyue Stella Li, Andrew N. Sloss, Kenneth N. Reid, Yuan Yuan, and Wolfgang Banzhaf. 2022. “Optimizing LLVM Pass Sequences with Shackleton: A Linear Genetic Programming Framework.” In Proceedings of the Genetic and Evolutionary Computation Conference Companion. ACM. https://doi.org/10.1145/3520304.3528945
Peischl, Bernhard, Markus Zanker, Mihai Nica, and Wolfgang Schmid. 2010. “Constraint-Based Recommendation for Software Project Effort Estimation.” Journal of Emerging Technologies in Web Intelligence 2 (4). https://doi.org/10.4304/jetwi.2.4.282-290
“Perception, Reality, and the Political Context of Conflict of Interest in University – Industry Relationships.” 2017. In Research Ethics. Routledge. https://doi.org/10.4324/9781315244426-57
Perrizo, William, Qin Ding, Maleq Khan, Anne Denton, and Qiang Ding. 2007. “An Efficient Weighted Nearest Neighbour Classifier Using Vertical Data Representation.” International Journal of Business Intelligence and Data Mining 2 (1): 64. https://doi.org/10.1504/ijbidm.2007.012946
Perry, Heather Brodie. 2018. “Undergraduates’ Perceptions of Conflict of Interest in Industry-Sponsored Research.” portal: Libraries and the Academy 18 (1): 163–82. https://doi.org/10.1353/pla.2018.0008
Perstein, Millard H. 1963. Jovial for the Dilettante and Beyond: Compiler Error Detection Lists. Defense Technical Information Center. https://doi.org/10.21236/ad0296332
Petersen, Anne Kristine, Peter Gundersen, Bjarke Lindsø Andersen, and Marianne Riis. 2024. “Unboxing the Process of Revision between Two Design-Based Hybrid Learning Interventions.” Proceedings of the International Conference on Networked Learning 13. https://doi.org/10.54337/nlc.v13.8529
Petersen, Sarah E., and Mari Ostendorf. 2007. “Text Simplification for Language Learners: A Corpus Analysis.” In Speech and Language Technology in Education (SLaTE 2007). ISCA. https://doi.org/10.21437/slate.2007-20
Petrick, B. A., and S. J. Yanke. 1989a. An Analysis of the Definition of a Production Quality Ada Compiler. Volume 1. Defense Technical Information Center. https://doi.org/10.21236/ada218808
Petrick, B. A., and S. J. Yanke. 1989b. An Analysis of the Definition of a Production Quality Ada Compiler. Volume 2. PQAC Test Suite. Defense Technical Information Center. https://doi.org/10.21236/ada219484
Petz, Adam, Grant Jurgensen, and Perry Alexander. 2021. “Design and Formal Verification of a Copland-Based Attestation Protocol.” In Proceedings of the 19th ACM-IEEE International Conference on Formal Methods and Models for System Design. ACM. https://doi.org/10.1145/3487212.3487340
Peyton Jones, Simon L., and Jon Salkild. 1989. “The Spineless Tagless G-Machine.” In Proceedings of the fourth international conference on Functional programming languages and computer architecture - FPCA ‘89. ACM Press. https://doi.org/10.1145/99370.99385
Phan, Hung, and Ali Jannesari. 2022. “Heterogeneous Graph Neural Networks for Software Effort Estimation.” In Proceedings of the 16th ACM / IEEE International Symposium on Empirical Software Engineering and Measurement. ACM. https://doi.org/10.1145/3544902.3546248
Phannachitta, Passakorn, Jacky Keung, Akito Monden, and Kenichi Matsumoto. 2014. “Scaling up Analogy-Based Software Effort Estimation: A Comparison of Multiple Hadoop Implementation Schemes.” In Proceedings of the International Workshop on Innovative Software Development Methodologies and Practices. ACM. https://doi.org/10.1145/2666581.2666582
Phannachitta, Passakorn, Akito Monden, Jacky Keung, and Kenichi Matsumoto. 2016b. “LSA-X: Exploiting Productivity Factors in Linear Size Adaptation for Analogy-Based Software Effort Estimation.” IEICE Transactions on Information and Systems E99.D (1): 151–62. https://doi.org/10.1587/transinf.2015edp7237
Phillips, Austin S., and Philip J. Kellman. 2025. “Path Integration Reflects an Intermediate Representation in Contour Perception.” Journal of Vision 25 (9): 2908. https://doi.org/10.1167/jov.25.9.2908
Pillai, S. K., and M. K. Jeyakumar. 2014a. “Evaluation of Neural Networks for Software Development Effort Estimation Using a New Criterion.” ACM SIGSOFT Software Engineering Notes 39 (5): 1–6. https://doi.org/10.1145/2659118.2659141
Pillai, S. K., and M. K. Jeyakumar. 2014c. “General Regression Neural Network for Software Effort Estimation of Small Programs Using a Single Variable.” In Lecture Notes in Electrical Engineering. Springer India. https://doi.org/10.1007/978-81-322-2119-7_107
Pisani, Flavio, Daniel Hugo Cámpora Pérez, and Niko Neufeld. 2015. “High-Speed Zero-Copy Data Transfer for DAQ Applications.” Journal of Physics: Conference Series 608: 012029. https://doi.org/10.1088/1742-6596/608/1/012028
Piskorski, Jakub, Witold Drożdżyński, Oliver Scherf, and Feiyu Xu. 2002. “A Flexible XML-Based Regular Compiler for Creation and Conversion of Linguistic Resources.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/5bicy9bkmeb3
Piumarta, Ian. 2010. “PEG-Based Transformer Provides Front-, Middle-and Back-End Stages in a Simple Compiler.” In Workshop on Self-Sustaining Systems. ACM. https://doi.org/10.1145/1942793.1942796
Plakal, Manoj, and Charles N. Fischer. 2000. “Concurrent Garbage Collection Using Program Slices on Multithreaded Processors.” In Proceedings of the 2nd international symposium on Memory management. ACM. https://doi.org/10.1145/362422.362468
“The Planning Fallacy: When Plans Lead to Optimistic Forecasts.” 2015. In The Psychology of Planning in Organizations. Routledge. https://doi.org/10.4324/9780203105894-7
Plattner, Hasso. 2013. “Data Layout in Main Memory.” In A Course in In-Memory Data Management. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-36524-9_8
Plattner, Hasso. 2014a. “Data Layout in Main Memory.” In A Course in In-Memory Data Management. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-55270-0_8
Plattner, Hasso. 2014b. “The Impact of Columnar in-Memory Databases on Enterprise Systems: Implications of Eliminating Transaction-Maintained Aggregates.” Proceedings of the VLDB Endowment 7 (13): 1722–29. https://doi.org/10.14778/2733004.2733074
Plattner, Hasso, and Bernd Leukert. 2015. “The Design Principles of an in-Memory Columnar Storage Database.” In The In-Memory Revolution. Springer International Publishing. https://doi.org/10.1007/978-3-319-16673-5_2
Plishka, Richard M., and Agustin Ifarraguerri. 1993. Evaluation of Alsys 037 Ada Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada266972
Podleś, Michał, Idelfonso Tafur Monroy, Juan Jose Vegas Olmos, and Boris Pismenny. 2026. “Towards Encrypted Zero-Copy L7 Load Balancing.” In Proceedings of the 2026 Applied Networking Research Workshop. ACM. https://doi.org/10.1145/3822163.3827944
Polishchuk, M., and O. Rolik. 2024. “Drone for Garbage Collection at Water Reservoirs: Design and Modeling.” Ecological Sciences 1 (1 (52)): 89–94. https://doi.org/10.32846/2306-9716/2024.eco.1-52.1.13
Polito, Guillermo, Nahuel Palumbo, Soufyane Labsari, Stéphane Ducasse, and Pablo Tesone. 2022a. “Interpreter Register Autolocalisation: Improving the Performance of Efficient Interpreters.” In Companion Proceedings of the 6th International Conference on the Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3532512.3532518
Poniszewska-Marańda, Aneta, and Konrad Kajszczak. 2026. “Enhancing Error Detection in Code: Leveraging Mining Software Repositories Techniques.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-32032-2_32
Ponnalagu, Karthikeyan, and Nanjangud Narendra. 2012. “Automated Trendline Generation for Accurate Software Effort Estimation.” In Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity. ACM. https://doi.org/10.1145/2384716.2384774
Popovic, Jovan, Dragan Bojic, and Nenad Korolija. 2015. “Analysis of Task Effort Estimation Accuracy Based on Use Case Point Size.” IET Software 9 (6): 166–73. https://doi.org/10.1049/iet-sen.2014.0254
Portillo-Dominguez, A. Omar. 2018. “Towards an Efficient Benchmark Generation Engine for Garbage Collection.” In Companion of the 2018 ACM/SPEC International Conference on Performance Engineering. ACM. https://doi.org/10.1145/3185768.3186303
Postiff, Matthew, David Greene, Charles Lefurgy, Dave Helder, and Trevor Mudge. 2000. The MIRV SimpleScalar/PISA Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada462001
Poupart, E., and E. Cortiade. 2004. “Automatic Code Generation Starting from Data Description.” In Space OPS 2004 Conference. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.2004-408-234
“Practical Model-Based Static Analysis for Definite Logic Programs.” 1995. In Logic Programming. The MIT Press. https://doi.org/10.7551/mitpress/4301.003.0038
“A Practice Unpacked: Unboxing as a Consumption Practice.” 2020. Global Fashion Management Conference 2020: 331–35. https://doi.org/10.15444/gmc2020.04.01.03
Pradeep Kumar. 2020. “The Role of Machine Learning in Optimizing Garbage Collection.” International Journal on Science and Technology 11 (2): 1642. https://doi.org/10.71097/ijsat.v11.i2.1642
Prater, James, Konstantinos Kirytopoulos, and Tony Ma. 2017. “Optimism Bias within the Project Management Context: A Systematic Quantitative Literature Review.” International Journal of Managing Projects in Business 10 (2): 370–85. https://doi.org/10.1108/ijmpb-07-2016-0063
Praynlin, E., and P. Latha. 2013. “Performance Analysis of Software Effort Estimation Models Using Neural Networks.” International Journal of Information Technology and Computer Science 5 (9): 101–7. https://doi.org/10.5815/ijitcs.2013.09.11
Prechtl, Ian, Ben Reber, Chen Ding, Dorin Patru, and Dong Chen. 2020. “CLAM: Compiler Lease of Cache Memory.” In The International Symposium on Memory Systems. ACM. https://doi.org/10.1145/3422575.3422800
“Predictive Modeling and Code-Mixing Corpus for Student Learning Behaviors in E-Learning Environments.” 2024. Nanotechnology Perceptions 20 (S12). https://doi.org/10.62441/nano-ntp.v20is12.34
Prepost, R., V. W. Hughes, and K. Ziock. 1961. “Observation of the Hyperfine Structure Splitting of Muonium by Use of a Static Magnetic Field.” Physical Review Letters 6 (1): 19–21. https://doi.org/10.1103/physrevlett.6.19
Price, Tia Tudor. 2025. “Influential Bodies: An Analysis of the Dark Fan Influencer through Murderabilia Unboxing Videos.” In Palgrave Fan Studies. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-99390-9_7
Printezis, Tony. 2013. “Garbage Collection: 50+ Years Later.” In Proceedings of the 8th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems. ACM. https://doi.org/10.1145/2491404.2491405
“Profile-Guided Compiler Optimizations Rajiv Gupta, Eduard Mehofer and Youtao Zhang.” 2002. In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579-8
“Program Derivation and Formal Verification.” 1996. In The Way of Z. Cambridge University Press. https://doi.org/10.1017/cbo9780511574924.032
“Project Effort Estimation.” 2009. In Software Testing as a Service. Auerbach Publications. https://doi.org/10.1201/9781420099577.ch4
Protzenko, Jonathan. 2013. “The Implementation of the Mezzo Type-Checker.” In Proceedings of the 25th symposium on Implementation and Application of Functional Languages. ACM. https://doi.org/10.1145/2620678.2620684
“PSAB Participates in Meeting on Conflict of Interest and Biomedical Research.” 2007. Microbe Magazine 2 (1): 12–12. https://doi.org/10.1128/microbe.2.12.1
Puguh Jayadi, Khairul Adilah binti Ahmad, Rayhan Zulfitri Dwi Cahyo, and Jofanza Denis Aldida. 2024. “Particle Swarm Optimization-Based Linear Regression for Software Effort Estimation.” Journal of Information System, Technology and Engineering 2 (2): 261–68. https://doi.org/10.61487/jiste.v2i2.69
Puja, Durga. 2017. “Intelligent Method for Cost Estimation during Software Maintenance.” International Journal Of Engineering And Computer Science. https://doi.org/10.18535/ijecs/v6i5.11
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
Puspaningrum, Alifia, Fachrul Pralienka Bani Muhammad, and Esti Mulyani. 2021. “Flower Pollination Algorithm for Software Effort Coefficients Optimization to Improve Effort Estimation Accuracy.” JUITA: Jurnal Informatika 9 (2): 139. https://doi.org/10.30595/juita.v9i2.10511
Qamar, Zoya. 2025. “Unboxing the Dilemma of a Fibro-Osseous Lesion of Maxilla: A Case Report.” Unboxing the Dilemma of a Fibro-Osseous Lesion of Maxilla: A Case Report 2 (1). https://doi.org/10.62830/mmj2-01-16c
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
Qi, Shixiong, Songyu Zhang, K. K. Ramakrishnan, Diman Zad Tootaghaj, Hardik Soni, and Puneet Sharma. 2025. “Palladium: A DPU-Enabled Multi-Tenant Serverless Cloud over Zero-Copy Multi-Node RDMA Fabrics.” In Proceedings of the ACM SIGCOMM 2025 Conference. ACM. https://doi.org/10.1145/3718958.3750494
Qin, Yuxin, Dejice Jacob, and Jeremy Singer. 2022. “Characterizing WebAssembly Bytecode.” In Proceedings of the 19th International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3546918.3560809
“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
Querel, Louis-Philippe, and Peter C. Rigby. 2018. “WarningsGuru: Integrating Statistical Bug Models with Static Analysis to Provide Timely and Specific Bug Warnings.” 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.3264599
Quinlan, Dan. 2000. “Rose: Compiler Support for Object-Oriented Frameworks.” Parallel Processing Letters 10 (02n03): 215–26. https://doi.org/10.1142/s0129626400000214
Quiroga, Jose, and Francisco Ortin. 2017. “SSA Transformations to Facilitate Type Inference in Dynamically Typed Code.” Computer Journal. https://doi.org/10.1093/comjnl/bxw108
Rabiha, Sucianna Ghadati, Harco Leslie Hendric Spits Warnars, Ford Lumban Gaol, and Benfano Soewito. 2022a. “RETRACTED CHAPTER: Software Effort Estimation of Teacher Engagement Application.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-16-5640-8_39
Rabiha, Sucianna Ghadati, Harco Leslie Hendric Spits Warnars, Ford Lumban Gaol, and Benfano Soewito. 2022b. “Retraction Note To: Software Effort Estimation of Teacher Engagement Application.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-16-5640-8_57
Rafkind, Jon, Adam Wick, John Regehr, and Matthew Flatt. 2009. “Precise Garbage Collection for C.” In Proceedings of the 2009 international symposium on Memory management. ACM. https://doi.org/10.1145/1542431.1542438
Raghavan, Deepti, Shreya Ravi, Gina Yuan, et al. 2023. “Cornflakes: Zero-Copy Serialization for Microsecond-Scale Networking.” In Proceedings of the 29th Symposium on Operating Systems Principles. ACM. https://doi.org/10.1145/3600006.3613137
Ragunathan, Vivek. 2016a. “Boxing/Unboxing.” In C++/CLI Primer. Apress. https://doi.org/10.1007/978-1-4842-2367-3_12
Ragunathan, Vivek. 2016b. “Garbage Collection Intro.” In C++/CLI Primer. Apress. https://doi.org/10.1007/978-1-4842-2367-3_10
Rahm, Erhard, and Philip A. Bernstein. 2006. “An Online Bibliography on Schema Evolution.” ACM SIGMOD Record 35 (4): 30–31. https://doi.org/10.1145/1228268.1228273
Rainhart, Nicolás, Guillermo Polito, Pablo Tesone, and Stephane Ducasse. 2022. “Analyzing the Cost of Safety for Vectorized Bytecode in Dynamically-Typed Languages.” In Proceedings of the 19th International Conference on Managed Programming Languages and Runtimes. ACM. https://doi.org/10.1145/3546918.3560803
Rais-Rohani, Masoud, and Jeremy Lokits. 2006a. “Comparison of First- and Zeroth-Order Approaches for Reinforcement Layout Optimization of Composite Submarine Sail Structures.” In 11th AIAA/ISSMO Multidisciplinary Analysis and Optimization Conference. AIAA 2006-6970. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/6.2006-6970
Rajagopalan, Subramanian, and Sharad Malik. 2002. “Retargetable Very Long InstructionWord Compiler Framework for Digital Signal Processors.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579.ch16
Rajagopalan, Subramanian, and Sharad Malik. 2007. “A Retargetable Very Long Instruction Word Compiler Framework for Digital Signal Processors.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420043839.ch18
Rajko, Jessica J. 2026. “Feminist Unboxing.” In Routledge Companion to Performance and Technology. Routledge. https://doi.org/10.4324/9781003482697-22
Rajkumar Sekar. 2025. “The Need for Auto Schema Evolution in Modern Data Engineering: Challenges and Solutions.” World Journal of Advanced Research and Reviews 26 (1): 909–17. https://doi.org/10.30574/wjarr.2025.26.1.1115
Ramacharan, S., and K. Venu Gopala Rao. 2013. “Parametric Models for Effort Estimation for Global Software Development.” Lecture Notes on Software Engineering: 178–82. https://doi.org/10.7763/lnse.2013.v1.40
Ramacharan, S., and K. Venu Gopala Rao. 2016. “Software Effort Estimation of GSD Projects Using Calibrated Parametric Estimation Models.” In Proceedings of the Second International Conference on Information and Communication Technology for Competitive Strategies. ACM. https://doi.org/10.1145/2905055.2905177
Ramakrishna, Jayshree, and Eddystone C. Nebel. 1996. “An Empirical Study of the Challenges Facing Hospitality Master’s Programs: A Hotel Industry Perspective.” Hospitality Research Journal 20 (2): 45–57. https://doi.org/10.1177/109634809602000204
Ramalingam, Vennila, and Susan Wiedenbeck. 1997. “An Empirical Study of Novice Program Comprehension in the Imperative and Object-Oriented Styles.” In Papers presented at the seventh workshop on Empirical studies of programmers - ESP ‘97. ACM Press. https://doi.org/10.1145/266399.266411
Ramananandro, Tahina, Zhong Shao, Shu-Chun Weng, Jérémie Koenig, and Yuchen Fu. 2015. “A Compositional Semantics for Verified Separate Compilation and Linking.” In Proceedings of the 2015 Conference on Certified Programs and Proofs. ACM. https://doi.org/10.1145/2676724.2693167
Ramasamy, Subburaj, Anuj Singh, and Deepak Singal. 2016. “Enhancing the Security of C/C++ Programs Using Static Analysis.” Indian Journal of Science and Technology 9 (44). https://doi.org/10.17485/ijst/2016/v9i44/104031
Ramil, Juan F. 2000. “Algorithmic Cost Estimation for Software Evolution.” In Proceedings of the 22nd international conference on Software engineering - ICSE ‘00. ACM Press. https://doi.org/10.1145/337180.337587
Ramil, Juan F., and Meir M. Lehman. 2000. “Effort Estimation from Change Records of Evolving Software (Poster Session).” In Proceedings of the 22nd international conference on Software engineering - ICSE ‘00. ACM Press. https://doi.org/10.1145/337180.337633
Rankovic, Nevena, Dragica Ranković, Mirjana Ivanovic, and Ljubomir Lazić. 2024a. “AI in Software Effort Estimation.” In Artificial Intelligence-Enhanced Software and Systems Engineering. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-76572-8_4
Rankovic, Nevena, Dragica Ranković, Mirjana Ivanovic, and Ljubomir Lazić. 2024b. “Optimizing Effort and Cost Estimation: Model Implementation Using Artificial Neural Networks and Taguchi’s Orthogonal Vector Plans.” In Artificial Intelligence-Enhanced Software and Systems Engineering. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-76572-8_9
Rao, Pradeep, and Kazuaki Murakami. 2009. “Identifying Processor Bottlenecks in Virtual Machine Based Execution of Java Bytecode.” IEICE Transactions on Electronics E92-C (10): 1265–75. https://doi.org/10.1587/transele.e92.c.1265
Rao, Jun, and Kenneth A. Ross. 2000. “Making B+- Trees Cache Conscious in Main Memory.” ACM SIGMOD Record 29 (2): 475–86. https://doi.org/10.1145/335191.335449
Rao Vasa, Mallikarjuna. 2025. “Minimizing Data Load Latency in Enterprise Cloud Migrations via Parallel ETL Orchestration and Zero-Copy Data Fidelity Control.” World Journal of Advanced Research and Reviews 25 (3): 2575–84. https://doi.org/10.30574/wjarr.2025.25.3.0758
Rashid, Adnan, and Osman Hasan. 2020. “Formal Verification of Robotic Cell Injection Systems up to 4-DOF Using HOL Light.” Formal Aspects of Computing 32 (2–3): 229–50. https://doi.org/10.1007/s00165-020-00514-3
Rasnayaka, Sanka, Guanlin Wang, Ridwan Shariffdeen, and Ganesh Neelakanta Iyer. 2024. “An Empirical Study on Usage and Perceptions of LLMs in a Software Engineering Project.” In Proceedings of the 1st International Workshop on Large Language Models for Code. ACM. https://doi.org/10.1145/3643795.3648379
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
Ravi, R. V., P. K. Dutta, and W. C. Lai. 2023. “Internet of Things-Based Garbage Collection for Smart Cities.” IET Conference Proceedings 2022 (26): 412–16. https://doi.org/10.1049/icp.2023.0640
Ravi Kumar, B. N., Y. K. Guruprasad, P. Srivani, and P. Mayur. 2025. “Software Effort Estimation Using AIML and a User Interface.” In Lecture Notes in Electrical Engineering. Springer Nature Singapore. https://doi.org/10.1007/978-981-96-4430-8_19
Ray, Sandip. 2010. “Overview of Formal Verification.” In Scalable Techniques for Formal Verification. Springer US. https://doi.org/10.1007/978-1-4419-5998-0_2
Razvodova, Iuliia. 2023. “The Main Features of the Spatial Structure of Cities with a Free Landscape Layout (the City of Yelets, Lipetsk Region).” Урбанистика, no. 4: 16–31. https://doi.org/10.7256/2310-8673.2023.4.43451
“Real-Time Garbage Collection.” 2011. In The Garbage Collection Handbook. CRC Press. https://doi.org/10.1201/9781315388021-20
Reddy, Dukka Karun Kumar, and H. S. Behera. 2020. “Software Effort Estimation Using Particle Swarm Optimization: Advances and Challenges.” In Advances in Intelligent Systems and Computing. Springer Singapore. https://doi.org/10.1007/978-981-15-2449-3_20
Redelmeier, Donald A., and Shina Namakian. 2023. “The Planning Fallacy in Patients with Chronic Lung Disease.” JAMA Network Open 6 (11): e2343988. https://doi.org/10.1001/jamanetworkopen.2023.43988
Redman, Barbara. 2023. “Conflict of Interest and Commitment and Research Integrity.” In Reconstructing Research Integrity. Springer International Publishing. https://doi.org/10.1007/978-3-031-27111-3_6
Redman, Barbara K. 2026a. “Avenues for Conflict-of-Interest Management in Research.” In Progress in Research Integrity. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-27479-3_14
Redman, Barbara K. 2026b. “Conflict of Interest as a Disorder of Research Integrity.” In Progress in Research Integrity. Springer Nature Switzerland. https://doi.org/10.1007/978-3-032-27479-3_1
“Redundancy Weighting for Software Effort Estimation with Case Based Reasoning.” 2017. In Proceedings of 2017 the 7th International Workshop on Computer Science and Engineering. WCSE. https://doi.org/10.18178/wcse.2017.06.032
“Register Allocation.” 1997. In Modern Compiler Implementation in ML. Cambridge University Press. https://doi.org/10.1017/cbo9780511811449.012
“Register Allocation.” 2012. In Introduction to Compiler Construction in a Java World. Chapman and Hall/CRC. https://doi.org/10.1201/9781482215076-13
“Register Allocation K. Gopinath.” 2002. In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579-17
“Regularizatton Neural Network Model for Construction Cost Estimation* 10.1 Introduction.” 2001. In Construction Scheduling, Cost Optimization and Management. CRC Press. https://doi.org/10.1201/9781482267686-13
Rehman, Semeen, Muhammad Shafique, and Jörg Henkel. 2016. “Software Program-Level Reliability Optimization for Dependable Code Generation.” In Reliable Software for Unreliable Hardware. Springer International Publishing. https://doi.org/10.1007/978-3-319-25772-3_5
Ren, Yongchang, and Zhe Li. 2025. “Cost Estimation of Software Projects Based on the COCOMOII Model.” In Lecture Notes on Data Engineering and Communications Technologies. Springer Nature Singapore. https://doi.org/10.1007/978-981-96-0211-7_20
Ren, Xiaolei, Mengfei Ren, Yu Lei, and Jiang Ming. 2025. “Revisiting Optimization-Resilience Claims in Binary Diffing Tools: Insights from LLVM Peephole Optimization Analysis.” Proceedings of the ACM on Software Engineering 2 (FSE): 2689–2711. https://doi.org/10.1145/3729389
Ren, Yupei, Hongyi Wu, Zhaoguang Long, et al. 2024. “CEAMC: Corpus and Empirical Study of Argument Analysis in Education via LLMs.” In Findings of the Association for Computational Linguistics: EMNLP 2024. Association for Computational Linguistics. https://doi.org/10.18653/v1/2024.findings-emnlp.408
Reppen, Randi. 2005. “Corpus Presenter: Software for Language Analysis.” Studies in Second Language Acquisition 27 (4): 650–650. https://doi.org/10.1017/s0272263105220296
“Research on Design and Performance Optimization of RDMA-Based Zero-Copy Message Middleware for High-Frequency Trading Matching Links.” 2026. Socio-Economic Statistics Research 7 (1). https://doi.org/10.38007/sesr.2026.070104
“Research on Malicious Code Detection Technology for Binary and WASM Bytecode Files in Web3.0 Distributed Applications.” 2025. International Journal of Big Data Intelligent Technology 6 (1). https://doi.org/10.38007/ijbdit.2025.060109
“Research on Register Allocation Optimization Technology.” 2014. In Computer, Intelligent Computing and Education Technology. CRC Press. https://doi.org/10.1201/9781315760827-99
“Research on Static Vulnerability Detection Model at the Bytecode Level of Blockchain Smart Contracts.” 2026. International Journal of Neural Network 5 (1). https://doi.org/10.38007/nn.2026.050105
Resmi, V., and S. Vijayalakshmi. 2019. “Analogy-Based Approaches to Improve Software Project Effort Estimation Accuracy.” Journal of Intelligent Systems 29 (1): 1468–79. https://doi.org/10.1515/jisys-2019-0023
Restrepo-Calle, Felipe, Antonio Martínez-Álvarez, Hipólito Guzmán-Miranda, F. R. Palomo, M. A. Aguirre, and Sergio Cuenca-Asensi. 2010. “A Compiler-Based Infrastructure for Fault-Tolerant Co-Design.” In Proceedings of the 13th International Workshop on Software & Compilers for Embedded Systems - SCOPES ‘10. ACM Press. https://doi.org/10.1145/1811212.1811218
“A Review of Hybrid Effort Estimation Model for Agile Based Projects.” 2021. In Global Emerging Innovation Summit (GEIS-2021), edited by Tina Bakshi, Mohit Arora. BENTHAM SCIENCE PUBLISHERS. https://doi.org/10.2174/9781681089010121010046
Rhmann, Wasiur. 2020. “Software Effort Estimation.” In Computational Intelligence Techniques and Their Applications to Software Engineering Problems. CRC Press. https://doi.org/10.1201/9781003079996-2
Rich, Edward D. 1927a. “Closure to “Garbage Disposal: A Symposium: Disposal by Hog Feeding: Garbage Collection and Disposal, Lansing, Michigan”.” Transactions of the American Society of Civil Engineers 91 (2): 849–52. https://doi.org/10.1061/taceat.0003809
Rich, Edward D. 1927b. “Garbage Disposal: A Symposium: Disposal by Hog Feeding: Garbage Collection and Disposal, Lansing, Michigan.” Transactions of the American Society of Civil Engineers 91 (2): 814–17. https://doi.org/10.1061/taceat.0003810
Rigger, Manuel. 2018. “Sandboxed Execution of C and Other Unsafe Languages on the Java Virtual Machine.” In Conference Companion of the 2nd International Conference on Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3191697.3213795
Rigger, Manuel, Roland Schatz, Matthias Grimmer, and Hanspeter Mössenböck. 2017. “Lenient Execution of C on a Java Virtual Machine: Or: How I Learned to Stop Worrying and Run the Code.” In Proceedings of the 14th International Conference on Managed Languages and Runtimes. ACM. https://doi.org/10.1145/3132190.3132204
Rijwani, Poonam, and Sonal Jain. 2022. “Software Effort Estimation Development From Neural Networks to Deep Learning Approaches.” Journal of Cases on Information Technology 24 (4): 1–16. https://doi.org/10.4018/jcit.296715
Rimawi, Diaeddin. 2020. “A Static Analysis of Android Source Code for Design Patterns Usage.” International Journal of Advanced Trends in Computer Science and Engineering 9 (2): 2178–86. https://doi.org/10.30534/ijatcse/2020/194922020
Ritson Carl G. 2009. “Translating ETC to LLVM Assembly.” In Concurrent Systems Engineering Series. IOS Press. https://doi.org/10.3233/978-1-60750-065-0-145
Rivera, Alexa, Francisco Iacobelli, and Renu Balyan. 2025. “A Code-Switched Corpus for Intelligent Tutoring Systems in Breast Cancer Education.” In EDULEARN Proceedings, vol. 1. IATED. https://doi.org/10.21125/edulearn.2025.2498
Robinson, Simon. 2004. “Understanding Garbage Collection.” In Expert .NET 1.1 Programming. Apress. https://doi.org/10.1007/978-1-4302-0726-9_5
Robles, Gregorio, Jesús M. González-Barahona, Carlos Cervigón, Andrea Capiluppi, and Daniel Izquierdo-Cortázar. 2014. “Estimating Development Effort in Free/Open Source Software Projects by Mining Software Repositories: A Case Study of OpenStack.” In Proceedings of the 11th Working Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/2597073.2597107
Robredo, Mikel, Nyyti Saarimaki, Valentina Lenarduzzi, Sira Vegas, and Davide Taibi. 2024. “Cohort Studies for Mining Software Repositories.” In Proceedings of the 21st International Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/3643991.3649103
Rochet, Florentin. 2025. “Contiguous Zero-Copy for Encrypted Transport Protocols.” ACM SIGCOMM Computer Communication Review 55 (3): 2–18. https://doi.org/10.1145/3787927.3787929
Rockey, Sally J. 2010. “Managing Financial Conflict of Interest in Biomedical Research.” JAMA 303 (23): 2400. https://doi.org/10.1001/jama.2010.774
Roddick, John F. 1992. “Schema Evolution in Database Systems: An Annotated Bibliography.” ACM SIGMOD Record 21 (4): 35–40. https://doi.org/10.1145/141818.141826
Roddick, John F. 2009. “Schema Evolution.” In Encyclopedia of Database Systems. Springer US. https://doi.org/10.1007/978-0-387-39940-9_1532
Roddick, John F. 2016. “Schema Evolution.” In Encyclopedia of Database Systems. Springer New York. https://doi.org/10.1007/978-1-4899-7993-3_1532-2
Roddick, John F. 2018. “Schema Evolution.” In Encyclopedia of Database Systems. Springer New York. https://doi.org/10.1007/978-1-4614-8265-9_1532
Rogith, K. K. 2025. “Efficient File Compression and Data Representation Using Video Pixels:RGB and Binary Modes.” International Journal of Scientific Research and Engineering Trends 11 (2): 1491–98. https://doi.org/10.61137/ijsret.vol.11.issue2.241
Rohou, Erven, Sergei Dyshel, Dorit Nuzman, et al. 2011. “Speculatively Vectorized Bytecode.” In Proceedings of the 6th International Conference on High Performance and Embedded Architectures and Compilers. ACM. https://doi.org/10.1145/1944862.1944871
Rokka Chhetri, Sujit, and Mohammad Abdullah Al Faruque. 2020. “Aiding Data-Driven Attack Model with a Compiler Modification.” In Data-Driven Modeling of Cyber-Physical Systems using Side-Channel Analysis. Springer International Publishing. https://doi.org/10.1007/978-3-030-37962-9_3
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. “Automated WebAssembly Function Purpose Identification with Semantics-Aware Analysis.” In Proceedings of the ACM Web Conference 2023. ACM. https://doi.org/10.1145/3543507.3583235
Romanovsky, Alexander, Alexei Iliasov, Dominic Taylor, and Linas Laibinis. 2022. “Formal Verification of Railway Interlocking and Its Safety Case.” In Safer Systems: The Next 30 Years. Safety-Critical Systems Club C.I.C. https://doi.org/10.65391/r1537
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
Roock, Stefan. 2006. “Agile Project Controlling and Effort Estimation.” In Management of the Object-Oriented Development Process. IGI Global. https://doi.org/10.4018/978-1-59140-604-4.ch013
Roquet, Paul. 2025. “Unboxing Japanese Videogames: A Metadata-Based Approach to the Production and Distribution of Spatial Instability, Written by Martin Roth.” Asiascape: Digital Asia 12 (1–3): 291–93. https://doi.org/10.1163/22142312-bja10065
Rosa, Wilson, Ray Madachy, Barry Boehm, and Brad Clark. 2014. “Simple Empirical Software Effort Estimation Model.” In Proceedings of the 8th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. ACM. https://doi.org/10.1145/2652524.2652558
Rosales, Eduardo, Andrea Rosà, and Walter Binder. 2019. “Optimization Coaching for Fork/join Applications on the Java Virtual Machine.” In Proceedings of the Conference Companion of the 3rd International Conference on Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3328433.3328441
Rose, Ralph L. 2013. “Crosslinguistic Corpus of Hesitation Phenomena: A Corpus for Investigating First and Second Language Speech Performance.” In Interspeech 2013. ISCA. https://doi.org/10.21437/interspeech.2013-175
Rosero, Edgar Eduardo Rosales, Andrea Rosà, and Walter Binder. 2020. “Profiling Streams on the Java Virtual Machine.” In Conference Companion of the 4th International Conference on Art, Science, and Engineering of Programming. ACM. https://doi.org/10.1145/3397537.3397565
Ross, Carl T. F. 1996. “Static Analysis of Three Dimensional Rigid-Jointed Frames.” In Finite Element Programs in Structural Engineering and Continuum Mechanics. Elsevier. https://doi.org/10.1533/9780857099839.72
Ross, Kenneth A. 2009. “Cache-Conscious Query Processing.” In Encyclopedia of Database Systems. Springer US. https://doi.org/10.1007/978-0-387-39940-9_658
Ross, Kenneth A. 2017. “Cache-Conscious Query Processing.” In Encyclopedia of Database Systems. Springer New York. https://doi.org/10.1007/978-1-4899-7993-3_658-2
Ross, Kenneth A. 2018. “Cache-Conscious Query Processing.” In Encyclopedia of Database Systems. Springer New York. https://doi.org/10.1007/978-1-4614-8265-9_658
Ross, William, and Byeong Kil Lee. 2019. “Effective Data Placement to Reduce Cache Thrashing in Last Level Cache.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-14070-0_40
Roy, Probir, and Xu Liu. 2016. “StructSlim: A Lightweight Profiler to Guide Structure Splitting.” In Proceedings of the 2016 International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/2854038.2854053
Roy-Chowdhury, Amber. 1995. Manual and Compiler Assisted Methods for Generating Fault-Tolerant Parallel Programs. Defense Technical Information Center. https://doi.org/10.21236/ada302812
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
Rozvany, G. I. N. 1988. “Optimality Criteria and Layout Theory in Structural Design: Recent Developments and Applications.” In Structural Optimization. Springer Netherlands. https://doi.org/10.1007/978-94-009-1413-1_34
Rozvany, G. I. N., W. Gollub, and M. Zhou. 1992. “Layout Optimization in Structural Design.” In Optimization and Artificial Intelligence in Civil and Structural Engineering. Springer Netherlands. https://doi.org/10.1007/978-94-017-2490-6_19
Rudalics, Martin. 1986. “Distributed Copying Garbage Collection.” In Proceedings of the 1986 ACM conference on LISP and functional programming - LFP ‘86. ACM Press. https://doi.org/10.1145/319838.319877
Rumpe, Bernhard. 2017a. “Principles of Code Generation.” In Agile Modeling with UML. Springer International Publishing. https://doi.org/10.1007/978-3-319-58862-9_4
Rumpe, Bernhard. 2017b. “Transformations for Code Generation.” In Agile Modeling with UML. Springer International Publishing. https://doi.org/10.1007/978-3-319-58862-9_5
Russo, Barbara, Marco Scotto, Alberto Sillitti, and Giancarlo Succi. 2010. “Effort Estimation.” In Agile Technologies in Open Source Development. IGI Global. https://doi.org/10.4018/978-1-59904-681-5.ch013
Ruthruff, Joseph R., Margaret Burnett, and Gregg Rothermel. 2005. “An Empirical Study of Fault Localization for End-User Programmers.” In Proceedings of the 27th international conference on Software engineering - ICSE ‘05. ACM Press. https://doi.org/10.1145/1062455.1062523
Ruthruff, Joseph R., Sebastian Elbaum, and Gregg Rothermel. 2006. “Experimental Program Analysis: A New Program Analysis Paradigm.” In Proceedings of the 2006 international symposium on Software testing and analysis. ACM. https://doi.org/10.1145/1146238.1146245
Saadi, Hossain Shaikh, Faria Alam, Mario Sanz-Guerrero, Minh Duc Bui, Manuel Mager, and Katharina von der Wense. 2025. “NALA_MAINZ at BLP-2025 Task 2: A Multi-Agent Approach for Bengali Instruction to Python Code Generation.” In Proceedings of the Second Workshop on Bangla Language Processing (BLP-2025). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.banglalp-1.61
Saal, Harry J. 1978. “Considerations in the Design of a Compiler for APL.” ACM SIGAPL APL Quote Quad 8 (4): 8–14. https://doi.org/10.1145/586032.586034
Saban, A. 2018. “Alcohol Industry Funding for University Research: A Conflict of Interest.” European Journal of Public Health 28 (suppl_4). https://doi.org/10.1093/eurpub/cky212.296
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
Sadiq, Mohd., Mohammad Asim, Javed Ahmed, Vinish Kumar, and Shadab Khan. 2011. “Prediction of Software Project Effort Estimation: A Case Study.” International Journal of Modeling and Optimization: 37–43. https://doi.org/10.7763/ijmo.2011.v1.7
Saeed, Ayesha, Wasi Haider Butt, Farwa Kazmi, and Madeha Arif. 2018. “Survey of Software Development Effort Estimation Techniques.” In Proceedings of the 2018 7th International Conference on Software and Computer Applications. ACM. https://doi.org/10.1145/3185089.3185140
Safavi, Sarah Afzal, and Maqbool Uddin Shaikh. 2011. “Effort Estimation Model for Each Phase of Software Development Life Cycle.” In Handbook of Research on E-Services in the Public Sector. IGI Global. https://doi.org/10.4018/978-1-61520-789-3.ch021
Safina, Larisa. 2026. “Towards Hybrid and Reusable Type Inference for Dynamically-Typed Languages.” In Anais do XXIX Congresso Ibero-Americano em Engenharia de Software (CIbSE 2026). Sociedade Brasileira de Computação. https://doi.org/10.5753/cibse.2026.42446
Sagar, Paul. 2016. “Burke Unboxed.” Political Theory 46 (2): 280–98. https://doi.org/10.1177/0090591716672403
Saha, Bratin, Valery Trifonov, and Zhong Shao. 2005a. Fully Reflexive Intensional Type Analysis. Defense Technical Information Center. https://doi.org/10.21236/ada436483
Saha, Bratin, Valery Trifonov, and Zhong Shao. 2005b. Fully Reflexive Intensional Type Analysis in Type Erasure Semantics. Defense Technical Information Center. https://doi.org/10.21236/ada436474
Sahoo, Prateek, Dayal Kumar Behera, Pulak Sahoo, Jacob George, Mahendra Kumar Gourisaria, and J. R. Mohanty. 2024a. “Forecasting Software Effort Estimation from UML Class Models Using Predictive Learning.” In Lecture Notes in Networks and Systems. Springer Nature Singapore. https://doi.org/10.1007/978-981-97-7360-2_10
Sahoo, Pulak, Dayal Kumar Behera, Subhra Swetanisha, and J. R. Mohanty. 2024b. “Software Development Effort Estimation Using UML Activity Models with Regression Analysis.” In Lecture Notes in Electrical Engineering. Springer Nature Singapore. https://doi.org/10.1007/978-981-97-0767-6_21
Sahu, Satej Kumar. 2025. “Megabrains 101: Generative AI and LLMs Unboxed.” In Generative AI-Driven Application Development with Java. Apress. https://doi.org/10.1007/979-8-8688-1609-3_1
Saif, Syed Mohsin. 2020. “Software Effort Estimation for Successful Software Application Development.” In Advances in Systems Analysis, Software Engineering, and High Performance Computing. IGI Global. https://doi.org/10.4018/978-1-7998-1863-2.ch003
Saif, Syed Mohsin. 2022. “Software Effort Estimation for Successful Software Application Development.” In Research Anthology on Agile Software, Software Development, and Testing. IGI Global. https://doi.org/10.4018/978-1-6684-3702-5.ch008
Saikkonen, Riku, and Eljas Soisalon-Soininen. 2015. “Cache-Sensitive Memory Layout for Dynamic Binary Trees.” Computer Journal 59 (5): 630–49. https://doi.org/10.1093/comjnl/bxv090
Saini, Jatinderkumar R., and Vikas S. Chomal. 2020a. “Domain-Based Ranking of Software Test—Effort Estimation Techniques for Academic Projects.” In Advances in Intelligent Systems and Computing. Springer Singapore. https://doi.org/10.1007/978-981-15-0936-0_5
Saini, Jatinderkumar R., and Vikas S. Chomal. 2020b. “A Double-Weighted Parametric Model for Academic Software Project Effort Estimation.” In Lecture Notes in Networks and Systems. Springer Singapore. https://doi.org/10.1007/978-981-15-0630-7_4
Sait, Edward M. 1971. Analysis of Officer Performance on an Experimental Task: Airfield Layout. Defense Technical Information Center. https://doi.org/10.21236/ada079382
Sakai, Yusuke. 2025. “Simultaneous Interpretation Corpus Construction by Large Language Models in Distant Language Pair.” Journal of Natural Language Processing 32 (1): 348–54. https://doi.org/10.5715/jnlp.32.348
Sakurai, Junji. 1978. “An Isolation Structure and Layout of the Buried Oxide CMOS-IC.” In Extended Abstracts of the 1978 International Conference on Solid State Devices and Materials. The Japan Society of Applied Physics. https://doi.org/10.7567/ssdm.1978.a-2-1
Sally, Sherina. 2022. “Sentiment Analysis on Youtube Smart Phone Unboxing Video Reviews in Sri Lanka.” International Journal of Research -GRANTHAALAYAH 10 (11). https://doi.org/10.29121/granthaalayah.v10.i11.2022.4884
Salmanoglu, Murat, Tuna Hacaloglu, and Onur Demirors. 2017. “Effort Estimation for Agile Software Development: Comparative Case Studies Using COSMIC Functional Size Measurement and Story Points.” In Proceedings of the 27th International Workshop on Software Measurement and 12th International Conference on Software Process and Product Measurement. ACM. https://doi.org/10.1145/3143434.3143450
Sam, A. G., M. Khanna, and R. Innes. 2009. “Voluntary Pollution Reduction Programs, Environmental Management, and Environmental Performance: An Empirical Study.” Land Economics 85 (4): 692–711. https://doi.org/10.3368/le.85.4.692
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
“Sampling Based Top-K Garbage Collection Algorithm on Flash Memory.” 2011. In International Conference on Measurement and Control Engineering 2nd (ICMCE 2011). ASME Press. https://doi.org/10.1115/1.859858.paper39
SangYun Lee. 2012. “Java Garbage Collection for Embedded Java Virtual Machines: Design, Implementation, and Performance Evaluation.” Journal of Next Generation Information Technology 3 (3): 27–40. https://doi.org/10.4156/jnit.vol3.issue3.4
Sansom, Patrick M., and Simon L. Peyton Jones. 1993. “Generational Garbage Collection for Haskell.” In Proceedings of the conference on Functional programming languages and computer architecture. ACM. https://doi.org/10.1145/165180.165195
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
Santone, Antonella, and Gigliola Vaglini. 2002. “Local Model Checking of Java Bytecode.” In Proceedings of the 14th international conference on Software engineering and knowledge engineering. ACM. https://doi.org/10.1145/568760.568827
Santos, Marcos V., and Michel S. Soares. 2025. “Cost Estimation for Agile Software Development in Small and Medium-Sized Enterprises.” In Anais Estendidos do XXIV Simpósio Brasileiro de Qualidade de Software (SBQS 2025). Sociedade Brasileira de Computação - SBC. https://doi.org/10.5753/sbqs_estendido.2025.13396
Santoso, Ganis Zulfa, Song-Woo Sok, Young-Woo Jung, and Dong-Jae Kang. 2017. “Optimizing I/O Performance in ViMo-S Hypervisor with Zero-Copy Method.” In Proceedings of the 6th International Conference on Software and Computer Applications. ACM. https://doi.org/10.1145/3056662.3056719
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
Sapna Yadav and Prajakta Patil. 2025. “Advanced Garbage Collection Strategies for Java Performance.” International Journal of Latest Technology in Engineering Management & Applied Science 14 (13): 48–51. https://doi.org/10.51583/ijltemas.2025.1413sp011
Saraswathi, S., and N. Kannan. 2016. “A Hybrid Associative Classification Model for Software Development Effort Estimation.” Circuits and Systems 07 (06): 824–34. https://doi.org/10.4236/cs.2016.76071
Sarimbekov, Aibek. 2013. “Comparison of Instrumentation Techniques for Dynamic Program Analysis on the Java Virtual Machine.” In Proceedings of the 12th annual international conference companion on Aspect-oriented software development. ACM. https://doi.org/10.1145/2457392.2457406
Sarimbekov, Aibek, Andreas Sewe, Walter Binder, Philippe Moret, Martin Schoeberl, and Mira Mezini. 2011b. “Portable and Accurate Collection of Calling-Context-Sensitive Bytecode Metrics for the Java Virtual Machine.” In Proceedings of the 9th International Conference on Principles and Practice of Programming in Java. ACM. https://doi.org/10.1145/2093157.2093160
Sarrab, Mohamed. 2015. “Bytecode Instrumentation Mechanism for Monitoring Mobile Application Information Flow.” International Journal of Security and Networks 10 (3): 191. https://doi.org/10.1504/ijsn.2015.071835
Sarrion, Eric. 2023. “Using ChatGPT for Code Generation in Computer Programs.” In Exploring the Power of ChatGPT. Apress. https://doi.org/10.1007/978-1-4842-9529-8_15
Sarro, Federica. 2011. “Search-Based Approaches for Software Development Effort Estimation.” In Proceedings of the 12th International Conference on Product Focused Software Development and Process Improvement. ACM. https://doi.org/10.1145/2181101.2181111
Sarro, Federica, Filomena Ferrucci, and Carmine Gravino. 2012. “Single and Multi Objective Genetic Programming for Software Development Effort Estimation.” In Proceedings of the 27th Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/2245276.2231968
Sarro, Federica, Alessio Petrozziello, and Mark Harman. 2016. “Multi-Objective Software Effort Estimation.” In Proceedings of the 38th International Conference on Software Engineering. ACM. https://doi.org/10.1145/2884781.2884830
Satapathy, Shashank Mouli, Barada Prasanna Acharya, and Santanu Kumar Rath. 2016. “Early Stage Software Effort Estimation Using Random Forest Technique Based on Use Case Points.” IET Software 10 (1): 10–17. https://doi.org/10.1049/iet-sen.2014.0122
Satapathy, Shashank Mouli, and Santanu Kumar Rath. 2014. “Class Point Approach for Software Effort Estimation Using Various Support Vector Regression Kernel Methods.” In Proceedings of the 7th India Software Engineering Conference. ACM. https://doi.org/10.1145/2590748.2590752
Satapathy, Shashank Mouli, and Santanu Kumar Rath. 2017. “Empirical Assessment of Machine Learning Models for Effort Estimation of Web-Based Applications.” In Proceedings of the 10th Innovations in Software Engineering Conference. ACM. https://doi.org/10.1145/3021460.3021468
Sateanpattanakul, Siwadol, and Duangpen Jetpipattanapong. 2026. “Improved Control-Flow Classification via Java Bytecode-Metadata.” In Proceedings of the 2026 9th International Conference on Software Engineering and Information Management. ACM. https://doi.org/10.1145/3796315.3796325
Sateanpattanakul, Siwadol, Duangpen Jetpipattanapong, and Seksan Mathulaprangsan. 2021. “Java Bytecode Control Flow Classification: Framework for Guiding Java Decompilation.” Journal of Mobile Multimedia. https://doi.org/10.13052/jmm1550-4646.1822
Sathi, Harbans L. 1986. “A Project-Based Course in Compiler Construction.” ACM SIGCSE Bulletin 18 (1): 114–19. https://doi.org/10.1145/953055.5698
Sato, Shimpei, Yukinori Sato, and Toshio Endo. 2015. “Investigating Potential Performance Benefits of Memory Layout Optimization Based on Roofline Model.” In Proceedings of the 2nd International Workshop on Software Engineering for Parallel Systems. ACM. https://doi.org/10.1145/2837476.2837483
Sattar, Abdul, and Torben Lorenzen. 2007. “Develop a Compiler in Java for a Compiler Design Course.” ACM SIGCSE Bulletin 39 (2): 80–82. https://doi.org/10.1145/1272848.1272890
Schatz, Bruce R., Bruce W. Leverett, Joseph M. Newcomer, Andrew H. Reiner, and William A. Wulf. 1979. TCOL Ada: An Intermediate Representation for the DoD Standard Programming Language. Defense Technical Information Center. https://doi.org/10.21236/ada955948
Schellhorn, Gerhard, and Wolfgang Ahrendt. 1998. “The WAM Case Study: Verifying Compiler Correctness for Prolog with KIV.” In Applied Logic Series. Springer Netherlands. https://doi.org/10.1007/978-94-017-0437-3_7
Schelvis, M. 1989. “Incremental Distribution of Timestamp Packets: A New Approach to Distributed Garbage Collection.” In Conference proceedings on Object-oriented programming systems, languages and applications. ACM. https://doi.org/10.1145/74877.74883
“Schema Evolution in Process Management Systems.” 2009. In Encyclopedia of Database Systems. Springer US. https://doi.org/10.1007/978-0-387-39940-9_3527
“Schema Evolution in Workflow Management Systems.” 2009. In Encyclopedia of Database Systems. Springer US. https://doi.org/10.1007/978-0-387-39940-9_3528
Schenk, Wolfgang. 2002. “Retargetable Code Generation for Parallel, Pipelined Processor Structures.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_7
Scherzinger, Stefanie, Stephanie Sombach, Katharina Wiech, Meike Klettke, and Uta Störl. 2016. “Datalution: A Tool for Continuous Schema Evolution in NoSQL-Backed Web Applications.” In Proceedings of the 2nd International Workshop on Quality-Aware DevOps. ACM. https://doi.org/10.1145/2945408.2945416
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
Schmid, Hans Albrecht. 1972. “The Structure of a Flexible and Efficient Compiler for Algorithmic Conversational Languages.” In Lecture Notes in Economics and Mathematical Systems. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-80718-3_11
Schmitz, Lothar. 1992a. “SIC — Ein Smalltalk-basierter Interaktiver Compiler-Compiler.” In Multimedia, Vernetzung und Software für die Lehre. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-84863-6_16
Schneider, Frederick W., and Glen D. Johnson. 1964. “META-3 Syntax-Directed Compiler Writing Compiler to Generate Efficient Code.” In Proceedings of the 1964 19th ACM national conference on -. ACM Press. https://doi.org/10.1145/800257.808898
Schnieber, Martha, and Rolf Drechsler. 2023. “Polynomial Formal Verification of KFDD Circuits.” In Proceedings of the 21st ACM-IEEE International Conference on Formal Methods and Models for System Design. ACM. https://doi.org/10.1145/3610579.3611080
Scholz, Bernhard, Herbert Jordan, Pavle Subotić, and Till Westmann. 2016. “On Fast Large-Scale Program Analysis in Datalog.” In Proceedings of the 25th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/2892208.2892226
Schuck, J., N. Wehn, M. Glesner, and G. Kamp. 1987. “The ALGIC Silicon Compiler System: Implementation, Design Experience and Results.” In 24th ACM/IEEE conference proceedings on Design automation conference - DAC ‘87. ACM Press. https://doi.org/10.1145/37888.37944
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
Schwartz, Steven. 1994. “Heuristics and Biases in Medical Judgment and Decision Making.” In Social Psychological Applications to Social Issues. Springer US. https://doi.org/10.1007/978-1-4757-9238-6_4
Schwarz, Fritz. 2002. “Alltypes: An Algebraic Language and Type System.” In Mathematical Software. WORLD SCIENTIFIC. https://doi.org/10.1142/9789812777171_0051
Schwarzbeck, David, Daniela Novac, and Michael Philippsen. 2025. “Register Expansion, SemaCall, and SideData: Three Low-Overhead Dynamic Watermarks Suitable for Automation in LLVM.” Digital Threats: Research and Practice 6 (3): 1–22. https://doi.org/10.1145/3743152
Sciampacone, R. A., V. Sundaresan, D. Maier, and T. Gray-Donald. 2010. “Exploitation of Multicore Systems in a Java Virtual Machine.” IBM Journal of Research and Development 54 (5): 1:1-1:11. https://doi.org/10.1147/jrd.2010.2057911
“Screenshot Guide to Absoft Compiler Graphical User Interface.” 2010. In Ludwig’s Applied Process Design for Chemical and Petrochemical Plants. Elsevier. https://doi.org/10.1016/b978-0-7506-8366-1.10032-5
“Section 2255 of the Judicial Code: The Threatened Demise of Habeas Corpus.” 1950. Yale Law Journal 59 (6): 1183. https://doi.org/10.2307/792999
“Section E: The Lungs and Respiration E1 LAYOUT AND STRUCTURE O F THE RESPIRATORY TRACT.” 2013. In BIOS Instant Notes in Human Physiology. Taylor & Francis. https://doi.org/10.4324/9780203002650-26
Sehra, Sumeet Kaur, Yadwinder Singh Brar, and Navdeep Kaur. 2017a. “Evolutionary Computing Techniques for Software Effort Estimation.” International Journal of Computer Science and Information Technology 9 (2): 123–30. https://doi.org/10.5121/ijcsit.2017.9211
Seligman, Erik, Tom Schubert, and M. V. Achutha Kiran Kumar. 2015a. “Basic Formal Verification Algorithms.” In Formal Verification. Elsevier. https://doi.org/10.1016/b978-0-12-800727-3.00002-2
Seligman, Erik, Tom Schubert, and M. V. Achutha Kiran Kumar. 2015b. “Formal Verification.” In Formal Verification. Elsevier. https://doi.org/10.1016/b978-0-12-800727-3.00001-0
Seligman, Erik, Tom Schubert, and M. V. Achutha Kiran Kumar. 2015c. “Formal Verification’s Greatest Bloopers.” In Formal Verification. Elsevier. https://doi.org/10.1016/b978-0-12-800727-3.00009-5
Seligman, Erik, Tom Schubert, and M. V. Achutha Kiran Kumar. 2023a. “Basic Formal Verification Algorithms.” In Formal Verification. Elsevier. https://doi.org/10.1016/b978-0-323-95612-3.00002-1
Seligman, Erik, Tom Schubert, and M. V. Achutha Kiran Kumar. 2023b. “Formal Verification: From Dreams to Reality.” In Formal Verification. Elsevier. https://doi.org/10.1016/b978-0-323-95612-3.00001-x
Sells, A. Lytton. 2025. “The Compiler.” In Oliver Goldsmith. Routledge. https://doi.org/10.4324/9781003664703-31
Semerdjiev, Tzvetan. 1998. “The Impact of the MSDF Technologies on the Information Space Structure Reordering and Evolution.” Information & Security: An International Journal 1 (1): 75–89. https://doi.org/10.11610/isij.0106
Seo, Yeong-Seok, Kyung-A. Yoon, and Doo-Hwan Bae. 2008. “An Empirical Analysis of Software Effort Estimation with Outlier Elimination.” In Proceedings of the 4th international workshop on Predictor models in software engineering. ACM. https://doi.org/10.1145/1370788.1370796
Seong-Min Lee, Seong-Min Lee, and Kwon-Woo Lee Kwon-Woo Lee. 1996. “The Optimization of Passivation Layout Structure for Reliability Improvement of Memory Devices.” Japanese Journal of Applied Physics 35 (10R): 5462. https://doi.org/10.1143/jjap.35.5462
Seref, Berna. 2014. “Software Effort Estimation Using Multilayer Perceptron and Adaptive Neuro Fuzzy Inference System.” International Journal of Innovation, Management and Technology. https://doi.org/10.7763/ijimt.2014.v5.543
Serrano, Mauricio J., and Xiaotong Zhuang. 2009. “Placement Optimization Using Data Context Collected during Garbage Collection.” In Proceedings of the 2009 international symposium on Memory management. ACM. https://doi.org/10.1145/1542431.1542442
Seth, Kirti, Ashish Seth, and Aprna Tripathi. 2020. “Effort Estimation Techniques for Legacy Systems.” In Component-Based Systems. CRC Press. https://doi.org/10.1201/9781003013884-2
Sethi, Ravi. 1973. “Complete Register Allocation Problems.” In Proceedings of the fifth annual ACM symposium on Theory of computing - STOC ‘73. ACM Press. https://doi.org/10.1145/800125.804049
Settle, Brett, David Otasek, John H. Morris, and Barry Demchak. 2018. “Copycat Layout: Network Layout Alignment via Cytoscape Automation.” F1000Research 7: 822. https://doi.org/10.12688/f1000research.15144.2
SeyedAlinaghi, SeyedAhmad, Faeze Abbaspour, and Esmaeil Mehraeen. 2024. “Conflict of Interest in Health Research Articles.” Shiraz E-Medical Journal 26 (3). https://doi.org/10.5812/semj-149783
Seymour, Keith, and Jack Dongarra. 2001. “Automatic Translation of Fortran to JVM Bytecode.” In Proceedings of the 2001 joint ACM-ISCOPE conference on Java Grande. ACM. https://doi.org/10.1145/376656.376833
Shah, Muhammad Arif, N. Dayang, Mohd Adham, Karzan Wakil, Muhammad Younas, and Ahmed Mustafa. 2019a. “MINN: A Missing Data Imputation Technique for Analogy-Based Effort Estimation.” International Journal of Advanced Computer Science and Applications 10 (2). https://doi.org/10.14569/ijacsa.2019.0100230
Shah, Jalal, Nazri Kama, and Nur Azaliah A Bakar. 2018. “A Novel Effort Estimation Model for Software Requirement Changes during Software Development Phase.” International Journal of Software Engineering & Applications 9 (6): 11–30. https://doi.org/10.5121/ijsea.2018.9602
Shah, Jalal, Nazri Kama, Nur Azaliah A. Bakar, and Zuhaibuddin Bhutto. 2019b. “Software Requirement Change Effort Estimation Model Prototype Tool for Software Development Phase.” International Journal of Software Engineering & Applications 10 (03): 09–19. https://doi.org/10.5121/ijsea.2019.10302
Shahbaz, Muhammad, and Nick Feamster. 2015. “The Case for an Intermediate Representation for Programmable Data Planes.” In Proceedings of the 1st ACM SIGCOMM Symposium on Software Defined Networking Research. ACM. https://doi.org/10.1145/2774993.2775000
Shahrier, Md Kaf, Suhana Binta Rashid, Hasan Mesbaul Ali Taher, and Mohammed Moshiul Hoque. 2025. “CUET_Expelliarmus at BLP2025 Task 2: Leveraging Instruction Translation and Refinement for Bangla-to-Python Code Generation with Open-Source LLMs.” In Proceedings of the Second Workshop on Bangla Language Processing (BLP-2025). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.banglalp-1.62
Shaikh, Farheen. 2024. “Garbage Collection Android Application.” International Journal for Research in Applied Science and Engineering Technology 12 (4): 1826–33. https://doi.org/10.22214/ijraset.2024.59995
Shamparov, Viktor, and Murad Neiman-Zade. 2021. “Data Layout Optimization for the LCC Compiler.” Proceedings of the Institute for System Programming of the RAS 33 (3): 51–60. https://doi.org/10.15514/ispras-2021-33(3)-4
Shankar, Priti. 2002. “Instruction Selection Using Tree Parsing.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579.ch15
Shankar, Priti. 2007. “Instruction Selection Using Tree Parsing.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420043839.ch17
Shapley, Deborah. 1973. “Auto Pollution: Research Group Charged with Conflict of Interest.” Science 181 (4101): 732–35. https://doi.org/10.1126/science.181.4101.732
Sharan, Kishori. 2014. “Garbage Collection.” In Beginning Java 8 Language Features. Apress. https://doi.org/10.1007/978-1-4302-6659-4_11
Sharan, Kishori. 2018. “Garbage Collection.” In Java Language Features. Apress. https://doi.org/10.1007/978-1-4842-3348-1_11
Sharma, Shreyansh. 2026. “Data Normalization and Schema Evolution for Ticker Symbol Insights.” International Journal of Emerging Trends in Computer Science and Information Technology 7 (1): 63–72. https://doi.org/10.63282/3050-9246.ijetcsit-v7i1p109
Sharma, Amrita, and Neha Chaudhary. 2022. “The Combined Model for Software Development Effort Estimation Using Polynomial Regression for Heterogeneous Projects.” Radioelectronic and Computer Systems, no. 2: 75–82. https://doi.org/10.32620/reks.2022.2.06
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, Sudhir, and Shripal Vijayvargiya. 2020. “Applying Soft Computing Techniques for Software Project Effort Estimation Modelling.” In Lecture Notes in Electrical Engineering. Springer Singapore. https://doi.org/10.1007/978-981-15-7486-3_21
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
Shemitz, Jon. 2006. “Garbage Collection.” In .NET 2.0 for Delphi Programmers. Apress. https://doi.org/10.1007/978-1-4302-0174-8_3
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
Sherriff, Mark S., Sarah Smith Heckman, J. Michael Lake, and Laurie A. Williams. 2007. “Using Groupings of Static Analysis Alerts to Identify Files Likely to Contain Field Failures.” In The 6th Joint Meeting on European software engineering conference and the ACM SIGSOFT symposium on the foundations of software engineering: companion papers. ACM. https://doi.org/10.1145/1295014.1295042
Shi, Pei. 2020. “The Method and Static Analysis of Making Well Logging Interpretation Standard of Oil-Water Formation by Network.” Journal of Physics: Conference Series 1578 (1): 012134. https://doi.org/10.1088/1742-6596/1578/1/012134
Shi, Beixiang, Junyan Yang, and Yi Zheng. 2021. “Spatial Layout of the UC Structure.” In The Centre of City: Urban Central Structure. Springer Singapore. https://doi.org/10.1007/978-981-33-6675-6_4
Shiloh, Shoshana. 1994. “Heuristics and Biases in Health Decision Making.” In Social Psychological Applications to Social Issues. Springer US. https://doi.org/10.1007/978-1-4757-9238-6_2
Shimchenko, Marina, Erik Österlund, and Tobias Wrigstad. 2024. “Scheduling Garbage Collection for Energy Efficiency on Asymmetric Multicore Processors.” Art, Science, and Engineering of Programming 8 (3): 10. https://doi.org/10.22152/programming-journal.org/2024/8/10
Shimmi, Samiha, and Mona Rahimi. 2022. “Mining Software Repositories for Patternizing Attack-and-Defense Co-Evolution.” In Proceedings of the 1st International Workshop on Mining Software Repositories Applications for Privacy and Security. ACM. https://doi.org/10.1145/3549035.3561181
Shin, Insup, Seungwhun Paik, and Youngsoo Shin. 2009. “Register Allocation for High-Level Synthesis Using Dual Supply Voltages.” In Proceedings of the 46th Annual Design Automation Conference. ACM. https://doi.org/10.1145/1629911.1630152
Shir, Rony, Priyanka Surve, Yuval Elovici, and Asaf Shabtai. 2025. “Robust Vulnerability Detection across Compilations: LLVM-IR vs. Assembly with Transformer Model.” Proceedings of the ACM on Software Engineering 2 (ISSTA): 618–39. https://doi.org/10.1145/3728903
Shivhare, Jyoti, and Santanu Ku. Rath. 2014. “Software Effort Estimation Using Machine Learning Techniques.” In Proceedings of the 7th India Software Engineering Conference. ACM. https://doi.org/10.1145/2590748.2590767
Shoaib, Muhammad, Noor Yasin, and Abdul G. Abbassi. 2016. “Smart Card Based Protection for Dalvik Bytecode — Dynamically Loadable Component of an Android APK.” International Journal of Computer Theory and Engineering 8 (2): 156–60. https://doi.org/10.7763/ijcte.2016.v8.1036
Shojai, Siamack, William J. Davis, and Patricia S. Root. 2013. “Developmental Relationship Programs: An Empirical Study of the Impact of Peer-Mentoring Programs.” Contemporary Issues in Education Research (CIER) 7 (1): 31. https://doi.org/10.19030/cier.v7i1.8309
Shpak, Myroslav, Oleg, and Yurii Shcheblanin. 2026. “Reducing the Vulnerability Level of Garbage Collection Using Arena Allocator.” Cybersecurity Education Science Technique: 550. https://doi.org/10.28925/2663-4023.2026.32.1096
Shreesha Hegde Kukkuhalli. 2022. “Building a Dynamic Data Ingestion Framework to Manage Schema Evolution for an Enterprise.” International Journal For Multidisciplinary Research 4 (2): 12014. https://doi.org/10.36948/ijfmr.2022.v04i02.12014
Shrivastava, Aviral, and Nikil Dutt. 2007. “Compiler-Aided Design of Embedded Computers.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420043839.ch3
Shulman, Michael. 2017. “Idempotents in Intensional Type Theory.” Logical Methods in Computer Science Volume 12, Issue 3: 2027. https://doi.org/10.2168/lmcs-12(3:9)2016
Shweta, Shweta, and P. K. Singh. 2022. “Score Based Garbage Collection Algorithm for Flash Based Storage System.” International Journal of Next-Generation Computing. https://doi.org/10.47164/ijngc.v13i3.617
Siachitema, Alice K. 1991. “The Social Significance of Language Use and Language Choice in a Zambian Urban Setting: An Empirical Study of Three Neighbourhoods in Lusaka.” In English around the World. Cambridge University Press. https://doi.org/10.1017/cbo9780511611889.033
Siddiqi, Jawed. 1987. “How Do Software Practitioners Write Programs? An Empirical Study.” In Empirical Foundations of Information and Software Science IV. Springer US. https://doi.org/10.1007/978-1-4684-5472-7_27
Siddiqui, Tamanna, and Ausaf Ahmad. 2017. “Data Mining Tools and Techniques for Mining Software Repositories: A Systematic Review.” In Advances in Intelligent Systems and Computing. Springer Singapore. https://doi.org/10.1007/978-981-10-6620-7_70
Siddiqui, Tamanna, and Ausaf Ahmad. 2019. “Mining Software Repositories for Software Metrics (MSR-SM): Conceptual Framework.” International Journal of Innovative Technology and Exploring Engineering 8 (10): 4173–77. https://doi.org/10.35940/ijitee.j1051.0881019
Siddiqui, Zeeshan Ali, and Kirti Tyagi. 2018. “Study on Service Selection Effort Estimation in Service Oriented Architecture-Based Applications Powered by Information Entropy Weight Fuzzy Comprehensive Evaluation Model.” IET Software 12 (2): 76–84. https://doi.org/10.1049/iet-sen.2016.0141
Siebert, Fridtjof. 2008. “Limits of Parallel Marking Garbage Collection.” In Proceedings of the 7th international symposium on Memory management. ACM. https://doi.org/10.1145/1375634.1375638
Siebert, Fridtjof. 2011. “Parallel Real-Time Garbage Collection.” In Distributed, Embedded and Real-time Java Systems. Springer US. https://doi.org/10.1007/978-1-4419-8158-5_4
Sigweni, Boyce. 2014. “Feature Weighting for Case-Based Reasoning Software Project Effort Estimation.” In Proceedings of the 18th International Conference on Evaluation and Assessment in Software Engineering. ACM. https://doi.org/10.1145/2601248.2613081
Sigweni, Boyce, and Martin Shepperd. 2014. “Feature Weighting Techniques for CBR in Software Effort Estimation Studies: A Review and Empirical Evaluation.” In Proceedings of the 10th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2639490.2639508
Sigweni, Boyce, Martin Shepperd, and Tommaso Turchi. 2016. “Realistic Assessment of Software Effort Estimation Models.” In Proceedings of the 20th International Conference on Evaluation and Assessment in Software Engineering. ACM. https://doi.org/10.1145/2915970.2916005
Silhavy, Petr, Radek Silhavy, and Zdenka Prokopova. 2019b. “Outliners Detection Method for Software Effort Estimation Models.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-19807-7_43
Silva, Wilamis Kleiton Nunes da. 2026. “Hybrid Model for Improving the Accuracy of Software Development Team Effort Estimation with Genetic Algorithm-Optimized Regression Ensembles.” In Anais do XXIX Congresso Ibero-Americano em Engenharia de Software (CIbSE 2026). Sociedade Brasileira de Computação. https://doi.org/10.5753/cibse.2026.42458
Silva, Wilamis Kleiton Nunes da, Rafael Batista Duarte, and Bernan Rodrigues Nascimento. 2026. “Classifier Ensembles for Software Development Team Effort Estimation: A Rapid Systematic Literature Review.” In Anais do XXIX Congresso Ibero-Americano em Engenharia de Software (CIbSE 2026). Sociedade Brasileira de Computação. https://doi.org/10.5753/cibse.2026.42453
Silvester, Carly. 2021. “Planning Fallacy.” In Decision Making in Emergency Medicine. Springer Singapore. https://doi.org/10.1007/978-981-16-0143-9_43
Simanovsky, A. A. 2008. “Data Schema Evolution Support in XML-Relational Database Systems.” Programming and Computer Software 34 (1): 16–26. https://doi.org/10.1134/s0361768808010039
Simbolon, Emerson C. 2013. “Behavior Engineering Methodology Enhancement to Support Code Generation.” International Journal of Modeling and Optimization: 523–28. https://doi.org/10.7763/ijmo.2013.v3.334
Simons, Barbara. 1989. “Parallelism, Compiler Optimization, and Deterministic Scheduling Theory.” In Opportunities and Constraints of Parallel Computing. Springer US. https://doi.org/10.1007/978-1-4613-9668-0_33
“A Simple Compiler.” 1997. In AMAST Series in Computing. WORLD SCIENTIFIC. https://doi.org/10.1142/9789812830685_0004
“The Simple Type System.” 1998. In Theories of Programming Languages. Cambridge University Press. https://doi.org/10.1017/cbo9780511626364.016
Singal, Prerna, Prabha Sharma, and A. Charan Kumari Charan Kumari. 2024. “Integrated Software Effort Estimation: A Hybrid Approach.” Informatica 48 (3). https://doi.org/10.31449/inf.v48i3.4515
Singal, Prerna, Prabha Sharma, and A. Charan Kumari. 2026. “Optimizing Risk Integrated Software Effort Estimation: A Differential Evolution Approach.” In Springer Proceedings in Mathematics & Statistics. Springer Nature Singapore. https://doi.org/10.1007/978-981-95-3596-5_18
Singer, Jeremy, Richard E. Jones, Gavin Brown, and Mikel Luján. 2010. “The Economics of Garbage Collection.” In Proceedings of the 2010 international symposium on Memory management. ACM. https://doi.org/10.1145/1806651.1806669
Singh, Shweta P. K. 2024. “MFGC: Minimal First Garbage Collection for Monitoring of Context-Aware Victim Selection.” Journal of Electrical Systems 20 (1s): 547–57. https://doi.org/10.52783/jes.802
Singh, Rachna, and Gunjan Gupta. 2025. “High-Level Area Estimation Model for FPGA-Based Designs Using LLVM.” International Journal on Smart Sensing and Intelligent Systems 18 (1): 20250042. https://doi.org/10.2478/ijssis-2025-0042
Singh, A. J., and Mukesh Kumar. 2020. “Comparative Analysis on Prediction of Software Effort Estimation Using Machine Learning Techniques.” Preprint, . https://doi.org/10.2139/ssrn.3565822
Singh, Bijendra, Ankit Kumar, and Dheeraj Kumar Sahni. 2021. “Investigating the Need of Hybrid Integration of ERNN and BMO in Software Testing Effort Estimation.” In Algorithms for Intelligent Systems. Springer Singapore. https://doi.org/10.1007/978-981-16-1048-6_26
Singh, Gagandeep, Jacob Laurel, Sasa Misailovic, et al. 2025. “Safety and Trust in Artificial Intelligence with Abstract Interpretation.” Foundations and Trends® in Programming Languages 8 (3–4): 250–408. https://doi.org/10.1561/2500000062
Singh, Sandeepak, Harishita Rana, and Tarang Sharma. 2026. “Effort and Cost Estimation in Agile Software Development.” Preprint, . https://doi.org/10.2139/ssrn.6127067
Singh, Brajesh Kumar, Shailesh Tiwari, K. K. Mishra, and A. K. Misra. 2013. “Tuning of Cost Drivers by Significance Occurrences and Their Calibration with Novel Software Effort Estimation Method.” Advances in Software Engineering 2013: 1–10. https://doi.org/10.1155/2013/351913
Singha, Ananya, Bhavya Chopra, Anirudh Khatry, et al. 2024. “Semantically Aligned Question and Code Generation for Automated Insight Generation.” In Proceedings of the 1st International Workshop on Large Language Models for Code. ACM. https://doi.org/10.1145/3643795.3648381
“Single Static Assignment Form as Intermediate Representation.” 2009. In Data Flow Analysis. CRC Press. https://doi.org/10.1201/9780849332517.ch6
“Single Static Assignment Form as Intermediate Representation.” 2017. In Data Flow Analysis. CRC Press. https://doi.org/10.1201/9780849332517-7
Sinha, Ripu Ranjan, and Rajani Kumari Gora. 2020. “Software Effort Estimation Using Machine Learning Techniques.” In Lecture Notes in Networks and Systems. Springer Singapore. https://doi.org/10.1007/978-981-15-5421-6_8
Sinha, Puja, Priyanka Srivastava, and Sumeet Kumar. 2019. “Software Development Effort Estimation Using Soft Computing Methods.” International Journal of Computer Engineering and Technology 10 (5). https://doi.org/10.34218/ijcet.10.5.2019.001
Sinhal, Amit, and Bhupendra Verma. 2013. “A Novel Fuzzy Based Approach for Effort Estimation in Software Development.” ACM SIGSOFT Software Engineering Notes 38 (5): 1–6. https://doi.org/10.1145/2507288.2507313
Sison, Robert, and Toby Murray. 2021. “Verified Secure Compilation for Mixed-Sensitivity Concurrent Programs.” Journal of Functional Programming 31: e18. https://doi.org/10.1017/s0956796821000162
SjÃ¶lund, Martin, Peter Fritzson, and Adrian Pop. 2014. “Bootstrapping a Compiler for an Equation-Based Object-Oriented Language.” Modeling, Identification and Control: A Norwegian Research Bulletin 35 (1): 1–19. https://doi.org/10.4173/mic.2014.1.1
Skakkebaek, Jens U., Robert B. Jones, and David L. Dill. 1998. Formal Verification of out-of-Order Execution Using Incremental Flushing. Defense Technical Information Center. https://doi.org/10.21236/ada400401
Skhiri, Afef. 2022. “Conflict of Interest in Scientific Research.” (IJRE) International Journal of Research and Ethics (ISSN 2665-7481) 5 (1). https://doi.org/10.51766/ijre.v5i1.112
Skruch, Paweł, Marek Długosz, and Wojciech Mitkowski. 2017. “Improving the Success Rate of Student Software Projects through Developing Effort Estimation Practices.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-319-60699-6_83
Skut, Wojciech, Stefan Ulrich, and Kathrine Hammervold. 2004. “A Flexible Rule Compiler for Speech Synthesis.” In Intelligent Information Processing and Web Mining. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-540-39985-8_27
Skvortsov, Leonid Vladlenovich, Roman Vyacheslavovich Baev, Ksenia Yurievna Dolgorukova, and Eugene Yurievich Sharygin. 2021. “Developing an LLVM-Based Compiler for Stack Based TF16 Processor Architecture.” Proceedings of the Institute for System Programming of the RAS 33 (5): 137–54. https://doi.org/10.15514/ispras-2021-33(5)-8
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
“A Small C Compiler: Language, Usage, Theory, and Design.” 1989. Choice Reviews Online 26 (05): 26-2731-26-2731. https://doi.org/10.5860/choice.26-2731
Smith, Randy K., Allen Parrish, and Joanne Hale. 1998. “Cost Estimation for Component Based Software Development.” In Proceedings of the 36th annual Southeast regional conference on - ACM-SE 36. ACM Press. https://doi.org/10.1145/275295.275378
Smoryński, Craig A. 1991. “Stewart Shapiro. Introduction—Intensional Mathematics and Constructive Mathematics. Intensional Mathematics, Edited by Stewart Shapiro, Studies in Logic and the Foundations of Mathematics, Vol. 113, North-Holland, Amsterdam, New York, and Oxford, 1985, Pp. 1–10.: Stewart Shapiro. Epistemic and Intuitionistic Arithmetic. Intensional Mathematics, Edited by Stewart Shapiro, Studies in Logic and the Foundations of Mathematics, Pp. 11–46.: John Myhill. Intensional Set Theory. Intensional Mathematics, Edited by Stewart Shapiro, Studies in Logic and the Foundations of Mathematics, Pp. 47–61.: Nicolas D. Goodman. a Genuinely Intensional Set Theory. Intensional Mathematics, Edited by Stewart Shapiro, Studies in Logic and the Foundations of Mathematics, Pp. 63–79.: Andrej Ščedrov. Extending Godel’s Modal Interpretation to Type Theory and Set Theory. Intensional Mathematics, Edited by Stewart Shapiro, Studies in Logic and the Foundations of Mathematics, Pp. 81–119.: Robert C. Flagg. Church’s Thesis Is Consistent with Epistemic Arithmetic. Intensional Mathematics, Edited by Stewart Shapiro, Studies in Logic and the Foundations of Mathematics, Pp. 121–172.” Journal of Symbolic Logic 56 (4): 1496–99. https://doi.org/10.2307/2275497
Snavely, Allan. 2011. Test and Evaluation of Architecture-Aware Compiler Environment. Defense Technical Information Center. https://doi.org/10.21236/ada563246
Sneed, Harry M. 2003. “Software Maintenance Cost Estimation.” In Advances in Software Maintenance Management. IGI Global. https://doi.org/10.4018/978-1-59140-047-9.ch008
Snyder, Alan. 1975. A Portable Compiler for the Language C. Defense Technical Information Center. https://doi.org/10.21236/ada010218
So, Byoungro, Pedro C. Diniz, and Mary W. Hall. 2003. “Using Estimates from Behavioral Synthesis Tools in Compiler-Directed Design Space Exploration.” In Proceedings of the 40th conference on Design automation - DAC ‘03. ACM Press. https://doi.org/10.1145/775959.775963
Soares, Edson, Matheus Paixao, and Allysson Allex Araújo. 2024. “MicroSensor: Towards an Extensible Tool for the Static Analysis of Microservices Systems in Continuous Integration.” In Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3663529.3663874
Sobalvarro, Patrick. 1988. A Lifetime-Based Garbage Collector for LISP Systems on General-Purpose Computers. Defense Technical Information Center. https://doi.org/10.21236/ada290169
“A Social Cost Benefit Analysis of “Door to Door Garbage Collection Project”.” 2021. Journal of Contemporary Issues in Business and Government 27 (02). https://doi.org/10.47750/cibg.2021.27.02.185
“Software Development Effort Estimation for Testing Data Analysis.” 2004. KIPS Transactions:PartD 11D (1): 173–82. https://doi.org/10.3745/kipstd.2004.11d.1.173
“Software Development Effort Estimation Using Ensemble Machine Learning.” 2017. International Journal of Computing, Communication and Instrumentation Engineering 4 (1). https://doi.org/10.15242/ijccie.e0317026
“Software Effort Estimation with Metaheuristic Optimized Ensemble for Software Crowdsourcing.” 2023. In Proceedings of the 16th International Conference Information Systems 2023. IADIS Press. https://doi.org/10.33965/is2023_202301l019
“Software Project Eort and Cost Estimation.” 2016. In Software Project Management. Auerbach Publications. https://doi.org/10.1201/b11362-6
Solan, Brian, Gregory Stern, and Michael Pilone. 2002. RASE: Run-Time Automated Schema Evolution: An Implementation of Schema Evolution and Mapping. Defense Technical Information Center. https://doi.org/10.21236/ada401128
Solhjell, Randi. 2019. “Garbage Collection in Bukavu: “The Political Class Does Not Take Care of Garbage Here”.” In Negotiating Public Services in the Congo. Zed Books Ltd. https://doi.org/10.5040/9781350221482.ch-008
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, 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
Son, JeongWook, and Eddy M. Rojas. 2011. “Impact of Optimism Bias Regarding Organizational Dynamics on Project Planning and Control.” Journal of Construction Engineering and Management 137 (2): 147–57. https://doi.org/10.1061/(asce)co.1943-7862.0000260
Song, Sanghoun. 2018. “Phraseological Analysis of Learner Corpus Based on Language Model.” Language and Information 22 (1): 123–52. https://doi.org/10.29403/li.22.1.6
Song, Liyan, Leandro L. Minku, and Xin Yao. 2013. “The Impact of Parameter Tuning on Software Effort Estimation Using Learning Machines.” In Proceedings of the 9th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2499393.2499394
Song, Liyan, Leandro L. Minku, and Xin Yao. 2014. “The Potential Benefit of Relevance Vector Machine to Software Effort Estimation.” In Proceedings of the 10th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2639490.2639510
Song, Liyan, Leandro L. Minku, and Xin Yao. 2018. “A Novel Automated Approach for Software Effort Estimation Based on Data Augmentation.” 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.3236052
Song, Huaiming, Yanlong Yin, Yong Chen, and Xian-He Sun. 2011. “A Cost-Intelligent Application-Specific Data Layout Scheme for Parallel File Systems.” In Proceedings of the 20th international symposium on High performance distributed computing. ACM. https://doi.org/10.1145/1996130.1996138
Sorokin, Maksim, Dmitry Zhdanov, Andrei Zhdanov, and Igor Potemin. 2023. “Joint Layout, Object Pose, and Mesh Reconstruction Method from Scanned Point Clouds with Restoration of Missing Points.” In Optoelectronic Imaging and Multimedia Technology X, edited by Qionghai Dai, Tsutomu Shimura, Zhenrong Zheng. SPIE. https://doi.org/10.1117/12.2687671
Soto, Ciroa., and Alejandro R. DÍAz. 1993. “A Model for Layout Optimization of Plate Structures.” In Optimal Design with Advanced Materials. Elsevier. https://doi.org/10.1016/b978-0-444-89869-2.50028-7
Soule, Paul. 2010. “The RemoteJ Compiler/Generator Implementation.” In Autonomics Development: A Domain-Specific Aspect Language Approach. Springer Basel. https://doi.org/10.1007/978-3-0346-0540-3_5
“Space Launch Vehicle Structures and Layout.” 2022. In Design of Rockets and Space Launch Vehicles, Second Edition. American Institute of Aeronautics and Astronautics, Inc. https://doi.org/10.2514/5.9781624106422.0407.0462
Spasojević, Boris, Mircea Lungu, and Oscar Nierstrasz. 2014. “Mining the Ecosystem to Improve Type Inference for Dynamically Typed Languages.” In Proceedings of the 2014 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming & Software. ACM. https://doi.org/10.1145/2661136.2661141
Späth, Peter. 2019. “About Type Safety: Generics.” In Learn Kotlin for Android Development. Apress. https://doi.org/10.1007/978-1-4842-4467-8_13
Späth, Peter. 2023. “Garbage Collection.” In Pro Jakarta EE 10. Apress. https://doi.org/10.1007/978-1-4842-8214-4_37
Speight, Samuel L. 2024. “Groupoidal Realizability for Intensional Type Theory.” Mathematical Structures in Computer Science 34 (9): 911–44. https://doi.org/10.1017/s0960129524000343
Spoladore, Izabella P. B., Stella A. D. Sampaio, Carolina Barreto, Rafael M. D. Rosa, Gustavo R. Gondran, and Antonio M. Barreto Neto. 2024. “Evaluation of Subsea Production System in Deepwater Oil Fields Using Alfasim: Definition of Base Layout and Flow Analysis.” In Anais do 12º PdPetro. Associação Brasileira de Pesquisa e Desenvolvimento em Petróleo e Gás. https://doi.org/10.71190/2024-12-1224053
Sree, Sripada Rama, and Chatla Prasada Rao. 2020. “A Study on Application of Soft Computing Techniques for Software Effort Estimation.” In Intelligent Systems Reference Library. Springer International Publishing. https://doi.org/10.1007/978-3-030-40928-9_8
Sreeram, Jaswanth, and Santosh Pande. 2012. “Safe Compiler-Driven Transaction Checkpointing and Recovery.” In Proceedings of the ACM international conference on Object oriented programming systems languages and applications. ACM. https://doi.org/10.1145/2384616.2384620
Sridhar, S. 2011. “Extended Angel: Knowledge-Based Approach for Loc and Effort Estimation for Multimedia Projects in Medical Domain.” International Journal of Software Engineering & Applications 2 (4): 97–105. https://doi.org/10.5121/ijsea.2011.2409
Sridhar, Swaroop, and Jonathan S. Shapiro. 2006. “Type Inference for Unboxed Types and First Class Mutability.” In Proceedings of the 3rd workshop on Programming languages and operating systems: linguistic support for modern operating systems. ACM. https://doi.org/10.1145/1215995.1216002
Srikant, Y. 2002. “Scalar Compiler Optimizations on the Static Single Assignment Form and the Flow Graph.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579.ch3
Srikant, Y., and K. Ananda Vardhan. 2007. “Energy-Aware Compiler Optimizations.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420043839.ch7
Srikanth and P.V. Bhaskar Reddy. 2022. “Machine Learning-Based Software Effort Estimation of Suggestive Agile and Scrumban Methodologies.” International Journal For Multidisciplinary Research 4 (5): 865. https://doi.org/10.36948/ijfmr.2022.v04i05.865
Srikanth, B. V., P. V. Bhaskar Reddy, and D. B. K. Kamesh. 2023. “Machine Learning Based Software Effort Estimation of Suggestive Agile and Scrumban Methodologies.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-27524-1_48
Srisa-an, Witawas, and Mulyadi Oey. 2005. “Remote Objects: The Next Garbage Collection Challenge.” Journal of Object Technology 4 (4): 155. https://doi.org/10.5381/jot.2005.4.4.a4
Stambach, Amy. 2019. “Ethnology Unboxed: The Making of Culture through Its Performative (Un)doing.” Ethnologies 40 (2): 111–29. https://doi.org/10.7202/1056386ar
Stanek, Marlena, and and Beata Czarnacka-Chrobot. 2023. “Use of Artificial Neural Networks and Decision Trees for Cost Estimation of Software Projects – a Model Proposal.” In Analytics in Finance and Risk Management. CRC Press. https://doi.org/10.1201/9780367854690-5
Stärk, Robert F., Joachim Schmid, and Egon Börger. 2001a. “Bytecode Type Assignments.” In Java and the Java Virtual Machine. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-59495-3_16
Stärk, Robert F., Joachim Schmid, and Egon Börger. 2001b. “Correctness of the Compiler.” In Java and the Java Virtual Machine. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-59495-3_14
“A Static Analysis for Classical Linear Logic Programming Language.” 1999. In Logic Programming. The MIT Press. https://doi.org/10.7551/mitpress/4304.003.0055
Staunstrup, Jørgen. 1994. “Formal Verification.” In A Formal Approach to Hardware Design. Springer US. https://doi.org/10.1007/978-1-4615-2764-0_3
Steil Jr. and Gilbert P. 1968. Using the Readily Available Algebraic Language as a Compiler Environment. Defense Technical Information Center. https://doi.org/10.21236/ad0669092
Steiner, Edwin, Andreas Krall, and Christian Thalinger. 2007. “Adaptive Inlining and on-Stack Replacement in the CACAO Virtual Machine.” In Proceedings of the 5th international symposium on Principles and practice of programming in Java - PPPJ ‘07. ACM Press. https://doi.org/10.1145/1294325.1294356
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
Stepney, Susan, Dave Whitley, David Cooper, and Colin Grant. 1991. “A Demonstrably Correct Compiler.” Formal Aspects of Computing 3 (1): 58–101. https://doi.org/10.1007/bf01211435
Stoltzfus, Larisa, Murali Emani, Pei-Hung Lin, and Chunhua Liao. 2018. “Data Placement Optimization in GPU Memory Hierarchy Using Predictive Modeling.” In Proceedings of the Workshop on Memory Centric High Performance Computing. ACM. https://doi.org/10.1145/3286475.3286482
Stoonkisto, Peter, and Jaspal Subhlok. 1997. Coordinating Foreign Modules with a Parallelizing Compiler. Defense Technical Information Center. https://doi.org/10.21236/ada327279
Storm, Mark W., and Jim A. Polk. 1976. “Usage of an XPL Based Compiler Generator System.” In Proceedings of the 14th annual Southeast regional conference on - ACM-SE 14. ACM Press. https://doi.org/10.1145/503562.503567
Stoy, Christian, and Sara Bender. 2021. “Process Gaps of Model-Based Construction Cost Estimation from Selected Constellation of Actors.” In 28th Annual European Real Estate Society Conference. European Real Estate Society. https://doi.org/10.15396/eres2021_191
Strach, Patricia, and Kathleen S. Sullivan. 2023a. “Getting and Keeping Garbage Collection: Municipal Reliance on Racial Hierarchy.” In The Politics of Trash. Cornell University Press. https://doi.org/10.7591/cornell/9781501766985.003.0007
Strach, Patricia, and Kathleen S. Sullivan. 2023b. “The Politics of Garbage Collection: Lessons Learned.” In The Politics of Trash. Cornell University Press. https://doi.org/10.7591/cornell/9781501766985.003.0008
Strandh, Robert. 2014. “An Improvement to Sliding Garbage Collection.” In Proceedings of ILC 2014 on 8th International Lisp Conference. ACM. https://doi.org/10.1145/2635648.2635655
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
Streicher, Thomas. 2015. “How Intensional Is Homotopy Type Theory?” In Trends in Mathematics. Springer International Publishing. https://doi.org/10.1007/978-3-319-21284-5_20
Struska, Zdenek, Jirí Vanícek, and Martin Závodný. 2011. “Methods for Software Complexity and Development Effort Estimation and Its Importance in the Area of ICT Governance.” In Cases on Adoption, Diffusion and Evaluation of Global E-Governance Systems. IGI Global. https://doi.org/10.4018/978-1-61692-814-8.ch006
Stubbs, Michael. 2001. “On Inference Theories and Code Theories: Corpus Evidence for Semantic Schemas.” Text - Interdisciplinary Journal for the Study of Discourse 21 (3). https://doi.org/10.1515/text.2001.007
“Study of Roadway Layout in the σHV Type in-Situ Stress Field.” 2014. In Green Building, Materials and Civil Engineering. CRC Press. https://doi.org/10.1201/b17568-106
Su, Ruoyu, Matteo Esposito, Davide Taibi, and Valentina Lenarduzzi. 2026. “Running Large Language Models at Scale for Mining Software Repositories: Lessons Learned from HPC-Based Batch Inference.” In Proceedings of the 23rd International Conference on Mining Software Repositories. ACM. https://doi.org/10.1145/3793302.3793383
Su, Xing, Hanzhong Liang, Hao Wu, Ben Niu, Fengyuan Xu, and Sheng Zhong. 2025. “DiSCo: Towards Decompiling EVM Bytecode to Source Code Using Large Language Models.” Proceedings of the ACM on Software Engineering 2 (FSE): 2311–34. https://doi.org/10.1145/3729373
Su, Moon Ting, Teck Chaw Ling, Keat Keong Phang, Chee Sun Liew, and Peck Yen Man. 2007. “Enhanced Software Development Effort and Cost Estimation Using Fuzzy Logic Model.” Malaysian Journal of Computer Science 20 (2): 199–207. https://doi.org/10.22452/mjcs.vol20no2.7
Su, Yunlin, and Song Y. Yan. 2011. “Algebraic Method of Compiler Design.” In Principles of Compilers. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-20835-5_9
“Subjectivity in Causal Connectives: An Empirical Study of Language in Use.” 2002. cogl 12 (3): 247–73. https://doi.org/10.1515/cogl.2002.003
Subrahmanyam, Ramesh. 2002. “Type Systems in Programming Languages.” In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579.ch21
Sudarmaningtyas, Pantjawati, and Rozlina Mohamed. 2021. “A Review Article on Software Effort Estimation in Agile Methodology.” Pertanika Journal of Science and Technology 29 (2). https://doi.org/10.47836/pjst.29.2.08
Sudarmaningtyas, Pantjawati, and Rozlina Mohamed. 2022. “Significant Factors in Agile Software Development of Effort Estimation.” Pertanika Journal of Science and Technology 30 (4): 2851–78. https://doi.org/10.47836/pjst.30.4.30
Suezawa, Takashi. 2000. “Persistent Execution State of a Java Virtual Machine.” In Proceedings of the ACM 2000 conference on Java Grande. ACM. https://doi.org/10.1145/337449.337536
Sugai, Kenta, Hiroshi Hosobe, and Shaoying Liu. 2021. “SMT-Based Theorem Verification for Testing-Based Formal Verification.” In 2021 10th International Conference on Software and Computer Applications. ACM. https://doi.org/10.1145/3457784.3457823
Sui, Yulei, and Jingling Xue. 2016. “SVF: Interprocedural Static Value-Flow Analysis in LLVM.” In Proceedings of the 25th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/2892208.2892235
Sujuan Zhang, Yuekun Ma, Jinghua Bao, and Jun Ma. 2013. “Internet of Things Control System Performance Optimization Based on Zero-Copy.” International Journal of Advancements in Computing Technology 5 (5): 281–88. https://doi.org/10.4156/ijact.vol5.issue5.34
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
Sukumar, Jairam, and Navakanta Bhat. 2015. “A Compiler Based Approach for Design and Analysis of Gyroscopes.” Journal of Computational and Theoretical Nanoscience 12 (11): 4842–48. https://doi.org/10.1166/jctn.2015.4448
Sun, Jinping. 2019. “An Empirical Study of Value-Based Cost-Benefit Analysis of Early Childhood Support Programs.” In Proceedings of the 2019 AERA Annual Meeting. AERA. https://doi.org/10.3102/1430845
Sun, Yu, Lingfeng Bao, and Xiaohu Yang. 2025b. “FIRE: Smart Contract Bytecode Function Identification via Graph-Refined Hybrid Feature Encoding.” In Proceedings of the 16th International Conference on Internetware. ACM. https://doi.org/10.1145/3755881.3755883
Sun, Xian-He, Yong Chen, and Yanlong Yin. 2009. “Data Layout Optimization for Petascale File Systems.” In Proceedings of the 4th Annual Workshop on Petascale Data Storage. ACM. https://doi.org/10.1145/1713072.1713077
Sun, Chengnian, Vu Le, Qirun Zhang, and Zhendong Su. 2016c. “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, Runfeng, and Wenjia Liu. 2025. “Spatial Layout Characteristics of Northern Wei Luoyang: A Spatial Humanities Analysis of the “Record of the Monasteries of Luoyang”.” PLOS One 20 (5): e0320159. https://doi.org/10.1371/journal.pone.0320159
Sundaram, R. 2007. “Image Data Representation for Efficient Optimization of Objective Criterion.” In SPIE Proceedings, vol. 6575, edited by Zia-ur Rahman, Stephen E. Reichenbach, Mark A. Neifeld. SPIE. https://doi.org/10.1117/12.718366
Sung, I-Jui, John A. Stratton, and Wen-Mei W. Hwu. 2010. “Data Layout Transformation Exploiting Memory-Level Parallelism in Structured Grid Many-Core Applications.” In Proceedings of the 19th international conference on Parallel architectures and compilation techniques. ACM. https://doi.org/10.1145/1854273.1854336
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
Suo, Kun, Jia Rao, Hong Jiang, and Witawas Srisa-an. 2018. “Characterizing and Optimizing Hotspot Parallel Garbage Collection on Multicore Systems.” In Proceedings of the Thirteenth EuroSys Conference. ACM. https://doi.org/10.1145/3190508.3190512
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
Suresh Kumar, P., and H. S. Behera. 2019. “Role of Soft Computing Techniques in Software Effort Estimation: An Analytical Study.” In Advances in Intelligent Systems and Computing. Springer Singapore. https://doi.org/10.1007/978-981-13-9042-5_70
Surgen, Olive. 1955. “The Records Section: Space, Location, and Layout.” American Archivist 18 (3): 231–40. https://doi.org/10.17723/aarc.18.3.216305416n95vt48
Suri, P. K., and Pallavi Ranjan. 2012. “Comparative Analysis of Software Effort Estimation Techniques.” International Journal of Computer Applications 48 (21): 12–19. https://doi.org/10.5120/7479-0540
Suwancharoen, Chaturapat, and Worawan Marurngsith. 2015. “Compiler Support for Accelerating C++11 Range-Based Loops on Heterogeneous Systems.” International Journal of Computer and Electrical Engineering 7 (2): 109–17. https://doi.org/10.17706/ijcee.2015.v7.877
Suzumura, Toyotaro, Michiaki Tatsubori, Scott Trent, Akihiko Tozawa, and Tamiya Onodera. 2009. “Highly Scalable Web Applications with Zero-Copy Data Transfer.” In Proceedings of the 18th international conference on World wide web. ACM. https://doi.org/10.1145/1526709.1526833
Swamy, Gitanjali. 2020. “Incremental Methods for Formal Verification and Logic Synthesis.” Preprint, . https://doi.org/10.2139/ssrn.3702088
Swasey, David, Vii Murphy, Crary Tom, Harper Karl, and Robert. 2006. A Separate Compilation Extension to Standard ML (Revised and Expanded). Defense Technical Information Center. https://doi.org/10.21236/ada457137
Sweet, M. 2009. “Australian Research Council Reviews Conflict of Interest Requirements.” BMJ 338 (jun09 1): b2338-b2338. https://doi.org/10.1136/bmj.b2338
Świderski, Michał, and Michał Zieliński. 2019. “Electric Field Tuning of Excitonic Fine-Structure Splitting in Asymmetric InAs/InP Nanowire Quantum Dot Molecules.” Physical Review B 100 (23): 235417. https://doi.org/10.1103/physrevb.100.235417
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 Translation and Intermediate Code Generation.” 2007. In Elements of Compiler Design. Auerbach Publications. https://doi.org/10.1201/9781420063257-9
Syromiatnikov, Mykyta V., and Victoria M. Ruvinskaya. 2025. “UA-Code-Bench: A Competitive Programming Benchmark for Evaluating Large Language Models Code Generation in Ukrainian.” Informatics Culture Technology 2: 308–14. https://doi.org/10.15276/ict.02.2025.47
Szabó, Kevin S. B., and Mohamed I. Elmasry. 1986. “The User Interface and Program Structure of a Graphical VLSI Layout Editor.” In Proceedings of the SIGCHI/GI Conference on Human Factors in Computing Systems and Graphics Interface. ACM. https://doi.org/10.1145/29933.275633
Szafrański, Tomasz, Jerzy Małachowski, and Krzysztof Damaziak. 2018. “Methodology of Shell Structure Reinforcement Layout Optimization.” In AIP Conference Proceedings, vol. 1922. Author(s). https://doi.org/10.1063/1.5019125
“T4 Code Generation.” 2010. In Pro Entity Framework 4.0. Apress. https://doi.org/10.1007/978-1-4302-0647-7_8
Tachibana, Kanta, and Ryuta Fukazawa. 2016. “Effect of an Ensemble Algorithm in Reinforcement Learning for Garbage-Collection Sailing.” In Robotic Sailing 2016. Springer International Publishing. https://doi.org/10.1007/978-3-319-45453-5_7
Taft, S. Tucker. 1982. “Diana as an Internal Representation in an Ada-in-Ada Compiler.” In Proceedings of the AdaTEC Conference on Ada. ACM. https://doi.org/10.1145/3304133.3304168
Taft, Tucker. 2020. “SPARK Formal Verification for Security.” ACM SIGAda Ada Letters 39 (1): 83–99. https://doi.org/10.1145/3379106.3379117
Tagliabue, Jacopo, Tyler Caraza-Harter, and Ciro Greco. 2024. “Bauplan: Zero-Copy, Scale-up FaaS for Data Pipelines.” In Proceedings of the 10th International Workshop on Serverless Computing. ACM. https://doi.org/10.1145/3702634.3702955
Takamichi, Shinnosuke, and Hiroshi Saruwatari. 2018. “CPJD Corpus: Crowdsourced Parallel Speech Corpus of Japanese Dialects.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/23papnq84qja
Takamizawa, Hidehisa, Kazuyuki Nakajima, and Masayoshi Aritsugi. 2006. “Array-Based Cache Conscious Trees.” IPSJ Digital Courier 2: 25–38. https://doi.org/10.2197/ipsjdc.2.25
Takezawa, Akihiro, Kanjuro Makihara, Nozomu Kogiso, and Mitsuru Kitamura. 2012. “CO-JP-1 Ground Structure Approach for PZT Layout Optimization in Semi-Active Vibration Control Systems of Space Structures.” Proceedings of Mechanical Engineering Congress, Japan 2012 (0): _CO-JP-1-1-_CO-JP-1-1. https://doi.org/10.1299/jsmemecj.2012._co-jp-1-1
Takizawa, Hiroyuki, Takeshi Yamada, Shoichi Hirasawa, and Reiji Suda. 2016. “A Use Case of a Code Transformation Rule Generator for Data Layout Optimization.” In Sustained Simulation Performance 2016. Springer International Publishing. https://doi.org/10.1007/978-3-319-46735-1_3
Takkalapally, DevenderRao, and Mahender Rao Takkellapally. 2023. “GC-TuneHFT: AI-Based Garbage Collection Optimization in High-Frequency Trading Environments.” American International Journal of Computer Science and Technology 5: 25–37. https://doi.org/10.63282/3117-5481/aijcst-v5i6p103
Tamura, Y., H. Sone, and S. Yamada. 2019. “Stochastic Effort Estimation for Open Source Projects.” In Recent Advancements in Software Reliability Assurance. CRC Press. https://doi.org/10.1201/9780429431630-2
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
Tandon, Pranay, Ugrasen Suman, and Maya Rathore. 2022. “A Systematic Literature Review on Effort Estimation in Agile Software Development Using Machine Learning Techniques.” International Journal of Computer Applications 184 (21): 15–23. https://doi.org/10.5120/ijca2022922238
Tang, Yufeng, Zheng Gong, Liangju Zhao, Di Li, and Zhe Liu. 2024. “Unboxing ARX-Based White-Box Ciphers: Chosen-Plaintext Computation Analysis and Its Applications.” IACR Transactions on Cryptographic Hardware and Embedded Systems 2024 (3): 634–70. https://doi.org/10.46586/tches.v2024.i3.634-670
Tang, Xun, Xin Jin, and Tao Yang. 2014. “Cache-Conscious Runtime Optimization for Ranking Ensembles.” In Proceedings of the 37th international ACM SIGIR conference on Research & development in information retrieval. ACM. https://doi.org/10.1145/2600428.2609525
Tang, Steven H., and Mark A. Linton. 1994. “Blending Structured Graphics and Layout.” In Proceedings of the 7th annual ACM symposium on User interface software and technology - UIST ‘94. ACM Press. https://doi.org/10.1145/192426.192493
Tanone, Jonathan, and Senny Harindahyani. 2018. “The Impact of Heuristics and Biases in the Application of Professional Judgement by Internal Auditors in the Stage of Fieldwork.” In Proceedings of the 15th International Symposium on Management (INSYMA 2018). Atlantis Press. https://doi.org/10.2991/insyma-18.2018.27
Tanveer, Binish, Liliana Guzmán, and Ulf Martin Engel. 2016. “Understanding and Improving Effort Estimation in Agile Software Development: An Industrial Case Study.” In Proceedings of the International Conference on Software and Systems Process. ACM. https://doi.org/10.1145/2904354.2904373
Tanveer, Binish, Anna Maria Vollmer, and Stefan Braun. 2018. “A Hybrid Methodology for Effort Estimation in Agile Development: An Industrial Evaluation.” In Proceedings of the 2018 International Conference on Software and System Process. ACM. https://doi.org/10.1145/3202710.3203152
Taranov, Konstantin, Steve Byan, Virendra Marathe, and Torsten Hoefler. 2022. “KafkaDirect: Zero-Copy Data Access for Apache Kafka over RDMA Networks.” In Proceedings of the 2022 International Conference on Management of Data. ACM. https://doi.org/10.1145/3514221.3526056
Tartara, Michele, Simone Campanoni, Giovanni Agosta, and Stefano Crespi Reghizzi. 2009. “Just-In-Time Compilation on ARM Processors.” In Proceedings of the 4th workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages and Programming Systems. ACM. https://doi.org/10.1145/1565824.1565834
Tasleem Mustafa and Kiran Ahsan. 2017. “Computing Based Effort Estimation in Software Development of Global Project.” International Journal of Computer and organization Trends 40 (1): 1–10. https://doi.org/10.14445/22492593/ijcot-v40p301
Tatikonda, Pruthvi. 2025. “The Evolution of Data Storage: Understanding the Impact of Columnar Formats on Enterprise Analytics.” International Journal of Information Technology and Management Information Systems 16 (1): 531–44. https://doi.org/10.34218/ijitmis_16_01_038
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
Teitelbaum, Tim. 2004. Programmable Interfaces for Advanced Static Analysis. Defense Technical Information Center. https://doi.org/10.21236/ada426890
“Television Unboxed: Expansion, Overflow, and Synergy.” 2009. In Television Entertainment. Routledge. https://doi.org/10.4324/9780203869017-9
Temte, Mark C. 1992. “A Compiler Construction Project for an Object-Oriented Language.” ACM SIGCSE Bulletin 24 (1): 138–41. https://doi.org/10.1145/135250.134538
Tenfjord, Kari, Paul Meurer, and Knut Hofland. 2006. “The ASK Corpus: A Language Learner Corpus of Norwegian as a Second Language.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/4uhdtbhi6d2g
Teng, Yuexiao. 2020. “A Survey of Mining Software Repositories in Social Network.” Journal of Software: 62–67. https://doi.org/10.17706/jsw.15.2.62-67
Teng, X., H. Yu, and X. Jiang. 2023. “Dynamic Layout Optimization of Stiffeners in Plate Structures Based on Power Flow Response.” In Inter-Noise 2022. Institute of Acoustics. https://doi.org/10.25144/15071
Teodoriu, Catalin, and Saeed Salehi. 2019. “How Heuristics and Biases Impact Judgment and Decision Making in Well Integrity Operations.” In Volume 8: Polar and Arctic Sciences and Technology; Petroleum Technology. American Society of Mechanical Engineers. https://doi.org/10.1115/omae2019-96820
Tereszkiewicz, Anna. 2023. “The language of English and Polish corporate tweets – a corpus analysis.” Kwartalnik Neofilologiczny. https://doi.org/10.24425/kn.2019.126503
Teufel, Bernd, Stephanie Schmidt, and Thomas Teufel. 1993a. “Code Generation and Optimization.” In C2 Compiler Concepts. Springer Vienna. https://doi.org/10.1007/978-3-7091-9274-0_7
Teufel, Bernd, Stephanie Schmidt, and Thomas Teufel. 1993b. “General Remarks on Compiler Theory.” In C2 Compiler Concepts. Springer Vienna. https://doi.org/10.1007/978-3-7091-9274-0_1
“Text to Pseudo Code Generation.” 2023. International Research Journal of Modernization in Engineering Technology and Science. https://doi.org/10.56726/irjmets45500
Tezcan, Mediha. 2013. “Cost Estimation in E-Learning Design Project Management.” In Project Management Approaches for Online Learning Design. IGI Global. https://doi.org/10.4018/978-1-4666-2830-4.ch012
Thakur, Chandan. 2014. “An Empirical Study of Attitude toward Cause Related Marketing Programs among Young Indian Consumers.” Indian Journal of Marketing 44 (9): 20. https://doi.org/10.17010/ijom/2014/v44/i9/80120
Thakurta, Dipto, and Bhargav Korrapati. 2026. “Methodologies for Advanced BEOL Test Structure Design and Synthetic Layout Pattern Generation for Sub-2nm Nodes.” In DTCO and Computational Patterning V, edited by Kevin Lucas, Harsha Grunes. SPIE. https://doi.org/10.1117/12.3093820
Thamarai, I., and S. Murugavalli. 2016a. “Competitive Advantage of Using Differential Evolution Algorithm for Software Effort Estimation.” In Communication and Power Engineering. De Gruyter. https://doi.org/10.1515/9783110469608-007
Thamarai, I., and S. Murugavalli. 2016b. “An Evolutionary Computation Approach for Project Selection in Analogy Based Software Effort Estimation.” Indian Journal of Science and Technology 9 (21). https://doi.org/10.17485/ijst/2016/v9i21/95286
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
Thanh-Hoang, Tung, Amirali Shambayati, and Andrew A. Chien. 2016. “A Data Layout Transformation (DLT) Accelerator: Architectural Support for Data Movement Optimization in Accelerated-Centric Heterogeneous Systems.” In Proceedings of the 2016 Design, Automation & Test in Europe Conference & Exhibition (DATE). Research Publishing Services. https://doi.org/10.3850/9783981537079_0906
Thees, Joachim, and Reinhard Gotzhein. 1998. “The Experimental Estelle Compiler: Automatic Generation of Implementations from Formal Specifications.” In Proceedings of the second workshop on Formal methods in software practice - FMSP ‘98. ACM Press. https://doi.org/10.1145/298595.298858
Thenmozhi, M., and K. Vivekanandan. 2014. “An Ontological Approach to Handle Multidimensional Schema Evolution for Data Warehouse.” International Journal of Database Management Systems 6 (3): 33–52. https://doi.org/10.5121/ijdms.2014.6303
Thiemann, Peter J. 1995. “Unboxed Values and Polymorphic Typing Revisited.” In Proceedings of the seventh international conference on Functional programming languages and computer architecture - FPCA ‘95. ACM Press. https://doi.org/10.1145/224164.224175
Thier, Patrick, M. Anton Ertl, and Andreas Krall. 2018. “Fast and Flexible Instruction Selection with Constraints.” In Proceedings of the 27th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3178372.3179501
Thiyagarajan, M., and N. Sairam. 2007. “Verification of the Correctness of Compiler Optimization Using Co-Induction.” Journal of Discrete Mathematical Sciences and Cryptography 10 (3): 329–49. https://doi.org/10.1080/09720529.2007.10698123
Thoman, Peter, Peter Zangerl, and Thomas Fahringer. 2017. “Task-Parallel Runtime System Optimization Using Static Compiler Analysis.” In Proceedings of the Computing Frontiers Conference. ACM. https://doi.org/10.1145/3075564.3075574
Thomas, Stephen W. 2011. “Mining Software Repositories Using Topic Models.” In Proceedings of the 33rd International Conference on Software Engineering. ACM. https://doi.org/10.1145/1985793.1986020
Thomas, G., F. Ogel, A. Galland, B. Folliot, and I. Piumarta. 2005. “Building a Flexible Java Runtime upon a Flexible Compiler.” International Journal of Computers and Applications 27 (1). https://doi.org/10.2316/journal.202.2005.1.202-1433
Thompson, Emma, Nason Maani, and Jeff Collin. 2025. ““This Supposed Conflict of Interest”: Analysis of Industry Framings of Partnership and Conflict of Interest in WHO Public Consultations on Alcohol Policy.” Journal of Studies on Alcohol and Drugs: jsad.25-00048. https://doi.org/10.15288/jsad.25-00048
Thorlin, J. F. 1967. “Code Generation for PIE (Parallel Instruction Execution) Computers.” In Proceedings of the April 18-20, 1967, spring joint computer conference on - AFIPS ‘67 (Spring). ACM Press. https://doi.org/10.1145/1465482.1465585
Thushara, Mg, and K. Somasundaram. 2019. “Static Analysis on Floating-Point Programs Dealing with Division Operations.” International Journal of Advanced Computer Science and Applications 10 (10). https://doi.org/10.14569/ijacsa.2019.0101058
Tian, Huan Huan, Wei Ping Hu, and Gui Yang Yao. 2011. “The Enlightenment of Space Layout of Dali Bai Local-Style Dwelling Houses Building for the New Rural Construction Layout.” Advanced Materials Research 374-377: 1694–97. https://doi.org/10.4028/www.scientific.net/amr.374-377.1694
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
Tibbetts, Janice. 2013. “Garbage Collection Is “One of the Most Hazardous Jobs”.” Canadian Medical Association Journal 185 (7): E284-E284. https://doi.org/10.1503/cmaj.109-4434
Tichadou, Florent Bouchez, and Fabrice Rastello. 2021. “Register Allocation.” In SSA-based Compiler Design. Springer International Publishing. https://doi.org/10.1007/978-3-030-80515-9_22
Tiganov, Daniil, Jeff Cho, Karim Ali, and Julian Dolby. 2020. “SWAN: A Static Analysis Framework for Swift.” 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.3417924
Timbermont, Stijn, Bram Adams, and Michael Haupt. 2008. “Towards a DSAL for Object Layout in Virtual Machines.” In Proceedings of the 2008 AOSD workshop on Domain-specific aspect languages. ACM. https://doi.org/10.1145/1404927.1404932
Ting, Zhou. 2020. “Study on Hydrodynamic Characteristics of Fluted Floating Garbage Collection Device.” Research & Development in Material Science 13 (1). https://doi.org/10.31031/rdms.2020.13.000801
Ting, Christopher H. A., and Peh Li Shiuan. 1996. “Using a Dependency Structure Parser without Any Grammar Formalism to Analyse a Software Manual Corpus.” In Industrial Parsing of Software Manuals. BRILL. https://doi.org/10.1163/9789004653610_011
Tingchi Liu, Matthew. 2009. “Do Credit Card Redemption Reward Programs Work in China? An Empirical Study.” Journal of Consumer Marketing 26 (6): 403–14. https://doi.org/10.1108/07363760910988229
Tinnefeld, Christian, Alexander Zeier, and Hasso Plattner. 2011. “Cache-Conscious Data Placement in an in-Memory Key-Value Store.” In Proceedings of the 15th Symposium on International Database Engineering & Applications - IDEAS ‘11. ACM Press. https://doi.org/10.1145/2076623.2076640
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
Titov, Alexandr Igorevich. 2016. “Software Development Effort Estimation Using a Neuro Network Approximation Approach.” SPIIRAS Proceedings 1 (44): 20. https://doi.org/10.15622/sp.44.2
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
Titzer, Ben L., and Jens Palsberg. 2007. “Vertical Object Layout and Compression for Fixed Heaps.” In Proceedings of the 2007 international conference on Compilers, architecture, and synthesis for embedded systems. ACM. https://doi.org/10.1145/1289881.1289914
Tiwari, Vikas Kumar. 2025. “Autonomous Garbage Collection Robot.” International Journal for Research in Applied Science and Engineering Technology 13 (1): 279–81. https://doi.org/10.22214/ijraset.2025.66258
Tiwari, Monika, Shefali Parihar, Neha Shrotiya, and Reeti Jaswal. 2026. “Effort Estimation in Software Projects Using Machine Learning Techniques.” In Smart and Distributed Computing. CRC Press. https://doi.org/10.1201/9781042009053-52
“To-Be-Recorded Analysis inside Derivative Code Compiler.” 2011. In International Conference on Software Technology and Engineering, 3rd (ICSTE 2011). ASME Press. https://doi.org/10.1115/1.859797.paper2
Toda, Koji, Akito Monden, and Ken-ichi Matsumoto. 2008. “Fit Data Selection for Software Effort Estimation Models.” In Proceedings of the Second ACM-IEEE international symposium on Empirical software engineering and measurement. ACM. https://doi.org/10.1145/1414004.1414084
Toda, K., A. Monden, and K.-i. Matsumoto. 2010. “Fit Data Selection Based on Project Features for Software Effort Estimation Models.” In Advances in Computer Science and Engineering. ACTAPRESS. https://doi.org/10.2316/p.2010.689-018
Todorov, Vassil, Frédéric Boulanger, and Safouan Taha. 2018. “Formal Verification of Automotive Embedded Software.” In Proceedings of the 6th Conference on Formal Methods in Software Engineering. ACM. https://doi.org/10.1145/3193992.3194003
Tofte, Mads. 1990a. “Compiler Generation, Composability and Self-Composability.” In Compiler Generators. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-61504-7_3
Tofte, Mads. 1990b. “Discussion of Technical Aspects of Compiler Generation.” In Compiler Generators. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-61504-7_4
Tofte, Mads. 1990c. “On Semantics, Compiler Generation, and Hacking.” In Compiler Generators. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-61504-7_5
Tofte, Mads. 1990d. “Report on the Compiler Generator CERES.” In Compiler Generators. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-61504-7_2
Tokarenko, L. D., and A. L. Tokarenko. 2018. “Layout of Plug-in Units of Standard Structural Systems Electronic Equipment.” Radio industry 28 (3): 46–54. https://doi.org/10.21778/2413-9599-2018-28-3-46-54
Toomey, John W. 1996. “Just-in-Time Execution.” In Mrp II. Springer US. https://doi.org/10.1007/978-1-4615-4117-2_11
“Topology and Layout Optimization of Discrete and Continuum Structures.” 1993. In Structural Optimization: Status And Promise. American Institute of Aeronautics and Astronautics. https://doi.org/10.2514/5.9781600866234.0517.0547
Torrado-Cespón, Milagros. 2020. “Proofreading, the Net and Foreign Language Anxiety in the Use of Apology Formulae in an Online Forum. a Learner Corpus Study 1.” In Corpus Analysis in Different Genres. Routledge. https://doi.org/10.4324/9780367815905-21
Torre, Juan Carlos de la, José Miguel Aragón-Jurado, Javier Jareño, Sébastien Varrette, and Bernabé Dorronsoro. 2022. “Obfuscating LLVM Intermediate Representation Source Code with NSGA-II.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-18409-3_18
Torrini, Paolo, and Reiko Heckel. 2010. “Resource-Bound Quantification for Graph Transformation.” Electronic Proceedings in Theoretical Computer Science 22: 14–25. https://doi.org/10.4204/eptcs.22.2
“ToT for Managing Road Accident and Garbage Collection.” 2017. International Journal of Advance Engineering and Research Development 4 (12). https://doi.org/10.21090/ijaerd.55819
Touati, Herve. 1988. A Prolog Garbage Collector for Aquarius. Defense Technical Information Center. https://doi.org/10.21236/ada619775
Towqir, Sheikh Shadab, Bowen Shen, Muhammad Ali Gulzar, and Na Meng. 2022. “Detecting Build Conflicts in Software Merge for Java Programs via Static Analysis.” In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering. ACM. https://doi.org/10.1145/3551349.3556950
Träff, Jesper Larsson, and Antoine Rougier. 2014. “Zero-Copy, Hierarchical Gather Is Not Possible with MPI Datatypes and Collectives.” In Proceedings of the 21st European MPI Users’ Group Meeting. ACM. https://doi.org/10.1145/2642769.2642772
“Training Structure Types and Layout.” 2013. In Inland Navigation. American Society of Civil Engineers. https://doi.org/10.1061/9780784412534.ch04
Tran, Minh Le Kim, William King, and Harvey Siy. 2023. “Exploring the Potential of Frama-C in IoT Static Analysis.” In Proceedings of the Twenty-fourth International Symposium on Theory, Algorithmic Foundations, and Protocol Design for Mobile Networks and Mobile Computing. ACM. https://doi.org/10.1145/3565287.3617617
Trancón y Widemann, Baltasar. 2008. “A Reference-Counting Garbage Collection Algorithmfor Cyclical Functional Programming.” In Proceedings of the 7th international symposium on Memory management. ACM. https://doi.org/10.1145/1375634.1375645
Trautsch, Alexander. 2024. “Usefulness of Automatic Static Analysis Tools: Evidence from Four Case Studies.” In Ernst Denert Award for Software Engineering 2022. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-44412-8_6
Trendowicz, Adam. 2012. “Why Software Effort Estimation?” In The Fraunhofer IESE Series on Software and Systems Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-30764-5_1
Trendowicz, Adam, and Ross Jeffery. 2013a. “Classification of Effort Estimation Methods.” In Software Project Effort Estimation. Springer International Publishing. https://doi.org/10.1007/978-3-319-03629-8_6
Trendowicz, Adam, and Ross Jeffery. 2013b. “Continuously Improving Effort Estimation.” In Software Project Effort Estimation. Springer International Publishing. https://doi.org/10.1007/978-3-319-03629-8_16
Trendowicz, Adam, and Ross Jeffery. 2013c. “Effort Estimation Best Practices.” In Software Project Effort Estimation. Springer International Publishing. https://doi.org/10.1007/978-3-319-03629-8_17
Trendowicz, Adam, and Ross Jeffery. 2013d. “Principles of Effort and Cost Estimation.” In Software Project Effort Estimation. Springer International Publishing. https://doi.org/10.1007/978-3-319-03629-8_2
Treviño, Teresa. 2021. “Unboxing the Trend: Understanding Why Children Watch Unboxing Videos on YouTube.” Journal of Digital & Social Media Marketing 8 (4): 347. https://doi.org/10.69554/beeu8763
Tripakis, Stavros, Dai Bui, Bert Rodiers, and Edward A. Lee. 2009. Compositionality in Synchronous Data Flow: Modular Code Generation from Hierarchical SDF Graphs. Defense Technical Information Center. https://doi.org/10.21236/ada538756
Tripathi, Akash Kumar, and Atul Gupta. 2014. “A Controlled Experiment to Evaluate the Effectiveness and the Efficiency of Four Static Program Analysis Tools for Java Programs.” In Proceedings of the 18th International Conference on Evaluation and Assessment in Software Engineering. ACM. https://doi.org/10.1145/2601248.2601288
Tripathi, Kshitij, Kunal Kukreja, and Vikas Rastogi. 2022. “Static Analysis of Multi-Metal Usage in Grid Stiffened Structures.” In Advances in Transdisciplinary Engineering. IOS Press. https://doi.org/10.3233/atde220755
Tripney, Brian, Christopher Foley, Richard Gourlay, and John Wilson. 2010. “Efficient Data Representation for XML in Peer-Based Systems.” International Journal of Web Information Systems 6 (2): 132–48. https://doi.org/10.1108/17440081011053122
Troelsen, Andrew. 2001. “Input, Output, and Object Serialization.” In C# and the .NET Platform. Apress. https://doi.org/10.1007/978-1-4302-1141-9_11
Troelsen, Andrew. 2002. “Input, Output, and Object Serialization.” In Visual Basic .NET and the .NET Platform: An Advanced Guide. Apress. https://doi.org/10.1007/978-1-4302-0849-5_12
Troelsen, Andrew. 2003. “Object Serialization and the .NET Remoting Layer.” In C# and the .NET Platform. Apress. https://doi.org/10.1007/978-1-4302-0667-5_12
Troelsen, Andrew. 2007. “Introducing Object Serialization.” In Pro C# 2008 and the .NET 3.5 Platform. Apress. https://doi.org/10.1007/978-1-4302-0422-0_21
Troelsen, Andrew. 2012. “File I/O and Object Serialization.” In Pro C# 5.0 and the .NET 4.5 Framework. Apress. https://doi.org/10.1007/978-1-4302-4234-5_20
Troelsen, Andrew, and Philip Japikse. 2015. “File I/O and Object Serialization.” In C# 6.0 and the .NET 4.6 Framework. Apress. https://doi.org/10.1007/978-1-4842-1332-2_20
Troelsen, Andrew, and Philip Japikse. 2017. “File I/O and Object Serialization.” In Pro C# 7. Apress. https://doi.org/10.1007/978-1-4842-3018-3_20
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
Trune, Dennis R., and Todd T. Sherer. 2001. “Conflict of Interest in Academic Research.” Journal of Commercial Biotechnology 7 (4). https://doi.org/10.5912/jcb398
Tschüter, Ronny, Johannes Ziegenbalg, Bert Wesarg, et al. 2017. “An LLVM Instrumentation Plug-in for Score-P.” In Proceedings of the Fourth Workshop on the LLVM Compiler Infrastructure in HPC. ACM. https://doi.org/10.1145/3148173.3148187
Tsunoda, Masateru, Sousuke Amasaki, and Chris Lokan. 2013a. “How to Treat Timing Information for Software Effort Estimation?” In Proceedings of the 2013 International Conference on Software and System Process. ACM. https://doi.org/10.1145/2486046.2486051
Tunbunheng, V., and H. Amano. 2008. “A Retargetable Compiler Based on Graph Representation for Dynamically Reconfigurable Processor Arrays.” IEICE Transactions on Information and Systems E91-D (11): 2655–65. https://doi.org/10.1093/ietisy/e91-d.11.2655
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
Tversky, Amos, and Daniel Kahneman. 1974. “Judgment under Uncertainty: Heuristics and Biases: Biases in Judgments Reveal Some Heuristics of Thinking under Uncertainty.” Science 185 (4157): 1124–31. https://doi.org/10.1126/science.185.4157.1124
“Type Inference for CLP(FD).” 1997. In Logic Programming. The MIT Press. https://doi.org/10.7551/mitpress/4283.003.0045
“Type Inference for Qualified Types.” 1994. In Qualified Types. Cambridge University Press. https://doi.org/10.1017/cbo9780511663086.004
“Type Layout.” n.d. The Rust Reference. Accessed October 24, 2026. https://doc.rust-lang.org/reference/type-layout.html
“Type Safety.” 2012. In Practical Foundations for Programming Languages. Cambridge University Press. https://doi.org/10.1017/cbo9781139342131.007
“Type Safety.” 2016. In Practical Foundations for Programming Languages. Cambridge University Press. https://doi.org/10.1017/cbo9781316576892.008
“Type Systems and Type Inference.” 2002. In Concepts in Programming Languages. Cambridge University Press. https://doi.org/10.1017/cbo9780511804175.007
“Type Systems in Programming Languages Ramesh Subrahmanyam.” 2002. In The Compiler Design Handbook. CRC Press. https://doi.org/10.1201/9781420040579-25
“TYPE THEORY.” 1993. In Formal Semantics. Cambridge University Press. https://doi.org/10.1017/cbo9781139166317.005
Udzir, Nur Izura, Hamidah Ibrahim, and Sileshi Demesie. 2012. “Finer Garbage Collection in Lindacap.” In Models for Capitalizing on Web Engineering Advancements. IGI Global. https://doi.org/10.4018/978-1-4666-0023-2.ch007
Ugawa, Tomoharu, Hideya Iwasaki, and Taiichi Yuasa. 2010. “Improved Replication-Based Incremental Garbage Collection for Embedded Systems.” In Proceedings of the 2010 international symposium on Memory management. ACM. https://doi.org/10.1145/1806651.1806664
Uma, V., Ramalatha Marimuthu, and Jamey Hicks. 2022. “Formal Verification of a 4 Bit Counter Using Kami Verification Flow.” In AIP Conference Proceedings, vol. 2393. AIP Publishing. https://doi.org/10.1063/5.0074153
“Unboxing Japanese Videogames.” 2025. In Unboxing Japanese Videogames. The MIT Press. https://doi.org/10.7551/mitpress/15321.003.0008
“Unboxing Libby by Steph Cherrywell (Review).” 2025. Bulletin of the Center for Children’s Books 78 (9): 333–333. https://doi.org/10.1353/bcc.2025.a957621
Unser-Schutz, Giancarla. 2011. “Developing a Text-Based Corpus of the Language of Japanese Comics (Manga).” In Corpus-based Studies in Language Use, Language Learning, and Language Documentation. BRILL. https://doi.org/10.1163/9789401206884_012
Urbanek, Tomas, Zdenka Prokopova, Radek Silhavy, and Ales Kuncar. 2016. “Using Analytical Programming for Software Effort Estimation.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-319-33622-0_24
Ureche, Vlad, Eugene Burmako, and Martin Odersky. 2014. “Late Data Layout: Unifying Data Representation Transformations.” In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications. ACM. https://doi.org/10.1145/2660193.2660197
Urhan, Canan. 2024. “Enhancing Semantic Understanding by Bridging Topic Modeling and Thematic Analysis: An Empirical Study on Self-Help Twitter Corpus and in-Depth Interviews.” In Digital Humanities Looking at the World. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-48941-9_5
“Using Static Analysis to Compile Non-Sequential Functional Logic Programs.” 1999. In Logic Programming. The MIT Press. https://doi.org/10.7551/mitpress/4304.003.0059
Usman, Muhammad, Jürgen Börstler, and Kai Petersen. 2017. “An Effort Estimation Taxonomy for Agile Software Development.” International Journal of Software Engineering and Knowledge Engineering 27 (04): 641–74. https://doi.org/10.1142/s0218194017500243
Usman, Muhammad, Emilia Mendes, and Jürgen Börstler. 2015. “Effort Estimation in Agile Software Development: A Survey on the State of the Practice.” In Proceedings of the 19th International Conference on Evaluation and Assessment in Software Engineering. ACM. https://doi.org/10.1145/2745802.2745813
Usman, Muhammad, Emilia Mendes, Francila Weidt, and Ricardo Britto. 2014. “Effort Estimation in Agile Software Development: A Systematic Literature Review.” In Proceedings of the 10th International Conference on Predictive Models in Software Engineering. ACM. https://doi.org/10.1145/2639490.2639503
Utomo, Bagus Wahyu. 2018. “Optimistic Bias in Time and Cost Estimation for Solar Power Plant Project.” Conference SENATIK STT Adisutjipto Yogyakarta 4. https://doi.org/10.28989/senatik.v4i0.223
Vaduva, Janalexandru, Stefan Dascalu, Ioana Culic, Alexandru Radovici, and Razvan Rughinis. 2020. “Vulnerability Analysis Pipeline Using Compiler Based Source to Source Translations and Deep Learning.” In eLearning and Software for Education, vol. 1. University Publishing House. https://doi.org/10.12753/2066-026x-20-084
Vahid Khatibi B. 2011. “A Hybrid Method for Increasing the Accuracy of Software Development Effort Estimation.” Scientific Research and Essays 6 (30). https://doi.org/10.5897/sre11.1736
Valentine, Jeremy. 2024. “Review of Fotiadou (2022): The Language of Employability: A Corpus-Based Analysis of UK University Websites.” Journal of Language and Politics. https://doi.org/10.1075/jlp.24065.val
Valerdi, Ricardo. 2013. “Systems Engineering Cost Estimation with a Parametric Model.” In Industrial Innovation. CRC Press. https://doi.org/10.1201/b15964-19
Valle, Ramon. 2023a. “LLVM CFI Support for Rust.” H2HC Magazine 0 (17): 157–74. https://doi.org/10.47986/17/11
Valle, Ramon. 2023b. “Suporte a LLVM CFI Para Rust.” H2HC Magazine 0 (17): 132–50. https://doi.org/10.47986/17/9
Vallis, Paul, and Jonathan S. Colton. 1995. “A Method of Object Oriented Information Management for Layout Design.” In ASME 1995 15th International Computers in Engineering Conference and the ASME 1995 9th Annual Engineering Database Symposium. American Society of Mechanical Engineers. https://doi.org/10.1115/edm1995-0851
van der Linden, Sophie, Xutong Liu, Andy Zaidman, and Carolin Brandt. 2026. “On the Energy Cost of Static Analysis Precision: An Empirical Study of SpotBugs Effort Levels.” In Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3803437.3805601
Van Hai, Vo, Ho Le Thi Kim Nhung, and Huynh Thai Hoc. 2019. “A Review of Software Effort Estimation by Using Functional Points Analysis.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-31362-3_40
Van Hai, Vo, Ho Le Thi Kim Nhung, and Huynh Thai Hoc. 2021. “Empirical Evidence in Early Stage Software Effort Estimation Using Data Flow Diagram.” In Lecture Notes in Networks and Systems. Springer International Publishing. https://doi.org/10.1007/978-3-030-77442-4_53
Van Hai, Vo, Nguyen Thuong Tin, and Zdenka Prokopova. 2025. “Software Architecture Influence on Software Effort Estimation.” In Lecture Notes in Networks and Systems. Springer Nature Switzerland. https://doi.org/10.1007/978-3-031-94770-4_25
Van Strydonck, Thomas, Frank Piessens, and Dominique Devriese. 2021. “Linear Capabilities for Fully Abstract Compilation of Separation-Logic-Verified Code.” Journal of Functional Programming 31: e6. https://doi.org/10.1017/s0956796821000022
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
Vanoostende, Paul, Etienne Vanzieleghem, Emmanuel Rousseau, Christian Massy, and François Gérard. 2002. “Retargetable Code Generation: Key Issues for Successful Introduction.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_2
Vardanyan, V., V. Ivanishin, S. Asryan, A. Khachatryan, and J. Hakobyan. 2015. “Dynamic Compilation of JavaScript Programs to the Statically Typed LLVM Intermediate Representation.” Proceedings of the Institute for System Programming of the RAS 27 (6): 33–48. https://doi.org/10.15514/ispras-2015-27(6)-3
Varian, L. C., and E. G. Coffman. 1967. “An Empirical Study of the Behavior of Programs in a Paging Environment.” In Proceedings of the ACM symposium on Operating System Principles - SOSP ‘67. ACM Press. https://doi.org/10.1145/800001.811682
Varinder Kaur Attri, Sonam Bhatia. 2015. “Implementing Decision Tree for Software Development Effort Estimation of Software Project.” International Journal of Innovative Research in Computer and Communication Engineering 03 (05): 4021–26. https://doi.org/10.15680/ijircce.2015.0305041
Vassilev, V., M. Vassilev, A. Penev, L. Moneta, and V. Ilieva. 2015. “Clad — Automatic Differentiation Using Clang and LLVM.” Journal of Physics: Conference Series 608: 012055. https://doi.org/10.1088/1742-6596/608/1/012055
Vayadande, Kuldeep, Yogesh Bodhe, Aditya Dharashivkar, et al. 2026. “Comparative Analysis of Quantum Intermediate Representation Generation Methods.” In Advances in Engineering Research. Atlantis Press International BV. https://doi.org/10.2991/978-94-6239-628-9_15
Veenstra, Tonjes. 2000. “Verb Serialization and Object Position.” Linguistics 38 (5). https://doi.org/10.1515/ling.2000.014
Vegdahl, Steven R. 1982. Local Code Generation and Compaction in Optimizing Microcode Compilers. Defense Technical Information Center. https://doi.org/10.21236/ada126026
Vegdahl, S. R. 1985. “The Design of an Interactive Compiler for Optimizing Microprograms.” ACM SIGMICRO Newsletter 16 (4): 129–36. https://doi.org/10.1145/18906.18919
Veiga, Luís, Rodrigo Bruno, and Paulo Ferreira. 2015. “Asynchronous Complete Garbage Collection for Graph Data Stores.” In Proceedings of the 16th Annual Middleware Conference. ACM. https://doi.org/10.1145/2814576.2814813
Veiga, L., and P. Ferreira. 2003. “Complete Distributed Garbage Collection: An Experience with Rotor.” IEE Proceedings - Software 150 (5): 283. https://doi.org/10.1049/ip-sen:20030993
Vela, Mihaela, Anne-Kathrin Schumann, and Andrea Wurm. 2014. “Beyond Linguistic Equivalence. an Empirical Study of Translation Evaluation in a Translation Learner Corpus.” In Proceedings of the EACL 2014 Workshop on Humans and Computer-assisted Translation. Association for Computational Linguistics. https://doi.org/10.3115/v1/w14-0308
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
Venkat, Anand, Manu Shantharam, Mary Hall, and Michelle Mills Strout. 2014. “Non-Affine Extensions to Polyhedral Code Generation.” In Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/2544137.2544141
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
Venturini, Simone. 2022. “From the Vaults: Unboxing Analogue Film Storage.” Le Temps des médias n° 39 (2): 118–40. https://doi.org/10.3917/tdm.039.0118
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
Vesterinen, Petri. 1999. “Issues in Calibrating Effort Estimation Models.” ACM SIGSOFT Software Engineering Notes 24 (3): 63–65. https://doi.org/10.1145/311963.312006
Vicinanza, Steven S., Tridas Mukhopadhyay, and Michael J. Prietula. 1991. “Software-Effort Estimation: An Exploratory Study of Expert Performance.” Information Systems Research 2 (4): 243–62. https://doi.org/10.1287/isre.2.4.243
Viégas, Deracilde Santana da Silva, and Gildevan Nolasco Lopes. 2017. “Garbage Collection in State Maranhão (Brazil).” Journal of Geospatial Modelling 2 (3): 26. https://doi.org/10.22615/2526-1746-jgm-2.3-7930
Viglas, Stratis D. 2013. “Just-in-Time Compilation for SQL Query Processing.” Proceedings of the VLDB Endowment 6 (11): 1190–91. https://doi.org/10.14778/2536222.2536254
Villalobos-Arias, Leonardo, Christian Quesada-López, Alexandra Martínez, and Marcelo Jenkins. 2021a. “Hyper-Parameter Tuning of Classification and Regression Trees for Software Effort Estimation.” In Advances in Intelligent Systems and Computing. Springer International Publishing. https://doi.org/10.1007/978-3-030-72660-7_56
Vinay, K., S. Thushar, Vempalli Surya, and Meena Belwal. 2025. “Comparative Analysis of Parallel Compiler Optimizations: A Survey.” Preprint, . https://doi.org/10.2139/ssrn.5089085
Vinnakota, Santosh. 2024. “Implementing Schema Evolution in Real-Time Analytics Architectures.” International Scientific Journal of Engineering and Management 03 (07): 1–8. https://doi.org/10.55041/isjem02065
Vishwakarma, Priyanshu. 2026. “Enhancing Code Generation in Low-Code Platforms through Systematic Prompt Engineering.” International Journal for Research in Applied Science and Engineering Technology 14 (1): 315–22. https://doi.org/10.22214/ijraset.2026.76796
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
Vitkin, Lev, Susan Dong, Rick Searcy, and Manjunath Bc. 2006. “Effort Estimation in Model-Based Software Development.” In SAE Technical Paper Series, vol. 1. SAE International. https://doi.org/10.4271/2006-01-0309
Voinea, Lucian, and Alexandru Telea. 2006. “Mining Software Repositories with CVSgrab.” In Proceedings of the 2006 international workshop on Mining software repositories. ACM. https://doi.org/10.1145/1137983.1138024
Volk, Martin, and Simon Clematide. 2014. “Detecting Code-Switching in a Multilingual Alpine Heritage Corpus.” In Proceedings of the First Workshop on Computational Approaches to Code Switching. Association for Computational Linguistics. https://doi.org/10.3115/v1/w14-3903
Volk, Martin, Lukas Fischer, Patricia Scheurer, et al. 2022. “Nunc Profana Tractemus. Detecting Code-Switching in a Large Corpus of 16th Century Letters.” In Proceedings of the Language Resources and Evaluation Conference. European Language Resources Association (ELRA). https://doi.org/10.63317/5nvqrsftsr37
Volokh, Sasha, and William G. J. Halfond. 2022. “Static Analysis for Automated Identification of Valid Game Actions during Exploration.” In Proceedings of the 17th International Conference on the Foundations of Digital Games. ACM. https://doi.org/10.1145/3555858.3555898
von Hardenberg, Louisa, and Heinke Heise. 2018. “German Pig Farmers’ Attitudes towards Animal Welfare Programs and Their Willingness to Participate in These Programs: An Empirical Study.” International Journal on Food System Dynamics 9 (3): 289–301. https://doi.org/10.18461/ijfsd.v9i3.937
von Koch, Tobias J. K. Edler, Stanislav Manilov, Christos Vasiladiotis, Murray Cole, and Björn Franke. 2018. “Towards a Compiler Analysis for Parallel Algorithmic Skeletons.” In Proceedings of the 27th International Conference on Compiler Construction. ACM. https://doi.org/10.1145/3178372.3179513
Voronov, Nikolay Andreevich. 2018. “Boxing as Type of Martial Art.” Interactive science, no. 8 (30): 21–23. https://doi.org/10.21661/r-472798
“Vulnerability Detection and Formal Verification Methods of Blockchain Smart Contracts in Supply Chain Finance.” 2026. Socio-Economic Statistics Research. https://doi.org/10.38007/sesr.2026.070201
Wagner, Jens, and Rainer Leupers. 2003. “Compiler Backend Optimizations for Network Processors with Bit Packet Addressing.” In Network Processor Design. Elsevier. https://doi.org/10.1016/b978-155860875-7.50023-5
Waite, William M., and Gerhard Goos. 1984a. “Code Generation.” In Compiler Construction. Springer New York. https://doi.org/10.1007/978-1-4612-5192-7_10
Waite, William M., and Gerhard Goos. 1984b. “Implementing the Compiler.” In Compiler Construction. Springer New York. https://doi.org/10.1007/978-1-4612-5192-7_14
Waite, William M., Assad Jarrahian, Michele H. Jackson, and Amer Diwan. 2006. “Design and Implementation of a Modern Compiler Course.” ACM SIGCSE Bulletin 38 (3): 18–22. https://doi.org/10.1145/1140123.1140132
Wakeling, David. 1999. “Compiling Lazy Functional Programs for the Java Virtual Machine.” Journal of Functional Programming 9 (6): 579–603. https://doi.org/10.1017/s0956796899003603
Walczer, Jarrod. 2020. “US-Based Toy Unboxing Production in Children’s Culture.” In The Routledge Companion to Digital Media and Children. Routledge. https://doi.org/10.4324/9781351004107-53
Walczer, Jarrod. 2021. “8 Toy Unboxing Creator Communities.” In Creator Culture. New York University Press. https://doi.org/10.18574/nyu/9781479890118.003.0012
Walhout, T. S. 1999. “Similarity Renormalization, Hamiltonian Flow Equations, and Dyson’s Intermediate Representation.” Physical Review D 59 (6): 065009. https://doi.org/10.1103/physrevd.59.065009
Wand, Mitchell. 1995. “Compiler Correctness for Parallel Languages.” In Proceedings of the seventh international conference on Functional programming languages and computer architecture - FPCA ‘95. ACM Press. https://doi.org/10.1145/224164.224193
Wang, Bing. 2001. “A Formal Dynamic Schema Evolution Model for Hypermedia Databases.” In OOIS 2000. Springer London. https://doi.org/10.1007/978-1-4471-0299-1_3
Wang, Zheni. 2024c. “Unboxing the Temporal Patterns of Employee Engagement: A Daily and Weekly Analysis of Needs Satisfaction, Work Motivation and Employee Well-Being.” Evidence-based HRM: a Global Forum for Empirical Scholarship 13 (3): 413–31. https://doi.org/10.1108/ebhrm-10-2023-0292
Wang, Yuzhi. 2025b. “A Review of Research on AI-Assisted Code Generation and AI-Driven Code Review.” Academic Journal of Science and Technology 18 (2): 236–41. https://doi.org/10.54097/d6775287
Wang, Cheng, Sunita Chandrasekaran, and Barbara Chapman. 2017a. “An Efficient Data Layout Transformation Algorithm for Locality-Aware Parallel Sparse FFT.” In Proceedings of the Seventh Workshop on Irregular Applications: Architectures and Algorithms. ACM. https://doi.org/10.1145/3149704.3149769
Wang, Shen, Ning Chen, Yan Huang, Dong Wei, Bo Liang, and Yuling Li. 2023b. “Analysis and Research on Road Garbage Recognition and Detection Based on Mobile Garbage Collection Robot.” In Second International Conference on Advanced Manufacturing Technology and Manufacturing Systems (ICAMTMS 2023), edited by Bin Yu, Yun Wang. SPIE. https://doi.org/10.1117/12.2689066
Wang, Peng, Santiago Cuellar, and Adam Chlipala. 2014a. “Compiler Verification Meets Cross-Language Linking via Data Abstraction.” In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications. ACM. https://doi.org/10.1145/2660193.2660201
Wang, Yunsen, and Alexander Kogan. 2019. “Cloud-Based in-Memory Columnar Database Architecture for Continuous Audit Analytics.” Journal of Information Systems 34 (2): 87–107. https://doi.org/10.2308/isys-52531
Wang, Hyunkai, and Min Lee. 2024. “An Intelligent Garbage Collection Robot for Highway Cleaning.” In International Conference on Automation Control, Algorithm, and Intelligent Bionics (ACAIB 2024), edited by Jing Na, Shuping He. SPIE. https://doi.org/10.1117/12.3039414
Wang, Yiran, José Antonio Hernández López, Ulf Nilsson, and Dániel Varró. 2024b. “Using Run-Time Information to Enhance Static Analysis of Machine Learning Code in Notebooks.” In Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3663529.3663785
Wang, Chih-Sheng, Guillermo Perez, Yeh-Ching Chung, Wei-Chung Hsu, Wei-Kuan Shih, and Hong-Rong Hsu. 2011. “A Method-Based Ahead-of-Time Compiler for Android Applications.” In Proceedings of the 14th international conference on Compilers, architectures and synthesis for embedded systems. ACM. https://doi.org/10.1145/2038698.2038704
Wang, Jun, Pengju Shang, and Jiangling Yin. 2014b. “DRAW: A New Data-gRouping-AWare Data Placement Scheme for Data Intensive Applications with Interest Locality.” In Cloud Computing for Data-Intensive Applications. Springer New York. https://doi.org/10.1007/978-1-4939-1905-5_7
Wang, Fei, Xiaohua Shi, and Chao Li. 2017c. “YA-JOP:Yet Another Java Object Profiler on Art Virtual Machine.” In Proceedings of the 2017 2nd Joint International Information Technology, Mechanical and Electronic Engineering Conference (JIMEC 2017). Atlantis Press. https://doi.org/10.2991/jimec-17.2017.33
Wang, Fei, Xiaohua Shi, and Xinghai Lu. 2018a. “A Low-Overhead and Efficient Java Object Profiler on ART Virtual Machine.” Journal of Intelligent & Fuzzy Systems 35 (3): 2997–3009. https://doi.org/10.3233/jifs-169655
Wang, Yu, Junjing Shi, Linzhang Wang, Jianhua Zhao, and Xuandong Li. 2015b. “Detecting Data Races in Interrupt-Driven Programs Based on Static Analysis and Dynamic Simulation.” In Proceedings of the 7th Asia-Pacific Symposium on Internetware. ACM. https://doi.org/10.1145/2875913.2875943
Wang, Jiacun, and William Tepfenhart. 2019. “Formal Verification by Model Checking.” In Formal Methods in Computer Science. Chapman and Hall/CRC. https://doi.org/10.1201/9780429184185-7
Wang, Zhenjiang, Chenggang Wu, and Pen-Chung Yew. 2010a. “On Improving Heap Memory Layout by Dynamic Pool Allocation.” In Proceedings of the 8th annual IEEE/ACM international symposium on Code generation and optimization. ACM. https://doi.org/10.1145/1772954.1772969
Wang, Xiaocong, Fei Yan, and Fan He. 2013b. “Automatic Vulnerability Mining with Abstract Interpretation and Static Taint Trace.” In Proceedings of the 2013 2nd International Conference on Intelligent System and Applied Material. EDUGAIT Press. https://doi.org/10.12696/gsam.2013.0925
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
Wang, Xu, and Boxin Yang. 2023. “Optimizing the Cost of Garbage Collection in F2FS Using Working Set Strategy.” Highlights in Science, Engineering and Technology 39: 896–901. https://doi.org/10.54097/hset.v39i.6673
Wang, Baokang, Min Yu, and Wenlun Zhang. 2025a. “A Cache Memory with 3-Level Tile-Based Data Layout and Tag-Memory Optimization Method for 2-D Data Access.” IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences E108.A (12): 1612–19. https://doi.org/10.1587/transfun.2024eap1180
Wang, Na, and ShiMing Zhang. 2013. “Construction of Compiler Technology Course in Application-Based University.” In Proceedings of the 2013 the International Conference on Education Technology and Information Systems. Atlantis Press. https://doi.org/10.2991/icetis-13.2013.143
Wang, Liang, and Jianxin Zhao. 2022. “Compiler Backends.” In Architecture of Advanced Numerical Analysis Systems. Apress. https://doi.org/10.1007/978-1-4842-8853-5_8
Ward, A. C., and W. P. Seering. 1989. “Quantitative Inference in a Mechanical Design “Compiler”.” In 1st International Conference on Design Theory and Methodology. American Society of Mechanical Engineers. https://doi.org/10.1115/detc1989-0011
Ward, A. C., and W. P. Seering. 1993a. “The Performance of a Mechanical Design ‘Compiler’.” Journal of Mechanical Design 115 (3): 341–45. https://doi.org/10.1115/1.2919197
Ward, A. C., and W. P. Seering. 1993b. “Quantitative Inference in a Mechanical Design ‘Compiler’.” Journal of Mechanical Design 115 (1): 29–35. https://doi.org/10.1115/1.2919320
Wąsowski, Andrzej, and Thorsten Berger. 2023. “Code Generation.” In Domain-Specific Languages. Springer International Publishing. https://doi.org/10.1007/978-3-031-23669-3_9
Watson, Des. 2017. “Code Generation.” In Undergraduate Topics in Computer Science. Springer International Publishing. https://doi.org/10.1007/978-3-319-52789-5_8
Watson, Edward, and Bradley Busch. 2021. “The One about the Planning Fallacy.” In The Science of Learning. Routledge. https://doi.org/10.4324/9781003107866-5
Wazlawick, Raul Sidnei. 2024. “Code Generation.” In Object-Oriented Analysis and Design for Information Systems. Elsevier. https://doi.org/10.1016/b978-0-443-13739-6.00017-4
“Weaknesses in Java Bytecode Verifier.” 1996. Network Security 1996 (4): 2. https://doi.org/10.1016/s1353-4858(96)90173-7
WebAssembly Community Group. n.d. “GC Proposal for WebAssembly.” GitHub. Accessed October 24, 2026. https://github.com/WebAssembly/gc
“WebAssembly Für Die Industrie 4.0 – Sichere, Skalierbare Plattformen Mit Bytecode-Basierten Virtuellen Maschinen.” 2023. Industrie 4.0 Management 2023 (3): 48–51. https://doi.org/10.30844/im_23-3_48-51
Weber, Irene. 2021. “Low-Code from Frontend to Backend: Connecting Conversational User Interfaces to Backend Services via a Low-Code IoT Platform.” In CUI 2021 - 3rd Conference on Conversational User Interfaces. ACM. https://doi.org/10.1145/3469595.3469632
Wegbreit, Ben. 1971. A Generalized Compactifying Garbage Collector (a Computer Storage Management Algorithm). Defense Technical Information Center. https://doi.org/10.21236/ad0739376
Wei, Lili, Yepang Liu, and Shing-Chi Cheung. 2017. “OASIS: Prioritizing Static Analysis Warnings for Android Apps Based on App User Reviews.” In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering. ACM. https://doi.org/10.1145/3106237.3106294
Wei, Guannan, Shangyin Tan, Oliver Bračevac, and Tiark Rompf. 2021. “LLSC: A Parallel Symbolic Execution Compiler for LLVM IR.” In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3468264.3473108
Wei, Shiyi, Omer Tripp, Barbara G. Ryder, and Julian Dolby. 2016. “Revamping JavaScript Static Analysis via Localization and Remediation of Root Causes of Imprecision.” In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering. ACM. https://doi.org/10.1145/2950290.2950338
Weiderman, Nelson H. 1989. Ada Adoption Handbook: Compiler Evaluation and Selection. Version 1.0. Defense Technical Information Center. https://doi.org/10.21236/ada207717
Weight, Thomas H. 1989. A Microcode Compiler That Runs on the IBM AT and Supports Cascadable Microcomputers. Part 1. Defense Technical Information Center. https://doi.org/10.21236/ada215888
Weik, Martin H. 2000a. “Record Layout.” In Computer Science and Communications Dictionary. Springer US. https://doi.org/10.1007/1-4020-0613-6_15713
Weik, Martin H. 2000b. “Record Layout Descriptor.” In Computer Science and Communications Dictionary. Springer US. https://doi.org/10.1007/1-4020-0613-6_15714
Weik, Martin H. 2000c. “Record Layout-Level Identifier.” In Computer Science and Communications Dictionary. Springer US. https://doi.org/10.1007/1-4020-0613-6_15715
Weik, Martin H. 2000d. “Shared Record Layout.” In Computer Science and Communications Dictionary. Springer US. https://doi.org/10.1007/1-4020-0613-6_17218
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
Wenjun, Liu. 2012. “Performance Study for Java Virtual Machine in Embedded Systems.” In Advances in Intelligent and Soft Computing. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-29458-7_112
Wess, Bernhard. 2002. “Code Generation Based on Trellis Diagrams.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_11
Wheeler, Mark D., and Katsushi Ikeuchi. 1992. Towards a Vision Algorithm Compiler for Recognition of Partially Occluded 3-D Objects. Defense Technical Information Center. https://doi.org/10.21236/ada259711
White, Jim. 2013. “The Pedantic Javadoc Corpus: Comments and Code as Bitext.” In Proceedings of the Workshop on Twenty Years of Bitext. Association for Computational Linguistics. https://doi.org/10.18653/v1/2013.bitext-1.6
Wickline, Philip, Peter Lee, and Frank Pfenning. 1998. Run-Time Code Generation and Modal-ML. Defense Technical Information Center. https://doi.org/10.21236/ada339112
Wickramaarachchi, Dilani, and Richard Lai. 2017. “Effort Estimation in Global Software Development: A Systematic Review.” Computer Science and Information Systems 14 (2): 393–421. https://doi.org/10.2298/csis160229007w
Widdowson, Simon. 2006. “Occlusion Costing for Multimedia Object Layout in a Constrained Window.” In SPIE Proceedings, vol. 6073, edited by Edward Y. Chang, Alan Hanjalic, Nicu Sebe. SPIE. https://doi.org/10.1117/12.643131
Widemann, Baltasar Trancón, and Markus Lepper. 2015. “On-Line Synchronous Total Purely Functional Data-Flow Programming on the Java Virtual Machine with Sig.” In Proceedings of the Principles and Practices of Programming on The Java Platform. ACM. https://doi.org/10.1145/2807426.2807430
Wiedemann, Ole, and Volkmar Sieh. 2025. “Static Analysis of Reference-Counted Objects for the C Programming Language.” In Proceedings of the 13th Workshop on Programming Languages and Operating Systems. ACM. https://doi.org/10.1145/3764860.3768328
Wieder, Robert. 2011. Microfluidic Flow Retardation for Tagless Cancer Cell Analysis. Defense Technical Information Center. https://doi.org/10.21236/ada549637
Wieder, Robert. 2012. Microfluidic Flow Retardation for Tagless Cancer Cell Analysis. Defense Technical Information Center. https://doi.org/10.21236/ada566937
Wiedmann, Clark. 1983. “A Performance Comparison between an APL Interpreter and Compiler.” ACM SIGAPL APL Quote Quad 13 (3): 211–17. https://doi.org/10.1145/390005.801219
Wiedmann, Clark. 1986. “Field Results with the APL Compiler.” ACM SIGAPL APL Quote Quad 16 (4): 187–96. https://doi.org/10.1145/22008.22035
Wienholt, Nick. 2004. “Garbage Collection and Object Lifetime Management.” In Maximizing .NET Performance. Apress. https://doi.org/10.1007/978-1-4302-0784-9_7
Wiesenthal, Christine. 2020. “Nox, Unboxed: Anne Carson’s Uncommon Long Verse “Epitaph” (or Economies of the Unlost).” University of Toronto Quarterly 89 (2): 188–218. https://doi.org/10.3138/utq.89.2.02
Wigodsky, Herman S. 1993. “Biomedical Research: Collaboration and Conflict of Interest.” JAMA: The Journal of the American Medical Association 269 (2): 290. https://doi.org/10.1001/jama.1993.03500020126045
Wijayasiriwardhane, T., R. Lai, and K. C. Kang. 2011. “Effort Estimation of Component-Based Software Development – a Survey.” IET Software 5 (2): 216–28. https://doi.org/10.1049/iet-sen.2009.0051
Wijs, Anton, and Luc Engelen. 2012. “Incremental Formal Verification for Model Refining.” In Proceedings of the Workshop on Model-Driven Engineering, Verification and Validation. ACM. https://doi.org/10.1145/2427376.2427382
Wilbers, Ilmar M., Kent-Andre Mardal, and Martin S. Alnæs. 2012. “Instant: Just-in-Time Compilation of C/C++ in Python.” In Lecture Notes in Computational Science and Engineering. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-23099-8_14
Wilhelm, Reinhard, Helmut Seidl, and Sebastian Hack. 2013. “The Structure of Compilers.” In Compiler Design. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-17540-4_1
William, Zuo. 2019. “Multi-Scale Spatial Layout Structure System Experiences of Shanghai Mega City Spatial Planning.” In Proceedings of the 55th ISOCARP World Planning Congress. ISOCARP. https://doi.org/10.47472/vbsy8828
Williams, Kevin, Albert Noll, Andreas Gal, and David Gregg. 2008. “Optimization Strategies for a Java Virtual Machine Interpreter on the Cell Broadband Engine.” In Proceedings of the 5th conference on Computing frontiers. ACM. https://doi.org/10.1145/1366230.1366265
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
Wilson, Tom, Gary Grewal, Shawn Henshall, and Dilip Banerji. 2002. “An ILP-Based Approach to Code Generation.” In Code Generation for Embedded Processors. Springer US. https://doi.org/10.1007/978-1-4615-2323-9_6
Wilton, Donald R. 1977. Static Analysis of Conical Antenna over a Ground Plane. Defense Technical Information Center. https://doi.org/10.21236/ada042352
Wimmer, Christian, and Michael Franz. 2010. “Linear Scan Register Allocation on SSA Form.” In Proceedings of the 8th annual IEEE/ACM international symposium on Code generation and optimization. ACM. https://doi.org/10.1145/1772954.1772979
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
Wimmer, Christian, and Hanspeter Mössenböck. 2007. “Automatic Feedback-Directed Object Inlining in the Java Hotspot™ Virtual Machine.” In Proceedings of the 3rd international conference on Virtual execution environments. ACM. https://doi.org/10.1145/1254810.1254813
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
Winkelmann, Hendrik, and Herbert Kuchen. 2022. “Constraint-Logic Object-Oriented Programming on the Java Virtual Machine.” In Proceedings of the 37th ACM/SIGAPP Symposium on Applied Computing. ACM. https://doi.org/10.1145/3477314.3507058
Witka, T., and H. Krummel. 1994. “High Resolution 3D Seismic Survey over a Waste Site: 1. Field Layout and Data Acquisition.” In 56th EAEG Meeting. European Association of Geoscientists & Engineers. https://doi.org/10.3997/2214-4609.201409954
Witt, Michael D. 1994. “Conflict of Interest Dilemmas in Biomedical Research.” JAMA: The Journal of the American Medical Association 271 (7): 547. https://doi.org/10.1001/jama.1994.03510310077042
Wojcicki, Margaret A., and Paul Strooper. 2006. “Maximising the Information Gained from an Experimental Analysis of Code Inspection and Static Analysis for Concurrent Java Components.” In Proceedings of the 2006 ACM/IEEE international symposium on Empirical software engineering. ACM. https://doi.org/10.1145/1159733.1159761
Wolczko, Mario, and Ifor Williams. 1993. “Multi-Level Garbage Collection in a High-Performance Persistent Object System.” In Workshops in Computing. Springer London. https://doi.org/10.1007/978-1-4471-3209-7_23
Wolf, Wayne, John Newkirk, Robert Mathews, and Robert Dutton. 1983. “Dumbo, a Schematic-to-Layout Compiler.” In Third Caltech Conference on Very Large Scale Integration. Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-95432-0_21
Won, Jongse, and Yeong-Seok Seo. 2019. “Software Test Effort Estimation Based on Source Code Change History and Defect Information.” In Lecture Notes in Electrical Engineering. Springer Singapore. https://doi.org/10.1007/978-981-13-9341-9_38
Wong, K. F. 1987. “Garbage Collection Coprocessor System.” Electronics Letters 23 (15): 798–800. https://doi.org/10.1049/el:19870566
Wong, Limsoon. 1995. “An Introduction to Remy’s Fast Polymorphic Record Projection.” ACM SIGMOD Record 24 (3): 34–39. https://doi.org/10.1145/211990.212013
Wood, John, and Harold C. Grossman. 1992. “Interprocedural Register Allocation for RISC Machines.” In Proceedings of the 30th annual Southeast regional conference on - ACM-SE 30. ACM Press. https://doi.org/10.1145/503793.503796
“The World of Theoretical Chemistry: Unboxed.” 2022. Journal of Chemistry: Education Research and Practice 6 (2). https://doi.org/10.33140/jcerp.06.02.11
Wright, Jorja B. 2023. “Examining Factors That Contribute to the Planning Fallacy in Healthcare Cybersecurity Business Continuity Planning.” In Advances in Human and Social Aspects of Technology. IGI Global Scientific Publishing. https://doi.org/10.4018/979-8-3693-1630-6.ch006
Wu, Xiaojie, Qiming Sun, and Yuanheng Wang. 2026. “Designing Quantum Chemistry Algorithms with Just-in-Time Compilation.” Journal of Chemical Physics 164 (19): 194102. https://doi.org/10.1063/5.0314659
Wu, Yang, and Nobutaka Suzuki. 2015. “Detecting XSLT Rules Affected by Schema Evolution.” In Proceedings of the 2015 ACM Symposium on Document Engineering. ACM. https://doi.org/10.1145/2682571.2797086
Wu, Pei-Chi, Feng-Jian Wang, and Kai-Ru Young. 1992. “An Object-Oriented Specification and Its Generation for Compiler.” In Proceedings of the 1992 ACM annual conference on Communications - CSC ‘92. ACM Press. https://doi.org/10.1145/131214.131255
Wu, Xin-Song, Zhou-Yi Zhou, Ye-Ping He, Hong-Liang Liang, and Chun-Yang Yuan. 2009. “Static Analysis Based Correctness Verification for Mandatory Access Control Framework.” Chinese Journal of Computers 32 (4): 730–39. https://doi.org/10.3724/sp.j.1016.2009.00730
Würthinger, Thomas. 2011. “Extending the Graal Compiler to Optimize Libraries.” In Proceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion. ACM. https://doi.org/10.1145/2048147.2048168
Würthinger, Thomas, Walter Binder, Danilo Ansaloni, Philippe Moret, and Hanspeter Mössenböck. 2010a. “Improving Aspect-Oriented Programming with Dynamic Code Evolution in an Enhanced Java Virtual Machine.” In Proceedings of the 7th Workshop on Reflection, AOP and Meta-Data for Software Evolution. ACM. https://doi.org/10.1145/1890683.1890688
x86-psABIs. 2019. “x86-64 psABI.” GitLab. Accessed October 24, 2026. https://gitlab.com/x86-psABIs/x86-64-ABI
Xi, Fang, Takeshi Mishima, and Haruo Yokota. 2015. “Cache-Conscious Data Access for DBMS in Multicore Environments.” IEICE Transactions on Information and Systems E98.D (5): 1001–12. https://doi.org/10.1587/transinf.2014dap0004
Xia, Chun, and Josep Torrellas. 1996. “Instruction Prefetching of Systems Codes with Layout Optimized for Reduced Cache Misses.” ACM SIGARCH Computer Architecture News 24 (2): 271–82. https://doi.org/10.1145/232974.233001
Xia, Yulong, Hong Yu, Shuyin Xia, Hongyuan Shan, and Wanming Yang. 2021. “Deep Hash Image Retrieval Based on Supervised Semantic Preservation.” In Second International Conference on Industrial IoT, Big Data, and Supply Chain, edited by Hong Yu, Yongxin Zhu, Victor Chang. SPIE. https://doi.org/10.1117/12.2624163
Xie, Lucheng. 2024. “Deep Learning Compiler Optimization Based on Constraint Programming.” In Proceedings of the 3rd International Conference on Computer, Artificial Intelligence and Control Engineering. ACM. https://doi.org/10.1145/3672758.3672767
Xie, Shane, and Yiliu Tu. 2011. “Cost Estimation and Optimisation Framework for Rapid Product Development.” In Rapid One-of-a-kind Product Development. Springer London. https://doi.org/10.1007/978-1-84996-341-1_11
Xie, Yuanmin, Zhenyang Xu, Yongqiang Tian, Min Zhou, Xintong Zhou, and Chengnian Sun. 2025b. “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
Xie, Rui, Xuejiao Zhong, Xin Chen, Shaohui Xu, Haiyang Yu, and Xinyuan Guo. 2024a. “Automatic Construction and Verification Algorithm for Smart Contracts Based on Formal Verification.” AIP Advances 14 (11): 115304. https://doi.org/10.1063/5.0238456
“An XML Compiler Generator Using Object Oriented Attribute Grammar and SML.” 2004. KIPS Transactions:PartA 11A (2): 149–58. https://doi.org/10.3745/kipsta.2004.11a.2.149
Xu, Haoran. 2023a. “Deegen: A Meta-Compiler Approach for High Performance VMs at Low Engineering Cost (Invited Talk).” 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.3607815
Xu, Jingjing. 2023b. “A Natural Language Processing Based Technique for Sentiment Analysis of College English Corpus.” PeerJ Computer Science 9: e1235. https://doi.org/10.7717/peerj-cs.1235
Xu, Gejing. 2025a. “The Application and Evaluation of AI-Assisted Automatic Code Generation in Programming Instruction.” In Frontiers in Artificial Intelligence and Applications. IOS Press. https://doi.org/10.3233/faia250366
Xu, Yuting, and Ling Long. 2015. “Research on Autonomous Cruise Garbage Collection System.” In Computer Science and Engineering Technology (CSET2015), Medical Science and Biological Engineering (MSBE2015). WORLD SCIENTIFIC. https://doi.org/10.1142/9789814651011_0020
Xu Xinsheng, Fang Shuiliang, and Gu Xinjian. 2006. “A Model for Manufacturing Cost Estimation Based on Machining Feature.” In International Technology and Innovation Conference 2006 (ITIC 2006), vol. 2006. IEE. https://doi.org/10.1049/cp:20060769
Xue, Jingling. 2000. “SPMD Code Generation.” In Loop Tiling for Parallelism. Springer US. https://doi.org/10.1007/978-1-4615-4337-4_5
Yadav, Chandra Shekhar, and Raghuraj Singh. 2014. “Prediction Model for Object Oriented Software Development Effort Estimation Using One Hidden Layer Feed Forward Neural Network with Genetic Algorithm.” Advances in Software Engineering 2014: 1–6. https://doi.org/10.1155/2014/284531
Yamada, Shigeru, Yoshinobu Tamura, and Kodai Sugisaki. 2023. “OSS Reliability Analysis and Project Effort Estimation Based on Computational Intelligence.” In Springer Handbooks. Springer London. https://doi.org/10.1007/978-1-4471-7503-2_23
Yamauchi, Toshihiro, Masahiro Tsuruya, and Hideo Taniguchi. 2015. “Fast Control Method of Software-Managed TLB for Reducing Zero-Copy Communication Overhead.” IEICE Transactions on Information and Systems E98.D (12): 2187–91. https://doi.org/10.1587/transinf.2015pal0003
Yamazaki, Tetsuro, and Shigeru Chiba. 2018. “Buffered Garbage Collection for Self-Reflective Customization.” In Proceedings of the 33rd Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/3167132.3167416
Yamazaki, Tetsuro, and Shigeru Chiba. 2019. “Buffered Garbage Collection: An Approach to Collecting Self-Created Garbage Objects.” Journal of Information Processing 27 (0): 479–88. https://doi.org/10.2197/ipsjjip.27.479
Yan, Dongmei. 2018. “Research of Automatic Scoring of Student Programs Based on Static Analysis.” Journal of Electrical and Electronic Engineering 6 (2): 53. https://doi.org/10.11648/j.jeee.20180602.13
Yan, Jianian, Wenguang Chen, and Weimin Zheng. 2011. “PMU Guided Structure Data-Layout Optimization.” Tsinghua Science and Technology 16 (2): 145–50. https://doi.org/10.1016/s1007-0214(11)70022-0
Yan, Qing, Chengsheng Cui, Qin Liu, and Lianqin Jia. 2020. “A Large-Scale Garbage Collection System with a Garbage Delivery Mark Device.” IOP Conference Series: Earth and Environmental Science 510 (4): 042051. https://doi.org/10.1088/1755-1315/510/4/042051
Yan, Kaiwen, Hongcheng Guo, Xuanqing Shi, Shaosheng Cao, Donglin Di, and Zhoujun Li. 2025. “CodeIF: Benchmarking the Instruction-Following Capabilities of Large Language Models for Code Generation.” In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 6: Industry Track). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.acl-industry.89
Yang, Zhe. 2000. “Reasoning about Code-Generation in Two-Level Languages.” BRICS Report Series 7 (46). https://doi.org/10.7146/brics.v7i46.20213
Yang, Heejae. 2005. “Memory Access Behavior of Embedded Java Virtual Machine in Energy Viewpoint.” KIPS Transactions:PartA 12A (3): 223–28. https://doi.org/10.3745/kipsta.2005.12a.3.223
Yang, Liu, Sun Chan, G. R. Gao, Roy Ju, Guei-Yuan Lueh, and Zhaoqing Zhang. 2003. “Inter-Procedural Stacked Register Allocation for Itanium® like Architecture.” In Proceedings of the 17th annual international conference on Supercomputing. ACM. https://doi.org/10.1145/782814.782844
Yang, Chen, Junjie Chen, Xingyu Fan, Jiajun Jiang, and Jun Sun. 2023b. “Silent Compiler Bug De-Duplication via Three-Dimensional Analysis.” In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM. https://doi.org/10.1145/3597926.3598087
Yang, Hongbo, R. Govindarajan, Guang R. Gao, and Ziang Hu. 2005a. “Improving Power Efficiency with Compiler-Assisted Cache Replacement.” Journal of Embedded Computing 1 (4): 487–99. https://doi.org/10.3233/emc-2005-00048
Yang, Chaokun, Pengbo Nie, Ziyi Lin, et al. 2026b. “JOSer: Just-In-Time Object Serialization for Heavy Java Serialization Workloads.” In Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2. ACM. https://doi.org/10.1145/3779212.3790179
Yaniv, Ilan, and Dean P. Foster. 1995a. “Graininess of Judgment under Uncertainty: An Accuracy-Informativeness Trade-off.” Journal of Experimental Psychology: General 124 (4): 424–32. https://doi.org/10.1037/0096-3445.124.4.424
Yaniv, Ilan, and Dean P. Foster. 1995b. “Graininess of Judgment under Uncertainty: An Accuracynformativeness Trade-off.” Journal of Experimental Psychology: General 124 (4): 424–32. https://doi.org/10.1037//0096-3445.124.4.424
Yao, Xue, Bin Li, and Yahong Sun. 2017. “A User-Defined Code Reinforcement Technology Based on LLVM-Obfuscator.” In Lecture Notes in Electrical Engineering. Springer Singapore. https://doi.org/10.1007/978-981-10-7605-3_111
Yeboah-Antwi, Kwaku, and Benoit Baudry. 2017. “Online Genetic Improvement on the Java Virtual Machine with ECSELR.” ACM SIGEVOlution 9 (3): 21–21. https://doi.org/10.1145/3066862.3066869
Yermolovich, Alexander, Andreas Gal, and Michael Franz. 2008. “Portable Execution of Legacy Binaries on the Java Virtual Machine.” In Proceedings of the 6th international symposium on Principles and practice of programming in Java. ACM. https://doi.org/10.1145/1411732.1411742
Yi, Bairen, Jiacheng Xia, Li Chen, and Kai Chen. 2017. “Towards Zero Copy Dataflows Using RDMA.” In Proceedings of the SIGCOMM Posters and Demos. ACM. https://doi.org/10.1145/3123878.3131975
Yim, Joon-Seo, and Chong-Min Kyung. 1999. “Datapath Layout Compiler Using Bit-Wise Cell-Sizingscheme for Delay Balancing and Power Minimisation.” Electronics Letters 35 (21): 1788–89. https://doi.org/10.1049/el:19991236
Yin, Juan. 2014. “Research and Implementation of C Compiler for 32-Bit MIPS Processor Based on LCC.” In WIT Transactions on Information and Communication Technologies. WIT Press. https://doi.org/10.2495/icie20130782
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
Yin, Tingting, Chao Zhang, Yuandong Ni, et al. 2022. “An Empirical Study on Implicit Constraints in Smart Contract Static Analysis.” In Proceedings of the 44th International Conference on Software Engineering: Software Engineering in Practice. ACM. https://doi.org/10.1145/3510457.3513076
Ying, Zuobin, Min Ling, and Yiwen Zhang. 2024. “Machine Learning Based Software Effort Estimation Using Development-Centric Features for Crowdsourcing Platform.” Intelligent Data Analysis 28 (2): 451–65. https://doi.org/10.3233/ida-227358
Yogi, Muldani Hendrawan, Yuwana M. Yatna, and Sri Raharno. 2014. “CAIP Application in OMM Operation for Box Primitive Feature: Inpection Code Generation for on Machine Measurement Operation.” Applied Mechanics and Materials 660: 883–88. https://doi.org/10.4028/www.scientific.net/amm.660.883
Yongjin Park, Taeyong Park, Sung Tae Kim, and Jeong Hyun Yi. 2016. “Mobile Code Packing Scheme Based on Multi-Partitioned Bytecode Wrapping.” Research Briefs on Information and Communication Technology Evolution 2: 117–23. https://doi.org/10.56801/rebicte.v2i.40
Yongping, Luo, Ma Yuchun, and Wu Qiang. 2014. “An Efficient Method for Custom Instruction Mapping under the Safety Assurance of Code Generation.” In Advances in Intelligent Systems Research. Atlantis Press. https://doi.org/10.2991/csss-14.2014.42
Yotov, Kamen, Tom Roeder, Keshav Pingali, John Gunnels, and Fred Gustavson. 2007. “An Experimental Comparison of Cache-Oblivious and Cache-Conscious Programs.” In Proceedings of the nineteenth annual ACM symposium on Parallel algorithms and architectures. ACM. https://doi.org/10.1145/1248377.1248394
Young, W. 1989. “Verified Compilation in Micro-Gypsy.” ACM SIGSOFT Software Engineering Notes 14 (8): 20–26. https://doi.org/10.1145/75309.75312
Ysseldyke, James E., Bob Algozzine, and Linda Richey. 1982. “Judgment under Uncertainty: How Many Children Are Handicapped?” Exceptional Children 48 (6): 531–34. https://doi.org/10.1177/001440298204800610
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, Lizhen, Zhongwei Xu, Zuxi Chen, and Shuqing Zhang. 2013. “Formal Verification of Railway Interlocking System Based on Ladder Logic.” Journal of Computer Applications 33 (12): 3419–22. https://doi.org/10.3724/sp.j.1087.2013.03419
Yu, Jing, Yibo Zhao, Jiapeng Zhu, et al. 2025a. “Text Detoxification: Data Efficiency, Semantic Preservation and Model Generalization.” In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.emnlp-main.1636
Yu, Haonan, Jiaxin Zhu, Yingying Zheng, et al. 2026. “Understanding Code Similarity across Instruction Set Architectures: An Empirical Study.” Proceedings of the ACM on Software Engineering 3 (FSE): 2512–35. https://doi.org/10.1145/3808119
Yuan, Xiaoshu. 2025. “Corpus Approaches to Language in Social Media.” Corpus-based Studies across Humanities. https://doi.org/10.1515/csh-2025-0002
Yücalar, Fatih, Deniz Kilinc, Emin Borandag, and Akin Ozcift. 2016. “Regression Analysis Based Software Effort Estimation Method.” International Journal of Software Engineering and Knowledge Engineering 26 (05): 807–26. https://doi.org/10.1142/s0218194016500261
Yue, Feng, Jian-min Pang, and Rong-cai Zhao. 2014. “A Register Allocation Algorithm Based on Regions Priority.” Journal of Electronics & Information Technology 35 (12): 3005–10. https://doi.org/10.3724/sp.j.1146.2012.01382
Yun, Seokheon. 2021. “Analysis of Cost Estimation Level from BIM Model and Development of QDB Based Integrated Cost Management Model.” Turkish Journal of Computer and Mathematics Education (TURCOMAT) 12 (6): 659–65. https://doi.org/10.17762/turcomat.v12i6.2064
Zabel, Martin, Thomas B. Preußer, and Rainer G. Spallek. 2012. “Increasing the Efficiency of an Embedded Multi-Core Bytecode Processor Using an Object Cache.” In Proceedings of the 10th International Workshop on Java Technologies for Real-time and Embedded Systems. ACM. https://doi.org/10.1145/2388936.2388952
Zabel, Martin, and Rainer G. Spallek. 2010. “Application Requirements and Efficiency of Embedded Java Bytecode Multi-Cores.” In Proceedings of the 8th International Workshop on Java Technologies for Real-Time and Embedded Systems. ACM. https://doi.org/10.1145/1850771.1850777
Zainab Rustum Mohsin. 2021. “Investigating the Use of an Adaptive Neuro-Fuzzy Inference System in Software Development Effort Estimation.” Iraqi Journal for Computer Science and Mathematics: 18–24. https://doi.org/10.52866/ijcsm.2021.02.02.003
Zakeryfar, Maryam, and Peter Grogono. 2013. “Static Analysis of Concurrent Programs by Adapted Vector Clock.” In Proceedings of the International C* Conference on Computer Science and Software Engineering. ACM. https://doi.org/10.1145/2494444.2494476
Zakirov, Salikh S., Shigeru Chiba, and Etsuya Shibayama. 2010. “Optimizing Dynamic Dispatch with Fine-Grained State Tracking.” In Proceedings of the 6th symposium on Dynamic languages. ACM. https://doi.org/10.1145/1869631.1869634
Zakkak, Foivos S., and Polyvios Pratikakis. 2016. “Building a Java™ Virtual Machine for Non-Cache-Coherent Many-Core Architectures.” In Proceedings of the 14th International Workshop on Java Technologies for Real-Time and Embedded Systems. ACM. https://doi.org/10.1145/2990509.2990510
Zakowski, Yannick, David Cachera, Delphine Demange, and David Pichardie. 2018. “Verified Compilation of Linearizable Data Structures: Mechanizing Rely Guarantee for Semantic Refinement.” In Proceedings of the 33rd Annual ACM Symposium on Applied Computing. ACM. https://doi.org/10.1145/3167132.3167333
Zakrani, Abdelali, Ali Idri, and Mustapha Hain. 2019. “Software Effort Estimation Using an Optimal Trees Ensemble: An Empirical Comparative Study.” In Smart Innovation, Systems and Technologies. Springer International Publishing. https://doi.org/10.1007/978-3-030-21005-2_7
Zanardini, Damiano. 2006. “Abstract Non-Interference in a Fragment of Java Bytecode.” In Proceedings of the 2006 ACM symposium on Applied computing. ACM. https://doi.org/10.1145/1141277.1141706
Zaneldin, Essam. 2015. “A Spreadsheet Model for Detailed Cost Estimation.” In 3rd Annual International Conference on Architecture and Civil Engineering (ACE 2015). Global Science & Technology Forum (GSTF). https://doi.org/10.5176/2301-394x_ace15.68
Zarubin, Mikhail, Patrick Damme, Dirk Habich, and Wolfgang Lehner. 2020. “Polymorphic Compressed Replication of Columnar Data in Scale-Up Hybrid Memory Systems.” In Proceedings of the 13th ACM International Systems and Storage Conference. ACM. https://doi.org/10.1145/3383669.3398283
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
Zebchuk, Jason, Vijayalakshmi Srinivasan, Moinuddin K. Qureshi, and Andreas Moshovos. 2009. “A Tagless Coherence Directory.” In Proceedings of the 42nd Annual IEEE/ACM International Symposium on Microarchitecture. ACM. https://doi.org/10.1145/1669112.1669166
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, Dongrui, and Gang Tan. 2018. “From Debugging-Information Based Binary-Level Type Inference to CFG Generation.” In Proceedings of the Eighth ACM Conference on Data and Application Security and Privacy. ACM. https://doi.org/10.1145/3176258.3176309
Zeng, lingling, dunbo Zhang, li Shen, and qiang Dou. 2023. “Interleaving-Mapping: A Novel Data Layout in Scratchpad Memory.” In Sixth International Conference on Computer Information Science and Application Technology (CISAT 2023), edited by Shijie Jia, Huajun Dong. SPIE. https://doi.org/10.1117/12.3004060
Zhang, Wu-Sheng. 2005. “A Class-Based Garbage Collection Algorithm for the Runtime Environments.” Journal of Software 16 (8): 1506. https://doi.org/10.1360/jos161506
Zhang, Wei. 2006. “Compiler-Guided Next Sub-Bank Prediction for Reducing Instruction Cache Leakage Energy.” Journal of Embedded Computing 2 (1): 35–48. https://doi.org/10.3233/emc-2006-00058
Zhang, Wei. 2007. “Compiler-Assisted Leakage Energy Reduction for Cache Memories.” In Advances in Computers. Elsevier. https://doi.org/10.1016/s0065-2458(06)69003-7
Zhang, Zhi-Jie. 2008a. “Anchoring Effects in Duration Estimation.” Acta Psychologica Sinica 40 (2): 160–65. https://doi.org/10.3724/sp.j.1041.2008.00160
Zhang, Jian. 2009. “Sharp Static Analysis of Programs.” Chinese Journal of Computers 31 (9): 1549–53. https://doi.org/10.3724/sp.j.1016.2008.01549
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, Heng, and Long Cao. 2026. “Formal Verification of the Correctness of Elevator Control Systems Based on the Isabelle/HOL Theorem Prover.” Networking: 1. https://doi.org/10.2738/net.2026.0003
Zhang, Ziyao, Alessio Falai, Ariadna Sanchez, Orazio Angelini, and Kayoko Yanagisawa. 2022b. “Mix and Match: An Empirical Study on Training Corpus Composition for Polyglot Text-To-Speech (TTS).” In Interspeech 2022. ISCA. https://doi.org/10.21437/interspeech.2022-242
Zhang, Naifeng, and Franz Franchetti. 2025. “Code Generation for Cryptographic Kernels Using Multi-Word Modular Arithmetic on GPU.” In Proceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization. ACM. https://doi.org/10.1145/3696443.3708948
Zhang, Lan, and Wen Jiang. 2021. “Research and Implementation of Intelligent Garbage Collection Car System.” Journal of Physics: Conference Series 1883 (1): 012155. https://doi.org/10.1088/1742-6596/1883/1/012155
Zhang, W., M. Karakoy, M. Kandemir, and G. Chen. 2003. “A Compiler Approach for Reducing Data Cache Energy.” In Proceedings of the 17th annual international conference on Supercomputing - ICS ‘03. ACM Press. https://doi.org/10.1145/782827.782828
Zhang, Lei, Reza Karimi, Irfan Ahmad, and Ymir Vigfusson. 2020b. “Optimal Data Placement for Heterogeneous Cache, Memory, and Storage Systems.” ACM SIGMETRICS Performance Evaluation Review 48 (1): 85–86. https://doi.org/10.1145/3410048.3410098
Zhang, Yukong, and Hyuk Jae Lee. 2000. “Register Allocation by Systematic Merge of Register-Reusechains.” Electronics Letters 36 (1): 16–17. https://doi.org/10.1049/el:20000034
Zhang, Weiming, Qingyao Li, Xinyi Dai, et al. 2025e. “NL-Debugging: Exploiting Natural Language as an Intermediate Representation for Code Debugging.” In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.emnlp-main.80
Zhang, Linyan, Ximeng Li, Zhiping Shi, Yong Guan, Qinxiang Cao, and Qianying Zhang. 2024b. “Formal Verification of Functional Correctness for Mutexes in Microkernel.” International Journal of Software and Informatics 14 (4): 399–417. https://doi.org/10.21655/ijsi.1673-7288.00339
Zhang, Kai, Shigang Li, and Xueying Wang. 2026a. “Compiler-ASR: Bridging the IR-to-Assembly Gap for Compiler Optimization via Architecture-Specific Reward.” In Proceedings of the 40th ACM International Conference on Supercomputing - Workshops. ACM. https://doi.org/10.1145/3774895.3812196
Zhang, Haoyi, Tianfeng Liang, Huaijin Ran, Md Maruf Hasan, and Xunzhu Tang. 2026d. “SPECTRA: Specification-Oriented Static Analysis for Smart Contract Security and Behavioral Contract Inference.” In Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering. ACM. https://doi.org/10.1145/3803437.3807384
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, Luan, Dandan Song, Zhijing Wu, et al. 2025d. “Detecting Hallucination in Large Language Models through Deep Internal Representation Analysis.” In Proceedings of the Thirty-Fourth International Joint Conference on Artificial Intelligence. International Joint Conferences on Artificial Intelligence Organization. https://doi.org/10.24963/ijcai.2025/929
Zhang, Hui, and Jinzhao Wu. 2018. “Formal Verification and Quantitative Metrics of MPSoC Data Dynamics.” Formal Aspects of Computing 30 (2): 219–37. https://doi.org/10.1007/s00165-017-0444-0
Zhang, Cong-pin, Chang-mao Wu, and Li-li Zhao. 2010b. “Parallel Garbage Collection Algorithm Based on LISP2 for Multi-Core Systems.” Journal of Computer Applications 30 (11): 2876–79. https://doi.org/10.3724/sp.j.1087.2010.02876
Zhang, Hongbin, Mingjie Xing, Yanjun Wu, and Chen Zhao. 2023c. “Compiler Technologies in Deep Learning Co-Design: A Survey.” Intelligent Computing 2: 0040. https://doi.org/10.34133/icomputing.0040
Zhang, X., and Y. Xu. 2012. “The Contribution of Object Layout and Object Identity to Scene Representations in the Brain.” Journal of Vision 12 (9): 584–584. https://doi.org/10.1167/12.9.584
Zhang, Xiangyu, Yu Zhou, Guang Yang, Wei Cheng, and Taolue Chen. 2025a. “Beyond Sequences: Two-Dimensional Representation and Dependency Encoding for Code Generation.” In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.acl-long.308
Zhao, Jinman, Aws Albarghouthi, Vaibhav Rastogi, Somesh Jha, and Damien Octeau. 2018. “Neural-Augmented Static Analysis of Android Communication.” 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.3236066
Zhao, Kunsong, Zihao Li, Jianfeng Li, He Ye, Xiapu Luo, and Ting Chen. 2023a. “DeepInfer: Deep Type Inference from Smart Contract Bytecode.” 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.3616343
Zhao, Ziming, Tingting Li, and Jianwei Yin. 2026c. “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, Deshuo, and Bin Liu. 2021. “Thread-Level Speculation Execution Model Based on LLVM Compiler.” In 2021 2nd International Conference on Computing, Networks and Internet of Things (CNIOT 2021). ACM. https://doi.org/10.1145/3468691.3468707
Zhao, Xiaoyan, Zulkefli Mansor, Rozilawati Razali, Mohd Zakree Ahmad Nazri, liangyu Li, and Xuwei Guo. 2025d. “A Review of Optimization Techniques for Cost Estimation in Software Development.” Intelligent Data Analysis: An International Journal 30 (1): 217–34. https://doi.org/10.1177/1088467x251330476
Zhao, Sirong, Xuejun Yu, Jianchun Luo, and Guoqi Xie. 2023c. “Speculation-Free Function Table Construction in LLVM IR for Fine-Grained Control Flow Integrity.” Journal of Circuits, Systems and Computers 32 (16): 2350281. https://doi.org/10.1142/s021812662350281x
Zhao, Hongyan, Huibiao Zhu, Feng Sheng, Jifeng He, and Jonathan Bowen. 2025e. “Theoretical and Practical Approach to the Soundness and Completeness of Operational Semantics Based on Denotational Semantics for MDESL.” Formal Aspects of Computing 37 (2): 1–51. https://doi.org/10.1145/3696432
Zhaofei Meng and Shudong Zhang. 2013. “Research on Heap and Stack Management Mechanism in Java Virtual Machine.” Journal of Convergence Information Technology 8 (9): 138–44. https://doi.org/10.4156/jcit.vol8.issue9.18
Zhirkov, Igor. 2017. “Type System.” In Low-Level Programming. Apress. https://doi.org/10.1007/978-1-4842-2403-8_9
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
Zhou, Di, and Zhengyu Fu. 2015. “Static Analysis of Memory Leak in Android Applications.” In Proceedings of the 4th International Conference on Mechatronics, Materials, Chemistry and Computer Engineering 2015. Atlantis Press. https://doi.org/10.2991/icmmcce-15.2015.200
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, Guoliang, Yongli Zhu, and Guilan Wang. 2013. “Cache Conscious Star-Join in MapReduce Environments.” In Proceedings of the 2nd International Workshop on Cloud Intelligence. ACM. https://doi.org/10.1145/2501928.2501929
Zhu, Lin. 2024. “An Empirical Study of “v-Ing+n” Structure in Chinese Learners’ Writing: A Corpus-Based Study.” Open Journal of Social Sciences 12 (08): 405–16. https://doi.org/10.4236/jss.2024.128025
Zhu, Xi, Xue Han, Shuyuan Peng, Shuo Lei, Chao Deng, and Junlan Feng. 2023. “Beyond Layout Embedding: Layout Attention with Gaussian Biases for Structured Document Understanding.” In Findings of the Association for Computational Linguistics: EMNLP 2023. Association for Computational Linguistics. https://doi.org/10.18653/v1/2023.findings-emnlp.521
Zhu, Kelin, Yu Wang, Linzhang Wang, and Xuandong Li. 2025a. “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
Zhufeng, Huang, and Shang Jiandong. 2021. “Optimization Based on LLVM Global Instruction Selection.” Journal of Physics: Conference Series 1856 (1): 012004. https://doi.org/10.1088/1742-6596/1856/1/012004
Ziani, Yani, Téo Bernier, Nikolai Kosmatov, Frédéric Loulergue, and Daniel Gracia Pérez. 2025. “Towards Formal Verification of a TPM Software Stack: Achievements and Opportunities.” Formal Aspects of Computing 37 (4): 1–29. https://doi.org/10.1145/3743153
Zieliński, Bartosz. 2023. “Explanatory Denotational Semantics for Complex Event Patterns.” Formal Aspects of Computing 35 (4): 1–37. https://doi.org/10.1145/3608486
Zilberstein, Meital, and Eran Yahav. 2016. “Leveraging a Corpus of Natural Language Descriptions for Program Similarity.” In Proceedings of the 2016 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. ACM. https://doi.org/10.1145/2986012.2986013
Zima, Karoline. 2010. “Conflict of Interest in Medical Research, Education and Practice.” Pflege 23 (04): 0278–79. https://doi.org/10.1024/1012-5302/a000059
Zimmermann, Thomas Ede. 1989. “Intensional Logic and Two-Sorted Type Theory.” Journal of Symbolic Logic 54 (1): 65–77. https://doi.org/10.2307/2275016
Zitser, Misha, Richard Lippmann, and Tim Leek. 2004. “Testing Static Analysis Tools Using Exploitable Buffer Overflows from Open Source Code.” In Proceedings of the 12th ACM SIGSOFT twelfth international symposium on Foundations of software engineering. ACM. https://doi.org/10.1145/1029894.1029911
Ziyodov, Abduaziz. 2025. “Arithmetic Expression Compiler Using Python and LLVM.” American Journal of Applied Science and Technology 5 (10): 100–108. https://doi.org/10.37547/ajast/volume05issue10-20
Zorn, Benjamin. 1990. “Comparing Mark-and Sweep and Stop-and-Copy Garbage Collection.” In Proceedings of the 1990 ACM conference on LISP and functional programming. ACM. https://doi.org/10.1145/91556.91597
Zorn, Benjamin. 1991. The Effect of Garbage Collection on Cache Performance. Defense Technical Information Center. https://doi.org/10.21236/ada444548
Zou, Xiaofeng, Yuanxi Peng, and Qing Zhang. 2023. “Design and Implementation of a Compiler Supporting RISC-V Custom Cryptographic and Vector Instructions.” In Proceedings of the 7th International Conference on Computer Science and Application Engineering. ACM. https://doi.org/10.1145/3627915.3628090
Zulfa, Puspa Fortuna, and Pratomo Widodo. 2018. “Corpus Based Analysis of Swearing Speech of lNgapak Tegalanr Language in Tegal Movies.” In Proceedings of the International Conference of Communication Science Research (ICCSR 2018). Atlantis Press. https://doi.org/10.2991/iccsr-18.2018.11
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
Ørbæk, Peter. 1994. “Oasis: An Optimizing Action-Based Compiler Generator.” DAIMI Report Series 13 (471). https://doi.org/10.7146/dpb.v13i471.6944
Бузовский, Олег Владимирович, and Алексей Вадимович Алещенко. 2015. “Development of the System for Code Generation by Flowcharts with Intermediate Translation Language.” Technology audit and production reserves 4 (2(24)): 15. https://doi.org/10.15587/2312-8372.2015.47904
МГТУ им. Н.Э. Баумана, Д.Н. Ковега, В.А. Крищенко, and МГТУ им. Н.Э. Баумана. 2013. “LLVM-Based Dynamic Race Condition Detection.” Engineering Journal: Science and Innovation, no. 15. https://doi.org/10.18698/2308-6033-2013-2-549
عبدالشهيد, وديع جورج. 2026. “Integration of Heterogeneous Data Warehouse Sources: A Survey on Schema Evolution Challenges and Approaches.” النشرة المعلوماتية في الحاسبات والمعلومات 8 (1): 0–0. https://doi.org/10.21608/fcihib.2025.339027.1131
강현화. 2017. “An Analysis of Interlanguage in the Chinese Korean Learners’ Corpus.” Language Facts and Perspectives 41 (null): 5–47. https://doi.org/10.20988/lfp.2017.41..5
고광윤 and 이성운. 2008. “A Corpus-Based Analysis of the Language of English News in Korea.” Journal of Studies in Language 23 (4): 601–19. https://doi.org/10.18627/jslg.23.4.200802.601
이선희, Ross Israel, and markus dickinson. 2016. “Challenges of Learner Corpus Annotation: Focusing on Korean Learner Language Analysis (KoLLA) System.” Language Facts and Perspectives 38 (null): 221–51. https://doi.org/10.20988/lfp.2016.38..221
王, 心怡. 2025. “The Encroachment of the “Unboxing Thrill” on Commodity Use-Value in Live-Streamed Blind Unboxing—an Analysis Based on Marx’s Labor Theory of Value.” E-Commerce Letters 14 (09): 420–26. https://doi.org/10.12677/ecl.2025.1492929
罗, 齐. 2023. “Upgrading and Management Strategies of Rural Garbage Transfer Stations and Garbage Collection Points.” Advances in Environmental Protection 13 (04): 857–60. https://doi.org/10.12677/aep.2023.134104

Secondary Sources

Appel, Andrew W. 1997. Modern Compiler Implementation in ML. Cambridge University Press. https://doi.org/10.1017/cbo9780511811449

Sechter, Brendan. 2026. “Keleusma Research Spike: Blocking Frequency as the Ordering Principle for Instruction-Set Coverage.” Brendan A R Sechter’s Development Blog, August 6. https://sgeos.github.io/engineering/compilers/verification/2026/08/06/native_lowering_coverage.html
Sechter, Brendan. 2026. “Keleusma Research Spike: When an Apparent Design Wart Is a Semantic Boundary.” Brendan A R Sechter’s Development Blog, August 7. https://sgeos.github.io/engineering/compilers/verification/2026/08/07/two_calling_conventions.html
Sechter, Brendan. 2026. “Keleusma Research Spike: What a Verified Bound Says About the Code That Actually Runs.” Brendan A R Sechter’s Development Blog, August 8. https://sgeos.github.io/engineering/compilers/verification/2026/08/08/do_proven_bounds_survive_compilation.html

What this is a case study of

What You Need to Know to Read This

The Setting

Notation

The Measurement

What Remains, Enumerated

The Estimate Was Wrong Because It Named A Category

Threats to Validity

Pattern Extraction

The Contemporary Literature

The representation problem is a type-system problem, which is why it is not here

Object layout is expensive for reasons this language does not have

Layout is also a performance lever, and the design forecloses it

Most bytecodes do NOT bake offsets, which is why this result is unusual

The layout rules the backend does not have to invent

The backend literature this work actually sits in

Where the bytes go, which the arena decides

Types and verification, which is the series this article sits in

Counting a corpus, which is the method rather than the subject

Estimation and the biases that inflate it

The surrounding literature

The historical layer

What the survey shows

The Source Base

How the harvested survey was assembled

Epistemic State

Out of Scope

Conclusion

Equations

Notation

References

Primary Sources, Peer-Reviewed

Primary Sources, Non-Peer-Reviewed

Secondary Sources

Related Posts

Related posts

Referenced by